PersistentMapX (cyclops-reactor 9.0.0-FINAL API)

All Superinterfaces:

BiTransformable<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<PersistentMapX<K,V>>, Transformable<V>, Unwrapable

All Known Implementing Classes:

ExtensiblePMapX, PMapXImpl
```
public interface PersistentMapX<K,V>
extends To<PersistentMapX<K,V>>, org.pcollections.PMap<K,V>, Unwrapable, FluentMapX<K,V>, BiTransformable<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> PersistentMapX<U1,U2>`	`bicast(java.lang.Class<U1> type1, java.lang.Class<U2> type2)` Cast two data types simulatanously.
`default <R1,R2> PersistentMapX<R1,R2>`	`bimap(java.util.function.Function<? super K,? extends R1> fn1, java.util.function.Function<? super V,? extends R2> fn2)` Transform this BiTransformable, changing two value types at once.
`default PersistentMapX<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> PersistentMapX<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> PersistentMapX<K,U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a reactiveStream to a given type, possibly throwing a `ClassCastException`.
`static <K,V> PersistentMapX<K,V>`	`empty()`
`default PersistentMapX<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 PersistentMapX<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> PersistentMapX<K,V>`	`fromMap(java.util.Map<? extends K,? extends V> map)`
`default PersistentMapX<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> PersistentMapX<K,R>`	`map(java.util.function.Function<? super V,? extends R> fn)` Transform this functor using the supplied transformation function
`PersistentMapX<K,V>`	`minus(java.lang.Object key)`
`PersistentMapX<K,V>`	`minusAll(java.util.Collection<?> keys)`
`default PersistentMapX<K,V>`	`notNull()` Filter elements retaining only values which are not null
`default PersistentMapX<K,V>`	`onEmpty(org.jooq.lambda.tuple.Tuple2<K,V> value)` If this Container instance is zero, create a new instance containing the provided value
`default PersistentMapX<K,V>`	`onEmptyGet(java.util.function.Supplier<? extends org.jooq.lambda.tuple.Tuple2<K,V>> supplier)` If this Container instance is zero, create a new instance containing the value returned from the provided Supplier
`default PersistentMapX<K,V>`	`onEmptySwitch(java.util.function.Supplier<? extends org.pcollections.PMap<K,V>> supplier)` Switch to container created by provided Supplier, if current Container zero
`default <X extends java.lang.Throwable> PersistentMapX<K,V>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)` If this container instance is zero, throw the exception returned by the provided Supplier
`default PersistentMapX<K,V>`	`peek(java.util.function.Consumer<? super V> c)` Peek at the current value of this Transformable, without transforming it
`PersistentMapX<K,V>`	`plus(K key, V value)`
`PersistentMapX<K,V>`	`plusAll(java.util.Map<? extends K,? extends V> map)`
`default PersistentMapX<K,V>`	`removeAll(org.jooq.lambda.tuple.Tuple2<K,V>... values)` Remove all supplied elements from this filterable
`default PersistentMapX<K,V>`	`removeAllI(java.lang.Iterable<? extends org.jooq.lambda.tuple.Tuple2<K,V>> it)` Remove all elements in the supplied Iterable from this filterable
`default PersistentMapX<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 PersistentMapX<K,V>`	`retainAll(org.jooq.lambda.tuple.Tuple2<K,V>... values)` Retain only the supplied elements in the returned Filters
`default PersistentMapX<K,V>`	`retainAllI(java.lang.Iterable<? extends org.jooq.lambda.tuple.Tuple2<K,V>> it)` Retain only the supplied elements in the returned Filters
`default PersistentMapX<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
`static <K,V> PersistentMapX<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> BagX<T>`	`toBagX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)` Convert this MapX to a BagX via the provided transformation function
`default <T> LinkedListX<T>`	`toLinkedListX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)` Convert this MapX to a LinkedListX via the provided transformation function
`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> OrderedSetX<T>`	`toOrderedSetX(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> PersistentQueueX<T>`	`toPersistentQueueX(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> PersistentSetX<T>`	`toPersistentSetX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)` Convert this MapX to a PersistentSetX via the provided transformation function
`default <T> VectorX<T>`	`toVectorX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)` Convert this MapX to a VectorX via the provided transformation function
`default <R> PersistentMapX<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.foldable.To
to

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

Methods inherited from interface com.aol.cyclops2.types.Unwrapable
unwrap, unwrapIfInstance, unwrapNested

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.functor.Transformable
retry, retry

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

Methods inherited from interface com.aol.cyclops2.types.foldable.CyclopsCollectable
allMatch, anyMatch, collect, collectors, commonPrefix, commonSuffix, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, maxBy, min, minBy, mode, noneMatch, sum, sumDouble, sumInt, sumLong, to, toList, toMap, toMap, toSet, toString, toString

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

Methods inherited from interface com.aol.cyclops2.types.foldable.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, singleUnsafe, startsWith, startsWithIterable, takeOne, xMatch

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

- Method Detail
  - empty
```
static <K,V> PersistentMapX<K,V> empty()
```
  - singleton
```
static <K,V> PersistentMapX<K,V> singleton(K key,
                                           V value)
```
  - fromMap
```
static <K,V> PersistentMapX<K,V> fromMap(java.util.Map<? extends K,? extends V> map)
```
  - fromStream
```
default PersistentMapX<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>
  - 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
```
PersistentMapX<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
```
PersistentMapX<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
```
PersistentMapX<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
```
PersistentMapX<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 Folds<org.jooq.lambda.tuple.Tuple2<K,V>>
  - map
```
default <R> PersistentMapX<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> PersistentMapX<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: BiTransformable
    Transform this BiTransformable, 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 BiTransformable<K,V>
    
    Parameters:
    
    fn1 - transformation function for the first type
    
    fn2 - transformation function for the second type
    
    Returns:
    
    New BiTransformable containing transformed data
  - bipeek
```
default PersistentMapX<K,V> bipeek(java.util.function.Consumer<? super K> c1,
                                   java.util.function.Consumer<? super V> c2)
```
    Description copied from interface: BiTransformable
    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 BiTransformable<K,V>
    
    Parameters:
    
    c1 - consumer for the first type
    
    c2 - consumer for the second type
    
    Returns:
    
    New BiTransformable with the same data
  - bicast
```
default <U1,U2> PersistentMapX<U1,U2> bicast(java.lang.Class<U1> type1,
                                             java.lang.Class<U2> type2)
```
    Description copied from interface: BiTransformable
    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 BiTransformable<K,V>
    
    Returns:
  - bitrampoline
```
default <R1,R2> PersistentMapX<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: BiTransformable
    
    Perform a tail-call optimized recursive transformation operation across two data points simultaneously
    
    Specified by:
    
    bitrampoline in interface BiTransformable<K,V>
    
    Parameters:
    
    mapper1 - transformation function for the first type
    
    mapper2 - transformation function for the second type
    
    Returns:
    
    New BiTransformable containing transformed data
  - cast
```
default <U> PersistentMapX<K,U> cast(java.lang.Class<? extends U> type)
```
    Description copied from interface: Transformable
    
    Cast all elements in a reactiveStream 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 PersistentMapX<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> PersistentMapX<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 PersistentMapX<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 PersistentMapX<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 PersistentMapX<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 PersistentMapX<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
  - removeAllI
```
default PersistentMapX<K,V> removeAllI(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:
    
    removeAllI 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
  - removeAll
```
default PersistentMapX<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:
    
    Filters with all supplied values removed
  - retainAllI
```
default PersistentMapX<K,V> retainAllI(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:
    
    retainAllI 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 PersistentMapX<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
  - retainAll
```
default PersistentMapX<K,V> retainAll(org.jooq.lambda.tuple.Tuple2<K,V>... values)
```
    Description copied from interface: IterableFilterable
    
    Retain only the supplied elements in the returned Filters
    
    Specified by:
    
    retainAll 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 PersistentMapX<K,V> onEmpty(org.jooq.lambda.tuple.Tuple2<K,V> value)
```
    Description copied from interface: OnEmpty
    
    If this Container instance is zero, 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 zero, otherwise returns this container
  - onEmptyGet
```
default PersistentMapX<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 zero, 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 zero, otherwise this container
  - onEmptyThrow
```
default <X extends java.lang.Throwable> PersistentMapX<K,V> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
```
    Description copied from interface: OnEmpty
    
    If this container instance is zero, 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 zero, otherwise this container
  - onEmptySwitch
```
default PersistentMapX<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 zero
```
  
     ListX.zero().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 zero, 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 singleUnsafe value
    
    Returns:
    
    ListX of transformed values
  - toPersistentSetX
```
default <T> PersistentSetX<T> toPersistentSetX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)
```
    Convert this MapX to a PersistentSetX via the provided transformation function
    
    Parameters:
    
    fn - Mapping function to transform each Map entry into a singleUnsafe value
    
    Returns:
    
    PersistentSetX of transformed values
  - toOrderedSetX
```
default <T> OrderedSetX<T> toOrderedSetX(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 singleUnsafe value
    
    Returns:
    
    OrderedSetX of transformed values
  - toPersistentQueueX
```
default <T> PersistentQueueX<T> toPersistentQueueX(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 singleUnsafe value
    
    Returns:
    
    QueueX of transformed values
  - toLinkedListX
```
default <T> LinkedListX<T> toLinkedListX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)
```
    Convert this MapX to a LinkedListX via the provided transformation function
    
    Parameters:
    
    fn - Mapping function to transform each Map entry into a singleUnsafe value
    
    Returns:
    
    LinkedListX of transformed values
  - toVectorX
```
default <T> VectorX<T> toVectorX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)
```
    Convert this MapX to a VectorX via the provided transformation function
    
    Parameters:
    
    fn - Mapping function to transform each Map entry into a singleUnsafe value
    
    Returns:
    
    VectorX of transformed values
  - toBagX
```
default <T> BagX<T> toBagX(java.util.function.Function<? super org.jooq.lambda.tuple.Tuple2<? super K,? super V>,? extends T> fn)
```
    Convert this MapX to a BagX via the provided transformation function
    
    Parameters:
    
    fn - Mapping function to transform each Map entry into a singleUnsafe value
    
    Returns:
    
    BagX of transformed values

Interface PersistentMapX<K,V>

Nested Class Summary

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

Method Summary

Methods inherited from interface com.aol.cyclops2.types.foldable.To

Methods inherited from interface org.pcollections.PMap

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

Methods inherited from interface java.util.Map

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

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

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

Methods inherited from interface java.lang.Iterable

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

Methods inherited from interface com.aol.cyclops2.types.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

removeAllI

removeAll

retainAllI

retainAllS

retainAll

subscribe

onEmpty

onEmptyGet

onEmptyThrow

onEmptySwitch

toListX

toPersistentSetX

toOrderedSetX

toPersistentQueueX

toLinkedListX

toVectorX

toBagX