BaseExtendedStream (cyclops-reactor 9.0.0-FINAL API)

java.lang.Object
- com.aol.cyclops2.internal.stream.BaseExtendedStream<T>

All Implemented Interfaces:

Convert<Higher<Witness.reactiveSeq,T>>, Higher<Witness.reactiveSeq,T>, Unit<T>, Filters<T>, CyclopsCollectable<T>, Folds<T>, To<ReactiveSeq<T>>, FilterableTransformable<T>, Transformable<T>, TransformerTraversable<T>, ReactiveStreamsTerminalOperations<T>, OnEmpty<T>, OnEmptySwitch<T,java.util.stream.Stream<T>>, ExtendedTraversable<T>, FoldableTraversable<T>, IterableFilterable<T>, Sequential<T>, Traversable<T>, Unwrapable, Zippable<T>, ReactiveSeq<T>, java.lang.AutoCloseable, java.lang.Iterable<T>, java.util.stream.BaseStream<T,java.util.stream.Stream<T>>, java.util.stream.Stream<T>, org.reactivestreams.Publisher<T>

Direct Known Subclasses:

ReactiveStreamX, SpliteratorBasedStream
```
public abstract class BaseExtendedStream<T>
extends java.lang.Object
implements Unwrapable, ReactiveSeq<T>, java.lang.Iterable<T>
```
Created by johnmcclean on 13/01/2017.

Nested Class Summary
- Nested classes/interfaces inherited from interface cyclops.stream.ReactiveSeq
  ReactiveSeq.Instances
- Nested classes/interfaces inherited from interface java.util.stream.Stream
  java.util.stream.Stream.Builder<T>

Constructor Summary

Constructors
Constructor and Description

BaseExtendedStream()

Constructors
Constructor and Description
`BaseExtendedStream()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`allMatch(java.util.function.Predicate<? super T> c)` True if predicate matches all elements when Monad converted to a Stream
`AnyMSeq<Witness.reactiveSeq,T>`	`anyM()`
`boolean`	`anyMatch(java.util.function.Predicate<? super T> c)` True if a singleUnsafe element matches when Monad converted to a Stream
`void`	`close()`
`<R,A> R`	`collect(java.util.stream.Collector<? super T,A,R> collector)` Performs a mutable reduction operation on the elements of this reactiveStream using a `Collector`.
`<R> R`	`collect(java.util.function.Supplier<R> supplier, java.util.function.BiConsumer<R,? super T> accumulator, java.util.function.BiConsumer<R,R> combiner)` Performs a mutable reduction operation on the elements of this reactiveStream.
`protected abstract <R> ReactiveSeq<R>`	`createSeq(java.util.stream.Stream<R> rStream)`
`ReactiveSeq<T>`	`debounce(long time, java.util.concurrent.TimeUnit t)` Allow one element through per time period, drop all other elements in that time period
`boolean`	`endsWith(java.util.stream.Stream<T> iterable)` `assertTrue(ReactiveSeq.of(1,2,3,4,5,6) .endsWith(Stream.of(5,6)));`
`boolean`	`endsWithIterable(java.lang.Iterable<T> iterable)` `assertTrue(ReactiveSeq.of(1,2,3,4,5,6) .endsWith(Arrays.asList(5,6)));`
`abstract ReactiveSeq<T>`	`filterLazyPredicate(java.util.function.Supplier<java.util.function.Predicate<? super T>> fn)`
`java.util.Optional<T>`	`findAny()`
`T`	`firstValue()` `assertThat(ReactiveSeq.of(1,2,3,4) .map(u->{throw new RuntimeException();}) .recover(e->"hello") .firstValue(),equalTo("hello"));`
`ReactiveSeq<T>`	`fixedDelay(long l, java.util.concurrent.TimeUnit unit)` emit elements after a fixed delay
`ReactiveSeq<java.lang.String>`	`flatMapBufferedReader(java.util.function.Function<? super T,java.io.BufferedReader> fn)`
`ReactiveSeq<java.lang.Character>`	`flatMapCharSequence(java.util.function.Function<? super T,java.lang.CharSequence> fn)`
`<R> ReactiveSeq<R>`	`flatMapCompletableFuture(java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn)`
`ReactiveSeq<java.lang.String>`	`flatMapFile(java.util.function.Function<? super T,java.io.File> fn)`
`<R> ReactiveSeq<R>`	`flatMapOptional(java.util.function.Function<? super T,java.util.Optional<? extends R>> fn)`
`<R> ReactiveSeq<R>`	`flatMapStream(java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn)` flatMap operation
`java.util.stream.DoubleStream`	`flatMapToDouble(java.util.function.Function<? super T,? extends java.util.stream.DoubleStream> mapper)`
`java.util.stream.IntStream`	`flatMapToInt(java.util.function.Function<? super T,? extends java.util.stream.IntStream> mapper)`
`java.util.stream.LongStream`	`flatMapToLong(java.util.function.Function<? super T,? extends java.util.stream.LongStream> mapper)`
`ReactiveSeq<java.lang.String>`	`flatMapURL(java.util.function.Function<? super T,java.net.URL> fn)`
`T`	`foldLeft(Monoid<T> reducer)`
`T`	`foldLeft(T identity, java.util.function.BinaryOperator<T> accumulator)`
`<T> T`	`foldLeftMapToType(Reducer<T> reducer)`
`T`	`foldRight(Monoid<T> reducer)` `ReactiveSeq.of("a","b","c").foldRight(Reducers.toString("")); // "cab"`
`T`	`foldRight(T identity, java.util.function.BinaryOperator<T> accumulator)` Immutable reduction from right to left
`<U> U`	`foldRight(U seed, java.util.function.BiFunction<? super T,? super U,? extends U> function)` Immutable reduction from right to left
`<T> T`	`foldRightMapToType(Reducer<T> reducer)` Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
`void`	`forEachOrdered(java.util.function.Consumer<? super T> action)`
`HeadAndTail<T>`	`headAndTail()` extract head and tail together, where head is expected to be present Example :
`boolean`	`isParallel()`
`ReactiveSeq<T>`	`jitter(long l)` Introduce a random jitter / time delay between the emission of elements
`java.lang.String`	`join()` `assertEquals("123".length(),ReactiveSeq.of(1, 2, 3).join().length());`
`java.lang.String`	`join(java.lang.String sep)` `assertEquals("1, 2, 3".length(), ReactiveSeq.of(1, 2, 3).join(", ").length());`
`java.lang.String`	`join(java.lang.String sep, java.lang.String start, java.lang.String end)` `assertEquals("^1\|2\|3$".length(), of(1, 2, 3).join("\|", "^", "$").length());`
`abstract <R> ReactiveSeq<R>`	`mapLazyFn(java.util.function.Supplier<java.util.function.Function<? super T,? extends R>> fn)`
`<R> R`	`mapReduce(java.util.function.Function<? super T,? extends R> mapper, Monoid<R> reducer)` Attempt to map this Monad to the same type as the supplied Monoid, using supplied function Then use Monoid to reduce values
`<R> R`	`mapReduce(Reducer<R> reducer)` Attempt to map this Sequence to the same type as the supplied Monoid (Reducer) Then use Monoid to reduce values
`java.util.stream.DoubleStream`	`mapToDouble(java.util.function.ToDoubleFunction<? super T> mapper)`
`java.util.stream.IntStream`	`mapToInt(java.util.function.ToIntFunction<? super T> mapper)`
`java.util.stream.LongStream`	`mapToLong(java.util.function.ToLongFunction<? super T> mapper)`
`java.util.Optional<T>`	`max(java.util.Comparator<? super T> comparator)` Get the maximum value by a function.
`<C extends java.lang.Comparable<? super C>> java.util.Optional<T>`	`maxBy(java.util.function.Function<? super T,? extends C> f)` Get the maximum value by a function.
`java.util.Optional<T>`	`min(java.util.Comparator<? super T> comparator)` Get the minimum value by a function.
`<U extends java.lang.Comparable<? super U>> java.util.Optional<T>`	`minBy(java.util.function.Function<? super T,? extends U> function)` Get the minimum value by a function.
`boolean`	`noneMatch(java.util.function.Predicate<? super T> c)`
`ReactiveSeq<T>`	`onClose(java.lang.Runnable closeHandler)`
`ReactiveSeq<T>`	`onePer(long time, java.util.concurrent.TimeUnit t)` emit one element per time period
`ReactiveSeq<T>`	`parallel()`
`java.util.Optional<T>`	`reduce(java.util.function.BinaryOperator<T> accumulator)` An equivalent function to `Stream.reduce(BinaryOperator)`
`ListX<T>`	`reduce(java.lang.Iterable<? extends Monoid<T>> reducers)` Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first.
`T`	`reduce(Monoid<T> reducer)` `ReactiveSeq.of("hello","2","world","4").reduce(Reducers.toString(",")); //hello,2,world,4`
`ListX<T>`	`reduce(java.util.stream.Stream<? extends Monoid<T>> reducers)` Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first.
`T`	`reduce(T identity, java.util.function.BinaryOperator<T> accumulator)` An equivalent function to `Stream.reduce(Object, BinaryOperator)`
`<U> U`	`reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator, java.util.function.BinaryOperator<U> combiner)` An equivalent function to `Stream.reduce(Object, BiFunction, BinaryOperator)`
`ReactiveSeq<T>`	`sequential()`
`ReactiveSeq<T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`boolean`	`startsWith(java.util.stream.Stream<T> stream2)` `assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Stream.of(1,2,3)))`
`boolean`	`startsWithIterable(java.lang.Iterable<T> iterable)` `assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Arrays.asList(1,2,3)));`
`ReactiveSeq<T>`	`stream()` Convert this ReactiveSeq into a Stream
`java.lang.Object[]`	`toArray()`
`<A> A[]`	`toArray(java.util.function.IntFunction<A[]> generator)`
`java.util.List<T>`	`toList()` Collect the collectable into an `ArrayList`.
`java.util.Set<T>`	`toSet()` Collect the collectable into a `LinkedHashSet`.
`ReactiveSeq<T>`	`unordered()`
`abstract java.util.stream.Stream<T>`	`unwrapStream()`
`boolean`	`xMatch(int num, java.util.function.Predicate<? super T> c)` Check that there are specified number of matches of predicate in the Stream
`ReactiveSeq<T>`	`xPer(int x, long time, java.util.concurrent.TimeUnit t)` emit x elements per time period

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

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

Methods inherited from interface cyclops.stream.ReactiveSeq
allTypeclasses, allTypeclasses, ambWith, ambWith, append, append, append, appendS, backpressureAware, broadcast, cast, changes, coflatMap, collectAll, collectStream, combinations, combinations, combinationsT, combinationsT, combine, combine, complete, concat, concat, concat, concat, concatDoubles, concatInts, concatLongs, coproduct, count, crossJoin, cycle, cycle, cycle, cycleUntil, cycleWhile, deferred, deferredI, deferredP, deleteBetween, distinct, distinct, doubles, drop, dropRight, dropUntil, dropWhile, duplicate, duplicate, elapsed, elementAt, empty, enqueued, enqueued, enqueued, enqueuedAll, enums, enums, enums, enumsFromTo, fanOut, fanOut, fanOut, fanOutZipIn, fanOutZipIn, fanOutZipIn, fill, filter, filterInts, filterLongs, filterLongs, filterNot, findFirst, findFirstOrError, findOne, flatMap, flatMapAnyM, flatMapDoubles, flatMapI, flatMapInts, flatMapLongs, flatMapP, flatMapP, flatten, flattenI, flattenO, foldJool, foldParallel, foldParallel, forEach, forEach2, forEach2, forEach3, forEach3, forEach4, forEach4, forEachAsync, format, fromCharSequence, fromDoubleStream, fromIntStream, fromIterable, fromIterator, fromList, fromLongStream, fromPublisher, fromSpliterator, fromStream, generate, generate, get, groupBy, grouped, grouped, grouped, grouped, groupedBySizeAndTime, groupedBySizeAndTime, groupedBySizeAndTime, groupedByTime, groupedByTime, groupedByTime, groupedStatefullyUntil, groupedStatefullyUntil, groupedStatefullyWhile, groupedStatefullyWhile, groupedUntil, groupedUntil, groupedWhile, groupedWhile, hotStream, insertAt, insertAtS, intersperse, ints, isEmpty, isReplayable, iterate, iterate, jool, kindCokleisli, kindKleisli, liftM, limit, limit, limitDouble, limitInts, limitLast, limitLongs, limitUntil, limitUntilClosed, limitWhile, limitWhileClosed, longs, map, mapDoubles, mapInts, mapLongs, mapM, merge, mergeP, mergeP, multicast, narrowK, nested, notNull, of, of, ofDoubles, ofInts, ofLongs, ofNullable, ofType, onEmpty, onEmptyGet, onEmptySwitch, onEmptyThrow, oneShotList, oneShotStream, parallel, parallel, parallelFanOut, parallelFanOut, parallelFanOut, parallelFanOutZipIn, parallelFanOutZipIn, parallelFanOutZipIn, partition, pausableHotStream, peek, permutations, permutationsT, prepend, prepend, prepend, prependS, primedHotStream, primedPausableHotStream, print, print, printErr, printOut, product, product, publishTo, publishTo, quadruplicate, quadruplicate, range, range, rangeLong, rangeLong, reactiveSeq, recover, recover, reduce, reduceAll, remove, removeAll, removeAllI, removeAllS, retainAll, retainAllI, retainAllS, retry, retry, reverse, reversedListOf, reversedOf, scanLeft, scanLeft, scanRight, scanRight, schedule, scheduleFixedDelay, scheduleFixedRate, seq, shuffle, shuffle, single, single, singleUnsafe, size, skip, skip, skipDoubles, skipInts, skipLast, skipLongs, skipUntil, skipUntilClosed, skipWhile, skipWhileClosed, slice, sliding, sliding, sorted, sorted, sorted, splitAt, splitAtHead, splitBy, spliterator, subStream, tailRec, take, takeOne, takeRight, takeUntil, takeWhile, timestamp, trampoline, triplicate, triplicate, unfold, unit, unzip, unzip3, unzip4, visit, widen, zip, zip, zip, zip3, zip3, zip4, zip4, zipLatest, zipP, zipP, zipS, zipS, zipWith, zipWithIndex, zipWithP, zipWithS

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

Methods inherited from interface java.util.stream.Stream
builder

Methods inherited from interface java.util.stream.BaseStream
iterator

Methods inherited from interface com.aol.cyclops2.types.traversable.FoldableTraversable
asFunction, foldFuture, foldLazy, foldTry, forEach, forEach, forEach, forEach, forEach, forEachSubscribe, forEachSubscribe, forEachSubscribe, runFuture, runLazy, toListX, toSetX, visit

Methods inherited from interface com.aol.cyclops2.types.foldable.CyclopsCollectable
collectors, commonPrefix, commonSuffix, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, mode, sum, sumDouble, sumInt, sumLong, to, toMap, toMap, toString, toString

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

Methods inherited from interface com.aol.cyclops2.types.traversable.Traversable
subscribe, traversable, unitIterator

Methods inherited from interface java.lang.Iterable
iterator

Methods inherited from interface com.aol.cyclops2.types.functor.TransformerTraversable
groupedStatefullyUntilT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingT

Methods inherited from interface com.aol.cyclops2.hkt.Higher
applyHKT_, applyHKT, applyHKT

Methods inherited from interface com.aol.cyclops2.hkt.Convert
convert

- Constructor Detail
  - BaseExtendedStream
```
public BaseExtendedStream()
```
- Method Detail
  - unwrapStream
```
public abstract java.util.stream.Stream<T> unwrapStream()
```
  - parallel
```
public final ReactiveSeq<T> parallel()
```
    Specified by:
    
    parallel in interface ReactiveSeq<T>
    
    Specified by:
    
    parallel in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>
    
    Returns:
    
    Does nothing ReactiveSeq is for Sequential Streams
  - endsWithIterable
```
public boolean endsWithIterable(java.lang.Iterable<T> iterable)
```
    Description copied from interface: ReactiveSeq
```
 
  assertTrue(ReactiveSeq.of(1,2,3,4,5,6)
 				.endsWith(Arrays.asList(5,6)));

 
```
    Specified by:
    
    endsWithIterable in interface Folds<T>
    
    Specified by:
    
    endsWithIterable in interface ReactiveSeq<T>
    
    Parameters:
    
    iterable - Values to check
    
    Returns:
    
    true if ReactiveSeq ends with values in the supplied iterable
  - allMatch
```
public boolean allMatch(java.util.function.Predicate<? super T> c)
```
    Description copied from interface: ReactiveSeq
    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 CyclopsCollectable<T>
    
    Specified by:
    
    allMatch in interface ReactiveSeq<T>
    
    Specified by:
    
    allMatch in interface java.util.stream.Stream<T>
    
    Parameters:
    
    c - Predicate to check if all match
  - anyMatch
```
public boolean anyMatch(java.util.function.Predicate<? super T> c)
```
    Description copied from interface: ReactiveSeq
    True if a singleUnsafe 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 CyclopsCollectable<T>
    
    Specified by:
    
    anyMatch in interface ReactiveSeq<T>
    
    Specified by:
    
    anyMatch in interface java.util.stream.Stream<T>
    
    Parameters:
    
    c - Predicate to check if any match
  - xMatch
```
public boolean xMatch(int num,
                      java.util.function.Predicate<? super T> c)
```
    Description copied from interface: ReactiveSeq
    Check that there are specified number of matches of predicate in the Stream
```
 
  assertTrue(ReactiveSeq.of(1,2,3,5,6,7).xMatch(3, i-> i>4 ));
 
 
```
    Specified by:
    
    xMatch in interface Folds<T>
    
    Specified by:
    
    xMatch in interface ReactiveSeq<T>
  - noneMatch
```
public final boolean noneMatch(java.util.function.Predicate<? super T> c)
```
    Specified by:
    
    noneMatch in interface CyclopsCollectable<T>
    
    Specified by:
    
    noneMatch in interface ReactiveSeq<T>
    
    Specified by:
    
    noneMatch in interface java.util.stream.Stream<T>
  - join
```
public final java.lang.String join()
```
    Description copied from interface: ReactiveSeq
```
 
  assertEquals("123".length(),ReactiveSeq.of(1, 2, 3).join().length());
 
 
```
    Specified by:
    
    join in interface Folds<T>
    
    Specified by:
    
    join in interface ReactiveSeq<T>
    
    Returns:
    
    Stream as concatenated String
  - join
```
public final java.lang.String join(java.lang.String sep)
```
    Description copied from interface: ReactiveSeq
```
 
 assertEquals("1, 2, 3".length(), ReactiveSeq.of(1, 2, 3).join(", ").length());
 
 
```
    Specified by:
    
    join in interface Folds<T>
    
    Specified by:
    
    join in interface ReactiveSeq<T>
    
    Returns:
    
    Stream as concatenated String
  - join
```
public final java.lang.String join(java.lang.String sep,
                                   java.lang.String start,
                                   java.lang.String end)
```
    Description copied from interface: ReactiveSeq
```
 
 assertEquals("^1|2|3$".length(), of(1, 2, 3).join("|", "^", "$").length());
 
 
```
    Specified by:
    
    join in interface Folds<T>
    
    Specified by:
    
    join in interface ReactiveSeq<T>
    
    Returns:
    
    Stream as concatenated String
  - minBy
```
public final <U extends java.lang.Comparable<? super U>> java.util.Optional<T> minBy(java.util.function.Function<? super T,? extends U> function)
```
    Description copied from interface: CyclopsCollectable
    
    Get the minimum value by a function.
    
    Specified by:
    
    minBy in interface CyclopsCollectable<T>
  - min
```
public final java.util.Optional<T> min(java.util.Comparator<? super T> comparator)
```
    Description copied from interface: CyclopsCollectable
    
    Get the minimum value by a function.
    
    Specified by:
    
    min in interface CyclopsCollectable<T>
    
    Specified by:
    
    min in interface ReactiveSeq<T>
    
    Specified by:
    
    min in interface java.util.stream.Stream<T>
  - maxBy
```
public final <C extends java.lang.Comparable<? super C>> java.util.Optional<T> maxBy(java.util.function.Function<? super T,? extends C> f)
```
    Description copied from interface: CyclopsCollectable
    
    Get the maximum value by a function.
    
    Specified by:
    
    maxBy in interface CyclopsCollectable<T>
  - max
```
public final java.util.Optional<T> max(java.util.Comparator<? super T> comparator)
```
    Description copied from interface: CyclopsCollectable
    
    Get the maximum value by a function.
    
    Specified by:
    
    max in interface CyclopsCollectable<T>
    
    Specified by:
    
    max in interface ReactiveSeq<T>
    
    Specified by:
    
    max in interface java.util.stream.Stream<T>
  - headAndTail
```
public final HeadAndTail<T> headAndTail()
```
    Description copied from interface: FoldableTraversable
    extract head and tail together, where head is expected to be present Example :
```
 
  ReactiveSeq<String> helloWorld = ReactiveSeq.Of("hello","world","last");
    HeadAndTail<String> headAndTail = helloWorld.headAndTail();
    String head = headAndTail.head();

    //head == "hello"

    ReactiveSeq<String> tail =  headAndTail.tail();
    //["world","last]

    
  
```
    Specified by:
    
    headAndTail in interface FoldableTraversable<T>
    
    Specified by:
    
    headAndTail in interface ReactiveSeq<T>
    
    Returns:
  - findAny
```
public final java.util.Optional<T> findAny()
```
    Specified by:
    
    findAny in interface Folds<T>
    
    Specified by:
    
    findAny in interface ReactiveSeq<T>
    
    Specified by:
    
    findAny in interface java.util.stream.Stream<T>
    
    Returns:
    first matching element, but order is not guaranteed
    ReactiveSeq.of(1,2,3,4,5).filter(it -> it <3).findAny().get(); //3
    (non-deterministic)
  - mapReduce
```
public final <R> R mapReduce(Reducer<R> reducer)
```
    Description copied from interface: ReactiveSeq
    Attempt to map this Sequence to the same type as the supplied Monoid (Reducer) Then use Monoid to reduce values
```
 
 ReactiveSeq.of("hello","2","world","4").mapReduce(Reducers.toCountInt());

 //4
 
 
```
    Specified by:
    
    mapReduce in interface Folds<T>
    
    Specified by:
    
    mapReduce in interface ReactiveSeq<T>
    
    Parameters:
    
    reducer - Monoid to reduce values
    
    Returns:
    
    Reduce result
  - mapReduce
```
public final <R> R mapReduce(java.util.function.Function<? super T,? extends R> mapper,
                             Monoid<R> reducer)
```
    Description copied from interface: ReactiveSeq
    Attempt to map this Monad to the same type as the supplied Monoid, using supplied function Then use Monoid to reduce values
```
  
  ReactiveSeq.of("one","two","three","four")
           .mapReduce(this::toInt,Reducers.toTotalInt());

  //10

  int toInt(String s){
 		if("one".equals(s))
 			return 1;
 		if("two".equals(s))
 			return 2;
 		if("three".equals(s))
 			return 3;
 		if("four".equals(s))
 			return 4;
 		return -1;
 	   }
  
 
```
    Specified by:
    
    mapReduce in interface Folds<T>
    
    Specified by:
    
    mapReduce in interface ReactiveSeq<T>
    
    Parameters:
    
    mapper - Function to map Monad type
    
    reducer - Monoid to reduce values
    
    Returns:
    
    Reduce result
  - collect
```
public <R,A> R collect(java.util.stream.Collector<? super T,A,R> collector)
```
    Description copied from interface: ReactiveSeq
    
    Performs a mutable reduction operation on the elements of this reactiveStream using a Collector. A Collector encapsulates the function used as arguments to ReactiveSeq.collect(Supplier, BiConsumer, BiConsumer), allowing for reuse of toX strategies and composition of collect operations such as multiple-level grouping or partitioning.
    
    If the reactiveStream is parallel, and the Collector is concurrent, and lazy the reactiveStream is unordered or the collector is unordered, applyHKT a concurrent reduction will be performed (see Collector for details on concurrent reduction.)
    
    This is a terminal operation.
    
    When executed in parallel, multiple intermediate results may be instantiated, populated, and merged so as to maintain isolation of mutable data structures. Therefore, even when executed in parallel with non-thread-safe data structures (such as ArrayList), no additional synchronization is needed for a parallel reduction.
    
    Specified by:
    
    collect in interface CyclopsCollectable<T>
    
    Specified by:
    
    collect in interface ReactiveSeq<T>
    
    Specified by:
    
    collect in interface java.util.stream.Stream<T>
    
    Parameters:
    
    collector - the Collector describing the reduction
    
    Returns:
    
    the result of the reduction
    
    See Also:
    
    ReactiveSeq.collect(Supplier, BiConsumer, BiConsumer), Collectors
  - collect
```
public <R> R collect(java.util.function.Supplier<R> supplier,
                     java.util.function.BiConsumer<R,? super T> accumulator,
                     java.util.function.BiConsumer<R,R> combiner)
```
    Description copied from interface: ReactiveSeq
    Performs a mutable reduction operation on the elements of this reactiveStream. A mutable reduction is one in which the reduced value is a mutable result container, such as an ArrayList, and elements are incorporated by updating the state of the result rather than by replacing the result. This produces a result equivalent to:
```
     R result = supplier.get();
     for (T element : this reactiveStream)
         accumulator.accept(result, element);
     return result;
 
```
    Like ReactiveSeq.reduce(Object, BinaryOperator), collect operations can be parallelized without requiring additional synchronization.
    
    This is a terminal operation.
    Specified by:
    
    collect in interface ReactiveSeq<T>
    
    Specified by:
    
    collect in interface java.util.stream.Stream<T>
    
    Parameters:
    
    supplier - a function that creates a new result container. For a parallel execution, this function may be called multiple times and must return a fresh value each time.
    
    accumulator - an associative, non-interfering, stateless function for incorporating an additional element into a result
    
    combiner - an associative, non-interfering, stateless function for combining two values, which must be compatible with the accumulator function
    
    Returns:
    
    the result of the reduction
  - reduce
```
public final T reduce(Monoid<T> reducer)
```
    Description copied from interface: ReactiveSeq
```
 
 ReactiveSeq.of("hello","2","world","4").reduce(Reducers.toString(","));

 //hello,2,world,4
 
 
```
    Specified by:
    
    reduce in interface Folds<T>
    
    Specified by:
    
    reduce in interface ReactiveSeq<T>
    
    Parameters:
    
    reducer - Use supplied Monoid to reduce values
    
    Returns:
    
    reduced values
  - reduce
```
public <U> U reduce(U identity,
                    java.util.function.BiFunction<U,? super T,U> accumulator,
                    java.util.function.BinaryOperator<U> combiner)
```
    Description copied from interface: Folds
    
    An equivalent function to Stream.reduce(Object, BiFunction, BinaryOperator)
    
    Specified by:
    
    reduce in interface Folds<T>
    
    Specified by:
    
    reduce in interface ReactiveSeq<T>
    
    Specified by:
    
    reduce in interface java.util.stream.Stream<T>
  - reduce
```
public final ListX<T> reduce(java.util.stream.Stream<? extends Monoid<T>> reducers)
```
    Description copied from interface: ReactiveSeq
    Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first. I.e. streamedMonad().reduce(reducer)
```
 
  Monoid<Integer> sum = Monoid.of(0, (a, b) -> a + b);
  Monoid<Integer> mult = Monoid.of(1, (a, b) -> a * b);
  List<Integer> result = ReactiveSeq.of(1, 2, 3, 4).reduce(Arrays.asList(sum, mult).reactiveStream());

  assertThat(result, equalTo(Arrays.asList(10, 24)));

 
 
```
    Specified by:
    
    reduce in interface Folds<T>
    
    Specified by:
    
    reduce in interface ReactiveSeq<T>
    
    Returns:
    
    List of reduced values
  - reduce
```
public final ListX<T> reduce(java.lang.Iterable<? extends Monoid<T>> reducers)
```
    Description copied from interface: ReactiveSeq
    Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first. I.e. streamedMonad().reduce(reducer)
```
 
 Monoid<Integer> sum = Monoid.of(0,(a,b)->a+b);
 		Monoid<Integer> mult = Monoid.of(1,(a,b)->a*b);
 		List<Integer> result = ReactiveSeq.of(1,2,3,4))
 										.reduce(Arrays.asList(sum,mult) );


 		assertThat(result,equalTo(Arrays.asList(10,24)));

 
```
    Specified by:
    
    reduce in interface Folds<T>
    
    Specified by:
    
    reduce in interface ReactiveSeq<T>
    
    Returns:
  - foldLeft
```
public final T foldLeft(Monoid<T> reducer)
```
    Specified by:
    
    foldLeft in interface Folds<T>
  - foldLeft
```
public final T foldLeft(T identity,
                        java.util.function.BinaryOperator<T> accumulator)
```
    Specified by:
    
    foldLeft in interface Folds<T>
  - foldLeftMapToType
```
public final <T> T foldLeftMapToType(Reducer<T> reducer)
```
  - foldRight
```
public final T foldRight(Monoid<T> reducer)
```
    Description copied from interface: ReactiveSeq
```
                
 		ReactiveSeq.of("a","b","c").foldRight(Reducers.toString(""));

         // "cab"
         
 
```
    Specified by:
    
    foldRight in interface Folds<T>
    
    Specified by:
    
    foldRight in interface ReactiveSeq<T>
    
    Parameters:
    
    reducer - Use supplied Monoid to reduce values starting via foldRight
    
    Returns:
    
    Reduced result
  - foldRight
```
public final <U> U foldRight(U seed,
                             java.util.function.BiFunction<? super T,? super U,? extends U> function)
```
    Description copied from interface: Folds
    
    Immutable reduction from right to left
    
    Specified by:
    
    foldRight in interface Folds<T>
    
    Specified by:
    
    foldRight in interface ReactiveSeq<T>
    
    Parameters:
    
    seed - Identity value for the combiner function (leaves the input unchanged)
    
    function - Combining function
    
    Returns:
    
    Reduced value
  - foldRightMapToType
```
public final <T> T foldRightMapToType(Reducer<T> reducer)
```
    Description copied from interface: ReactiveSeq
    Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
```
                
 		ReactiveSeq.of(1,2,3).foldRightMapToType(Reducers.toString(""));

         // "321"
         
 
```
    Specified by:
    
    foldRightMapToType in interface Folds<T>
    
    Specified by:
    
    foldRightMapToType in interface ReactiveSeq<T>
    
    Parameters:
    
    reducer - Monoid to reduce values
    
    Returns:
    
    Reduce result
  - toSet
```
public final java.util.Set<T> toSet()
```
    Description copied from interface: CyclopsCollectable
    
    Collect the collectable into a LinkedHashSet.
    
    Specified by:
    
    toSet in interface CyclopsCollectable<T>
    
    Specified by:
    
    toSet in interface ReactiveSeq<T>
    
    Returns:
    
    This Stream converted to a set
  - toList
```
public final java.util.List<T> toList()
```
    Description copied from interface: CyclopsCollectable
    
    Collect the collectable into an ArrayList.
    
    Specified by:
    
    toList in interface CyclopsCollectable<T>
    
    Specified by:
    
    toList in interface ReactiveSeq<T>
    
    Returns:
    
    this Stream converted to a list
  - stream
```
public final ReactiveSeq<T> stream()
```
    Description copied from interface: ReactiveSeq
    
    Convert this ReactiveSeq into a Stream
    
    Specified by:
    
    stream in interface Folds<T>
    
    Specified by:
    
    stream in interface TransformerTraversable<T>
    
    Specified by:
    
    stream in interface ExtendedTraversable<T>
    
    Specified by:
    
    stream in interface FoldableTraversable<T>
    
    Specified by:
    
    stream in interface Sequential<T>
    
    Specified by:
    
    stream in interface Traversable<T>
    
    Specified by:
    
    stream in interface ReactiveSeq<T>
    
    Returns:
    
    This Traversable converted to a Stream
  - startsWithIterable
```
public final boolean startsWithIterable(java.lang.Iterable<T> iterable)
```
    Description copied from interface: ReactiveSeq
```
 
  assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Arrays.asList(1,2,3)));
 
 
```
    Specified by:
    
    startsWithIterable in interface Folds<T>
    
    Specified by:
    
    startsWithIterable in interface ReactiveSeq<T>
    
    Returns:
    
    True if Monad starts with Iterable sequence of data
  - startsWith
```
public final boolean startsWith(java.util.stream.Stream<T> stream2)
```
    Description copied from interface: ReactiveSeq
```
  assertTrue(ReactiveSeq.of(1,2,3,4).startsWith(Stream.of(1,2,3))) 
 
```
    Specified by:
    
    startsWith in interface Folds<T>
    
    Specified by:
    
    startsWith in interface ReactiveSeq<T>
    
    Parameters:
    
    stream2 - Stream to check if this Folds has the same elements in the same order, at the skip
    
    Returns:
    
    True if Monad starts with Iterators sequence of data
  - anyM
```
public AnyMSeq<Witness.reactiveSeq,T> anyM()
```
    Specified by:
    
    anyM in interface ReactiveSeq<T>
    
    Returns:
    
    this ReactiveSeq converted to AnyM format
  - flatMapStream
```
public final <R> ReactiveSeq<R> flatMapStream(java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn)
```
    Description copied from interface: ReactiveSeq
    flatMap operation
```
 
 	assertThat(ReactiveSeq.of(1,2,3)
                      .flatMapStream(i->IntStream.of(i))
                      .toList(),equalTo(Arrays.asList(1,2,3)));

 
 
```
    Specified by:
    
    flatMapStream in interface ReactiveSeq<T>
    
    Parameters:
    
    fn - to be applied
    
    Returns:
    
    new stage in Sequence with flatMap operation to be lazily applied
  - flatMapOptional
```
public final <R> ReactiveSeq<R> flatMapOptional(java.util.function.Function<? super T,java.util.Optional<? extends R>> fn)
```
  - createSeq
```
protected abstract <R> ReactiveSeq<R> createSeq(java.util.stream.Stream<R> rStream)
```
  - flatMapCompletableFuture
```
public final <R> ReactiveSeq<R> flatMapCompletableFuture(java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn)
```
  - flatMapCharSequence
```
public final ReactiveSeq<java.lang.Character> flatMapCharSequence(java.util.function.Function<? super T,java.lang.CharSequence> fn)
```
  - flatMapFile
```
public final ReactiveSeq<java.lang.String> flatMapFile(java.util.function.Function<? super T,java.io.File> fn)
```
  - flatMapURL
```
public final ReactiveSeq<java.lang.String> flatMapURL(java.util.function.Function<? super T,java.net.URL> fn)
```
  - flatMapBufferedReader
```
public final ReactiveSeq<java.lang.String> flatMapBufferedReader(java.util.function.Function<? super T,java.io.BufferedReader> fn)
```
  - isParallel
```
public boolean isParallel()
```
    Specified by:
    
    isParallel in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>
  - sequential
```
public ReactiveSeq<T> sequential()
```
    Specified by:
    
    sequential in interface ReactiveSeq<T>
    
    Specified by:
    
    sequential in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>
  - unordered
```
public ReactiveSeq<T> unordered()
```
    Specified by:
    
    unordered in interface ReactiveSeq<T>
    
    Specified by:
    
    unordered in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>
  - mapToInt
```
public java.util.stream.IntStream mapToInt(java.util.function.ToIntFunction<? super T> mapper)
```
    Specified by:
    
    mapToInt in interface Traversable<T>
    
    Specified by:
    
    mapToInt in interface ReactiveSeq<T>
    
    Specified by:
    
    mapToInt in interface java.util.stream.Stream<T>
  - mapToLong
```
public java.util.stream.LongStream mapToLong(java.util.function.ToLongFunction<? super T> mapper)
```
    Specified by:
    
    mapToLong in interface Traversable<T>
    
    Specified by:
    
    mapToLong in interface ReactiveSeq<T>
    
    Specified by:
    
    mapToLong in interface java.util.stream.Stream<T>
  - mapToDouble
```
public java.util.stream.DoubleStream mapToDouble(java.util.function.ToDoubleFunction<? super T> mapper)
```
    Specified by:
    
    mapToDouble in interface Traversable<T>
    
    Specified by:
    
    mapToDouble in interface ReactiveSeq<T>
    
    Specified by:
    
    mapToDouble in interface java.util.stream.Stream<T>
  - flatMapToInt
```
public java.util.stream.IntStream flatMapToInt(java.util.function.Function<? super T,? extends java.util.stream.IntStream> mapper)
```
    Specified by:
    
    flatMapToInt in interface java.util.stream.Stream<T>
  - flatMapToLong
```
public java.util.stream.LongStream flatMapToLong(java.util.function.Function<? super T,? extends java.util.stream.LongStream> mapper)
```
    Specified by:
    
    flatMapToLong in interface java.util.stream.Stream<T>
  - flatMapToDouble
```
public java.util.stream.DoubleStream flatMapToDouble(java.util.function.Function<? super T,? extends java.util.stream.DoubleStream> mapper)
```
    Specified by:
    
    flatMapToDouble in interface java.util.stream.Stream<T>
  - forEachOrdered
```
public void forEachOrdered(java.util.function.Consumer<? super T> action)
```
    Specified by:
    
    forEachOrdered in interface java.util.stream.Stream<T>
  - toArray
```
public java.lang.Object[] toArray()
```
    Specified by:
    
    toArray in interface java.util.stream.Stream<T>
  - toArray
```
public <A> A[] toArray(java.util.function.IntFunction<A[]> generator)
```
    Specified by:
    
    toArray in interface java.util.stream.Stream<T>
  - onClose
```
public ReactiveSeq<T> onClose(java.lang.Runnable closeHandler)
```
    Specified by:
    
    onClose in interface ReactiveSeq<T>
    
    Specified by:
    
    onClose in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>
  - close
```
public void close()
```
    Specified by:
    
    close in interface java.lang.AutoCloseable
    
    Specified by:
    
    close in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>
  - xPer
```
public ReactiveSeq<T> xPer(int x,
                           long time,
                           java.util.concurrent.TimeUnit t)
```
    Description copied from interface: ReactiveSeq
    emit x elements per time period
```
 
 	code
 	SimpleTimer timer = new SimpleTimer();
 	ReactiveSeq.of(1, 2, 3, 4, 5, 6)
             .xPer(6, 100000000, TimeUnit.NANOSECONDS)
             .collect(CyclopsCollectors.toList())
             .size();
 //6

 
 
```
    Specified by:
    
    xPer in interface Sequential<T>
    
    Specified by:
    
    xPer in interface ReactiveSeq<T>
    
    Parameters:
    
    x - number of elements to emit
    
    time - period
    
    t - Time unit
    
    Returns:
    
    ReactiveSeq that emits x elements per time period
  - sorted
```
public final ReactiveSeq<T> sorted()
```
    Description copied from interface: ReactiveSeq
```
  assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); 
 
```
    Specified by:
    
    sorted in interface Traversable<T>
    
    Specified by:
    
    sorted in interface ReactiveSeq<T>
    
    Specified by:
    
    sorted in interface java.util.stream.Stream<T>
  - mapLazyFn
```
public abstract <R> ReactiveSeq<R> mapLazyFn(java.util.function.Supplier<java.util.function.Function<? super T,? extends R>> fn)
```
  - filterLazyPredicate
```
public abstract ReactiveSeq<T> filterLazyPredicate(java.util.function.Supplier<java.util.function.Predicate<? super T>> fn)
```
  - onePer
```
public ReactiveSeq<T> onePer(long time,
                             java.util.concurrent.TimeUnit t)
```
    Description copied from interface: ReactiveSeq
    emit one element per time period
```
 
 ReactiveSeq.iterate("", last -> "next")
 				.limit(100)
 				.batchBySize(10)
 				.onePer(1, TimeUnit.MICROSECONDS)
 				.peek(batch -> System.out.println("batched : " + batch))
 				.flatMap(Collection::reactiveStream)
 				.peek(individual -> System.out.println("Flattened : "
 						+ individual))
 				.forEach(a->{});
 
```
    Specified by:
    
    onePer in interface Sequential<T>
    
    Specified by:
    
    onePer in interface ReactiveSeq<T>
    
    Parameters:
    
    time - period
    
    t - Time unit
    
    Returns:
    
    ReactiveSeq that emits 1 element per time period
  - debounce
```
public ReactiveSeq<T> debounce(long time,
                               java.util.concurrent.TimeUnit t)
```
    Description copied from interface: ReactiveSeq
    Allow one element through per time period, drop all other elements in that time period
```
 
 ReactiveSeq.of(1,2,3,4,5,6)
          .debounce(1000,TimeUnit.SECONDS).toList();

 // 1
 
 
```
    Specified by:
    
    debounce in interface ReactiveSeq<T>
    
    Parameters:
    
    time - Time to applyHKT debouncing over
    
    t - Time unit for debounce period
    
    Returns:
    
    ReactiveSeq with debouncing applied
  - fixedDelay
```
public ReactiveSeq<T> fixedDelay(long l,
                                 java.util.concurrent.TimeUnit unit)
```
    Description copied from interface: ReactiveSeq
    emit elements after a fixed delay
```
 
 	SimpleTimer timer = new SimpleTimer();
 	ReactiveSeq.of(1, 2, 3, 4, 5, 6)
             .fixedDelay(10000, TimeUnit.NANOSECONDS)
             .collect(CyclopsCollectors.toList())
             .size();
  //6
 	assertThat(timer.getElapsedNanoseconds(), greaterThan(60000l));
 
 
```
    Specified by:
    
    fixedDelay in interface Sequential<T>
    
    Specified by:
    
    fixedDelay in interface ReactiveSeq<T>
    
    Parameters:
    
    l - time length in nanos of the delay
    
    unit - for the delay
    
    Returns:
    
    ReactiveSeq that emits each element after a fixed delay
  - jitter
```
public ReactiveSeq<T> jitter(long l)
```
    Description copied from interface: ReactiveSeq
    Introduce a random jitter / time delay between the emission of elements
```
 { @code
        SimpleTimer timer = new SimpleTimer();
        ReactiveSeq.of(1, 2, 3, 4, 5, 6)
             .jitter(10000)
             .collect(CyclopsCollectors.toList());

        assertThat(timer.getElapsedNanoseconds(), greaterThan(20000l));
 }
 
```
    Specified by:
    
    jitter in interface ReactiveSeq<T>
    
    Parameters:
    
    l - - random number less than this is used for each jitter
    
    Returns:
    
    ReactiveSeq with a random jitter between element emission
  - foldRight
```
public T foldRight(T identity,
                   java.util.function.BinaryOperator<T> accumulator)
```
    Description copied from interface: ReactiveSeq
    Immutable reduction from right to left
```
 
  assertTrue(ReactiveSeq.of("a","b","c").foldRight("", String::concat).equals("cba"));
 
 
```
    Specified by:
    
    foldRight in interface Folds<T>
    
    Specified by:
    
    foldRight in interface ReactiveSeq<T>
    
    Parameters:
    
    identity - Identity value for the combiner function (leaves the input unchanged)
    
    accumulator - Combining function
    
    Returns:
    
    Reduced value
  - endsWith
```
public boolean endsWith(java.util.stream.Stream<T> iterable)
```
    Description copied from interface: ReactiveSeq
```
 
 assertTrue(ReactiveSeq.of(1,2,3,4,5,6)
 				.endsWith(Stream.of(5,6)));
 
 
```
    Specified by:
    
    endsWith in interface Folds<T>
    
    Specified by:
    
    endsWith in interface ReactiveSeq<T>
    
    Parameters:
    
    iterable - Values to check
    
    Returns:
    
    true if ReactiveSeq endswith values in the supplied Stream
  - firstValue
```
public T firstValue()
```
    Description copied from interface: ReactiveSeq
```
 
 	assertThat(ReactiveSeq.of(1,2,3,4)
 					.map(u->{throw new RuntimeException();})
 					.recover(e->"hello")
 					.firstValue(),equalTo("hello"));
 
 
```
    Specified by:
    
    firstValue in interface Folds<T>
    
    Specified by:
    
    firstValue in interface ReactiveSeq<T>
    
    Returns:
    
    first value in this Stream
  - reduce
```
public java.util.Optional<T> reduce(java.util.function.BinaryOperator<T> accumulator)
```
    Description copied from interface: Folds
    An equivalent function to Stream.reduce(BinaryOperator)
```
 
  
       ReactiveSeq.of(1,2,3,4,5).map(it -> it*100).reduce(
 (acc,next) -> acc+next)
        //Optional[1500]
  
  
```
    Specified by:
    
    reduce in interface Folds<T>
    
    Specified by:
    
    reduce in interface ReactiveSeq<T>
    
    Specified by:
    
    reduce in interface java.util.stream.Stream<T>
    
    Parameters:
    
    accumulator - Combiner function
    
    Returns:
  - reduce
```
public T reduce(T identity,
                java.util.function.BinaryOperator<T> accumulator)
```
    Description copied from interface: Folds
    
    An equivalent function to Stream.reduce(Object, BinaryOperator)
    
    Specified by:
    
    reduce in interface Folds<T>
    
    Specified by:
    
    reduce in interface ReactiveSeq<T>
    
    Specified by:
    
    reduce in interface java.util.stream.Stream<T>
    
    accumulator - Combiner function
    
    Returns:
    
    Value emitted by applying the current accumulated value and the next value to the combiner function as this Folds is traversed from left to right

Class BaseExtendedStream<T>

Nested Class Summary

Nested classes/interfaces inherited from interface cyclops.stream.ReactiveSeq

Nested classes/interfaces inherited from interface java.util.stream.Stream

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Methods inherited from interface cyclops.stream.ReactiveSeq

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

Methods inherited from interface java.util.stream.Stream

Methods inherited from interface java.util.stream.BaseStream

Methods inherited from interface com.aol.cyclops2.types.traversable.FoldableTraversable

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

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

Methods inherited from interface com.aol.cyclops2.types.traversable.Traversable

Methods inherited from interface java.lang.Iterable

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

Methods inherited from interface com.aol.cyclops2.hkt.Higher

Methods inherited from interface com.aol.cyclops2.hkt.Convert

Constructor Detail

BaseExtendedStream

Method Detail

unwrapStream

parallel

endsWithIterable

allMatch

anyMatch

xMatch

noneMatch

join

join

join

minBy

min

maxBy

max

headAndTail

findAny

mapReduce

mapReduce

collect

collect

reduce

reduce

reduce

reduce

foldLeft

foldLeft

foldLeftMapToType

foldRight

foldRight

foldRightMapToType

toSet

toList

stream

startsWithIterable

startsWith

anyM

flatMapStream

flatMapOptional

createSeq

flatMapCompletableFuture

flatMapCharSequence

flatMapFile

flatMapURL

flatMapBufferedReader

isParallel

sequential

unordered

mapToInt

mapToLong

mapToDouble

flatMapToInt

flatMapToLong

flatMapToDouble

forEachOrdered

toArray

toArray

onClose