PMapX (cyclops-reactor 8.4.2 API)

All Superinterfaces:

BiFunctor<K,V>, org.jooq.lambda.Collectable<org.jooq.lambda.tuple.Tuple2<K,V>>, CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>, Filterable<org.jooq.lambda.tuple.Tuple2<K,V>>, FluentMapX<K,V>, Foldable<org.jooq.lambda.tuple.Tuple2<K,V>>, Functor<V>, java.lang.Iterable<org.jooq.lambda.tuple.Tuple2<K,V>>, IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>, java.util.Map<K,V>, OnEmpty<org.jooq.lambda.tuple.Tuple2<K,V>>, OnEmptySwitch<org.jooq.lambda.tuple.Tuple2<K,V>,org.pcollections.PMap<K,V>>, org.pcollections.PMap<K,V>, org.reactivestreams.Publisher<org.jooq.lambda.tuple.Tuple2<K,V>>, To<PMapX<K,V>>

All Known Implementing Classes:

ExtensiblePMapX, PMapXImpl
```
public interface PMapX<K,V>
extends To<PMapX<K,V>>, org.pcollections.PMap<K,V>, FluentMapX<K,V>, BiFunctor<K,V>, Functor<V>, IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>, OnEmpty<org.jooq.lambda.tuple.Tuple2<K,V>>, OnEmptySwitch<org.jooq.lambda.tuple.Tuple2<K,V>,org.pcollections.PMap<K,V>>, org.reactivestreams.Publisher<org.jooq.lambda.tuple.Tuple2<K,V>>, Foldable<org.jooq.lambda.tuple.Tuple2<K,V>>, CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>
```

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.Map
  java.util.Map.Entry<K,V>

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default <U1,U2> PMapX<U1,U2>`	`bicast(java.lang.Class<U1> type1, java.lang.Class<U2> type2)` Cast two data types simulatanously.
`default <R1,R2> PMapX<R1,R2>`	`bimap(java.util.function.Function<? super K,? extends R1> fn1, java.util.function.Function<? super V,? extends R2> fn2)` Transform this BiFunctor, changing two value types at once.
`default PMapX<K,V>`	`bipeek(java.util.function.Consumer<? super K> c1, java.util.function.Consumer<? super V> c2)` Peek at two data types simulatanously (typically to perform a side-effect with each data point)
`default <R1,R2> PMapX<R1,R2>`	`bitrampoline(java.util.function.Function<? super K,? extends Trampoline<? extends R1>> mapper1, java.util.function.Function<? super V,? extends Trampoline<? extends R2>> mapper2)` Perform a tail-call optimized recursive transformation operation across two data points simultaneously
`default <U> PMapX<K,U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`default org.jooq.lambda.Collectable<org.jooq.lambda.tuple.Tuple2<K,V>>`	`collectable()` Narrow this class to a Collectable
`static <K,V> PMapX<K,V>`	`empty()`
`default PMapX<K,V>`	`filter(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> fn)` Keep only elements for which the supplied predicates hold e.g.
`default PMapX<K,V>`	`filterNot(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`static <K,V> PMapX<K,V>`	`fromMap(java.util.Map<? extends K,? extends V> map)`
`default PMapX<K,V>`	`fromStream(ReactiveSeq<org.jooq.lambda.tuple.Tuple2<K,V>> stream)`
`default java.util.Iterator<org.jooq.lambda.tuple.Tuple2<K,V>>`	`iterator()`
`default <R> PMapX<K,R>`	`map(java.util.function.Function<? super V,? extends R> fn)` Transform this functor using the supplied transformation function
`PMapX<K,V>`	`minus(java.lang.Object key)`
`PMapX<K,V>`	`minusAll(java.util.Collection<?> keys)`
`default PMapX<K,V>`	`notNull()` Filter elements retaining only values which are not null
`default PMapX<K,V>`	`onEmpty(org.jooq.lambda.tuple.Tuple2<K,V> value)` If this Container instance is empty, create a new instance containing the provided value
`default PMapX<K,V>`	`onEmptyGet(java.util.function.Supplier<? extends org.jooq.lambda.tuple.Tuple2<K,V>> supplier)` If this Container instance is empty, create a new instance containing the value returned from the provided Supplier
`default PMapX<K,V>`	`onEmptySwitch(java.util.function.Supplier<? extends org.pcollections.PMap<K,V>> supplier)` Switch to container created by provided Supplier, if current Container empty
`default <X extends java.lang.Throwable> PMapX<K,V>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)` If this container instance is empty, throw the exception returned by the provided Supplier
`default <R> PMapX<K,R>`	`patternMatch(java.util.function.Function<Matchable.CheckValue1<V,R>,Matchable.CheckValue1<V,R>> case1, java.util.function.Supplier<? extends R> otherwise)` Transform the elements of this Stream with a Pattern Matching case and default value
`default PMapX<K,V>`	`peek(java.util.function.Consumer<? super V> c)` Peek at the current value of this Functor, without transforming it
`PMapX<K,V>`	`plus(K key, V value)`
`PMapX<K,V>`	`plusAll(java.util.Map<? extends K,? extends V> map)`
`default PMapX<K,V>`	`removeAll(java.lang.Iterable<? extends org.jooq.lambda.tuple.Tuple2<K,V>> it)` Remove all elements in the supplied Iterable from this filterable
`default PMapX<K,V>`	`removeAll(java.util.stream.Stream<? extends org.jooq.lambda.tuple.Tuple2<K,V>> stream)` Remove all elements in the supplied Stream from this filterable
`default PMapX<K,V>`	`removeAll(org.jooq.lambda.tuple.Tuple2<K,V>... values)` Remove all supplied elements from this filterable
`default PMapX<K,V>`	`retainAll(java.lang.Iterable<? extends org.jooq.lambda.tuple.Tuple2<K,V>> it)` Retain only the supplied elements in the returned Filterable
`default PMapX<K,V>`	`retainAll(java.util.stream.Stream<? extends org.jooq.lambda.tuple.Tuple2<K,V>> stream)` Retain only the supplied elements in the returned Filterable
`default PMapX<K,V>`	`retainAll(org.jooq.lambda.tuple.Tuple2<K,V>... values)` Retain only the supplied elements in the returned Filterable
`static <K,V> PMapX<K,V>`	`singleton(K key, V value)`
`default ReactiveSeq<org.jooq.lambda.tuple.Tuple2<K,V>>`	`stream()`
`default void`	`subscribe(org.reactivestreams.Subscriber<? super org.jooq.lambda.tuple.Tuple2<K,V>> s)`
`default <T> ListX<T>`	`toListX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)` Convert this MapX to a ListX via the provided transformation function
`default <T> PBagX<T>`	`toPBagX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)` Convert this MapX to a PBagX via the provided transformation function
`default <T> POrderedSetX<T>`	`toPOrderedSetX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)` Convert this MapX to a POrderdSetX via the provided transformation function
`default <T> PQueueX<T>`	`toPQueueX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)` Convert this MapX to a QueueX via the provided transformation function
`default <T> PSetX<T>`	`toPSetX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)` Convert this MapX to a PSetX via the provided transformation function
`default <T> PStackX<T>`	`toPStackX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)` Convert this MapX to a PStackX via the provided transformation function
`default <T> PVectorX<T>`	`toPVectorX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)` Convert this MapX to a PVectorX via the provided transformation function
`default <R> PMapX<K,R>`	`trampoline(java.util.function.Function<? super V,? extends Trampoline<? extends R>> mapper)` Performs a map operation that can call a recursive method without running out of stack space

Methods inherited from interface com.aol.cyclops.types.To
to

Methods inherited from interface org.pcollections.PMap
clear, put, putAll, remove

Methods inherited from interface java.util.Map
compute, computeIfAbsent, computeIfPresent, containsKey, containsValue, entrySet, equals, forEach, get, getOrDefault, hashCode, isEmpty, keySet, merge, putIfAbsent, remove, replace, replace, replaceAll, size, values

Methods inherited from interface com.aol.cyclops.types.Filterable
ofType

Methods inherited from interface com.aol.cyclops.types.stream.CyclopsCollectable
allMatch, anyMatch, avg, avg, avgDouble, avgInt, avgLong, bitAnd, bitAnd, bitAndInt, bitAndLong, bitOr, bitOr, bitOrInt, bitOrLong, collect, commonPrefix, commonSuffix, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, foldFuture, foldLazy, foldTry, max, max, max, max, maxAll, maxAll, maxAll, maxAll, maxAllBy, maxAllBy, maxBy, maxBy, median, median, medianBy, medianBy, min, min, min, min, minAll, minAll, minAll, minAll, minAllBy, minAllBy, minBy, minBy, mode, modeAll, modeAllBy, modeBy, noneMatch, percentile, percentile, percentileBy, percentileBy, sum, sum, sumDouble, sumInt, sumLong, toCollection, toList, toList, toMap, toMap, toSet, toSet, toString, toString

Methods inherited from interface org.jooq.lambda.Collectable
collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface com.aol.cyclops.types.Foldable
endsWith, endsWithIterable, findAny, findFirst, firstValue, foldable, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleOptional, startsWith, startsWithIterable, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, validate, xMatch

- Method Detail
  - empty
```
static <K,V> PMapX<K,V> empty()
```
  - singleton
```
static <K,V> PMapX<K,V> singleton(K key,
                                  V value)
```
  - fromMap
```
static <K,V> PMapX<K,V> fromMap(java.util.Map<? extends K,? extends V> map)
```
  - fromStream
```
default PMapX<K,V> fromStream(ReactiveSeq<org.jooq.lambda.tuple.Tuple2<K,V>> stream)
```
  - iterator
```
default java.util.Iterator<org.jooq.lambda.tuple.Tuple2<K,V>> iterator()
```
    Specified by:
    
    iterator in interface java.lang.Iterable<org.jooq.lambda.tuple.Tuple2<K,V>>
  - collectable
```
default org.jooq.lambda.Collectable<org.jooq.lambda.tuple.Tuple2<K,V>> collectable()
```
    Description copied from interface: CyclopsCollectable
    
    Narrow this class to a Collectable
    
    Specified by:
    
    collectable in interface CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Returns:
    
    Collectable
  - plus
```
PMapX<K,V> plus(K key,
                V value)
```
    Specified by:
    
    plus in interface FluentMapX<K,V>
    
    Specified by:
    
    plus in interface org.pcollections.PMap<K,V>
  - plusAll
```
PMapX<K,V> plusAll(java.util.Map<? extends K,? extends V> map)
```
    Specified by:
    
    plusAll in interface FluentMapX<K,V>
    
    Specified by:
    
    plusAll in interface org.pcollections.PMap<K,V>
  - minus
```
PMapX<K,V> minus(java.lang.Object key)
```
    Specified by:
    
    minus in interface FluentMapX<K,V>
    
    Specified by:
    
    minus in interface org.pcollections.PMap<K,V>
  - minusAll
```
PMapX<K,V> minusAll(java.util.Collection<?> keys)
```
    Specified by:
    
    minusAll in interface FluentMapX<K,V>
    
    Specified by:
    
    minusAll in interface org.pcollections.PMap<K,V>
  - stream
```
default ReactiveSeq<org.jooq.lambda.tuple.Tuple2<K,V>> stream()
```
    Specified by:
    
    stream in interface Foldable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Returns:
    
    this Foldable converted to a Stream (ReactiveSeq) of it's elements
  - map
```
default <R> PMapX<K,R> map(java.util.function.Function<? super V,? extends R> fn)
```
    Description copied from interface: Functor
    Transform this functor using the supplied transformation function
```
  
  
  
    of(1,2,3).map(i->i*2)
    
    //[2,4,6]
  
 
 
```
    Specified by:
    
    map in interface Functor<V>
    
    Parameters:
    
    fn - Transformation function
    
    Returns:
    
    Transformed Functor
  - bimap
```
default <R1,R2> PMapX<R1,R2> bimap(java.util.function.Function<? super K,? extends R1> fn1,
                                   java.util.function.Function<? super V,? extends R2> fn2)
```
    Description copied from interface: BiFunctor
    Transform this BiFunctor, changing two value types at once.
```
 
     MapX<String,Integer> map = MapXs.of("hello",2);
     MapX<String,Integer> transformedMap = map.bimap(s->s+" world",i->i*4);
     //["hello world",8]
 
 
```
    Specified by:
    
    bimap in interface BiFunctor<K,V>
    
    Parameters:
    
    fn1 - transformation function for the first type
    
    fn2 - transformation function for the second type
    
    Returns:
    
    New BiFunctor containing transformed data
  - bipeek
```
default PMapX<K,V> bipeek(java.util.function.Consumer<? super K> c1,
                          java.util.function.Consumer<? super V> c2)
```
    Description copied from interface: BiFunctor
    Peek at two data types simulatanously (typically to perform a side-effect with each data point)
```
 
     MapX<String,Integer> map = MapXs.of("hello",2);
     map.bipeek(s->System.out.pritnln("key = " + s),System.out::println);
 
 
```
    Specified by:
    
    bipeek in interface BiFunctor<K,V>
    
    Parameters:
    
    c1 - consumer for the first type
    
    c2 - consumer for the second type
    
    Returns:
    
    New BiFunctor with the same data
  - bicast
```
default <U1,U2> PMapX<U1,U2> bicast(java.lang.Class<U1> type1,
                                    java.lang.Class<U2> type2)
```
    Description copied from interface: BiFunctor
    Cast two data types simulatanously.
```
 
     MapX<Animal,Food> map = MapXs.of(cow,grass);
     MapX<Mamaml,Vegitation> herbervoreMammals = map.bicast(Mammal.class,Vegitation.class);
 
 
```
    Specified by:
    
    bicast in interface BiFunctor<K,V>
    
    Returns:
  - bitrampoline
```
default <R1,R2> PMapX<R1,R2> bitrampoline(java.util.function.Function<? super K,? extends Trampoline<? extends R1>> mapper1,
                                          java.util.function.Function<? super V,? extends Trampoline<? extends R2>> mapper2)
```
    Description copied from interface: BiFunctor
    
    Perform a tail-call optimized recursive transformation operation across two data points simultaneously
    
    Specified by:
    
    bitrampoline in interface BiFunctor<K,V>
    
    Parameters:
    
    mapper1 - transformation function for the first type
    
    mapper2 - transformation function for the second type
    
    Returns:
    
    New BiFunctor containing transformed data
  - cast
```
default <U> PMapX<K,U> cast(java.lang.Class<? extends U> type)
```
    Description copied from interface: Functor
    
    Cast all elements in a stream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)
    
    Specified by:
    
    cast in interface Functor<V>
  - peek
```
default PMapX<K,V> peek(java.util.function.Consumer<? super V> c)
```
    Description copied from interface: Functor
    Peek at the current value of this Functor, without transforming it
```
  
  
  
    of(1,2,3).map(System.out::println)
    
    1
    2
    3
  
 
 
```
    Specified by:
    
    peek in interface Functor<V>
    
    Parameters:
    
    c - Consumer that recieves each element from this Functor
    
    Returns:
    
    Functor that will peek at each value
  - trampoline
```
default <R> PMapX<K,R> trampoline(java.util.function.Function<? super V,? extends Trampoline<? extends R>> mapper)
```
    Description copied from interface: Functor
    Performs a map operation that can call a recursive method without running out of stack space
```
 
 ReactiveSeq.of(10,20,30,40)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println); 
    			 
    	Trampoline<Long> fibonacci(int i){
    		return fibonacci(i,1,0);
    	}
    	Trampoline<Long> fibonacci(int n, long a, long b) {
        	return n == 0 ? Trampoline.done(b) : Trampoline.more( ()->fibonacci(n-1, a+b, a));
    	}		 
    			 
 55
    	6765
    	832040
    	102334155
 
 
 ReactiveSeq.of(10_000,200_000,3_000_000,40_000_000)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println);
    			 
    			 
 completes successfully
 
 
```
    Specified by:
    
    trampoline in interface Functor<V>
    
    Parameters:
    
    mapper - TCO Transformation function
    
    Returns:
    
    Functor transformed by the supplied transformation function
  - filter
```
default PMapX<K,V> filter(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> fn)
```
    Description copied from interface: Filterable
    Keep only elements for which the supplied predicates hold e.g.
```
  
   
     of(1,2,3).filter(i->i>2);
     
     //[3]
   
 
 
```
    Specified by:
    
    filter in interface Filterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    fn - to filter elements by, retaining matches
    
    Returns:
    
    Filterable with elements removed where the predicate does not hold
  - filterNot
```
default PMapX<K,V> filterNot(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> fn)
```
    Description copied from interface: Filterable
    Remove any elements for which the predicate holds (inverse operation to filter) e.g.
```
  
   
     of(1,2,3).filter(i->i>2);
     
     //[1,2]
   
 
 
```
    Specified by:
    
    filterNot in interface Filterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    fn - to filter elements by, retaining matches
    
    Returns:
    
    Filterable with elements removed where the predicate does not hold
  - notNull
```
default PMapX<K,V> notNull()
```
    Description copied from interface: Filterable
    Filter elements retaining only values which are not null
```
  
 
   of(1,2,null,4).nonNull();
 
   //[1,2,4]
   
 
 
```
    Specified by:
    
    notNull in interface Filterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Returns:
    
    Filterable with nulls removed
  - removeAll
```
default PMapX<K,V> removeAll(java.util.stream.Stream<? extends org.jooq.lambda.tuple.Tuple2<K,V>> stream)
```
    Description copied from interface: IterableFilterable
    
    Remove all elements in the supplied Stream from this filterable
    
    Specified by:
    
    removeAll in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    stream - of elements to remove
    
    Returns:
    
    Filterable with all supplied elements removed
  - removeAll
```
default PMapX<K,V> removeAll(java.lang.Iterable<? extends org.jooq.lambda.tuple.Tuple2<K,V>> it)
```
    Description copied from interface: IterableFilterable
    
    Remove all elements in the supplied Iterable from this filterable
    
    Specified by:
    
    removeAll in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    it - an Iterable of elements to remove
    
    Returns:
    
    Filterable with all supplied elements removed
  - removeAll
```
default PMapX<K,V> removeAll(org.jooq.lambda.tuple.Tuple2<K,V>... values)
```
    Description copied from interface: IterableFilterable
    
    Remove all supplied elements from this filterable
    
    Specified by:
    
    removeAll in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    values - to remove
    
    Returns:
    
    Filterable with all supplied values removed
  - retainAll
```
default PMapX<K,V> retainAll(java.lang.Iterable<? extends org.jooq.lambda.tuple.Tuple2<K,V>> it)
```
    Description copied from interface: IterableFilterable
    
    Retain only the supplied elements in the returned Filterable
    
    Specified by:
    
    retainAll in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    it - Iterable of elements to retain
    
    Returns:
    
    Filterable with supplied values retained, and others removed
  - retainAll
```
default PMapX<K,V> retainAll(java.util.stream.Stream<? extends org.jooq.lambda.tuple.Tuple2<K,V>> stream)
```
    Description copied from interface: IterableFilterable
    
    Retain only the supplied elements in the returned Filterable
    
    Specified by:
    
    retainAll in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    stream - of elements to retain
    
    Returns:
    
    Filterable with supplied values retained, and others removed
  - retainAll
```
default PMapX<K,V> retainAll(org.jooq.lambda.tuple.Tuple2<K,V>... values)
```
    Description copied from interface: IterableFilterable
    
    Retain only the supplied elements in the returned Filterable
    
    Specified by:
    
    retainAll in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    values - elements to retain
    
    Returns:
    
    Filterable with supplied values retained, and others removed
  - patternMatch
```
default <R> PMapX<K,R> patternMatch(java.util.function.Function<Matchable.CheckValue1<V,R>,Matchable.CheckValue1<V,R>> case1,
                                    java.util.function.Supplier<? extends R> otherwise)
```
    Description copied from interface: Functor
    Transform the elements of this Stream with a Pattern Matching case and default value
```
 
 List<String> result = CollectionX.of(1,2,3,4)
                                             .patternMatch(
                                                       c->c.valuesWhere(i->"even", (Integer i)->i%2==0 )
                                                     )
 
 // CollectionX["odd","even","odd","even"]
 
```
    Specified by:
    
    patternMatch in interface Functor<V>
    
    Parameters:
    
    case1 - Function to generate a case (or chain of cases as a single case)
    
    otherwise - Value if supplied case doesn't match
    
    Returns:
    
    CollectionX where elements are transformed by pattern matching
  - subscribe
```
default void subscribe(org.reactivestreams.Subscriber<? super org.jooq.lambda.tuple.Tuple2<K,V>> s)
```
    Specified by:
    
    subscribe in interface org.reactivestreams.Publisher<org.jooq.lambda.tuple.Tuple2<K,V>>
  - onEmpty
```
default PMapX<K,V> onEmpty(org.jooq.lambda.tuple.Tuple2<K,V> value)
```
    Description copied from interface: OnEmpty
    
    If this Container instance is empty, create a new instance containing the provided value
    
    Specified by:
    
    onEmpty in interface OnEmpty<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Returns:
    
    New instance containing value if container is empty, otherwise returns this container
  - onEmptyGet
```
default PMapX<K,V> onEmptyGet(java.util.function.Supplier<? extends org.jooq.lambda.tuple.Tuple2<K,V>> supplier)
```
    Description copied from interface: OnEmpty
    
    If this Container instance is empty, create a new instance containing the value returned from the provided Supplier
    
    Specified by:
    
    onEmptyGet in interface OnEmpty<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    supplier - to determine new value for container
    
    Returns:
    
    New Container with value if this is empty, otherwise this container
  - onEmptyThrow
```
default <X extends java.lang.Throwable> PMapX<K,V> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
```
    Description copied from interface: OnEmpty
    
    If this container instance is empty, throw the exception returned by the provided Supplier
    
    Specified by:
    
    onEmptyThrow in interface OnEmpty<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    supplier - to create exception from
    
    Returns:
    
    Throw exception if empty, otherwise this container
  - onEmptySwitch
```
default PMapX<K,V> onEmptySwitch(java.util.function.Supplier<? extends org.pcollections.PMap<K,V>> supplier)
```
    Description copied from interface: OnEmptySwitch
    Switch to container created by provided Supplier, if current Container empty
```
  
     ListX.empty().onEmptySwitch(()->ListX.of(1));
  
 
```
    Specified by:
    
    onEmptySwitch in interface OnEmptySwitch<org.jooq.lambda.tuple.Tuple2<K,V>,org.pcollections.PMap<K,V>>
    
    Parameters:
    
    supplier - to create replacement container
    
    Returns:
    
    Either this container or if empty, an alternative returned by the provided supplier
  - toListX
```
default <T> ListX<T> toListX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)
```
    Convert this MapX to a ListX via the provided transformation function
    
    Parameters:
    
    fn - Mapping function to transform each Map entry into a single value
    
    Returns:
    
    ListX of transformed values
  - toPSetX
```
default <T> PSetX<T> toPSetX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)
```
    Convert this MapX to a PSetX via the provided transformation function
    
    Parameters:
    
    fn - Mapping function to transform each Map entry into a single value
    
    Returns:
    
    PSetX of transformed values
  - toPOrderedSetX
```
default <T> POrderedSetX<T> toPOrderedSetX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)
```
    Convert this MapX to a POrderdSetX via the provided transformation function
    
    Parameters:
    
    fn - Mapping function to transform each Map entry into a single value
    
    Returns:
    
    POrderedSetX of transformed values
  - toPQueueX
```
default <T> PQueueX<T> toPQueueX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)
```
    Convert this MapX to a QueueX via the provided transformation function
    
    Parameters:
    
    fn - Mapping function to transform each Map entry into a single value
    
    Returns:
    
    QueueX of transformed values
  - toPStackX
```
default <T> PStackX<T> toPStackX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)
```
    Convert this MapX to a PStackX via the provided transformation function
    
    Parameters:
    
    fn - Mapping function to transform each Map entry into a single value
    
    Returns:
    
    PStackX of transformed values
  - toPVectorX
```
default <T> PVectorX<T> toPVectorX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)
```
    Convert this MapX to a PVectorX via the provided transformation function
    
    Parameters:
    
    fn - Mapping function to transform each Map entry into a single value
    
    Returns:
    
    PVectorX of transformed values
  - toPBagX
```
default <T> PBagX<T> toPBagX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)
```
    Convert this MapX to a PBagX via the provided transformation function
    
    Parameters:
    
    fn - Mapping function to transform each Map entry into a single value
    
    Returns:
    
    PBagX of transformed values

Interface PMapX<K,V>

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.Map

Method Summary

Methods inherited from interface com.aol.cyclops.types.To

Methods inherited from interface org.pcollections.PMap

Methods inherited from interface java.util.Map

Methods inherited from interface com.aol.cyclops.types.Filterable

Methods inherited from interface com.aol.cyclops.types.stream.CyclopsCollectable

Methods inherited from interface org.jooq.lambda.Collectable

Methods inherited from interface java.lang.Iterable

Methods inherited from interface com.aol.cyclops.types.Foldable

Method Detail

empty

singleton

fromMap

fromStream

iterator

collectable

plus

plusAll

minus

minusAll

stream

map

bimap

bipeek

bicast

bitrampoline

cast

peek

trampoline

filter

filterNot

notNull

removeAll

removeAll

removeAll

retainAll

retainAll

retainAll

patternMatch

subscribe

onEmpty

onEmptyGet

onEmptyThrow

onEmptySwitch

toListX

toPSetX

toPOrderedSetX

toPQueueX

toPStackX

toPVectorX

toPBagX