SequenceM (cyclops-sequence-api 6.0.1 API)

All Superinterfaces:

java.lang.AutoCloseable, java.util.stream.BaseStream<T,java.util.stream.Stream<T>>, java.lang.Iterable<T>, org.reactivestreams.Publisher<T>, org.jooq.lambda.Seq<T>, java.util.stream.Stream<T>, Unwrapable
```
public interface SequenceM<T>
extends Unwrapable, java.util.stream.Stream<T>, org.jooq.lambda.Seq<T>, java.lang.Iterable<T>, org.reactivestreams.Publisher<T>
```

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

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default 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
`AnyM<T>`	`anyM()`
`boolean`	`anyMatch(java.util.function.Predicate<? super T> c)` True if a single element matches when Monad converted to a Stream
`SequenceM<T>`	`append(T... values)` Append values to the end of this SequenceM
`SequenceM<T>`	`appendStream(java.util.stream.Stream<T> stream)` Append Stream to this SequenceM
`SequenceM<java.util.List<T>>`	`batchBySize(int size)` Batch elements in a Stream by size into Lists
`<C extends java.util.Collection<T>> SequenceM<C>`	`batchBySize(int size, java.util.function.Supplier<C> supplier)` Batch elements in a Stream by size into a collection created by the supplied factory
`SequenceM<java.util.List<T>>`	`batchBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit t)` Batch elements by size into a List
`<C extends java.util.Collection<T>> SequenceM<C>`	`batchBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory)` Batch elements by size into a collection created by the supplied factory
`SequenceM<java.util.List<T>>`	`batchByTime(long time, java.util.concurrent.TimeUnit t)` Batch elements in a Stream by time period
`<C extends java.util.Collection<T>> SequenceM<C>`	`batchByTime(long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory)` Batch elements by time into a collection created by the supplied factory
`SequenceM<java.util.List<T>>`	`batchUntil(java.util.function.Predicate<T> predicate)` Create a SequenceM batched by List, where each batch is populated until the predicate holds
`<C extends java.util.Collection<T>> SequenceM<C>`	`batchUntil(java.util.function.Predicate<T> predicate, java.util.function.Supplier<C> factory)` Create a SequenceM batched by a Collection, where each batch is populated until the predicate holds
`SequenceM<java.util.List<T>>`	`batchWhile(java.util.function.Predicate<T> predicate)` Create a SequenceM batched by List, where each batch is populated while the predicate holds
`<C extends java.util.Collection<T>> SequenceM<C>`	`batchWhile(java.util.function.Predicate<T> predicate, java.util.function.Supplier<C> factory)` Create a SequenceM batched by a Collection, where each batch is populated while the predicate holds
`<U> SequenceM<U>`	`cast(java.lang.Class<U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`<R> java.util.List<R>`	`collectIterable(java.lang.Iterable<java.util.stream.Collector> collectors)` Apply multiple Collectors, simultaneously to a Stream
`java.util.List`	`collectStream(java.util.stream.Stream<java.util.stream.Collector> collectors)` Apply multiple collectors Simulataneously to this Monad
`SequenceM<T>`	`concat(java.util.stream.Stream<T> other)`
`SequenceM<T>`	`concat(T... other)`
`SequenceM<T>`	`concat(T other)`
`<U> SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>>`	`crossJoin(java.util.stream.Stream<U> other)`
`SequenceM<T>`	`cycle()` Convert to a Stream with the values infinitely cycled
`<R> SequenceM<R>`	`cycle(java.lang.Class<R> monadC, int times)` Convert to a Stream, repeating the resulting structure specified times and lifting all values to the specified Monad type
`SequenceM<T>`	`cycle(int times)` Convert to a Stream with the values repeated specified times
`SequenceM<T>`	`cycle(Monoid<T> m, int times)` Convert to a Stream with the result of a reduction operation repeated specified times
`SequenceM<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`SequenceM<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`SequenceM<T>`	`debounce(long time, java.util.concurrent.TimeUnit t)` Allow one element through per time period, drop all other elements in that time period
`SequenceM<T>`	`deleteBetween(int start, int end)` Delete elements between given indexes in a Stream
`SequenceM<T>`	`distinct()`
`<U> SequenceM<T>`	`distinct(java.util.function.Function<? super T,? extends U> keyExtractor)`
`org.jooq.lambda.tuple.Tuple2<SequenceM<T>,SequenceM<T>>`	`duplicateSequence()` Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
`default SequenceM<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`elapsed()` `SequenceM.of(1,2,3,4,5) .elapsed() .forEach(System.out::println);`
`default java.util.Optional<T>`	`elementAt(long index)` Return the elementAt index or Optional.empty
`boolean`	`endsWith(java.lang.Iterable<T> iterable)` `assertTrue(SequenceM.of(1,2,3,4,5,6) .endsWith(Arrays.asList(5,6)));`
`boolean`	`endsWith(java.util.stream.Stream<T> stream)` `assertTrue(SequenceM.of(1,2,3,4,5,6) .endsWith(Stream.of(5,6)));`
`SequenceM<T>`	`filter(java.util.function.Predicate<? super T> fn)`
`java.util.Optional<T>`	`findAny()`
`java.util.Optional<T>`	`findFirst()`
`T`	`firstValue()` `assertThat(SequenceM.of(1,2,3,4) .map(u->{throw new RuntimeException();}) .recover(e->"hello") .firstValue(),equalTo("hello"));`
`SequenceM<T>`	`fixedDelay(long l, java.util.concurrent.TimeUnit unit)` emit elements after a fixed delay
`<R> SequenceM<R>`	`flatMap(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)` flatMap operation
`<R> SequenceM<R>`	`flatMapAnyM(java.util.function.Function<? super T,AnyM<? extends R>> fn)` Allows flatMap return type to be any Monad type
`SequenceM<java.lang.String>`	`flatMapBufferedReader(java.util.function.Function<? super T,java.io.BufferedReader> fn)` Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied BufferedReaders
`SequenceM<java.lang.Character>`	`flatMapCharSequence(java.util.function.Function<? super T,java.lang.CharSequence> fn)` Perform a flatMap operation where the result will be a flattened stream of Characters from the CharSequence returned by the supplied function.
`<R> SequenceM<R>`	`flatMapCollection(java.util.function.Function<? super T,java.util.Collection<? extends R>> fn)` FlatMap where the result is a Collection, flattens the resultant collections into the host SequenceM
`<R> SequenceM<R>`	`flatMapCompletableFuture(java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn)` flatMap to CompletableFuture - will block until Future complete, although (for non-blocking behaviour use AnyM wrapping CompletableFuture and flatMap to Stream there)
`SequenceM<java.lang.String>`	`flatMapFile(java.util.function.Function<? super T,java.io.File> fn)` Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied files.
`<R> SequenceM<R>`	`flatMapOptional(java.util.function.Function<? super T,java.util.Optional<? extends R>> fn)` flatMap to optional - will result in null values being removed
`<R> SequenceM<R>`	`flatMapStream(java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn)` flatMap operation
`SequenceM<java.lang.String>`	`flatMapURL(java.util.function.Function<? super T,java.net.URL> fn)` Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied URLs
`<T1> SequenceM<T1>`	`flatten()` join / flatten one level of a nested hierarchy
`T`	`foldLeft(Monoid<T> reducer)` `SequenceM.of("a","b","c").foldLeft(Reducers.toString("")); // "abc"`
`T`	`foldLeft(T identity, java.util.function.BinaryOperator<T> accumulator)` foldLeft : immutable reduction from left to right
`<T> T`	`foldLeftMapToType(Monoid<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
`T`	`foldRight(Monoid<T> reducer)` `SequenceM.of("a","b","c").foldRight(Reducers.toString("")); // "cab"`
`T`	`foldRight(T identity, java.util.function.BinaryOperator<T> accumulator)` Immutable reduction from right to left
`<T> T`	`foldRightMapToType(Monoid<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
`static SequenceM<java.lang.Double>`	`fromDoubleStream(java.util.stream.DoubleStream stream)` Construct a Sequence from a Stream
`static SequenceM<java.lang.Integer>`	`fromIntStream(java.util.stream.IntStream stream)` Construct a Sequence from a Stream
`static <T> SequenceM<T>`	`fromIterable(java.lang.Iterable<T> iterable)` Construct a Sequence from an Iterable
`static <T> SequenceM<T>`	`fromList(java.util.List<T> list)` Construct a Sequence from a List (prefer this method if the source is a list, as it allows more efficient Stream reversal).
`static SequenceM<java.lang.Long>`	`fromLongStream(java.util.stream.LongStream stream)` Construct a Sequence from a Stream
`static <T> SequenceM<T>`	`fromStream(java.util.stream.Stream<T> stream)` Construct a Sequence from a Stream
`FutureOperations<T>`	`futureOperations(java.util.concurrent.Executor exec)` Access asynchronous terminal operations (each returns a Future)
`static <T> SequenceM<T>`	`generate(java.util.function.Supplier<T> s)`
`default org.jooq.lambda.tuple.Tuple2<T,SequenceM<T>>`	`get(long index)` Gets the element at index, and returns a Tuple containing the element (it must be present) and a lazy copy of the Sequence for further processing.
`<K> java.util.Map<K,java.util.List<T>>`	`groupBy(java.util.function.Function<? super T,? extends K> classifier)` Use classifier function to group elements in this Sequence into a Map
`SequenceM<java.util.List<T>>`	`grouped(int groupSize)` Group elements in a Stream
`HeadAndTail<T>`	`headAndTail()` extract head and tail together, where head is expected to be present
`java.util.Optional<HeadAndTail<T>>`	`headAndTailOptional()` extract head and tail together, where no head or tail may be present
`HotStream<T>`	`hotStream(java.util.concurrent.Executor e)` Turns this SequenceM into a HotStream, a connectable Stream, being executed on a thread on the supplied executor, that is producing data
`default <U> SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>>`	`innerJoin(java.util.stream.Stream<U> other, java.util.function.BiPredicate<T,U> predicate)`
`SequenceM<T>`	`insertAt(int pos, T... values)` Insert data into a stream at given position
`SequenceM<T>`	`insertStreamAt(int pos, java.util.stream.Stream<T> stream)` Insert a Stream into the middle of this stream at the specified position
`SequenceM<T>`	`intersperse(T value)` Returns a stream with a given value interspersed between any two values of this stream.
`static <T> SequenceM<T>`	`iterate(T seed, java.util.function.UnaryOperator<T> f)`
`SequenceM<T>`	`jitter(long maxJitterPeriodInNanos)` Introduce a random jitter / time delay between the emission of elements
`java.lang.String`	`join()` `assertEquals("123".length(),SequenceM.of(1, 2, 3).join().length());`
`java.lang.String`	`join(java.lang.String sep)` `assertEquals("1, 2, 3".length(), SequenceM.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());`
`default <U> SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>>`	`leftOuterJoin(java.util.stream.Stream<U> other, java.util.function.BiPredicate<T,U> predicate)`
`SequenceM<T>`	`limit(long num)` `assertThat(SequenceM.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`SequenceM<T>`	`limit(long time, java.util.concurrent.TimeUnit unit)` Return all elements until specified time period has elapsed
`SequenceM<T>`	`limitLast(int num)` Limit results to the last x elements in a SequenceM
`SequenceM<T>`	`limitUntil(java.util.function.Predicate<? super T> p)` `assertThat(SequenceM.of(4,3,6,7).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3)));`
`SequenceM<T>`	`limitWhile(java.util.function.Predicate<? super T> p)` `assertThat(SequenceM.of(4,3,6,7).sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4)));`
`<R> SequenceM<R>`	`map(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(Monoid<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<T>`	`max(java.util.Comparator<? super T> comparator)`
`<C extends java.lang.Comparable<C>> java.util.Optional<T>`	`maxBy(java.util.function.Function<T,C> f)` Extract the maximum as determined by the supplied function
`java.util.Optional<T>`	`min(java.util.Comparator<? super T> comparator)`
`<C extends java.lang.Comparable<C>> java.util.Optional<T>`	`minBy(java.util.function.Function<T,C> f)` Extract the minimum as determined by supplied function
`boolean`	`noneMatch(java.util.function.Predicate<? super T> c)`
`static <T> SequenceM<T>`	`of(T... elements)` Create an efficiently reversable Sequence from the provided elements
`<U> SequenceM<U>`	`ofType(java.lang.Class<U> type)` Keep only those elements in a stream that are of a given type.
`SequenceM<T>`	`onClose(java.lang.Runnable closeHandler)`
`SequenceM<T>`	`onEmpty(T value)`
`SequenceM<T>`	`onEmptyGet(java.util.function.Supplier<T> supplier)`
`default SequenceM<T>`	`onEmptySwitch(java.util.function.Supplier<java.util.stream.Stream<T>> switchTo)` If this SequenceM is empty replace it with a another Stream
`<X extends java.lang.Throwable> SequenceM<T>`	`onEmptyThrow(java.util.function.Supplier<X> supplier)`
`SequenceM<T>`	`onePer(long time, java.util.concurrent.TimeUnit t)` emit one element per time period
`SequenceM<T>`	`parallel()`
`org.jooq.lambda.tuple.Tuple2<SequenceM<T>,SequenceM<T>>`	`partitionSequence(java.util.function.Predicate<T> splitter)` Partition a Stream into two one a per element basis, based on predicate's boolean value
`SequenceM<T>`	`peek(java.util.function.Consumer<? super T> c)`
`SequenceM<T>`	`prepend(T... values)` Prepend given values to the start of the Stream
`SequenceM<T>`	`prependStream(java.util.stream.Stream<T> stream)` Prepend Stream to this SequenceM
`org.jooq.lambda.tuple.Tuple4<SequenceM<T>,SequenceM<T>,SequenceM<T>,SequenceM<T>>`	`quadruplicate()` Makes four copies of a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
`static SequenceM<java.lang.Integer>`	`range(int start, int end)` Create an efficiently reversable Sequence that produces the integers between start and end
`<EX extends java.lang.Throwable> SequenceM<T>`	`recover(java.lang.Class<EX> exceptionClass, java.util.function.Function<EX,T> fn)` Recover from a particular exception type
`SequenceM<T>`	`recover(java.util.function.Function<java.lang.Throwable,T> fn)` Recover from an exception with an alternative value
`java.util.Optional<T>`	`reduce(java.util.function.BinaryOperator<T> accumulator)`
`java.util.List<T>`	`reduce(java.lang.Iterable<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)` `SequenceM.of("hello","2","world","4").reduce(Reducers.toString(",")); //hello,2,world,4`
`java.util.List<T>`	`reduce(java.util.stream.Stream<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)`
`<U> U`	`reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator, java.util.function.BinaryOperator<U> combiner)`
`default <R> SequenceM<R>`	`retry(java.util.function.Function<T,R> fn)` Retry a transformation if it fails.
`SequenceM<T>`	`reverse()`
`static <T> SequenceM<T>`	`reversedListOf(java.util.List<T> elements)` Construct a Reveresed Sequence from the provided elements Can be reversed (again) efficiently
`static <T> SequenceM<T>`	`reversedOf(T... elements)` Construct a Reveresed Sequence from the provided elements Can be reversed (again) efficiently
`<U> SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>>`	`rightOuterJoin(java.util.stream.Stream<U> other, java.util.function.BiPredicate<T,U> predicate)`
`SequenceM<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`<U> SequenceM<U>`	`scanLeft(U seed, java.util.function.BiFunction<U,? super T,U> function)` Scan left
`SequenceM<T>`	`scanRight(Monoid<T> monoid)` Scan right
`<U> SequenceM<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,U,U> combiner)` Scan right
`SequenceM<T>`	`sequential()`
`SequenceM<T>`	`shuffle()`
`SequenceM<T>`	`shuffle(java.util.Random random)`
`default T`	`single()` `assertThat(SequenceM.of(1).single(),equalTo(1));`
`SequenceM<T>`	`skip(long num)` `assertThat(SequenceM.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`SequenceM<T>`	`skip(long time, java.util.concurrent.TimeUnit unit)` Skip all elements until specified time period has passed
`SequenceM<T>`	`skipLast(int num)` assertThat(SequenceM.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
`SequenceM<T>`	`skipUntil(java.util.function.Predicate<? super T> p)` `assertThat(SequenceM.of(4,3,6,7).skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));`
`SequenceM<T>`	`skipWhile(java.util.function.Predicate<? super T> p)` `assertThat(SequenceM.of(4,3,6,7).sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));`
`SequenceM<T>`	`slice(long from, long to)`
`SequenceM<java.util.List<T>>`	`sliding(int windowSize)` Create a sliding view over this Sequence
`SequenceM<java.util.List<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`SequenceM<T>`	`sorted()` `assertThat(SequenceM.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`SequenceM<T>`	`sorted(java.util.Comparator<? super T> c)` `assertThat(SequenceM.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));`
`<U extends java.lang.Comparable<? super U>> SequenceM<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`org.jooq.lambda.tuple.Tuple2<SequenceM<T>,SequenceM<T>>`	`splitAt(int where)` Split at supplied location
`org.jooq.lambda.tuple.Tuple2<SequenceM<T>,SequenceM<T>>`	`splitBy(java.util.function.Predicate<T> splitter)` Split stream at point where predicate no longer holds
`org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,SequenceM<T>>`	`splitSequenceAtHead()` Split a Stream at it's head (similar to headAndTail)
`boolean`	`startsWith(java.lang.Iterable<T> iterable)` `assertTrue(SequenceM.of(1,2,3,4).startsWith(Arrays.asList(1,2,3)));`
`boolean`	`startsWith(java.util.Iterator<T> iterator)` `assertTrue(SequenceM.of(1,2,3,4).startsWith(Arrays.asList(1,2,3).iterator()))`
`java.util.stream.Stream<T>`	`stream()` Convert this SequenceM into a Stream
`static <T> CyclopsSubscriber<T>`	`subscriber()` Create a subscriber that can listen to Reactive Streams (simple-react, RxJava AkkaStreams, Kontraktor, QuadarStreams etc)
`default SequenceM<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`timestamp()` `SequenceM.of(1,2,3,4,5) .timestamp() .forEach(System.out::println)`
`<C extends java.util.Collection<T>> C`	`toCollection(java.util.function.Supplier<C> collectionFactory)`
`java.util.concurrent.CompletableFuture<java.util.List<T>>`	`toCompletableFuture()` `CompletableFuture<List<String>> cf = SequenceM.of("hello","world") .toCompletableFuture(); assertThat(cf.join(),equalTo(Arrays.asList("hello","world")));`
`java.util.Collection<T>`	`toConcurrentLazyCollection()` Lazily converts this SequenceM into a Collection.
`Streamable<T>`	`toConcurrentLazyStreamable()` `Streamable<Integer> repeat = SequenceM.of(1,2,3,4,5,6) .map(i->i+2) .toConcurrentLazyStreamable(); assertThat(repeat.sequenceM().toList(),equalTo(Arrays.asList(2,4,6,8,10,12))); assertThat(repeat.sequenceM().toList(),equalTo(Arrays.asList(2,4,6,8,10,12)));`
`java.util.Collection<T>`	`toLazyCollection()` Lazily converts this SequenceM into a Collection.
`java.util.List<T>`	`toList()`
`java.util.Optional<java.util.List<T>>`	`toOptional()` Type safe unwrap
`java.util.Set<T>`	`toSet()`
`<T> java.util.stream.Stream<T>`	`toStream()` Convert this SequenceM into a Stream
`Streamable<T>`	`toStreamable()` `Streamable<Integer> repeat = SequenceM.of(1,2,3,4,5,6) .map(i->i*2) .toStreamable(); repeat.sequenceM().toList(); //Arrays.asList(2,4,6,8,10,12)); repeat.sequenceM().toList() //Arrays.asList(2,4,6,8,10,12));`
`org.jooq.lambda.tuple.Tuple3<SequenceM<T>,SequenceM<T>,SequenceM<T>>`	`triplicate()` Triplicates a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
`SequenceM<T>`	`unordered()`
`<R> R`	`unwrap()`
`static <T,U> org.jooq.lambda.tuple.Tuple2<SequenceM<T>,SequenceM<U>>`	`unzip(SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> sequence)` Unzip a zipped Stream
`static <T1,T2,T3> org.jooq.lambda.tuple.Tuple3<SequenceM<T1>,SequenceM<T2>,SequenceM<T3>>`	`unzip3(SequenceM<org.jooq.lambda.tuple.Tuple3<T1,T2,T3>> sequence)` Unzip a zipped Stream into 3
`static <T1,T2,T3,T4> org.jooq.lambda.tuple.Tuple4<SequenceM<T1>,SequenceM<T2>,SequenceM<T3>,SequenceM<T4>>`	`unzip4(SequenceM<org.jooq.lambda.tuple.Tuple4<T1,T2,T3,T4>> sequence)` Unzip a zipped Stream into 4
`SequenceM<Streamable<T>>`	`windowBySizeAndTime(int maxSize, long maxTime, java.util.concurrent.TimeUnit maxTimeUnit)` Create a Sequence of Streamables (replayable Streams / Sequences) where each Streamable is populated up to a max size, or for max period of time
`SequenceM<Streamable<T>>`	`windowByTime(long time, java.util.concurrent.TimeUnit t)` Create SequenceM of Streamables (replayable Streams / Sequences) where each Streamable is populated within a specified time window
`SequenceM<Streamable<T>>`	`windowStatefullyWhile(java.util.function.BiPredicate<Streamable<T>,T> predicate)` Create SequenceM of Streamables (replayable Streams / Sequences) where each Streamable is populated while the supplied bipredicate holds.
`SequenceM<Streamable<T>>`	`windowUntil(java.util.function.Predicate<T> predicate)` Create a Sequence of Streamables (replayable Streams / Sequences) where each Streamable is populated until the supplied predicate holds.
`SequenceM<Streamable<T>>`	`windowWhile(java.util.function.Predicate<T> predicate)` Create a Sequence of Streamables (replayable Streams / Sequences) where each Streamable is populated while the supplied predicate holds.
`boolean`	`xMatch(int num, java.util.function.Predicate<? super T> c)` Check that there are specified number of matches of predicate in the Stream
`SequenceM<T>`	`xPer(int x, long time, java.util.concurrent.TimeUnit t)` emit x elements per time period
`<U> SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(org.jooq.lambda.Seq<U> other)` Zip 2 streams into one
`<U,R> SequenceM<R>`	`zip(org.jooq.lambda.Seq<U> other, java.util.function.BiFunction<T,U,R> zipper)`
`<S,U> SequenceM<org.jooq.lambda.tuple.Tuple3<T,S,U>>`	`zip3(java.util.stream.Stream<? extends S> second, java.util.stream.Stream<? extends U> third)` zip 3 Streams into one
`<T2,T3,T4> SequenceM<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>`	`zip4(java.util.stream.Stream<T2> second, java.util.stream.Stream<T3> third, java.util.stream.Stream<T4> fourth)` zip 4 Streams into 1
`<S,R> SequenceM<R>`	`zipAnyM(AnyM<? extends S> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper)` Zip this SequenceM against any monad type.
`<S,R> SequenceM<R>`	`zipSequence(SequenceM<? extends S> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper)` Generic zip function.
`<S,R> SequenceM<R>`	`zipStream(java.util.stream.BaseStream<? extends S,? extends java.util.stream.BaseStream<? extends S,?>> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper)` Zip this Monad with a Stream
`<U> SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipStream(java.util.stream.Stream<U> other)` Zip 2 streams into one
`SequenceM<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`zipWithIndex()` Add an index to the current Stream

Methods inherited from interface org.jooq.lambda.Seq
cast, close, concat, count, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, cycle, duplicate, duplicate, empty, flatMapToDouble, flatMapToInt, flatMapToLong, foldLeft, foldLeft, foldRight, foldRight, forEach, generate, groupBy, groupBy, groupBy, groupBy, groupBy, intersperse, isEmpty, isNotEmpty, join, join, join, join, join, limit, limitUntil, limitWhile, mapToDouble, mapToInt, mapToLong, maxBy, minBy, ofType, partition, partition, reverse, scanLeft, scanRight, seq, seq, seq, seq, seq, seq, seq, seq, seq, seq, seq, shuffle, shuffle, skip, skipUntil, skipWhile, slice, splitAt, splitAt, splitAtHead, splitAtHead, spliterator, toCollection, toList, toList, toMap, toMap, toMap, toSet, toSet, toString, toString, toString, unfold, unzip, unzip, unzip, unzip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zipWithIndex

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

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

Methods inherited from interface java.lang.Iterable
iterator

Methods inherited from interface org.reactivestreams.Publisher
subscribe

Method Detail

unwrap
```
<R> R unwrap()
```
Specified by:

unwrap in interface Unwrapable

flatten

<T1> SequenceM<T1> flatten()

join / flatten one level of a nested hierarchy

  
  SequenceM.of(Arrays.asList(1,2)).flatten();
  
  //stream of (1,  2);		
  
  // or more advanced example 
  
  AnyM<AnyM<Integer>> applied =anyM(Optional.of(2))
			 							.simpleFilter(anyM(Streamable.of( (Integer a)->a>5 ,(Integer a) -> a<3)));
	
	     assertThat(applied.toSequence().flatten().toList(),equalTo(Arrays.asList(2)));

Returns:: Flattened / joined one level

toOptional

java.util.Optional<java.util.List<T>> toOptional()

Type safe unwrap

  
 Optional<List<String>> stream = SequenceM.of("hello","world")
												.toOptional();
												
		assertThat(stream.get(),equalTo(Arrays.asList("hello","world")));

Returns:

toCompletableFuture

java.util.concurrent.CompletableFuture<java.util.List<T>> toCompletableFuture()

  
 CompletableFuture<List<String>> cf = SequenceM.of("hello","world")
											.toCompletableFuture();
		assertThat(cf.join(),equalTo(Arrays.asList("hello","world")));

Returns:

cycle

SequenceM<T> cycle(int times)

Convert to a Stream with the values repeated specified times

  
 		assertThat(SequenceM.of(1,2,2)
								.cycle(3)
								.collect(Collectors.toList()),
								equalTo(Arrays.asList(1,2,2,1,2,2,1,2,2)));

Parameters:: times - Times values should be repeated within a Stream
Returns:: Stream with values repeated

cycle
```
SequenceM<T> cycle()
```
Convert to a Stream with the values infinitely cycled
```
 
 assertEquals(asList(1, 1, 1, 1, 1,1),SequenceM.of(1).cycle().limit(6).toList());
 
 
```
Specified by:

cycle in interface org.jooq.lambda.Seq<T>

Returns:

Stream with values repeated

duplicateSequence

org.jooq.lambda.tuple.Tuple2<SequenceM<T>,SequenceM<T>> duplicateSequence()

Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.

  
  Tuple2<SequenceM<Integer>, SequenceM<Integer>> copies =of(1,2,3,4,5,6).duplicate();
		 assertTrue(copies.v1.anyMatch(i->i==2));
		 assertTrue(copies.v2.anyMatch(i->i==2));

Returns:: duplicated stream

triplicate

org.jooq.lambda.tuple.Tuple3<SequenceM<T>,SequenceM<T>,SequenceM<T>> triplicate()

Triplicates a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.

  
 	Tuple3<SequenceM<Tuple3<T1,T2,T3>>,SequenceM<Tuple3<T1,T2,T3>>,SequenceM<Tuple3<T1,T2,T3>>> Tuple3 = sequence.triplicate();

quadruplicate

org.jooq.lambda.tuple.Tuple4<SequenceM<T>,SequenceM<T>,SequenceM<T>,SequenceM<T>> quadruplicate()

Makes four copies of a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.

 
 
 		Tuple4<SequenceM<Tuple4<T1,T2,T3,T4>>,SequenceM<Tuple4<T1,T2,T3,T4>>,SequenceM<Tuple4<T1,T2,T3,T4>>,SequenceM<Tuple4<T1,T2,T3,T4>>> quad = sequence.quadruplicate();

Returns:

splitSequenceAtHead

org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,SequenceM<T>> splitSequenceAtHead()

Split a Stream at it's head (similar to headAndTail)

  
 SequenceM.of(1,2,3).splitAtHead()
 
  //Optional[1], SequenceM[2,3]

splitAt

org.jooq.lambda.tuple.Tuple2<SequenceM<T>,SequenceM<T>> splitAt(int where)

Split at supplied location

  
 SequenceM.of(1,2,3).splitAt(1)
 
  //SequenceM[1], SequenceM[2,3]

splitBy

org.jooq.lambda.tuple.Tuple2<SequenceM<T>,SequenceM<T>> splitBy(java.util.function.Predicate<T> splitter)

Split stream at point where predicate no longer holds

 
   SequenceM.of(1, 2, 3, 4, 5, 6).splitBy(i->i<4)
   
   //SequenceM[1,2,3] SequenceM[4,5,6]

partitionSequence

org.jooq.lambda.tuple.Tuple2<SequenceM<T>,SequenceM<T>> partitionSequence(java.util.function.Predicate<T> splitter)

Partition a Stream into two one a per element basis, based on predicate's boolean value

  
  SequenceM.of(1, 2, 3, 4, 5, 6).partition(i -> i % 2 != 0) 
  
  //SequenceM[1,3,5], SequenceM[2,4,6]

cycle

SequenceM<T> cycle(Monoid<T> m,
                   int times)

Convert to a Stream with the result of a reduction operation repeated specified times

  
   		List<Integer> list = AsGenericMonad,asMonad(Stream.of(1,2,2))
 										.cycle(Reducers.toCountInt(),3)
 										.collect(Collectors.toList());
 	//is asList(3,3,3);

Parameters:: m - Monoid to be used in reduction; times - Number of times value should be repeated
Returns:: Stream with reduced values repeated

cycle

<R> SequenceM<R> cycle(java.lang.Class<R> monadC,
                       int times)

Convert to a Stream, repeating the resulting structure specified times and lifting all values to the specified Monad type

 {
        @code
        List<Optional<Integer>> list = monad(Stream.of(1, 2)).cycle(Optional.class,
                        2).toList();
 
        // is asList(Optional.of(1),Optional.of(2),Optional.of(1),Optional.of(2) ));
 
 }

Parameters:: monadC - class type; times -
Returns:

cycleWhile

SequenceM<T> cycleWhile(java.util.function.Predicate<? super T> predicate)

Repeat in a Stream while specified predicate holds

 
 count =0;
		assertThat(SequenceM.of(1,2,2)
							.cycleWhile(next -> count++<6)
							.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,2,1,2,2)));

Parameters:: predicate - repeat while true
Returns:: Repeating Stream

cycleUntil

SequenceM<T> cycleUntil(java.util.function.Predicate<? super T> predicate)

Repeat in a Stream until specified predicate holds

  
 	count =0;
		assertThat(SequenceM.of(1,2,2)
							.cycleUntil(next -> count++>6)
							.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,2,1,2,2,1)));

Parameters:: predicate - repeat while true
Returns:: Repeating Stream

zipStream

<U> SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> zipStream(java.util.stream.Stream<U> other)

Zip 2 streams into one

  
 List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
       // [[1,"a"],[2,"b"]]

zip

<U> SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<U> other)

Zip 2 streams into one

  
 List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
       // [[1,"a"],[2,"b"]]

Specified by:: zip in interface org.jooq.lambda.Seq<T>

zip3

<S,U> SequenceM<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.util.stream.Stream<? extends S> second,
                                                          java.util.stream.Stream<? extends U> third)

zip 3 Streams into one

  
 List<Tuple3<Integer,Integer,Character>> list =
				of(1,2,3,4,5,6).zip3(of(100,200,300,400),of('a','b','c'))
											.collect(Collectors.toList());
 
 //[[1,100,'a'],[2,200,'b'],[3,300,'c']]

zip4

<T2,T3,T4> SequenceM<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.util.stream.Stream<T2> second,
                                                                    java.util.stream.Stream<T3> third,
                                                                    java.util.stream.Stream<T4> fourth)

zip 4 Streams into 1

  
 List<Tuple4<Integer,Integer,Character,String>> list =
				of(1,2,3,4,5,6).zip4(of(100,200,300,400),of('a','b','c'),of("hello","world"))
												.collect(Collectors.toList());
			
 
  //[[1,100,'a',"hello"],[2,200,'b',"world"]]

zipWithIndex

SequenceM<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()

Add an index to the current Stream

  
 assertEquals(asList(new Tuple2("a", 0L), new Tuple2("b", 1L)), of("a", "b").zipWithIndex().toList());

Specified by:: zipWithIndex in interface org.jooq.lambda.Seq<T>

zipSequence

<S,R> SequenceM<R> zipSequence(SequenceM<? extends S> second,
                               java.util.function.BiFunction<? super T,? super S,? extends R> zipper)

Generic zip function. E.g. Zipping a Stream and an Optional

 {
        @code
        Stream<List<Integer>> zipped = asMonad(Stream.of(1, 2, 3)).zip(
                        asMonad(Optional.of(2)), (a, b) -> Arrays.asList(a, b));
        // [[1,2]]
 }

Parameters:: second - Monad to zip with; zipper - Zipping function
Returns:: Stream zipping two Monads

zipAnyM

<S,R> SequenceM<R> zipAnyM(AnyM<? extends S> second,
                           java.util.function.BiFunction<? super T,? super S,? extends R> zipper)

Zip this SequenceM against any monad type.

 
 Stream<List<Integer>> zipped = anyM(Stream.of(1,2,3))
										.asSequence()
										.zip(anyM(Optional.of(2)), 
											(a,b) -> Arrays.asList(a,b)).toStream();
		
		
		List<Integer> zip = zipped.collect(Collectors.toList()).get(0);
		assertThat(zip.get(0),equalTo(1));
		assertThat(zip.get(1),equalTo(2));

zipStream

<S,R> SequenceM<R> zipStream(java.util.stream.BaseStream<? extends S,? extends java.util.stream.BaseStream<? extends S,?>> second,
                             java.util.function.BiFunction<? super T,? super S,? extends R> zipper)

Zip this Monad with a Stream

 {
        @code
        Stream<List<Integer>> zipped = asMonad(Stream.of(1, 2, 3)).zip(
                        Stream.of(2, 3, 4), (a, b) -> Arrays.asList(a, b));
 
        // [[1,2][2,3][3,4]]
 }

Parameters:: second - Stream to zip with; zipper - Zip funciton
Returns:: This monad zipped with a Stream

sliding

SequenceM<java.util.List<T>> sliding(int windowSize)

Create a sliding view over this Sequence

  
 List<List<Integer>> list = anyM(Stream.of(1,2,3,4,5,6))
									.asSequence()
									.sliding(2)
									.collect(Collectors.toList());
		
	
		assertThat(list.get(0),hasItems(1,2));
		assertThat(list.get(1),hasItems(2,3));

Parameters:: windowSize - Size of sliding window
Returns:: SequenceM with sliding view

sliding

SequenceM<java.util.List<T>> sliding(int windowSize,
                                     int increment)

Create a sliding view over this Sequence

  
 List<List<Integer>> list = anyM(Stream.of(1,2,3,4,5,6))
									.asSequence()
									.sliding(3,2)
									.collect(Collectors.toList());
		
	
		assertThat(list.get(0),hasItems(1,2,3));
		assertThat(list.get(1),hasItems(3,4,5));

Parameters:: windowSize - number of elements in each batch; increment - for each window
Returns:: SequenceM with sliding view

grouped

SequenceM<java.util.List<T>> grouped(int groupSize)

Group elements in a Stream

 {
        @code
        List<List<Integer>> list = monad(Stream.of(1, 2, 3, 4, 5, 6)).grouped(3)
                        .collect(Collectors.toList());
 
        assertThat(list.get(0), hasItems(1, 2, 3));
        assertThat(list.get(1), hasItems(4, 5, 6));
 
 }

Parameters:: groupSize - Size of each Group
Returns:: Stream with elements grouped by size

groupBy

<K> java.util.Map<K,java.util.List<T>> groupBy(java.util.function.Function<? super T,? extends K> classifier)

Use classifier function to group elements in this Sequence into a Map

  
 Map<Integer, List<Integer>> map1 =of(1, 2, 3, 4).groupBy(i -> i % 2);
		        assertEquals(asList(2, 4), map1.get(0));
		        assertEquals(asList(1, 3), map1.get(1));
		        assertEquals(2, map1.size());

Specified by:: groupBy in interface org.jooq.lambda.Seq<T>

distinct
```
SequenceM<T> distinct()
```
Specified by:

distinct in interface org.jooq.lambda.Seq<T>

Specified by:

distinct in interface java.util.stream.Stream<T>

scanLeft

SequenceM<T> scanLeft(Monoid<T> monoid)

Scan left using supplied Monoid

   
 
 	assertEquals(asList("", "a", "ab", "abc"),SequenceM.of("a", "b", "c")
 													.scanLeft(Reducers.toString("")).toList());

Parameters:: monoid -
Returns:

scanLeft

<U> SequenceM<U> scanLeft(U seed,
                          java.util.function.BiFunction<U,? super T,U> function)

Scan left

  
  assertThat(of("a", "b", "c").scanLeft("", String::concat).toList().size(),
        		is(4));

Specified by:: scanLeft in interface org.jooq.lambda.Seq<T>

scanRight

SequenceM<T> scanRight(Monoid<T> monoid)

Scan right

  
 assertThat(of("a", "b", "c").scanRight(Monoid.of("", String::concat)).toList().size(),
            is(asList("", "c", "bc", "abc").size()));

scanRight

<U> SequenceM<U> scanRight(U identity,
                           java.util.function.BiFunction<? super T,U,U> combiner)

Scan right

  
 assertThat(of("a", "ab", "abc").map(str->str.length()).scanRight(0, (t, u) -> u + t).toList().size(),
            is(asList(0, 3, 5, 6).size()));

Specified by:: scanRight in interface org.jooq.lambda.Seq<T>

sorted

SequenceM<T> sorted()

  assertThat(SequenceM.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));

Specified by:: sorted in interface org.jooq.lambda.Seq<T>
Specified by:: sorted in interface java.util.stream.Stream<T>

sorted
```
SequenceM<T> sorted(java.util.Comparator<? super T> c)
```
```
 
 	assertThat(SequenceM.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));
 
 
```
Specified by:

sorted in interface org.jooq.lambda.Seq<T>

Specified by:

sorted in interface java.util.stream.Stream<T>

Parameters:

c - Compartor to sort with

Returns:

Sorted Monad

skip
```
SequenceM<T> skip(long num)
```
```
 assertThat(SequenceM.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); 
 
```
Specified by:

skip in interface org.jooq.lambda.Seq<T>

Specified by:

skip in interface java.util.stream.Stream<T>

Parameters:

num - Number of elemenets to skip

Returns:

Monad converted to Stream with specified number of elements skipped

skipWhile
```
SequenceM<T> skipWhile(java.util.function.Predicate<? super T> p)
```
```
 
 assertThat(SequenceM.of(4,3,6,7).sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));
 
 
```
Specified by:

skipWhile in interface org.jooq.lambda.Seq<T>

Parameters:

p - Predicate to skip while true

Returns:

Monad converted to Stream with elements skipped while predicate holds

skipUntil
```
SequenceM<T> skipUntil(java.util.function.Predicate<? super T> p)
```
```
 assertThat(SequenceM.of(4,3,6,7).skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));
 
```
Specified by:

skipUntil in interface org.jooq.lambda.Seq<T>

Parameters:

p - Predicate to skip until true

Returns:

Monad converted to Stream with elements skipped until predicate holds

limit
```
SequenceM<T> limit(long num)
```
```
 assertThat(SequenceM.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
 
```
Specified by:

limit in interface org.jooq.lambda.Seq<T>

Specified by:

limit in interface java.util.stream.Stream<T>

Parameters:

num - Limit element size to num

Returns:

Monad converted to Stream with elements up to num

limitWhile

SequenceM<T> limitWhile(java.util.function.Predicate<? super T> p)

  assertThat(SequenceM.of(4,3,6,7).sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4)));

Specified by:: limitWhile in interface org.jooq.lambda.Seq<T>
Parameters:: p - Limit while predicate is true
Returns:: Monad converted to Stream with limited elements

limitUntil

SequenceM<T> limitUntil(java.util.function.Predicate<? super T> p)

  assertThat(SequenceM.of(4,3,6,7).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3)));

Specified by:: limitUntil in interface org.jooq.lambda.Seq<T>
Parameters:: p - Limit until predicate is true
Returns:: Monad converted to Stream with limited elements

parallel
```
SequenceM<T> parallel()
```
Specified by:

parallel in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>

Specified by:

parallel in interface org.jooq.lambda.Seq<T>

Returns:

Does nothing SequenceM is for Sequential Streams

allMatch
```
boolean allMatch(java.util.function.Predicate<? super T> c)
```
True if predicate matches all elements when Monad converted to a Stream
```
 
 assertThat(SequenceM.of(1,2,3,4,5).allMatch(it-> it>0 && it <6),equalTo(true));
 
 
```
Specified by:

allMatch in interface java.util.stream.Stream<T>

Parameters:

c - Predicate to check if all match

anyMatch
```
boolean anyMatch(java.util.function.Predicate<? super T> c)
```
True if a single element matches when Monad converted to a Stream
```
 
 assertThat(SequenceM.of(1,2,3,4,5).anyMatch(it-> it.equals(3)),equalTo(true));
 
 
```
Specified by:

anyMatch in interface java.util.stream.Stream<T>

Parameters:

c - Predicate to check if any match

xMatch

boolean xMatch(int num,
               java.util.function.Predicate<? super T> c)

Check that there are specified number of matches of predicate in the Stream

  
  assertTrue(SequenceM.of(1,2,3,5,6,7).xMatch(3, i-> i>4 ));

noneMatch
```
boolean noneMatch(java.util.function.Predicate<? super T> c)
```
Specified by:

noneMatch in interface java.util.stream.Stream<T>

join

java.lang.String join()

 
  assertEquals("123".length(),SequenceM.of(1, 2, 3).join().length());

Specified by:: join in interface org.jooq.lambda.Seq<T>
Returns:: Stream as concatenated String

join

java.lang.String join(java.lang.String sep)

 
 assertEquals("1, 2, 3".length(), SequenceM.of(1, 2, 3).join(", ").length());

Returns:: Stream as concatenated String

join

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());

Returns:: Stream as concatenated String

minBy
```
<C extends java.lang.Comparable<C>> java.util.Optional<T> minBy(java.util.function.Function<T,C> f)
```
Extract the minimum as determined by supplied function

Specified by:

minBy in interface org.jooq.lambda.Seq<T>

min

java.util.Optional<T> min(java.util.Comparator<? super T> comparator)

Specified by:: min in interface java.util.stream.Stream<T>

maxBy
```
<C extends java.lang.Comparable<C>> java.util.Optional<T> maxBy(java.util.function.Function<T,C> f)
```
Extract the maximum as determined by the supplied function

Specified by:

maxBy in interface org.jooq.lambda.Seq<T>

max

java.util.Optional<T> max(java.util.Comparator<? super T> comparator)

Specified by:: max in interface java.util.stream.Stream<T>

headAndTail

HeadAndTail<T> headAndTail()

extract head and tail together, where head is expected to be present

 
  SequenceM<String> helloWorld = SequenceM.of("hello","world","last");
		HeadAndTail<String> headAndTail = helloWorld.headAndTail();
		 String head = headAndTail.head();
		 assertThat(head,equalTo("hello"));
		
		SequenceM<String> tail =  headAndTail.tail();
		assertThat(tail.headAndTail().head(),equalTo("world"));

Returns:

headAndTailOptional

java.util.Optional<HeadAndTail<T>> headAndTailOptional()

extract head and tail together, where no head or tail may be present

  
 SequenceM<String> helloWorld = SequenceM.of();
		Optional<HeadAndTail<String>> headAndTail = helloWorld.headAndTailOptional();
		assertTrue(!headAndTail.isPresent());

Returns:

findFirst
```
java.util.Optional<T> findFirst()
```
Specified by:

findFirst in interface java.util.stream.Stream<T>

Returns:
First matching element in sequential order
```
 
 SequenceM.of(1,2,3,4,5).filter(it -> it <3).findFirst().get();
 
 //3
 
 
```
(deterministic)

findAny
```
java.util.Optional<T> findAny()
```
Specified by:

findAny in interface java.util.stream.Stream<T>

Returns:
first matching element, but order is not guaranteed
```
 
 SequenceM.of(1,2,3,4,5).filter(it -> it <3).findAny().get();
 
 //3
 
 
```
(non-deterministic)

mapReduce
```
<R> R mapReduce(Monoid<R> reducer)
```
Attempt to map this Sequence to the same type as the supplied Monoid (Reducer) Then use Monoid to reduce values
```
 
 SequenceM.of("hello","2","world","4").mapReduce(Reducers.toCountInt());
 
 //4
 
 
```
Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

mapReduce

<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

  
  SequenceM.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;
	   }

Parameters:: mapper - Function to map Monad type; reducer - Monoid to reduce values
Returns:: Reduce result

collectStream

java.util.List collectStream(java.util.stream.Stream<java.util.stream.Collector> collectors)

Apply multiple collectors Simulataneously to this Monad


	  	List result =SequenceM.of(1,2,3).collect(Stream.of(Collectors.toList(),
	  															Collectors.summingInt(Integer::intValue),
	  															Collectors.averagingInt(Integer::intValue)));
		
		assertThat(result.get(0),equalTo(Arrays.asList(1,2,3)));
		assertThat(result.get(1),equalTo(6));
		assertThat(result.get(2),equalTo(2.0));

Parameters:: collectors - Stream of Collectors to apply
Returns:: List of results

collectIterable

<R> java.util.List<R> collectIterable(java.lang.Iterable<java.util.stream.Collector> collectors)

Apply multiple Collectors, simultaneously to a Stream

  
 List result = SequenceM.of(1,2,3).collect(
								Arrays.asList(Collectors.toList(),
								Collectors.summingInt(Integer::intValue),
								Collectors.averagingInt(Integer::intValue)));
		
		assertThat(result.get(0),equalTo(Arrays.asList(1,2,3)));
		assertThat(result.get(1),equalTo(6));
		assertThat(result.get(2),equalTo(2.0));

Parameters:: stream - Stream to collect; collectors - Collectors to apply
Returns:: Result as a list

reduce

T reduce(Monoid<T> reducer)

  
 SequenceM.of("hello","2","world","4").reduce(Reducers.toString(","));
 
 //hello,2,world,4

Parameters:: reducer - Use supplied Monoid to reduce values
Returns:: reduced values

reduce

java.util.Optional<T> reduce(java.util.function.BinaryOperator<T> accumulator)

Specified by:: reduce in interface java.util.stream.Stream<T>

reduce

T reduce(T identity,
         java.util.function.BinaryOperator<T> accumulator)

Specified by:: reduce in interface java.util.stream.Stream<T>

reduce

<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 java.util.stream.Stream<T>

reduce

java.util.List<T> reduce(java.util.stream.Stream<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. 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 = SequenceM.of(1,2,3,4)
						.reduce(Arrays.asList(sum,mult).stream() );
				
		 
		assertThat(result,equalTo(Arrays.asList(10,24)));

Parameters:: reducers -
Returns:

reduce

java.util.List<T> reduce(java.lang.Iterable<Monoid<T>> reducers)

  
 Monoid<Integer> sum = Monoid.of(0,(a,b)->a+b);
		Monoid<Integer> mult = Monoid.of(1,(a,b)->a*b);
		List<Integer> result = SequenceM.of(1,2,3,4))
										.reduce(Arrays.asList(sum,mult) );
				
		 
		assertThat(result,equalTo(Arrays.asList(10,24)));

Parameters:: reducers -
Returns:

foldLeft

T foldLeft(Monoid<T> reducer)

                
		SequenceM.of("a","b","c").foldLeft(Reducers.toString(""));
       
        // "abc"

Parameters:: reducer - Use supplied Monoid to reduce values starting via foldLeft
Returns:: Reduced result

foldLeft

T foldLeft(T identity,
           java.util.function.BinaryOperator<T> accumulator)

foldLeft : immutable reduction from left to right

  
 
 assertTrue(SequenceM.of("a", "b", "c").foldLeft("", String::concat).equals("abc"));

foldLeftMapToType
```
<T> T foldLeftMapToType(Monoid<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
```
 
		SequenceM.of(1,2,3).foldLeftMapToType(Reducers.toString(""));
 
 // "123"
 
 
```
Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

foldRight

T foldRight(Monoid<T> reducer)

                
		SequenceM.of("a","b","c").foldRight(Reducers.toString(""));
       
        // "cab"

Parameters:: reducer - Use supplied Monoid to reduce values starting via foldRight
Returns:: Reduced result

foldRight

T foldRight(T identity,
            java.util.function.BinaryOperator<T> accumulator)

Immutable reduction from right to left

  
  assertTrue(SequenceM.of("a","b","c").foldRight("", String::concat).equals("cba"));

Parameters:: identity -; accumulator -
Returns:

foldRightMapToType
```
<T> T foldRightMapToType(Monoid<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
```
 
		SequenceM.of(1,2,3).foldRightMapToType(Reducers.toString(""));
 
 // "321"
 
 
```
Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

toStreamable

Streamable<T> toStreamable()

  
 	Streamable<Integer> repeat = SequenceM.of(1,2,3,4,5,6)
												.map(i->i*2)
												.toStreamable();
		
		repeat.sequenceM().toList(); //Arrays.asList(2,4,6,8,10,12));
		repeat.sequenceM().toList() //Arrays.asList(2,4,6,8,10,12));

Returns:: Lazily Convert to a repeatable Streamable

toSet
```
java.util.Set<T> toSet()
```
Specified by:

toSet in interface org.jooq.lambda.Seq<T>

Returns:

This Stream converted to a set

toList
```
java.util.List<T> toList()
```
Specified by:

toList in interface org.jooq.lambda.Seq<T>

Returns:

this Stream converted to a list

toCollection

<C extends java.util.Collection<T>> C toCollection(java.util.function.Supplier<C> collectionFactory)

Specified by:: toCollection in interface org.jooq.lambda.Seq<T>

toStream
```
<T> java.util.stream.Stream<T> toStream()
```
Convert this SequenceM into a Stream

Returns:

calls to stream() but more flexible on type for inferencing purposes.

stream
```
java.util.stream.Stream<T> stream()
```
Convert this SequenceM into a Stream

Specified by:

stream in interface org.jooq.lambda.Seq<T>

startsWith

boolean startsWith(java.lang.Iterable<T> iterable)

  
  assertTrue(SequenceM.of(1,2,3,4).startsWith(Arrays.asList(1,2,3)));

Parameters:: iterable -
Returns:: True if Monad starts with Iterable sequence of data

startsWith

boolean startsWith(java.util.Iterator<T> iterator)

 assertTrue(SequenceM.of(1,2,3,4).startsWith(Arrays.asList(1,2,3).iterator()))

Parameters:: iterator -
Returns:: True if Monad starts with Iterators sequence of data

anyM
```
AnyM<T> anyM()
```
Returns:

this SequenceM converted to AnyM format

map
```
<R> SequenceM<R> map(java.util.function.Function<? super T,? extends R> fn)
```
Specified by:

map in interface org.jooq.lambda.Seq<T>

Specified by:

map in interface java.util.stream.Stream<T>

peek
```
SequenceM<T> peek(java.util.function.Consumer<? super T> c)
```
Specified by:

peek in interface org.jooq.lambda.Seq<T>

Specified by:

peek in interface java.util.stream.Stream<T>

flatMap

<R> SequenceM<R> flatMap(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)

flatMap operation

 
 	assertThat(SequenceM.of(1,2)
 						.flatMap(i -> asList(i, -i).stream())
 						.toList(),equalTo(asList(1, -1, 2, -2)));

Specified by:: flatMap in interface org.jooq.lambda.Seq<T>
Specified by:: flatMap in interface java.util.stream.Stream<T>
Parameters:: fn - to be applied
Returns:: new stage in Sequence with flatMap operation to be lazily applied

flatMapAnyM

<R> SequenceM<R> flatMapAnyM(java.util.function.Function<? super T,AnyM<? extends R>> fn)

Allows flatMap return type to be any Monad type

  
 	assertThat(SequenceM.of(1,2,3)).flatMapAnyM(i-> anyM(CompletableFuture.completedFuture(i+2))).toList(),equalTo(Arrays.asList(3,4,5)));

Parameters:: fn - to be applied
Returns:: new stage in Sequence with flatMap operation to be lazily applied

flatMapCollection

<R> SequenceM<R> flatMapCollection(java.util.function.Function<? super T,java.util.Collection<? extends R>> fn)

FlatMap where the result is a Collection, flattens the resultant collections into the host SequenceM

  
 	SequenceM.of(1,2)
 			.flatMap(i -> asList(i, -i))
          .toList();
          
   //1,-1,2,-2

Parameters:: fn -
Returns:

flatMapStream

<R> SequenceM<R> flatMapStream(java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn)

flatMap operation

  
 	assertThat(SequenceM.of(1,2,3)
                      .flatMapStream(i->IntStream.of(i))
                      .toList(),equalTo(Arrays.asList(1,2,3)));

Parameters:: fn - to be applied
Returns:: new stage in Sequence with flatMap operation to be lazily applied

flatMapOptional

<R> SequenceM<R> flatMapOptional(java.util.function.Function<? super T,java.util.Optional<? extends R>> fn)

flatMap to optional - will result in null values being removed

  
 	assertThat(SequenceM.of(1,2,3,null)
                      .flatMapOptional(Optional::ofNullable)
			      			.collect(Collectors.toList()),
			      			equalTo(Arrays.asList(1,2,3)));

Parameters:: fn -
Returns:

flatMapCompletableFuture

<R> SequenceM<R> flatMapCompletableFuture(java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn)

flatMap to CompletableFuture - will block until Future complete, although (for non-blocking behaviour use AnyM wrapping CompletableFuture and flatMap to Stream there)

  
  	assertThat(SequenceM.of(1,2,3).flatMapCompletableFuture(i->CompletableFuture.completedFuture(i+2))
				  								.collect(Collectors.toList()),
				  								equalTo(Arrays.asList(3,4,5)));

Parameters:: fn -
Returns:

flatMapCharSequence

SequenceM<java.lang.Character> flatMapCharSequence(java.util.function.Function<? super T,java.lang.CharSequence> fn)

Perform a flatMap operation where the result will be a flattened stream of Characters from the CharSequence returned by the supplied function.

  
   List<Character> result = SequenceM.of("input.file")
									.flatMapCharSequence(i->"hello world")
									.toList();
		
		assertThat(result,equalTo(Arrays.asList('h','e','l','l','o',' ','w','o','r','l','d')));

Parameters:: fn -
Returns:

flatMapFile

SequenceM<java.lang.String> flatMapFile(java.util.function.Function<? super T,java.io.File> fn)

Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied files.

 
 
		List<String> result = SequenceM.of("input.file")
								.map(getClass().getClassLoader()::getResource)
								.peek(System.out::println)
								.map(URL::getFile)
								.flatMapFile(File::new)
								.toList();
		
		assertThat(result,equalTo(Arrays.asList("hello","world")));

Parameters:: fn -
Returns:

flatMapURL

SequenceM<java.lang.String> flatMapURL(java.util.function.Function<? super T,java.net.URL> fn)

Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied URLs

  
 List<String> result = SequenceM.of("input.file")
								.flatMapURL(getClass().getClassLoader()::getResource)
								.toList();
		
		assertThat(result,equalTo(Arrays.asList("hello","world")));

Parameters:: fn -
Returns:

flatMapBufferedReader

SequenceM<java.lang.String> flatMapBufferedReader(java.util.function.Function<? super T,java.io.BufferedReader> fn)

Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied BufferedReaders

 List result = SequenceM.of("input.file")
                                                                .map(getClass().getClassLoader()::getResourceAsStream)
                                                                .map(InputStreamReader::new)
                                                                .liftAndBindBufferedReader(BufferedReader::new)
                                                                .toList();
                
                assertThat(result,equalTo(Arrays.asList("hello","world")));

Parameters:: fn -
Returns:

filter
```
SequenceM<T> filter(java.util.function.Predicate<? super T> fn)
```
Specified by:

filter in interface org.jooq.lambda.Seq<T>

Specified by:

filter in interface java.util.stream.Stream<T>

sequential
```
SequenceM<T> sequential()
```
Specified by:

sequential in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>

Specified by:

sequential in interface org.jooq.lambda.Seq<T>

unordered
```
SequenceM<T> unordered()
```
Specified by:

unordered in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>

Specified by:

unordered in interface org.jooq.lambda.Seq<T>

intersperse
```
SequenceM<T> intersperse(T value)
```
Returns a stream with a given value interspersed between any two values of this stream. // (1, 0, 2, 0, 3, 0, 4) SequenceM.of(1, 2, 3, 4).intersperse(0)

Specified by:

intersperse in interface org.jooq.lambda.Seq<T>

ofType
```
 SequenceM ofType(java.lang.Class type)
```
Keep only those elements in a stream that are of a given type. // (1, 2, 3) SequenceM.of(1, "a", 2, "b",3).ofType(Integer.class)

Specified by:

ofType in interface org.jooq.lambda.Seq<T>

cast
```
 SequenceM cast(java.lang.Class type)
```
Cast all elements in a stream to a given type, possibly throwing a ClassCastException. // ClassCastException SequenceM.of(1, "a", 2, "b", 3).cast(Integer.class)

Specified by:

cast in interface org.jooq.lambda.Seq<T>

toLazyCollection

java.util.Collection<T> toLazyCollection()

Lazily converts this SequenceM into a Collection. This does not trigger the Stream. E.g. Collection is not thread safe on the first iteration.

  
 Collection<Integer> col = SequenceM.of(1,2,3,4,5)
											.peek(System.out::println)
											.toLazyCollection();
		System.out.println("first!");
		col.forEach(System.out::println);
 
 
 //Will print out "first!" before anything else

Returns:

toConcurrentLazyCollection

java.util.Collection<T> toConcurrentLazyCollection()

Lazily converts this SequenceM into a Collection. This does not trigger the Stream. E.g.

  
 Collection<Integer> col = SequenceM.of(1,2,3,4,5)
											.peek(System.out::println)
											.toConcurrentLazyCollection();
		System.out.println("first!");
		col.forEach(System.out::println);
 
 
 //Will print out "first!" before anything else

Returns:

toConcurrentLazyStreamable

Streamable<T> toConcurrentLazyStreamable()

  
 Streamable<Integer> repeat = SequenceM.of(1,2,3,4,5,6)
												.map(i->i+2)
												.toConcurrentLazyStreamable();
		
		assertThat(repeat.sequenceM().toList(),equalTo(Arrays.asList(2,4,6,8,10,12)));
		assertThat(repeat.sequenceM().toList(),equalTo(Arrays.asList(2,4,6,8,10,12)));

Returns:: Streamable that replay this SequenceM, populated lazily and can be populated across threads

reverse
```
SequenceM<T> reverse()
```
Specified by:

reverse in interface org.jooq.lambda.Seq<T>

onClose
```
SequenceM<T> onClose(java.lang.Runnable closeHandler)
```
Specified by:

onClose in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>

Specified by:

onClose in interface org.jooq.lambda.Seq<T>

shuffle
```
SequenceM<T> shuffle()
```
Specified by:

shuffle in interface org.jooq.lambda.Seq<T>

appendStream

SequenceM<T> appendStream(java.util.stream.Stream<T> stream)

Append Stream to this SequenceM

  
 List<String> result = 	SequenceM.of(1,2,3)
                                  .appendStream(SequenceM.of(100,200,300))
										.map(it ->it+"!!")
										.collect(Collectors.toList());

			assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));

Parameters:: stream - to append
Returns:: SequenceM with Stream appended

prependStream

SequenceM<T> prependStream(java.util.stream.Stream<T> stream)

Prepend Stream to this SequenceM

  
 List<String> result = SequenceM.of(1,2,3)
 								  .prependStream(of(100,200,300))
									  .map(it ->it+"!!")
									  .collect(Collectors.toList());

			assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));

Parameters:: stream - to Prepend
Returns:: SequenceM with Stream prepended

append

SequenceM<T> append(T... values)

Append values to the end of this SequenceM

  
 List<String> result = SequenceM.of(1,2,3)
 								   .append(100,200,300)
										.map(it ->it+"!!")
										.collect(Collectors.toList());

			assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));

Parameters:: values - to append
Returns:: SequenceM with appended values

prepend

SequenceM<T> prepend(T... values)

Prepend given values to the start of the Stream

  
 List<String> result = 	SequenceM.of(1,2,3)
 									 .prepend(100,200,300)
										 .map(it ->it+"!!")
										 .collect(Collectors.toList());

			assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));

Parameters:: values - to prepend
Returns:: SequenceM with values prepended

insertAt

SequenceM<T> insertAt(int pos,
                      T... values)

Insert data into a stream at given position

  
 List<String> result = 	SequenceM.of(1,2,3)
 									 .insertAt(1,100,200,300)
										 .map(it ->it+"!!")
										 .collect(Collectors.toList());

			assertThat(result,equalTo(Arrays.asList("1!!","100!!","200!!","300!!","2!!","3!!")));

Parameters:: pos - to insert data at; values - to insert
Returns:: Stream with new data inserted

deleteBetween

SequenceM<T> deleteBetween(int start,
                           int end)

Delete elements between given indexes in a Stream

  
 List<String> result = 	SequenceM.of(1,2,3,4,5,6)
 									 .deleteBetween(2,4)
										 .map(it ->it+"!!")
										 .collect(Collectors.toList());

			assertThat(result,equalTo(Arrays.asList("1!!","2!!","5!!","6!!")));

Parameters:: start - index; end - index
Returns:: Stream with elements removed

insertStreamAt

SequenceM<T> insertStreamAt(int pos,
                            java.util.stream.Stream<T> stream)

Insert a Stream into the middle of this stream at the specified position

  
 List<String> result = 	SequenceM.of(1,2,3)
 									 .insertStreamAt(1,of(100,200,300))
										 .map(it ->it+"!!")
										 .collect(Collectors.toList());

			assertThat(result,equalTo(Arrays.asList("1!!","100!!","200!!","300!!","2!!","3!!")));

Parameters:: pos - to insert Stream at; stream - to insert
Returns:: newly conjoined SequenceM

futureOperations
```
FutureOperations<T> futureOperations(java.util.concurrent.Executor exec)
```
Access asynchronous terminal operations (each returns a Future)

Parameters:

exec - Executor to use for Stream execution

Returns:

Async Future Terminal Operations

endsWith

boolean endsWith(java.lang.Iterable<T> iterable)

 
  assertTrue(SequenceM.of(1,2,3,4,5,6)
				.endsWith(Arrays.asList(5,6)));

Parameters:: iterable - Values to check
Returns:: true if SequenceM ends with values in the supplied iterable

endsWith

boolean endsWith(java.util.stream.Stream<T> stream)

 
 assertTrue(SequenceM.of(1,2,3,4,5,6)
				.endsWith(Stream.of(5,6)));

Parameters:: stream - Values to check
Returns:: true if SequenceM endswith values in the supplied Stream

skip

SequenceM<T> skip(long time,
                  java.util.concurrent.TimeUnit unit)

Skip all elements until specified time period has passed

  
 List<Integer> result = SequenceM.of(1,2,3,4,5,6)
										.peek(i->sleep(i*100))
										.skip(1000,TimeUnit.MILLISECONDS)
										.toList();
		
		
		//[4,5,6]

Parameters:: time - Length of time; unit - Time unit
Returns:: SequenceM that skips all elements until time period has elapsed

limit

SequenceM<T> limit(long time,
                   java.util.concurrent.TimeUnit unit)

Return all elements until specified time period has elapsed

  
 List<Integer> result = SequenceM.of(1,2,3,4,5,6)
										.peek(i->sleep(i*100))
										.limit(1000,TimeUnit.MILLISECONDS)
										.toList();
		
		
		//[1,2,3,4]

Parameters:: time - Length of time; unit - Time unit
Returns:: SequenceM that returns all elements until time period has elapsed

skipLast
```
SequenceM<T> skipLast(int num)
```
assertThat(SequenceM.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));

Parameters:

num -

Returns:

limitLast

SequenceM<T> limitLast(int num)

Limit results to the last x elements in a SequenceM

  
 	assertThat(SequenceM.of(1,2,3,4,5)
							.limitLast(2)
							.collect(Collectors.toList()),equalTo(Arrays.asList(4,5)));

Parameters:: num - of elements to return (last elements)
Returns:: SequenceM limited to last num elements

hotStream

HotStream<T> hotStream(java.util.concurrent.Executor e)

Turns this SequenceM into a HotStream, a connectable Stream, being executed on a thread on the supplied executor, that is producing data

  
  HotStream<Integer> ints = SequenceM.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

Parameters:: e - Executor to execute this SequenceM on
Returns:: a Connectable HotStream

firstValue

T firstValue()

  
 	assertThat(SequenceM.of(1,2,3,4)
					.map(u->{throw new RuntimeException();})
					.recover(e->"hello")
					.firstValue(),equalTo("hello"));

Returns:: first value in this Stream

single

default T single()

  
 assertThat(SequenceM.of(1).single(),equalTo(1));

Returns:: a single value or an exception if 0/1 values in this Stream

elementAt

default java.util.Optional<T> elementAt(long index)

Return the elementAt index or Optional.empty

 
 	assertThat(SequenceM.of(1,2,3,4,5).elementAt(2).get(),equalTo(3));

Parameters:: index - to extract element from
Returns:: elementAt index

get
```
default org.jooq.lambda.tuple.Tuple2<T,SequenceM<T>> get(long index)
```
Gets the element at index, and returns a Tuple containing the element (it must be present) and a lazy copy of the Sequence for further processing.
```
 
 SequenceM.of(1,2,3,4,5).get(2).v1
 //3
 
 
```
Parameters:

index - to extract element from

Returns:

Element and Sequence

elapsed

default SequenceM<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> elapsed()

  
 SequenceM.of(1,2,3,4,5)
				 .elapsed()
				 .forEach(System.out::println);

Returns:: Sequence that adds the time between elements in millis to each element

timestamp

default SequenceM<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> timestamp()

 
    SequenceM.of(1,2,3,4,5)
				   .timestamp()
				   .forEach(System.out::println)

Returns:: Sequence that adds a timestamp to each element

subscriber

static <T> CyclopsSubscriber<T> subscriber()

Create a subscriber that can listen to Reactive Streams (simple-react, RxJava AkkaStreams, Kontraktor, QuadarStreams etc)

 
 CyclopsSubscriber<Integer> sub = SequenceM.subscriber();
		SequenceM.of(1,2,3).subscribe(sub);
		sub.sequenceM().forEach(System.out::println);
		
		  1 
		  2
		  3

Returns:: A reactive-streams Subscriber

of
```
static <T> SequenceM<T> of(T... elements)
```
Create an efficiently reversable Sequence from the provided elements

Specified by:

of in interface org.jooq.lambda.Seq<T>

Specified by:

of in interface java.util.stream.Stream<T>

Parameters:

elements - To Construct sequence from

Returns:

reversedOf
```
static <T> SequenceM<T> reversedOf(T... elements)
```
Construct a Reveresed Sequence from the provided elements Can be reversed (again) efficiently

Parameters:

elements - To Construct sequence from

Returns:

reversedListOf
```
static <T> SequenceM<T> reversedListOf(java.util.List<T> elements)
```
Construct a Reveresed Sequence from the provided elements Can be reversed (again) efficiently

Parameters:

elements - To Construct sequence from

Returns:

range
```
static SequenceM<java.lang.Integer> range(int start,
 int end)
```
Create an efficiently reversable Sequence that produces the integers between start and end

Parameters:

start - Number of range to start from

end - Number for range to end at

Returns:

Range SequenceM

fromStream
```
static <T> SequenceM<T> fromStream(java.util.stream.Stream<T> stream)
```
Construct a Sequence from a Stream

Parameters:

stream - Stream to construct Sequence from

Returns:

fromIntStream
```
static SequenceM<java.lang.Integer> fromIntStream(java.util.stream.IntStream stream)
```
Construct a Sequence from a Stream

Parameters:

stream - Stream to construct Sequence from

Returns:

fromLongStream
```
static SequenceM<java.lang.Long> fromLongStream(java.util.stream.LongStream stream)
```
Construct a Sequence from a Stream

Parameters:

stream - Stream to construct Sequence from

Returns:

fromDoubleStream
```
static SequenceM<java.lang.Double> fromDoubleStream(java.util.stream.DoubleStream stream)
```
Construct a Sequence from a Stream

Parameters:

stream - Stream to construct Sequence from

Returns:

fromList
```
static <T> SequenceM<T> fromList(java.util.List<T> list)
```
Construct a Sequence from a List (prefer this method if the source is a list, as it allows more efficient Stream reversal).

Parameters:

iterable - to construct Sequence from

Returns:

SequenceM

fromIterable
```
static <T> SequenceM<T> fromIterable(java.lang.Iterable<T> iterable)
```
Construct a Sequence from an Iterable

Parameters:

iterable - to construct Sequence from

Returns:

SequenceM

iterate
```
static <T> SequenceM<T> iterate(T seed,
 java.util.function.UnaryOperator<T> f)
```
Specified by:

iterate in interface org.jooq.lambda.Seq<T>

Specified by:

iterate in interface java.util.stream.Stream<T>

See Also:

Stream.iterate(Object, UnaryOperator)

generate
```
static <T> SequenceM<T> generate(java.util.function.Supplier<T> s)
```
Specified by:

generate in interface org.jooq.lambda.Seq<T>

Specified by:

generate in interface java.util.stream.Stream<T>

See Also:

Stream.generate(Supplier)

unzip

static <T,U> org.jooq.lambda.tuple.Tuple2<SequenceM<T>,SequenceM<U>> unzip(SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> sequence)

Unzip a zipped Stream

  
  unzip(SequenceM.of(new Tuple2(1, "a"), new Tuple2(2, "b"), new Tuple2(3, "c")))
  
  // SequenceM[1,2,3], SequenceM[a,b,c]

unzip3

static <T1,T2,T3> org.jooq.lambda.tuple.Tuple3<SequenceM<T1>,SequenceM<T2>,SequenceM<T3>> unzip3(SequenceM<org.jooq.lambda.tuple.Tuple3<T1,T2,T3>> sequence)

Unzip a zipped Stream into 3

  
    unzip3(SequenceM.of(new Tuple3(1, "a", 2l), new Tuple3(2, "b", 3l), new Tuple3(3,"c", 4l)))
 
 // SequenceM[1,2,3], SequenceM[a,b,c], SequenceM[2l,3l,4l]

unzip4

static <T1,T2,T3,T4> org.jooq.lambda.tuple.Tuple4<SequenceM<T1>,SequenceM<T2>,SequenceM<T3>,SequenceM<T4>> unzip4(SequenceM<org.jooq.lambda.tuple.Tuple4<T1,T2,T3,T4>> sequence)

Unzip a zipped Stream into 4

  
 unzip4(SequenceM.of(new Tuple4(1, "a", 2l,'z'), new Tuple4(2, "b", 3l,'y'), new Tuple4(3,
						"c", 4l,'x')));
		
                // SequenceM[1,2,3], SequenceM[a,b,c], SequenceM[2l,3l,4l], SequenceM[z,y,x]

crossJoin

<U> SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> crossJoin(java.util.stream.Stream<U> other)

Specified by:: crossJoin in interface org.jooq.lambda.Seq<T>

innerJoin

default <U> SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> innerJoin(java.util.stream.Stream<U> other,
                                                                   java.util.function.BiPredicate<T,U> predicate)

Specified by:: innerJoin in interface org.jooq.lambda.Seq<T>

leftOuterJoin

default <U> SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> leftOuterJoin(java.util.stream.Stream<U> other,
                                                                       java.util.function.BiPredicate<T,U> predicate)

Specified by:: leftOuterJoin in interface org.jooq.lambda.Seq<T>

rightOuterJoin

<U> SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> rightOuterJoin(java.util.stream.Stream<U> other,
                                                                java.util.function.BiPredicate<T,U> predicate)

Specified by:: rightOuterJoin in interface org.jooq.lambda.Seq<T>

onEmptySwitch

default SequenceM<T> onEmptySwitch(java.util.function.Supplier<java.util.stream.Stream<T>> switchTo)

If this SequenceM is empty replace it with a another Stream

  
 assertThat(SequenceM.of(4,5,6)
							.onEmptySwitch(()->SequenceM.of(1,2,3))
							.toList(),
							equalTo(Arrays.asList(4,5,6)));

Parameters:: switchTo - Supplier that will generate the alternative Stream
Returns:: SequenceM that will switch to an alternative Stream if empty

onEmpty
```
SequenceM<T> onEmpty(T value)
```
Specified by:

onEmpty in interface org.jooq.lambda.Seq<T>

onEmptyGet
```
SequenceM<T> onEmptyGet(java.util.function.Supplier<T> supplier)
```
Specified by:

onEmptyGet in interface org.jooq.lambda.Seq<T>

onEmptyThrow

<X extends java.lang.Throwable> SequenceM<T> onEmptyThrow(java.util.function.Supplier<X> supplier)

Specified by:: onEmptyThrow in interface org.jooq.lambda.Seq<T>

concat
```
SequenceM<T> concat(java.util.stream.Stream<T> other)
```
Specified by:

concat in interface org.jooq.lambda.Seq<T>

concat
```
SequenceM<T> concat(T other)
```
Specified by:

concat in interface org.jooq.lambda.Seq<T>

concat
```
SequenceM<T> concat(T... other)
```
Specified by:

concat in interface org.jooq.lambda.Seq<T>

distinct

<U> SequenceM<T> distinct(java.util.function.Function<? super T,? extends U> keyExtractor)

Specified by:: distinct in interface org.jooq.lambda.Seq<T>

zip

<U,R> SequenceM<R> zip(org.jooq.lambda.Seq<U> other,
                       java.util.function.BiFunction<T,U,R> zipper)

Specified by:: zip in interface org.jooq.lambda.Seq<T>

shuffle
```
SequenceM<T> shuffle(java.util.Random random)
```
Specified by:

shuffle in interface org.jooq.lambda.Seq<T>

slice

SequenceM<T> slice(long from,
                   long to)

Specified by:: slice in interface org.jooq.lambda.Seq<T>

sorted

<U extends java.lang.Comparable<? super U>> SequenceM<T> sorted(java.util.function.Function<? super T,? extends U> function)

Specified by:: sorted in interface org.jooq.lambda.Seq<T>

xPer

SequenceM<T> xPer(int x,
                  long time,
                  java.util.concurrent.TimeUnit t)

emit x elements per time period

  
  SimpleTimer timer = new SimpleTimer();
		assertThat(SequenceM.of(1,2,3,4,5,6)
		                    .xPer(6,100000000,TimeUnit.NANOSECONDS)
		                    .collect(Collectors.toList()).size(),is(6));

Parameters:: x - number of elements to emit; time - period; t - Time unit
Returns:: SequenceM that emits x elements per time period

onePer

SequenceM<T> onePer(long time,
                    java.util.concurrent.TimeUnit t)

emit one element per time period

  
 SequenceM.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->{});

Parameters:: time - period; t - Time unit
Returns:: SequenceM that emits 1 element per time period

debounce

SequenceM<T> debounce(long time,
                      java.util.concurrent.TimeUnit t)

Allow one element through per time period, drop all other elements in that time period

  
 SequenceM.of(1,2,3,4,5,6)
          .debounce(1000,TimeUnit.SECONDS).toList();
          
 // 1

Parameters:: time -; t -
Returns:

batchBySizeAndTime

SequenceM<java.util.List<T>> batchBySizeAndTime(int size,
                                                long time,
                                                java.util.concurrent.TimeUnit t)

Batch elements by size into a List

 
 SequenceM.of(1,2,3,4,5,6)
				.batchBySizeAndTime(3,10,TimeUnit.SECONDS)
				.toList();
			
 //[[1,2,3],[4,5,6]]

Parameters:: size - Max size of a batch; time - (Max) time period to build a single batch in; t - time unit for batch
Returns:: SequenceM batched by size and time

batchBySizeAndTime

<C extends java.util.Collection<T>> SequenceM<C> batchBySizeAndTime(int size,
                                                                    long time,
                                                                    java.util.concurrent.TimeUnit unit,
                                                                    java.util.function.Supplier<C> factory)

Batch elements by size into a collection created by the supplied factory

  
 List<ArrayList<Integer>> list = of(1,2,3,4,5,6)
					.batchBySizeAndTime(10,1,TimeUnit.MICROSECONDS,()->new ArrayList<>())
					.toList();

Parameters:: size - Max size of a batch; time - (Max) time period to build a single batch in; unit - time unit for batch; factory - Collection factory
Returns:: SequenceM batched by size and time

batchByTime

SequenceM<java.util.List<T>> batchByTime(long time,
                                         java.util.concurrent.TimeUnit t)

Batch elements in a Stream by time period

  
 assertThat(SequenceM.of(1,2,3,4,5,6).batchByTime(1,TimeUnit.SECONDS).collect(Collectors.toList()).size(),is(1));
 assertThat(SequenceM.of(1,2,3,4,5,6).batchByTime(1,TimeUnit.NANOSECONDS).collect(Collectors.toList()).size(),greaterThan(5));

Parameters:: time - - time period to build a single batch in; t - time unit for batch
Returns:: SequenceM batched into lists by time period

batchByTime

<C extends java.util.Collection<T>> SequenceM<C> batchByTime(long time,
                                                             java.util.concurrent.TimeUnit unit,
                                                             java.util.function.Supplier<C> factory)

Batch elements by time into a collection created by the supplied factory

  
   assertThat(SequenceM.of(1,1,1,1,1,1)
                       .batchByTime(1500,TimeUnit.MICROSECONDS,()-> new TreeSet<>())
                       .toList()
                       .get(0)
                       .size(),is(1));

Parameters:: time - - time period to build a single batch in; unit - time unit for batch; factory - Collection factory
Returns:: SequenceM batched into collection types by time period

batchBySize

SequenceM<java.util.List<T>> batchBySize(int size)

Batch elements in a Stream by size into Lists

  
  assertThat(SequenceM.of(1,2,3,4,5,6)
                      .batchBySize(3)
                      .collect(Collectors.toList())
                      .size(),is(2));

Parameters:: size - of batch
Returns:: SequenceM batched by size into Lists

batchBySize

<C extends java.util.Collection<T>> SequenceM<C> batchBySize(int size,
                                                             java.util.function.Supplier<C> supplier)

Batch elements in a Stream by size into a collection created by the supplied factory

 
 assertThat(SequenceM.of(1,1,1,1,1,1)
 						.batchBySize(3,()->new TreeSet<>())
 						.toList()
 						.get(0)
 						.size(),is(1));

Parameters:: size - batch size; supplier - Collection factory
Returns:: SequenceM batched into collection types by size

fixedDelay

SequenceM<T> fixedDelay(long l,
                        java.util.concurrent.TimeUnit unit)

emit elements after a fixed delay

  
 	SimpleTimer timer = new SimpleTimer();
		assertThat(SequenceM.of(1,2,3,4,5,6)
							.fixedDelay(10000,TimeUnit.NANOSECONDS)
							.collect(Collectors.toList())
							.size(),is(6));
		assertThat(timer.getElapsedNanoseconds(),greaterThan(60000l));

Parameters:: l - time length in nanos of the delay; unit - for the delay
Returns:: SequenceM that emits each element after a fixed delay

jitter

SequenceM<T> jitter(long maxJitterPeriodInNanos)

Introduce a random jitter / time delay between the emission of elements

  
 SimpleTimer timer = new SimpleTimer();
		assertThat(SequenceM.of(1,2,3,4,5,6)
							.jitter(10000)
							.collect(Collectors.toList())
							.size(),is(6));
		assertThat(timer.getElapsedNanoseconds(),greaterThan(20000l));

Parameters:: maxJitterPeriodInNanos - - random number less than this is used for each jitter
Returns:: Sequence with a random jitter between element emission

windowBySizeAndTime

SequenceM<Streamable<T>> windowBySizeAndTime(int maxSize,
                                             long maxTime,
                                             java.util.concurrent.TimeUnit maxTimeUnit)

Create a Sequence of Streamables (replayable Streams / Sequences) where each Streamable is populated up to a max size, or for max period of time

  
 assertThat(SequenceM.of(1,2,3,4,5,6)
						.windowBySizeAndTime(3,10,TimeUnit.SECONDS)
						.toList()
						.get(0)
						.stream()
						.count(),is(3l));

Parameters:: maxSize - of window; maxTime - of window; maxTimeUnit - of window
Returns:: Windowed SequenceM

windowWhile
```
SequenceM<Streamable<T>> windowWhile(java.util.function.Predicate<T> predicate)
```
Create a Sequence of Streamables (replayable Streams / Sequences) where each Streamable is populated while the supplied predicate holds. When the predicate failsa new window/ Stremable opens
```
 
 SequenceM.of(1,2,3,4,5,6)
				.windowWhile(i->i%3!=0)
				.forEach(System.out::println);
 
 StreamableImpl(streamable=[1, 2, 3]) 
 StreamableImpl(streamable=[4, 5, 6])
 
 
```
Parameters:

predicate - Window while true

Returns:

SequenceM windowed while predicate holds

windowUntil
```
SequenceM<Streamable<T>> windowUntil(java.util.function.Predicate<T> predicate)
```
Create a Sequence of Streamables (replayable Streams / Sequences) where each Streamable is populated until the supplied predicate holds. When the predicate failsa new window/ Stremable opens
```
 
 SequenceM.of(1,2,3,4,5,6)
				.windowUntil(i->i%3==0)
				.forEach(System.out::println);
 
 StreamableImpl(streamable=[1, 2, 3]) 
 StreamableImpl(streamable=[4, 5, 6])
 
 
```
Parameters:

predicate - Window until true

Returns:

SequenceM windowed until predicate holds

windowStatefullyWhile
```
SequenceM<Streamable<T>> windowStatefullyWhile(java.util.function.BiPredicate<Streamable<T>,T> predicate)
```
Create SequenceM of Streamables (replayable Streams / Sequences) where each Streamable is populated while the supplied bipredicate holds. The bipredicate recieves the Streamable from the last window as well as the current value and can choose to aggregate the current value or create a new window
```
 
 assertThat(SequenceM.of(1,2,3,4,5,6)
				.windowStatefullyWhile((s,i)->s.sequenceM().toList().contains(4) ? true : false)
				.toList().size(),equalTo(5));
 
 
```
Parameters:

predicate - Window while true

Returns:

SequenceM windowed while predicate holds

windowByTime

SequenceM<Streamable<T>> windowByTime(long time,
                                      java.util.concurrent.TimeUnit t)

Create SequenceM of Streamables (replayable Streams / Sequences) where each Streamable is populated within a specified time window

  
 assertThat(SequenceM.of(1,2,3,4,5, 6)
							.map(n-> n==6? sleep(1) : n)
							.windowByTime(10,TimeUnit.MICROSECONDS)
							.toList()
							.get(0).sequenceM().toList()
							,not(hasItem(6)));

Parameters:: time - max time per window; t - time unit per window
Returns:: SequenceM windowed by time

batchUntil
```
SequenceM<java.util.List<T>> batchUntil(java.util.function.Predicate<T> predicate)
```
Create a SequenceM batched by List, where each batch is populated until the predicate holds
```
 
 assertThat(SequenceM.of(1,2,3,4,5,6)
				.batchUntil(i->i%3==0)
				.toList()
				.size(),equalTo(2));
 
 
```
Parameters:

predicate - Batch until predicate holds, then open next batch

Returns:

SequenceM batched into lists determined by the predicate supplied

batchWhile
```
SequenceM<java.util.List<T>> batchWhile(java.util.function.Predicate<T> predicate)
```
Create a SequenceM batched by List, where each batch is populated while the predicate holds
```
 
 assertThat(SequenceM.of(1,2,3,4,5,6)
				.batchWhile(i->i%3!=0)
				.toList().size(),equalTo(2));
	
 
 
```
Parameters:

predicate - Batch while predicate holds, then open next batch

Returns:

SequenceM batched into lists determined by the predicate supplied

batchWhile

<C extends java.util.Collection<T>> SequenceM<C> batchWhile(java.util.function.Predicate<T> predicate,
                                                            java.util.function.Supplier<C> factory)

Create a SequenceM batched by a Collection, where each batch is populated while the predicate holds

  
 assertThat(SequenceM.of(1,2,3,4,5,6)
				.batchWhile(i->i%3!=0)
				.toList()
				.size(),equalTo(2));

Parameters:: predicate - Batch while predicate holds, then open next batch; factory - Collection factory
Returns:: SequenceM batched into collections determined by the predicate supplied

batchUntil

<C extends java.util.Collection<T>> SequenceM<C> batchUntil(java.util.function.Predicate<T> predicate,
                                                            java.util.function.Supplier<C> factory)

Create a SequenceM batched by a Collection, where each batch is populated until the predicate holds

  
 assertThat(SequenceM.of(1,2,3,4,5,6)
				.batchUntil(i->i%3!=0)
				.toList()
				.size(),equalTo(2));

Parameters:: predicate - Batch until predicate holds, then open next batch; factory - Collection factory
Returns:: SequenceM batched into collections determined by the predicate supplied

recover

SequenceM<T> recover(java.util.function.Function<java.lang.Throwable,T> fn)

Recover from an exception with an alternative value

  
 assertThat(SequenceM.of(1,2,3,4)
						   .map(i->i+2)
						   .map(u->{throw new RuntimeException();})
						   .recover(e->"hello")
						   .firstValue(),equalTo("hello"));

Parameters:: fn - Function that accepts a Throwable and returns an alternative value
Returns:: SequenceM that can recover from an Exception

recover

<EX extends java.lang.Throwable> SequenceM<T> recover(java.lang.Class<EX> exceptionClass,
                                                      java.util.function.Function<EX,T> fn)

Recover from a particular exception type

  
 assertThat(SequenceM.of(1,2,3,4)
					.map(i->i+2)
					.map(u->{ExceptionSoftener.throwSoftenedException( new IOException()); return null;})
					.recover(IOException.class,e->"hello")
					.firstValue(),equalTo("hello"));

Parameters:: exceptionClass - Type to recover from; fn - That accepts an error and returns an alternative value
Returns:: Sequence that can recover from a particular exception

retry

default <R> SequenceM<R> retry(java.util.function.Function<T,R> fn)

Retry a transformation if it fails. Default settings are to retry up to 7 times, with an doubling backoff period starting @ 2 seconds delay before retry.

  
 given(serviceMock.apply(anyInt())).willThrow(
				new RuntimeException(new SocketException("First")),
				new RuntimeException(new IOException("Second"))).willReturn(
				"42");

	
		String result = SequenceM.of( 1,  2, 3)
				.retry(serviceMock)
				.firstValue();

		assertThat(result, is("42"));

Parameters:: fn - Function to retry if fails

Interface SequenceM<T>

Nested Class Summary

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

Method Summary

Methods inherited from interface org.jooq.lambda.Seq

Methods inherited from interface java.util.stream.Stream

Methods inherited from interface java.util.stream.BaseStream

Methods inherited from interface java.lang.Iterable

Methods inherited from interface org.reactivestreams.Publisher

Method Detail

unwrap

flatten

toOptional

toCompletableFuture

cycle

cycle

duplicateSequence

triplicate

quadruplicate

splitSequenceAtHead

splitAt

splitBy

partitionSequence

cycle

cycle

cycleWhile

cycleUntil

zipStream

zip

zip3

zip4

zipWithIndex

zipSequence

zipAnyM

zipStream

sliding

sliding

grouped

groupBy

distinct

scanLeft

scanLeft

scanRight

scanRight

sorted

sorted

skip

skipWhile

skipUntil

limit

limitWhile

limitUntil

parallel

allMatch

anyMatch

xMatch

noneMatch

join

join

join

minBy

min

maxBy

max

headAndTail

headAndTailOptional

findFirst

findAny

mapReduce

mapReduce

collectStream

collectIterable

reduce

reduce

reduce

reduce

reduce

reduce

foldLeft

foldLeft