PMapX (cyclops-react 2.0.0-MI1 API)

All Superinterfaces:

BiFunctor<K,V>, ConvertableToReactiveSeq<org.jooq.lambda.tuple.Tuple2<K,V>>, CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>, Filters<org.jooq.lambda.tuple.Tuple2<K,V>>, FluentMapX<K,V>, Folds<org.jooq.lambda.tuple.Tuple2<K,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>>, ReactiveStreamsTerminalOperations<org.jooq.lambda.tuple.Tuple2<K,V>>, To<PMapX<K,V>>, ToStream<org.jooq.lambda.tuple.Tuple2<K,V>>, Transformable<V>

All Known Implementing Classes:

PMapXImpl
```
public interface PMapX<K,V>
extends To<PMapX<K,V>>, org.pcollections.PMap<K,V>, FluentMapX<K,V>, BiFunctor<K,V>, Transformable<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>>, Folds<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`.
`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)`
`boolean`	`isEmpty()`
`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 PMapX<K,V>`	`peek(java.util.function.Consumer<? super V> c)` Peek at the current value of this Transformable, 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>`	`removeAllS(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>`	`removeAllS(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>`	`removeAllS(org.jooq.lambda.tuple.Tuple2<K,V>... values)` Remove all supplied elements from this filterable
`default PMapX<K,V>`	`retainAllS(java.lang.Iterable<? extends org.jooq.lambda.tuple.Tuple2<K,V>> it)` Retain only the supplied elements in the returned Filters
`default PMapX<K,V>`	`retainAllS(java.util.stream.Stream<? extends org.jooq.lambda.tuple.Tuple2<K,V>> stream)` Retain only the supplied elements in the returned Filters
`default PMapX<K,V>`	`retainAllS(org.jooq.lambda.tuple.Tuple2<K,V>... values)` Retain only the supplied elements in the returned Filters
`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.cyclops2.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, keySet, merge, putIfAbsent, remove, replace, replace, replaceAll, size, values

Methods inherited from interface com.aol.cyclops2.types.Transformable
retry, retry

Methods inherited from interface com.aol.cyclops2.types.Filters
ofType

Methods inherited from interface com.aol.cyclops2.types.stream.CyclopsCollectable
allMatch, anyMatch, avg, avgDouble, avgInt, avgLong, bitAnd, bitAndInt, bitAndLong, bitOr, bitOrInt, bitOrLong, collect, collectable, commonPrefix, commonSuffix, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, 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, sumDouble, sumInt, sumLong, toCollection, toList, toList, toMap, toMap, toSet, toSet, toString, toString

Methods inherited from interface com.aol.cyclops2.types.Folds
endsWith, endsWithIterable, findAny, findFirst, firstValue, foldLeft, foldLeft, foldLeft, foldLeft, 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, xMatch

Methods inherited from interface com.aol.cyclops2.types.stream.ToStream
futureStream, getStreamable, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStream

Methods inherited from interface com.aol.cyclops2.types.stream.reactive.ReactiveStreamsTerminalOperations
forEach, forEach, forEach, forEach, forEach

- 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)
```
  - isEmpty
```
boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface java.util.Map<K,V>
    
    Specified by:
    
    isEmpty in interface ToStream<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Returns:
    
    True if this type is empty, false otherwise
  - 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>>
  - 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 ToStream<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Returns:
    
    ReactiveSeq from this Streamable
  - map
```
default <R> PMapX<K,R> map(java.util.function.Function<? super V,? extends R> fn)
```
    Description copied from interface: Transformable
    Transform this functor using the supplied transformation function
```
  
  
  
    of(1,2,3).map(i->i*2)
    
    //[2,4,6]
  
 
 
```
    Specified by:
    
    map in interface Transformable<V>
    
    Parameters:
    
    fn - Transformation function
    
    Returns:
    
    Transformed Transformable
  - 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: Transformable
    
    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 Transformable<V>
  - peek
```
default PMapX<K,V> peek(java.util.function.Consumer<? super V> c)
```
    Description copied from interface: Transformable
    Peek at the current value of this Transformable, without transforming it
```
  
  
  
    of(1,2,3).map(System.out::println)
    
    1
    2
    3
  
 
 
```
    Specified by:
    
    peek in interface Transformable<V>
    
    Parameters:
    
    c - Consumer that recieves each element from this Transformable
    
    Returns:
    
    Transformable 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: Transformable
    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 Transformable<V>
    
    Parameters:
    
    mapper - TCO Transformation function
    
    Returns:
    
    Transformable 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: Filters
    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 Filters<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    fn - to filter elements by, retaining matches
    
    Returns:
    
    Filters 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: Filters
    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 Filters<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    fn - to filter elements by, retaining matches
    
    Returns:
    
    Filters with elements removed where the predicate does not hold
  - notNull
```
default PMapX<K,V> notNull()
```
    Description copied from interface: Filters
    Filter elements retaining only values which are not null
```
  
 
   of(1,2,null,4).nonNull();
 
   //[1,2,4]
   
 
 
```
    Specified by:
    
    notNull in interface Filters<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Returns:
    
    Filters with nulls removed
  - removeAllS
```
default PMapX<K,V> removeAllS(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:
    
    removeAllS in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    stream - of elements to remove
    
    Returns:
    
    Filters with all supplied elements removed
  - removeAllS
```
default PMapX<K,V> removeAllS(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:
    
    removeAllS in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    it - an Iterable of elements to remove
    
    Returns:
    
    Filters with all supplied elements removed
  - removeAllS
```
default PMapX<K,V> removeAllS(org.jooq.lambda.tuple.Tuple2<K,V>... values)
```
    Description copied from interface: IterableFilterable
    
    Remove all supplied elements from this filterable
    
    Specified by:
    
    removeAllS in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    values - to remove
    
    Returns:
    
    Filters with all supplied values removed
  - retainAllS
```
default PMapX<K,V> retainAllS(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 Filters
    
    Specified by:
    
    retainAllS in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    it - Iterable of elements to retain
    
    Returns:
    
    Filters with supplied values retained, and others removed
  - retainAllS
```
default PMapX<K,V> retainAllS(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 Filters
    
    Specified by:
    
    retainAllS in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    stream - of elements to retain
    
    Returns:
    
    Filters with supplied values retained, and others removed
  - retainAllS
```
default PMapX<K,V> retainAllS(org.jooq.lambda.tuple.Tuple2<K,V>... values)
```
    Description copied from interface: IterableFilterable
    
    Retain only the supplied elements in the returned Filters
    
    Specified by:
    
    retainAllS in interface IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    values - elements to retain
    
    Returns:
    
    Filters with supplied values retained, and others removed
  - 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.cyclops2.types.To

Methods inherited from interface org.pcollections.PMap

Methods inherited from interface java.util.Map

Methods inherited from interface com.aol.cyclops2.types.Transformable

Methods inherited from interface com.aol.cyclops2.types.Filters

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

Methods inherited from interface com.aol.cyclops2.types.Folds

Methods inherited from interface com.aol.cyclops2.types.stream.ToStream

Methods inherited from interface com.aol.cyclops2.types.stream.reactive.ReactiveStreamsTerminalOperations

Method Detail

empty

singleton

fromMap

fromStream

isEmpty

iterator

plus

plusAll

minus

minusAll

stream

map

bimap

bipeek

bicast

bitrampoline

cast

peek

trampoline

filter

filterNot

notNull

removeAllS

removeAllS

removeAllS

retainAllS

retainAllS

retainAllS

subscribe

onEmpty

onEmptyGet

onEmptyThrow

onEmptySwitch

toListX

toPSetX

toPOrderedSetX

toPQueueX

toPStackX

toPVectorX

toPBagX