BaseExtendedStream (cyclops 10.3.2 API)

java.lang.Object
- com.oath.cyclops.internal.stream.BaseExtendedStream<T>

All Implemented Interfaces:

Convert<Higher<DataWitness.reactiveSeq,T>>, Higher<DataWitness.reactiveSeq,T>, Unit<T>, Filters<T>, Contains<T>, Folds<T>, To<ReactiveSeq<T>>, FilterableTransformable<T>, ReactiveTransformable<T>, Transformable<T>, ReactiveStreamsTerminalOperations<T>, OnEmpty<T>, OnEmptySwitch<T,java.util.stream.Stream<T>>, IterableFilterable<T>, IterableX<T>, RecoverableTraversable<T>, Traversable<T>, Unwrapable, Zippable<T>, ReactiveSeq<T>, io.kindedj.Hk<DataWitness.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 java.util.stream.Stream
  java.util.stream.Stream.Builder<T>

Field Summary
- Fields inherited from interface cyclops.reactive.ReactiveSeq
  empty

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
`boolean`	`anyMatch(java.util.function.Predicate<? super T> c)` True if a single 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 stream 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 stream.
`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.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(T alt)` `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
`<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)`
`T`	`foldLeft(Monoid<T> reducer)`
`T`	`foldLeft(T identity, java.util.function.BinaryOperator<T> accumulator)`
`<R> R`	`foldLeftMapToType(Reducer<R,T> reducer)`
`<R> R`	`foldMap(java.util.function.Function<? super T,? extends R> mapper, Monoid<R> reducer)` `ReactiveSeq.of("one","two","three","four") .foldMap(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; }`
`<R> R`	`foldMap(Reducer<R,T> reducer)` `ReactiveSeq.of("hello","2","world","4").foldMap(Reducers.toCountInt()); //4`
`<R> R`	`foldMapRight(Reducer<R,T> reducer)` Attempt to transform this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
`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
`void`	`forEachOrdered(java.util.function.Consumer<? super T> action)`
`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)`
`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)`
`java.util.Optional<T>`	`min(java.util.Comparator<? super T> comparator)`
`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)`
`Seq<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`
`T`	`reduce(T identity, java.util.function.BinaryOperator<T> accumulator)`
`<U> U`	`reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator, java.util.function.BinaryOperator<U> combiner)`
`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.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()`
`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.oath.cyclops.types.Unwrapable
unwrap, unwrapIfInstance, unwrapNested

Methods inherited from interface cyclops.reactive.ReactiveSeq
ambWith, ambWith, append, appendAll, appendAll, appendStream, backpressureAware, broadcast, changes, coflatMap, collectAll, combinations, combinations, combine, combine, concat, concat, concat, concat, concatDoubles, concatInts, concatLongs, concatMap, concatMapnts, count, crossJoin, cycle, cycle, cycle, cycleUntil, cycleWhile, defer, deferFromPublisher, deferFromStream, deleteBetween, distinct, distinct, doubles, drop, drop, dropRight, dropUntil, dropUntilInclusive, dropWhile, dropWhileInclusive, duplicate, duplicate, elapsed, elementAt, elementAtAndStream, empty, enqueued, enqueued, enqueued, enqueuedAll, enums, enums, enums, enumsFromTo, fanOut, fanOut, fanOut, fanOutZipIn, fanOutZipIn, fanOutZipIn, fill, filter, filterInts, filterLongs, filterLongs, filterNot, findFirst, findFirstOrError, flatMap, flatMapDoubles, flatMapLongs, flatten, flattenIterable, fold, foldParallel, foldParallel, forEach, forEach2, forEach2, forEach3, forEach3, forEach4, forEach4, forEachAsync, fromCharSequence, fromDoubleStream, fromIntStream, fromIterable, fromIterator, fromList, fromLongStream, fromPublisher, fromSpliterator, fromStream, generate, generate, groupBy, grouped, grouped, groupedBySizeAndTime, groupedBySizeAndTime, groupedBySizeAndTime, groupedByTime, groupedByTime, groupedByTime, groupedUntil, groupedUntil, groupedUntil, groupedUntil, groupedWhile, groupedWhile, groupedWhile, groupedWhile, headOption, hotStream, insertAt, insertAt, insertAt, insertAt, insertStreamAt, intersperse, ints, isEmpty, isReplayable, iterate, iterate, limit, limitDouble, limitInts, limitLongs, longs, map, mapDoubles, mapInts, mapLongs, merge, merge, merge, mergeMap, mergeMap, mergeP, mergeP, multicast, narrow, narrowK, notNull, of, of, ofDoubles, ofInts, ofLongs, ofNullable, ofType, onComplete, onEmpty, onEmptyError, onEmptyGet, onEmptySwitch, onError, oneShotList, oneShotStream, parallel, parallel, parallelFanOut, parallelFanOut, parallelFanOut, parallelFanOutZipIn, parallelFanOutZipIn, parallelFanOutZipIn, partition, pausableHotStream, peek, permutations, plus, plusAll, prepend, prependAll, prependAll, prependStream, primedHotStream, primedPausableHotStream, print, print, printErr, printOut, publishTo, publishTo, quadruplicate, quadruplicate, range, range, rangeLong, rangeLong, reactiveSeq, recover, recover, recoverWith, recoverWith, recoverWith, reduce, reduceAll, removeAll, removeAll, removeAt, removeFirst, removeStream, removeValue, retainAll, retainAll, retainStream, retry, retry, reverse, reversedListOf, reversedOf, scanLeft, scanLeft, scanRight, scanRight, schedule, scheduleFixedDelay, scheduleFixedRate, shuffle, shuffle, single, single, singleOrElse, size, skip, skipDoubles, skipInts, skipLongs, slice, sliding, sliding, sorted, sorted, sorted, splitAt, splitAtHead, splitBy, spliterator, subStream, tailRec, take, take, takeOne, takeRight, takeUntil, takeUntilInclusive, takeWhile, takeWhileInclusive, timestamp, triplicate, triplicate, unfold, unit, unzip, unzip3, unzip4, updateAt, widen, zip, zip, zip, zip3, zip3, zip4, zip4, zipLatest, zipWithIndex, zipWithPublisher, zipWithStream, zipWithStream

Methods inherited from interface com.oath.cyclops.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.oath.cyclops.types.traversable.IterableX
asFunction, containsValue, equalToIteration, foldFuture, foldLazy, foldTry, forEach, forEach, forEach, forEach, forEach, forEachSubscribe, forEachSubscribe, forEachSubscribe, runFuture, runLazy, seq, to, toHashSet, unitIterable

Methods inherited from interface com.oath.cyclops.types.traversable.Traversable
subscribe, traversable

Methods inherited from interface java.lang.Iterable
iterator

Methods inherited from interface com.oath.cyclops.types.foldable.Contains
contains

Methods inherited from interface com.oath.cyclops.types.foldable.Folds
atPercentile, bankersQueue, collect, collect, countDistinct, doubleStats, foldLeft, foldLeft, foldLeft, foldLeft, hashSet, indexOf, indexOfSlice, intStats, iterableTo, lastIndexOf, lastIndexOfSlice, lazySeq, longStats, maxBy, maxBy, maximum, mean, median, minBy, minBy, minimum, mode, nonEmptyList, occurances, populationVariance, scheduleStream, stdDeviation, sumDouble, sumInt, sumLong, toCollection, toHashMap, toHashMap, toMap, toMap, treeSet, variance, vector, withPercentiles

Methods inherited from interface com.oath.cyclops.hkt.Higher
applyHKT_, applyHKT, applyHKT

Methods inherited from interface com.oath.cyclops.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
  - endsWith
```
public boolean endsWith(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:
    
    endsWith in interface Folds<T>
    
    Specified by:
    
    endsWith 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 Folds<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 fold
  - anyMatch
```
public boolean anyMatch(java.util.function.Predicate<? super T> c)
```
    Description copied from interface: ReactiveSeq
    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 Folds<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 fold
  - 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 Folds<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
  - min
```
public final java.util.Optional<T> min(java.util.Comparator<? super T> comparator)
```
    Specified by:
    
    min in interface ReactiveSeq<T>
    
    Specified by:
    
    min in interface java.util.stream.Stream<T>
  - max
```
public final java.util.Optional<T> max(java.util.Comparator<? super T> comparator)
```
    Specified by:
    
    max in interface ReactiveSeq<T>
    
    Specified by:
    
    max in interface java.util.stream.Stream<T>
  - findAny
```
public final java.util.Optional<T> findAny()
```
    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().getValue(); //3
    (non-deterministic)
  - foldMap
```
public final <R> R foldMap(Reducer<R,T> reducer)
```
    Description copied from interface: ReactiveSeq
```
 
 ReactiveSeq.of("hello","2","world","4").foldMap(Reducers.toCountInt());

 //4
 
 
```
    Specified by:
    
    foldMap in interface Folds<T>
    
    Specified by:
    
    foldMap in interface ReactiveSeq<T>
    
    Parameters:
    
    reducer - Monoid to reduce values
    
    Returns:
    
    Reduce result
  - foldMap
```
public final <R> R foldMap(java.util.function.Function<? super T,? extends R> mapper,
                           Monoid<R> reducer)
```
    Description copied from interface: ReactiveSeq
```
  
  ReactiveSeq.of("one","two","three","four")
           .foldMap(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:
    
    foldMap in interface Folds<T>
    
    Specified by:
    
    foldMap in interface ReactiveSeq<T>
    
    Parameters:
    
    mapper - Function to transform 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 stream 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 stream is parallel, and the Collector is concurrent, and lazy the stream 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 Folds<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 stream. 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.getValue();
     for (T element : this stream)
         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 Folds<T>
    
    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 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)
```
    Specified by:
    
    reduce in interface ReactiveSeq<T>
    
    Specified by:
    
    reduce in interface java.util.stream.Stream<T>
  - reduce
```
public final Seq<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 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 <R> R foldLeftMapToType(Reducer<R,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
  - foldMapRight
```
public final <R> R foldMapRight(Reducer<R,T> reducer)
```
    Description copied from interface: ReactiveSeq
    Attempt to transform 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:
    
    foldMapRight in interface Folds<T>
    
    Specified by:
    
    foldMapRight 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: Folds
    
    Collect the collectable into a LinkedHashSet.
    
    Specified by:
    
    toSet in interface Folds<T>
    
    Specified by:
    
    toSet in interface ReactiveSeq<T>
    
    Returns:
    
    This Stream converted to a set
  - toList
```
public final java.util.List<T> toList()
```
    Specified by:
    
    toList in interface Folds<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 IterableX<T>
    
    Specified by:
    
    stream in interface Traversable<T>
    
    Specified by:
    
    stream in interface ReactiveSeq<T>
    
    Returns:
    
    This Traversable converted to a Stream
  - startsWith
```
public final boolean startsWith(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:
    
    startsWith in interface Folds<T>
    
    Specified by:
    
    startsWith in interface ReactiveSeq<T>
    
    Returns:
    
    True if Monad starts with Iterable sequence of data
  - 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
  - createSeq
```
protected abstract <R> ReactiveSeq<R> createSeq(java.util.stream.Stream<R> rStream)
```
  - 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 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 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 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 Folds<T>
    
    Specified by:
    
    toArray in interface ReactiveSeq<T>
    
    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 Folds<T>
    
    Specified by:
    
    toArray in interface ReactiveSeq<T>
    
    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 Traversable<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 IterableX<T>
    
    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::stream)
 				.peek(individual -> System.out.println("Flattened : "
 						+ individual))
 				.forEach(a->{});
 
```
    Specified by:
    
    onePer in interface Traversable<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 Traversable<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
  - firstValue
```
public T firstValue(T alt)
```
    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)
```
    Specified by:
    
    reduce in interface ReactiveSeq<T>
    
    Specified by:
    
    reduce in interface java.util.stream.Stream<T>
  - reduce
```
public T reduce(T identity,
                java.util.function.BinaryOperator<T> accumulator)
```
    Specified by:
    
    reduce in interface ReactiveSeq<T>
    
    Specified by:
    
    reduce in interface java.util.stream.Stream<T>

Class BaseExtendedStream<T>

Nested Class Summary

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

Field Summary

Fields inherited from interface cyclops.reactive.ReactiveSeq

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.oath.cyclops.types.Unwrapable

Methods inherited from interface cyclops.reactive.ReactiveSeq

Methods inherited from interface com.oath.cyclops.types.foldable.To

Methods inherited from interface java.util.stream.Stream

Methods inherited from interface java.util.stream.BaseStream

Methods inherited from interface com.oath.cyclops.types.traversable.IterableX

Methods inherited from interface com.oath.cyclops.types.traversable.Traversable

Methods inherited from interface java.lang.Iterable

Methods inherited from interface com.oath.cyclops.types.foldable.Contains

Methods inherited from interface com.oath.cyclops.types.foldable.Folds

Methods inherited from interface com.oath.cyclops.hkt.Higher

Methods inherited from interface com.oath.cyclops.hkt.Convert

Constructor Detail

BaseExtendedStream

Method Detail

unwrapStream

parallel

endsWith

allMatch

anyMatch

xMatch

noneMatch

join

join

join

min

max

findAny

foldMap

foldMap

collect

collect

reduce

reduce

reduce

foldLeft

foldLeft

foldLeftMapToType

foldRight

foldRight

foldMapRight

toSet

toList

stream

startsWith

flatMapStream

createSeq

isParallel

sequential

unordered

mapToInt

mapToLong

mapToDouble

flatMapToInt

flatMapToLong

flatMapToDouble

forEachOrdered

toArray

toArray

onClose

close

xPer

sorted

mapLazyFn

filterLazyPredicate

onePer

debounce

fixedDelay

jitter

foldRight

firstValue

reduce