MapX (simple-react 1.0.0-RC3 API)

All Superinterfaces:

BiFunctor<K,V>, org.jooq.lambda.Collectable<org.jooq.lambda.tuple.Tuple2<K,V>>, ConvertableSequence<org.jooq.lambda.tuple.Tuple2<K,V>>, CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>, ExtendedTraversable<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>, org.reactivestreams.Publisher<org.jooq.lambda.tuple.Tuple2<K,V>>, TransformerTraversable<org.jooq.lambda.tuple.Tuple2<K,V>>, Traversable<org.jooq.lambda.tuple.Tuple2<K,V>>

All Known Implementing Classes:

MapXImpl
```
public interface MapX<K,V>
extends java.util.Map<K,V>, FluentMapX<K,V>, BiFunctor<K,V>, Functor<V>, IterableFilterable<org.jooq.lambda.tuple.Tuple2<K,V>>, ExtendedTraversable<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 boolean`	`allMatch(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> c)` True if predicate matches all elements when Monad converted to a Stream
`default boolean`	`anyMatch(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> c)` True if a single element matches when Monad converted to a Stream
`default <R1,R2> BiFunctor<R1,R2>`	`bimap(java.util.function.Function<? super K,? extends R1> fn1, java.util.function.Function<? super V,? extends R2> fn2)`
`default <U> MapX<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> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>>`	`defaultCollector()`
`default MapX<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 MapX<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.
`default <KR,VR> MapX<KR,VR>`	`flatMap(java.util.function.BiFunction<? super K,? super V,? extends MapX<KR,VR>> fn)`
`static <K,V> MapX<K,V>`	`fromMap(java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>> collector, java.util.Map<? extends K,? extends V> it)`
`static <K,V> MapX<K,V>`	`fromMap(java.util.Map<? extends K,? extends V> it)`
`default MapX<K,V>`	`fromStream(ReactiveSeq<org.jooq.lambda.tuple.Tuple2<K,V>> stream)`
`<K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>>`	`getCollector()`
`static <K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>>`	`immutableCollector()`
`default java.util.Iterator<org.jooq.lambda.tuple.Tuple2<K,V>>`	`iterator()`
`default <R> MapX<K,R>`	`map(java.util.function.Function<? super V,? extends R> fn)` Transform this functor using the supplied transformation function
`default java.util.Optional<org.jooq.lambda.tuple.Tuple2<K,V>>`	`max(java.util.Comparator<? super org.jooq.lambda.tuple.Tuple2<K,V>> comparator)`
`default java.util.Optional<org.jooq.lambda.tuple.Tuple2<K,V>>`	`min(java.util.Comparator<? super org.jooq.lambda.tuple.Tuple2<K,V>> comparator)`
`default MapX<K,V>`	`minus(java.lang.Object key)`
`default MapX<K,V>`	`minusAll(java.util.Collection<?> keys)`
`default boolean`	`noneMatch(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> c)`
`default MapX<K,V>`	`notNull()` Filter elements retaining only values which are not null
`default MapX<K,V>`	`peek(java.util.function.Consumer<? super V> c)` Peek at the current value of this Functor, without transforming it
`default MapX<K,V>`	`plus(K key, V value)`
`default MapX<K,V>`	`plusAll(java.util.Map<? extends K,? extends V> map)`
`default MapX<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 MapX<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 MapX<K,V>`	`removeAll(org.jooq.lambda.tuple.Tuple2<K,V>... values)` Remove all supplied elements from this filterable
`default MapX<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 MapX<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 MapX<K,V>`	`retainAll(org.jooq.lambda.tuple.Tuple2<K,V>... values)` Retain only the supplied elements in the returned Filterable
`int`	`size()`
`default ReactiveSeq<org.jooq.lambda.tuple.Tuple2<K,V>>`	`stream()`
`static <K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>>`	`toMapX()`
`default <R> MapX<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 java.util.Map
clear, compute, computeIfAbsent, computeIfPresent, containsKey, containsValue, entrySet, equals, forEach, get, getOrDefault, hashCode, isEmpty, keySet, merge, put, putAll, putIfAbsent, remove, remove, replace, replace, replaceAll, values

Methods inherited from interface com.aol.cyclops.types.BiFunctor
bicast, bipeek, bitrampoline

Methods inherited from interface com.aol.cyclops.types.Functor
patternMatch

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

Methods inherited from interface com.aol.cyclops.types.ExtendedTraversable
combinations, combinations, permutations

Methods inherited from interface com.aol.cyclops.types.Traversable
combine, cycle, cycle, cycleUntil, cycleWhile, distinct, dropRight, dropUntil, dropWhile, futureOperations, grouped, grouped, grouped, grouped, groupedStatefullyWhile, groupedUntil, groupedUntil, groupedWhile, groupedWhile, intersperse, lazyOperations, limit, limitLast, limitUntil, limitWhile, onEmpty, onEmptyGet, onEmptyThrow, reverse, scanLeft, scanLeft, scanRight, scanRight, shuffle, shuffle, skip, skipLast, skipUntil, skipWhile, slice, sliding, sliding, sorted, sorted, sorted, subscribe, takeRight, takeUntil, takeWhile, traversable, zip, zip, zip3, zip4, zipStream, zipWithIndex

Methods inherited from interface com.aol.cyclops.types.TransformerTraversable
groupedStatefullyWhileT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingT

Methods inherited from interface com.aol.cyclops.types.Foldable
endsWith, endsWithIterable, findAny, findFirst, firstValue, foldable, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, headAndTail, 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, visit, visit, xMatch

Methods inherited from interface com.aol.cyclops.types.stream.ConvertableSequence
seq, toCompletableFuture, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFutureStream, toFutureStream, toFutureW, toIor, toIorSecondary, toListX, toMapX, toMaybe, toOptional, toPBagX, toPMapX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toStreamable, toTry, toValue, toValueMap, toValueSet, toXor, toXorSecondary

Methods inherited from interface com.aol.cyclops.types.stream.CyclopsCollectable
avg, avg, avgDouble, avgInt, avgLong, bitAnd, bitAnd, bitAndInt, bitAndLong, bitOr, bitOr, bitOrInt, bitOrLong, collect, commonPrefix, commonSuffix, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, max, max, maxAll, maxAll, maxAll, maxAll, maxAllBy, maxAllBy, maxBy, maxBy, median, median, medianBy, medianBy, min, min, min, minAll, minAll, minAll, minAll, minAllBy, minAllBy, minBy, minBy, mode, modeAll, modeAllBy, modeBy, 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

- Method Detail
  - defaultCollector
```
static <K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>> defaultCollector()
```
  - immutableCollector
```
static <K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>> immutableCollector()
```
  - toMapX
```
static <K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>> toMapX()
```
  - getCollector
```
<K,V> java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>> getCollector()
```
  - stream
```
default ReactiveSeq<org.jooq.lambda.tuple.Tuple2<K,V>> stream()
```
    Specified by:
    
    stream in interface ConvertableSequence<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Specified by:
    
    stream in interface ExtendedTraversable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Specified by:
    
    stream in interface Foldable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Specified by:
    
    stream in interface TransformerTraversable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Specified by:
    
    stream in interface Traversable<org.jooq.lambda.tuple.Tuple2<K,V>>
  - fromMap
```
static <K,V> MapX<K,V> fromMap(java.util.Map<? extends K,? extends V> it)
```
  - fromMap
```
static <K,V> MapX<K,V> fromMap(java.util.stream.Collector<org.jooq.lambda.tuple.Tuple2<? extends K,? extends V>,?,java.util.Map<K,V>> collector,
                               java.util.Map<? extends K,? extends V> it)
```
  - fromStream
```
default MapX<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
  - flatMap
```
default <KR,VR> MapX<KR,VR> flatMap(java.util.function.BiFunction<? super K,? super V,? extends MapX<KR,VR>> fn)
```
  - map
```
default <R> MapX<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> BiFunctor<R1,R2> bimap(java.util.function.Function<? super K,? extends R1> fn1,
                                       java.util.function.Function<? super V,? extends R2> fn2)
```
    Specified by:
    
    bimap in interface BiFunctor<K,V>
  - size
```
int size()
```
    Specified by:
    
    size in interface java.util.Map<K,V>
  - allMatch
```
default boolean allMatch(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> c)
```
    Description copied from interface: CyclopsCollectable
    True if predicate matches all elements when Monad converted to a Stream
```
  
 assertThat(ReactiveSeq.of(1,2,3,4,5).allMatch(it-> it>0 && it <6),equalTo(true));
 
 
```
    Specified by:
    
    allMatch in interface org.jooq.lambda.Collectable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Specified by:
    
    allMatch in interface CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    c - Predicate to check if all match
  - anyMatch
```
default boolean anyMatch(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> c)
```
    Description copied from interface: CyclopsCollectable
    True if a single element matches when Monad converted to a Stream
```
  
 assertThat(ReactiveSeq.of(1,2,3,4,5).anyMatch(it-> it.equals(3)),equalTo(true));
 
 
```
    Specified by:
    
    anyMatch in interface org.jooq.lambda.Collectable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Specified by:
    
    anyMatch in interface CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Parameters:
    
    c - Predicate to check if any match
  - noneMatch
```
default boolean noneMatch(java.util.function.Predicate<? super org.jooq.lambda.tuple.Tuple2<K,V>> c)
```
    Specified by:
    
    noneMatch in interface org.jooq.lambda.Collectable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Specified by:
    
    noneMatch in interface CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>
  - max
```
default java.util.Optional<org.jooq.lambda.tuple.Tuple2<K,V>> max(java.util.Comparator<? super org.jooq.lambda.tuple.Tuple2<K,V>> comparator)
```
    Specified by:
    
    max in interface org.jooq.lambda.Collectable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Specified by:
    
    max in interface CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>
  - min
```
default java.util.Optional<org.jooq.lambda.tuple.Tuple2<K,V>> min(java.util.Comparator<? super org.jooq.lambda.tuple.Tuple2<K,V>> comparator)
```
    Specified by:
    
    min in interface org.jooq.lambda.Collectable<org.jooq.lambda.tuple.Tuple2<K,V>>
    
    Specified by:
    
    min in interface CyclopsCollectable<org.jooq.lambda.tuple.Tuple2<K,V>>
  - plus
```
default MapX<K,V> plus(K key,
                       V value)
```
    Specified by:
    
    plus in interface FluentMapX<K,V>
  - plusAll
```
default MapX<K,V> plusAll(java.util.Map<? extends K,? extends V> map)
```
    Specified by:
    
    plusAll in interface FluentMapX<K,V>
  - minus
```
default MapX<K,V> minus(java.lang.Object key)
```
    Specified by:
    
    minus in interface FluentMapX<K,V>
  - minusAll
```
default MapX<K,V> minusAll(java.util.Collection<?> keys)
```
    Specified by:
    
    minusAll in interface FluentMapX<K,V>
  - cast
```
default <U> MapX<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 MapX<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> MapX<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>
    
    Returns:
  - filter
```
default MapX<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 MapX<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 MapX<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 MapX<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 MapX<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 MapX<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 MapX<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 MapX<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 MapX<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

Interface MapX<K,V>

Nested Class Summary

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

Method Summary

Methods inherited from interface java.util.Map

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

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

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

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

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

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

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

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

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

Methods inherited from interface org.jooq.lambda.Collectable

Method Detail

defaultCollector

immutableCollector

toMapX

getCollector

stream

fromMap

fromMap

fromStream

iterator

collectable

flatMap

map

bimap

size

allMatch

anyMatch

noneMatch

max

min

plus

plusAll

minus

minusAll

cast

peek

trampoline

filter

filterNot

notNull

removeAll

removeAll

removeAll

retainAll

retainAll

retainAll