LazyFutureStreamImpl (simple-react 1.0.0-RC3 API)

java.lang.Object
- com.aol.cyclops.internal.react.LazyFutureStreamImpl

All Implemented Interfaces:

ReactiveSeq, ZippingApplicativable, ExtendedTraversable, Filterable, FilterableFunctor, Foldable, Functor, BaseSimpleReactStream, BlockingStream, ConfigurableStream<U,FastFuture>, LazyFutureStream, LazySimpleReactStream, LazyStream, LazyToQueue, ToQueue, IterableFilterable, IterableFunctor, ConvertableSequence, CyclopsCollectable, JoolManipulation, JoolWindowing, FutureStreamSynchronousPublisher, ReactiveStreamsTerminalOperations, TransformerTraversable, Traversable, Unit, Unwrapable, java.lang.AutoCloseable, java.lang.Iterable, java.util.stream.BaseStream<U,java.util.stream.Stream>, java.util.stream.Stream, org.jooq.lambda.Collectable, org.jooq.lambda.Seq, org.reactivestreams.Publisher
```
public class LazyFutureStreamImpl
extends java.lang.Object
implements LazyFutureStream
```

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

Constructor Summary

Constructors
Constructor and Description

LazyFutureStreamImpl(LazyReact lazyReact, java.util.stream.Stream stream)

Constructors
Constructor and Description
`LazyFutureStreamImpl(LazyReact lazyReact, java.util.stream.Stream<U> stream)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`allMatch(java.util.function.Predicate<? super U> c)` True if predicate matches all elements when Monad converted to a Stream
`boolean`	`anyMatch(java.util.function.Predicate<? super U> c)` True if a single element matches when Monad converted to a Stream
`LazyFutureStream<U>`	`append(U value)`
`void`	`cancel()` Cancel the CompletableFutures in this stage of the stream
`void`	`close()`
`<R,A> R`	`collect(java.util.stream.Collector<? super U,A,R> collector)`
`org.jooq.lambda.Collectable<U>`	`collectable()` Narrow this class to a Collectable
`long`	`count()`
`U`	`foldRight(Monoid<U> reducer)` `ReactiveSeq.of("a","b","c").foldRight(Reducers.toString("")); // "cab"`
`U`	`foldRight(U identity, java.util.function.BinaryOperator<U> accumulator)` 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
`java.lang.String`	`format()`
`void`	`forwardErrors(java.util.function.Consumer<java.lang.Throwable> c)`
`LazyReact`	`getPopulator()`
`com.nurkiewicz.asyncretry.RetryExecutor`	`getRetrier()`
`java.util.concurrent.Executor`	`getTaskExecutor()`
`HeadAndTail<U>`	`headAndTail()` extract head and tail together, where head is expected to be present
`HotStream<U>`	`hotStream(java.util.concurrent.Executor e)` Turns this ReactiveSeq into a HotStream, a connectable Stream, being executed on a thread on the supplied executor, that is producing data.
`boolean`	`isAsync()`
`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());`
`<R> R`	`mapReduce(java.util.function.Function<? super U,? 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.Optional<U>`	`max(java.util.Comparator<? super U> comparator)`
`LazyFutureStream<U>`	`maxActive(int max)` Configure the max active concurrent tasks.
`java.util.Optional<U>`	`min(java.util.Comparator<? super U> comparator)`
`boolean`	`noneMatch(java.util.function.Predicate<? super U> c)`
`PausableHotStream<U>`	`pausableHotStream(java.util.concurrent.Executor e)` Turns this ReactiveSeq into a HotStream, a connectable & pausable Stream, being executed on a thread on the supplied executor, that is producing data.
`LazyFutureStream<U>`	`prepend(U value)`
`HotStream<U>`	`primedHotStream(java.util.concurrent.Executor e)` Return a HotStream that will start emitting data when the first connecting Stream connects.
`PausableHotStream<U>`	`primedPausableHotStream(java.util.concurrent.Executor e)` Return a pausable HotStream that will start emitting data when the first connecting Stream connects.
`ListX<U>`	`reduce(java.lang.Iterable<? extends Monoid<U>> 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.
`U`	`reduce(Monoid<U> reducer)` `ReactiveSeq.of("hello","2","world","4").reduce(Reducers.toString(",")); //hello,2,world,4`
`ListX<U>`	`reduce(java.util.stream.Stream<? extends Monoid<U>> 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.
`void`	`returnPopulator(LazyReact service)`
`HotStream<U>`	`schedule(java.lang.String cron, java.util.concurrent.ScheduledExecutorService ex)` Execute this Stream on a schedule
`HotStream<U>`	`scheduleFixedDelay(long delay, java.util.concurrent.ScheduledExecutorService ex)` Execute this Stream on a schedule
`HotStream<U>`	`scheduleFixedRate(long rate, java.util.concurrent.ScheduledExecutorService ex)` Execute this Stream on a schedule
`<T> LazyFutureStream<T>`	`unit(T unit)`
`<T> LazyFutureStream<T>`	`unitIterator(java.util.Iterator<T> it)`
`LazyFutureStream<U>`	`withAsync(boolean b)`
`LazyFutureStream<U>`	`withLastActive(LazyStreamWrapper w)`
`LazyFutureStream<U>`	`withRetrier(com.nurkiewicz.asyncretry.RetryExecutor retry)`
`LazyFutureStream<U>`	`withTaskExecutor(java.util.concurrent.Executor e)`
`boolean`	`xMatch(int num, java.util.function.Predicate<? super U> c)` Check that there are specified number of matches of predicate in the Stream

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

Methods inherited from interface com.aol.cyclops.types.futurestream.LazyFutureStream
actOnFutures, anyM, ap1, append, appendStream, applicatives, async, boundedWaitFree, capture, cast, chunkLastReadIterator, chunkSinceLastRead, closeAll, collect, combinations, combine, concat, concat, concat, control, convertToSimpleReact, copy, crossJoin, cycle, cycle, cycle, cycleUntil, cycleWhile, debounce, deleteBetween, distinct, distinct, dropRight, dropUntil, dropWhile, duplicate, duplicateFutureStream, duplicateSequence, elapsed, empty, endsWith, endsWithIterable, filter, filterNot, findAny, findFirst, firstValue, fixedDelay, flatMap, flatMapAnyM, flatMapCompletableFuture, flatMapIterable, flatMapStream, flatMapToDouble, flatMapToInt, flatMapToLong, flatten, foldable, foldRight, forEach, forEach2, forEach2, forEach3, forEach3, forEachEvent, forEachOrdered, forEachWithError, forEachX, forEachXEvents, forEachXWithError, freeThread, freeThread, fromStream, fromStreamOfFutures, futureOperations, futureOperations, generate, generate, generate, getSimpleReact, getSubscription, group, grouped, grouped, groupedBySizeAndTime, groupedBySizeAndTime, groupedByTime, groupedByTime, groupedStatefullyWhile, groupedUntil, groupedUntil, groupedWhile, groupedWhile, hotStream, innerJoin, insertAt, insertStreamAt, intersperse, isParallel, iterate, iterator, jitter, lazyFutureStream, lazyFutureStream, lazyFutureStream, lazyFutureStream, lazyFutureStreamFrom, lazyFutureStreamFromIterable, leftOuterJoin, limit, limit, limitLast, limitUntil, limitWhile, map, mapToDouble, mapToInt, mapToLong, mergeLatest, notNull, of, of, ofType, onClose, onEmpty, onEmptyGet, onEmptySwitch, onEmptyThrow, onePer, onFail, onFail, parallel, parallel, partition, partitionFutureStream, partitionSequence, patternMatch, peek, peekSync, permutations, prepend, prependStream, quadruplicate, react, react, recover, recover, reduce, reduce, reduce, reduce, remove, retry, reverse, rightOuterJoin, scanLeft, scanLeft, scanRight, scanRight, self, sequential, shard, shuffle, shuffle, skip, skip, skipLast, skipUntil, skipWhile, slice, sliding, sliding, sorted, sorted, sorted, splitAt, splitBy, spliterator, splitSequenceAtHead, startsWith, startsWithIterable, stream, subscribe, subStream, switchOnNextValue, sync, takeRight, takeUntil, takeWhile, then, then, thenSync, toArray, toArray, toCollection, toCompletableFuture, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, toList, toOptional, toQueue, toSet, toStream, toStreamable, trampoline, triplicate, unboundedWaitFree, unordered, unwrap, withLazyCollector, withQueueFactory, withSubscription, xPer, zip, zip, zip3, zip4, zipAnyM, zipSequence, zipStream, zipStream, zipWithIndex

Methods inherited from interface com.aol.cyclops.types.futurestream.LazySimpleReactStream
assureSimpleReactException, copySimpleReactStream, filterSync, flatMapToCompletableFuture, flatMapToCompletableFutureSync, getLastActive, handleExceptions, streamCompletableFutures, withErrorHandler

Methods inherited from interface com.aol.cyclops.types.futurestream.ConfigurableStream
getErrorHandler

Methods inherited from interface com.aol.cyclops.types.futurestream.BaseSimpleReactStream
getQueueFactory, simpleReactStream, simpleReactStream, simpleReactStream, simpleReactStream, simpleReactStreamFrom, simpleReactStreamFromIterable

Methods inherited from interface com.aol.cyclops.types.futurestream.BlockingStream
block, block, getErrorHandler

Methods inherited from interface com.aol.cyclops.types.futurestream.LazyStream
getErrorHandler, getLastActive, getLazyCollector, getMaxActive, run, run, runContinuation, runOnCurrent, runThread

Methods inherited from interface com.aol.cyclops.control.ReactiveSeq
avg, avg, avgDouble, avgInt, avgLong, combinations, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, crossJoin, crossJoin, elementAt, fromDoubleStream, fromIntStream, fromIterable, fromIterator, fromList, fromLongStream, fromPublisher, fromStream, get, groupBy, grouped, grouped, innerJoin, innerJoin, innerJoin, leftOuterJoin, leftOuterJoin, leftOuterJoin, limitUntilClosed, max, max, max, maxBy, maxBy, median, median, medianBy, medianBy, min, min, min, minBy, minBy, mode, percentile, percentile, percentileBy, percentileBy, print, print, printErr, printOut, range, rangeLong, retry, reversedListOf, reversedOf, rightOuterJoin, rightOuterJoin, single, single, singleOptional, size, skipUntilClosed, subscriber, sum, sum, sumDouble, sumInt, sumLong, timestamp, toList, toMap, toSet, toString, toString, unzip, unzip3, unzip4, zip

Methods inherited from interface com.aol.cyclops.types.stream.JoolManipulation
removeAll, removeAll, removeAll, removeAll, retainAll, retainAll, retainAll, retainAll

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

Methods inherited from interface com.aol.cyclops.types.stream.CyclopsCollectable
bitAnd, bitAnd, bitAndInt, bitAndLong, bitOr, bitOr, bitOrInt, bitOrLong, commonPrefix, commonSuffix, maxAll, maxAll, maxAll, maxAll, maxAllBy, maxAllBy, minAll, minAll, minAll, minAll, minAllBy, minAllBy, modeAll, modeAllBy, modeBy, toMap

Methods inherited from interface com.aol.cyclops.types.stream.JoolWindowing
window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window

Methods inherited from interface org.jooq.lambda.Seq
append, append, append, append, cast, concat, concat, concat, concat, concat, concat, concat, contains, containsAll, containsAll, containsAll, containsAll, containsAny, containsAny, containsAny, containsAny, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, cycle, cycle, cycle, cycle, cycle, cycle, cycle, drop, duplicate, findFirst, findSingle, foldLeft, foldLeft, foldLeft, foldLeft, foldRight, foldRight, foldRight, groupBy, groupBy, groupBy, groupBy, groupBy, grouped, grouped, grouped, grouped, grouped, grouped, intersperse, isEmpty, isNotEmpty, join, join, join, join, join, limit, limitUntil, limitUntilClosed, limitWhile, limitWhileClosed, limitWhileClosed, ofType, partition, prepend, prepend, prepend, prepend, range, range, range, range, range, range, range, range, range, range, range, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, rangeClosed, reverse, reverse, reverse, scanLeft, scanLeft, scanLeft, scanRight, scanRight, scanRight, seq, seq, seq, seq, seq, seq, seq, seq, seq, seq, seq, seq, seq, seq, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, skip, skipUntil, skipUntilClosed, skipWhile, skipWhileClosed, skipWhileClosed, slice, sliding, sorted, splitAt, splitAt, splitAtHead, splitAtHead, take, toCollection, toList, toMap, toMap, toSet, toString, toString, transform, unfold, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, unzip, window, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipAll, zipWithIndex, zipWithIndex, zipWithIndex

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

Methods inherited from interface com.aol.cyclops.types.applicative.zipping.ZippingApplicativable
ap2, ap3, ap4, ap5

Methods inherited from interface com.aol.cyclops.types.IterableFunctor
flatMapPublisher, flatMapPublisher, flatMapPublisher, mergePublisher, mergePublisher

Methods inherited from interface com.aol.cyclops.types.Traversable
lazyOperations, traversable

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

Methods inherited from interface com.aol.cyclops.types.futurestream.LazyToQueue
add, addToQueue, toQueue, toQueue

Methods inherited from interface com.aol.cyclops.types.futurestream.ToQueue
getQueueFactory

Methods inherited from interface com.aol.cyclops.types.stream.reactive.FutureStreamSynchronousPublisher
getLastActive, subscribeSync

- Constructor Detail
 - LazyFutureStreamImpl
```
public LazyFutureStreamImpl(LazyReact lazyReact,
 java.util.stream.Stream stream)
```
- Method Detail
 - forwardErrors
```
public void forwardErrors(java.util.function.Consumer<java.lang.Throwable> c)
```
 Specified by:
 
 forwardErrors in interface FutureStreamSynchronousPublisher
 - getPopulator
```
public LazyReact getPopulator()
```
 Specified by:
 
 getPopulator in interface LazyToQueue
 - returnPopulator
```
public void returnPopulator(LazyReact service)
```
 Specified by:
 
 returnPopulator in interface LazyToQueue
 - collect
```
public <R,A> R collect(java.util.stream.Collector<? super U,A,R> collector)
```
 Specified by:
 
 collect in interface ReactiveSeq
 
 Specified by:
 
 collect in interface CyclopsCollectable
 
 Specified by:
 
 collect in interface java.util.stream.Stream
 
 Specified by:
 
 collect in interface org.jooq.lambda.Collectable
 - close
```
public void close()
```
 Specified by:
 
 close in interface java.lang.AutoCloseable
 
 Specified by:
 
 close in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 close in interface org.jooq.lambda.Seq
 - withAsync
```
public LazyFutureStream withAsync(boolean b)
```
 Specified by:
 
 withAsync in interface ConfigurableStream<U,FastFuture>
 
 Specified by:
 
 withAsync in interface LazyFutureStream
 
 Specified by:
 
 withAsync in interface LazySimpleReactStream
 - getTaskExecutor
```
public java.util.concurrent.Executor getTaskExecutor()
```
 Specified by:
 
 getTaskExecutor in interface BaseSimpleReactStream
 
 Specified by:
 
 getTaskExecutor in interface ConfigurableStream<U,FastFuture>
 - getRetrier
```
public com.nurkiewicz.asyncretry.RetryExecutor getRetrier()
```
 Specified by:
 
 getRetrier in interface ConfigurableStream<U,FastFuture>
 - isAsync
```
public boolean isAsync()
```
 Specified by:
 
 isAsync in interface BaseSimpleReactStream
 
 Specified by:
 
 isAsync in interface ConfigurableStream<U,FastFuture>
 - withTaskExecutor
```
public LazyFutureStream withTaskExecutor(java.util.concurrent.Executor e)
```
 Specified by:
 
 withTaskExecutor in interface ConfigurableStream<U,FastFuture>
 
 Specified by:
 
 withTaskExecutor in interface LazyFutureStream
 
 Specified by:
 
 withTaskExecutor in interface LazySimpleReactStream
 - withRetrier
```
public LazyFutureStream withRetrier(com.nurkiewicz.asyncretry.RetryExecutor retry)
```
 Specified by:
 
 withRetrier in interface BaseSimpleReactStream
 
 Specified by:
 
 withRetrier in interface ConfigurableStream<U,FastFuture>
 
 Specified by:
 
 withRetrier in interface LazyFutureStream
 
 Specified by:
 
 withRetrier in interface LazySimpleReactStream
 - withLastActive
```
public LazyFutureStream withLastActive(LazyStreamWrapper w)
```
 Specified by:
 
 withLastActive in interface LazyFutureStream
 
 Specified by:
 
 withLastActive in interface LazySimpleReactStream
 - maxActive
```
public LazyFutureStream maxActive(int max)
```
 Description copied from interface: LazyFutureStream
 Configure the max active concurrent tasks. The last set value wins, this can't be set per stage.
```
 
 	List<String> data = new LazyReact().react(urlFile)
 										.maxActive(100)
 										.flatMap(this::loadUrls)
 										.map(this::callUrls)
 										.block();
 
 
```
 Specified by:
 
 maxActive in interface LazyFutureStream
 
 Parameters:
 
 max - Maximum number of active task chains
 
 Returns:
 
 LazyFutureStream with new limits set
 - cancel
```
public void cancel()
```
 Cancel the CompletableFutures in this stage of the stream
 
 Specified by:
 
 cancel in interface FutureStreamSynchronousPublisher
 - schedule
```
public HotStream schedule(java.lang.String cron,
 java.util.concurrent.ScheduledExecutorService ex)
```
 Description copied from interface: ReactiveSeq
 Execute this Stream on a schedule
```
 
 //run at 8PM every night
 ReactiveSeq.generate(()->"next job:"+formatDate(new Date()))
 .map(this::processJob)
 .schedule("0 20 * * *",Executors.newScheduledThreadPool(1));
 
 
```
 Connect to the Scheduled Stream
```
 {
 @code
 HotStream<Data> dataStream = ReactiveSeq.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
 .schedule("0 20 * * *", Executors.newScheduledThreadPool(1));
 
 data.connect().forEach(this::logToDB);
 }
 
```
 Specified by:
 
 schedule in interface ReactiveSeq
 
 Specified by:
 
 schedule in interface Foldable
 
 Parameters:
 
 cron - Expression that determines when each job will run
 
 ex - ScheduledExecutorService
 
 Returns:
 
 Connectable HotStream of output from scheduled Stream
 - scheduleFixedDelay
```
public HotStream scheduleFixedDelay(long delay,
 java.util.concurrent.ScheduledExecutorService ex)
```
 Description copied from interface: ReactiveSeq
 Execute this Stream on a schedule
```
 
 //run every 60 seconds after last job completes
 ReactiveSeq.generate(()->"next job:"+formatDate(new Date()))
 .map(this::processJob)
 .scheduleFixedDelay(60_000,Executors.newScheduledThreadPool(1));
 
 
```
 Connect to the Scheduled Stream
```
 {
 @code
 HotStream<Data> dataStream = ReactiveSeq.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
 .scheduleFixedDelay(60_000, Executors.newScheduledThreadPool(1));
 
 data.connect().forEach(this::logToDB);
 }
 
```
 Specified by:
 
 scheduleFixedDelay in interface ReactiveSeq
 
 Specified by:
 
 scheduleFixedDelay in interface Foldable
 
 Parameters:
 
 delay - Between last element completes passing through the Stream until the next one starts
 
 ex - ScheduledExecutorService
 
 Returns:
 
 Connectable HotStream of output from scheduled Stream
 - scheduleFixedRate
```
public HotStream scheduleFixedRate(long rate,
 java.util.concurrent.ScheduledExecutorService ex)
```
 Description copied from interface: ReactiveSeq
 Execute this Stream on a schedule
```
 
 //run every 60 seconds
 ReactiveSeq.generate(()->"next job:"+formatDate(new Date()))
 .map(this::processJob)
 .scheduleFixedRate(60_000,Executors.newScheduledThreadPool(1));
 
 
```
 Connect to the Scheduled Stream
```
 {
 @code
 HotStream<Data> dataStream = ReactiveSeq.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
 .scheduleFixedRate(60_000, Executors.newScheduledThreadPool(1));
 
 data.connect().forEach(this::logToDB);
 }
 
```
 Specified by:
 
 scheduleFixedRate in interface ReactiveSeq
 
 Specified by:
 
 scheduleFixedRate in interface Foldable
 
 Parameters:
 
 rate - Time in millis between job runs
 
 ex - ScheduledExecutorService
 
 Returns:
 
 Connectable HotStream of output from scheduled Stream
 - unitIterator
```
public <T> LazyFutureStream<T> unitIterator(java.util.Iterator<T> it)
```
 Specified by:
 
 unitIterator in interface ReactiveSeq
 
 Specified by:
 
 unitIterator in interface IterableFunctor
 - append
```
public LazyFutureStream append(U value)
```
 Specified by:
 
 append in interface ReactiveSeq
 
 Specified by:
 
 append in interface org.jooq.lambda.Seq
 - prepend
```
public LazyFutureStream prepend(U value)
```
 Specified by:
 
 prepend in interface ReactiveSeq
 
 Specified by:
 
 prepend in interface org.jooq.lambda.Seq
 - unit
```
public <T> LazyFutureStream<T> unit(T unit)
```
 Specified by:
 
 unit in interface ReactiveSeq
 
 Specified by:
 
 unit in interface Unit
 - hotStream
```
public HotStream hotStream(java.util.concurrent.Executor e)
```
 Description copied from interface: ReactiveSeq
 Turns this ReactiveSeq into a HotStream, a connectable Stream, being executed on a thread on the supplied executor, that is producing data. Note this method creates a HotStream that starts emitting data immediately. For a hotStream that waits until the first user streams connect @see ReactiveSeq.primedHotStream(Executor). The generated HotStream is not pausable, for a pausable HotStream @see ReactiveSeq.pausableHotStream(Executor). Turns this ReactiveSeq into a HotStream, a connectable Stream, being executed on a thread on the supplied executor, that is producing data
```
 
 HotStream<Integer> ints = ReactiveSeq.range(0,Integer.MAX_VALUE)
 											.hotStream(exec)
 											
 		
 		ints.connect().forEach(System.out::println);									
 //print out all the ints
 //multiple consumers are possible, so other Streams can connect on different Threads
 
 
 
```
 Specified by:
 
 hotStream in interface ReactiveSeq
 
 Parameters:
 
 e - Executor to execute this ReactiveSeq on
 
 Returns:
 
 a Connectable HotStream
 - primedHotStream
```
public HotStream primedHotStream(java.util.concurrent.Executor e)
```
 Description copied from interface: ReactiveSeq
 Return a HotStream that will start emitting data when the first connecting Stream connects. Note this method creates a HotStream that starts emitting data only when the first connecting Stream connects. For a hotStream that starts to output data immediately @see ReactiveSeq.hotStream(Executor). The generated HotStream is not pausable, for a pausable HotStream @see ReactiveSeq.primedPausableHotStream(Executor).
```
 
 HotStream<Integer> ints = ReactiveSeq.range(0,Integer.MAX_VALUE)
											.hotStream(exec)
											
		
		ints.connect().forEach(System.out::println);									
 //print out all the ints - starting when connect is called.
 //multiple consumers are possible, so other Streams can connect on different Threads
 
 
 
```
 Specified by:
 
 primedHotStream in interface ReactiveSeq
 
 Returns:
 - pausableHotStream
```
public PausableHotStream pausableHotStream(java.util.concurrent.Executor e)
```
 Description copied from interface: ReactiveSeq
 Turns this ReactiveSeq into a HotStream, a connectable & pausable Stream, being executed on a thread on the supplied executor, that is producing data. Note this method creates a HotStream that starts emitting data immediately. For a hotStream that waits until the first user streams connect @see ReactiveSeq.primedPausableHotStream(Executor). The generated HotStream is pausable, for a unpausable HotStream (slightly faster execution) @see ReactiveSeq.hotStream(Executor).
```
 
 HotStream<Integer> ints = ReactiveSeq.range(0,Integer.MAX_VALUE)
											.hotStream(exec)
											
		
		ints.connect().forEach(System.out::println);
		
		ints.pause(); //on a separate thread pause the generating Stream
											
 //print out all the ints
 //multiple consumers are possible, so other Streams can connect on different Threads
 
 
 
```
 Specified by:
 
 pausableHotStream in interface ReactiveSeq
 
 Parameters:
 
 e - Executor to execute this ReactiveSeq on
 
 Returns:
 
 a Connectable HotStream
 - primedPausableHotStream
```
public PausableHotStream primedPausableHotStream(java.util.concurrent.Executor e)
```
 Description copied from interface: ReactiveSeq
 Return a pausable HotStream that will start emitting data when the first connecting Stream connects. Note this method creates a HotStream that starts emitting data only when the first connecting Stream connects. For a hotStream that starts to output data immediately @see ReactiveSeq.pausableHotStream(Executor). The generated HotStream is pausable, for a unpausable HotStream @see ReactiveSeq.primedHotStream(Executor).
```
 
 HotStream<Integer> ints = ReactiveSeq.range(0,Integer.MAX_VALUE)
											.hotStream(exec)
											
		
		ints.connect().forEach(System.out::println);									
 //print out all the ints - starting when connect is called.
 //multiple consumers are possible, so other Streams can connect on different Threads
 
 
 
```
 Specified by:
 
 primedPausableHotStream in interface ReactiveSeq
 
 Returns:
 - format
```
public java.lang.String format()
```
 Specified by:
 
 format in interface org.jooq.lambda.Seq
 - collectable
```
public org.jooq.lambda.Collectable collectable()
```
 Description copied from interface: CyclopsCollectable
 
 Narrow this class to a Collectable
 
 Specified by:
 
 collectable in interface ReactiveSeq
 
 Specified by:
 
 collectable in interface IterableFunctor
 
 Specified by:
 
 collectable in interface CyclopsCollectable
 
 Returns:
 
 Collectable
 - foldRight
```
public U foldRight(Monoid reducer)
```
 Description copied from interface: ReactiveSeq
```
 
 		ReactiveSeq.of("a","b","c").foldRight(Reducers.toString(""));
 
 // "cab"
 
 
```
 Specified by:
 
 foldRight in interface ReactiveSeq
 
 Specified by:
 
 foldRight in interface Foldable
 
 Parameters:
 
 reducer - Use supplied Monoid to reduce values starting via foldRight
 
 Returns:
 
 Reduced result
 - foldRightMapToType
```
public <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 ReactiveSeq
 
 Specified by:
 
 foldRightMapToType in interface Foldable
 
 Parameters:
 
 reducer - Monoid to reduce values
 
 Returns:
 
 Reduce result
 - mapReduce
```
public <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 ReactiveSeq
 
 Specified by:
 
 mapReduce in interface Foldable
 
 Parameters:
 
 reducer - Monoid to reduce values
 
 Returns:
 
 Reduce result
 - mapReduce
```
public <R> R mapReduce(java.util.function.Function<? super U,? 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 ReactiveSeq
 
 Specified by:
 
 mapReduce in interface Foldable
 
 Parameters:
 
 mapper - Function to map Monad type
 
 reducer - Monoid to reduce values
 
 Returns:
 
 Reduce result
 - reduce
```
public U reduce(Monoid 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
 
 Specified by:
 
 reduce in interface Foldable
 
 Parameters:
 
 reducer - Use supplied Monoid to reduce values
 
 Returns:
 
 reduced values
 - reduce
```
public ListX reduce(java.util.stream.Stream<? extends Monoid> 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)
```
 {
 @code
 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).stream());
 
 assertThat(result, equalTo(Arrays.asList(10, 24)));
 
 }
 
```
 Specified by:
 
 reduce in interface ReactiveSeq
 
 Specified by:
 
 reduce in interface Foldable
 
 Returns:
 - reduce
```
public ListX reduce(java.lang.Iterable<? extends Monoid> 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
 
 Specified by:
 
 reduce in interface Foldable
 
 Returns:
 - foldRight
```
public U foldRight(U identity,
 java.util.function.BinaryOperator 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 ReactiveSeq
 
 Specified by:
 
 foldRight in interface Foldable
 
 Returns:
 - min
```
public java.util.Optional min(java.util.Comparator<? super U> comparator)
```
 Specified by:
 
 min in interface ReactiveSeq
 
 Specified by:
 
 min in interface CyclopsCollectable
 
 Specified by:
 
 min in interface java.util.stream.Stream
 
 Specified by:
 
 min in interface org.jooq.lambda.Collectable
 - max
```
public java.util.Optional max(java.util.Comparator<? super U> comparator)
```
 Specified by:
 
 max in interface ReactiveSeq
 
 Specified by:
 
 max in interface CyclopsCollectable
 
 Specified by:
 
 max in interface java.util.stream.Stream
 
 Specified by:
 
 max in interface org.jooq.lambda.Collectable
 - count
```
public long count()
```
 Specified by:
 
 count in interface ReactiveSeq
 
 Specified by:
 
 count in interface LazyFutureStream
 
 Specified by:
 
 count in interface CyclopsCollectable
 
 Specified by:
 
 count in interface java.util.stream.Stream
 
 Specified by:
 
 count in interface org.jooq.lambda.Collectable
 
 Specified by:
 
 count in interface org.jooq.lambda.Seq
 - allMatch
```
public boolean allMatch(java.util.function.Predicate<? super U> 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 ReactiveSeq
 
 Specified by:
 
 allMatch in interface CyclopsCollectable
 
 Specified by:
 
 allMatch in interface java.util.stream.Stream
 
 Specified by:
 
 allMatch in interface org.jooq.lambda.Collectable
 
 Parameters:
 
 c - Predicate to check if all match
 - anyMatch
```
public boolean anyMatch(java.util.function.Predicate<? super U> 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 ReactiveSeq
 
 Specified by:
 
 anyMatch in interface CyclopsCollectable
 
 Specified by:
 
 anyMatch in interface java.util.stream.Stream
 
 Specified by:
 
 anyMatch in interface org.jooq.lambda.Collectable
 
 Parameters:
 
 c - Predicate to check if any match
 - xMatch
```
public boolean xMatch(int num,
 java.util.function.Predicate<? super U> 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 ReactiveSeq
 
 Specified by:
 
 xMatch in interface Foldable
 - noneMatch
```
public boolean noneMatch(java.util.function.Predicate<? super U> c)
```
 Specified by:
 
 noneMatch in interface ReactiveSeq
 
 Specified by:
 
 noneMatch in interface CyclopsCollectable
 
 Specified by:
 
 noneMatch in interface java.util.stream.Stream
 
 Specified by:
 
 noneMatch in interface org.jooq.lambda.Collectable
 - 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 ReactiveSeq
 
 Specified by:
 
 join in interface Foldable
 
 Specified by:
 
 join in interface org.jooq.lambda.Seq
 
 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 ReactiveSeq
 
 Specified by:
 
 join in interface Foldable
 
 Returns:
 
 Stream as concatenated String
 - join
```
public 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 ReactiveSeq
 
 Specified by:
 
 join in interface Foldable
 
 Returns:
 
 Stream as concatenated String
 - headAndTail
```
public HeadAndTail headAndTail()
```
 Description copied from interface: ReactiveSeq
 extract head and tail together, where head is expected to be present
```
 {
 @code
 ReactiveSeq<String> helloWorld = ReactiveSeq.of("hello", "world", "last");
 HeadAndTail<String> headAndTail = helloWorld.headAndTail();
 String head = headAndTail.head();
 assertThat(head, equalTo("hello"));
 
 ReactiveSeq<String> tail = headAndTail.tail();
 assertThat(tail.headAndTail().head(), equalTo("world"));
 }
 
```
 Specified by:
 
 headAndTail in interface ReactiveSeq
 
 Specified by:
 
 headAndTail in interface Foldable
 
 Returns:

Class LazyFutureStreamImpl<U>

Nested Class Summary

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.cyclops.types.futurestream.LazyFutureStream

Methods inherited from interface com.aol.cyclops.types.futurestream.LazySimpleReactStream

Methods inherited from interface com.aol.cyclops.types.futurestream.ConfigurableStream

Methods inherited from interface com.aol.cyclops.types.futurestream.BaseSimpleReactStream

Methods inherited from interface com.aol.cyclops.types.futurestream.BlockingStream

Methods inherited from interface com.aol.cyclops.types.futurestream.LazyStream

Methods inherited from interface com.aol.cyclops.control.ReactiveSeq

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

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

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

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

Methods inherited from interface org.jooq.lambda.Seq

Methods inherited from interface java.util.stream.Stream

Methods inherited from interface com.aol.cyclops.types.applicative.zipping.ZippingApplicativable

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

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

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

Methods inherited from interface com.aol.cyclops.types.futurestream.LazyToQueue

Methods inherited from interface com.aol.cyclops.types.futurestream.ToQueue

Methods inherited from interface com.aol.cyclops.types.stream.reactive.FutureStreamSynchronousPublisher

Constructor Detail

LazyFutureStreamImpl

Method Detail

forwardErrors

getPopulator

returnPopulator

collect

close

withAsync

getTaskExecutor

getRetrier

isAsync

withTaskExecutor

withRetrier

withLastActive

maxActive

cancel

schedule

scheduleFixedDelay

scheduleFixedRate

unitIterator

append

prepend

unit

hotStream

primedHotStream

pausableHotStream

primedPausableHotStream

format

collectable

foldRight

foldRightMapToType

mapReduce

mapReduce

reduce

reduce

reduce

foldRight

min

max

count

allMatch

anyMatch

xMatch

noneMatch

join

join

join

headAndTail