SequenceM (cyclops-base 5.1.0 API)

java.lang.Object
- com.aol.cyclops.lambda.monads.SequenceM<T>

All Implemented Interfaces:

Unwrapable, java.lang.AutoCloseable, java.lang.Iterable<T>, java.util.stream.BaseStream<T,java.util.stream.Stream<T>>, java.util.stream.Stream<T>
```
public class SequenceM<T>
extends java.lang.Object
implements Unwrapable, java.util.stream.Stream<T>, java.lang.Iterable<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 Concrete Methods
Modifier and Type	Method and Description
`boolean`	`allMatch(java.util.function.Predicate<? super T> c)` True if predicate matches all elements when Monad converted to a Stream
`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
`<U> SequenceM<U>`	`cast(java.lang.Class<U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`void`	`close()`
`<R,A> R`	`collect(java.util.stream.Collector<? super T,A,R> collector)` Mutable reduction / collection over this Monad converted to a Stream
`java.util.List`	`collect(java.util.stream.Stream<java.util.stream.Collector> collectors)` Apply multiple collectors Simulataneously to this Monad
`<R> R`	`collect(java.util.function.Supplier<R> supplier, java.util.function.BiConsumer<R,? super T> accumulator, java.util.function.BiConsumer<R,R> combiner)`
`<R> java.util.List<R>`	`collectIterable(java.lang.Iterable<java.util.stream.Collector> collectors)` Apply multiple Collectors, simultaneously to a Stream
`long`	`count()`
`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>`	`deleteBetween(int start, int end)` Delete elements between given indexes in a Stream
`SequenceM<T>`	`distinct()`
`Pair<SequenceM<T>,SequenceM<T>>`	`duplicate()` Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
`static <T> SequenceM<T>`	`empty()`
`SequenceM<T>`	`filter(java.util.function.Predicate<? super T> fn)`
`java.util.Optional<T>`	`findAny()`
`java.util.Optional<T>`	`findFirst()`
`<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)`
`<R> SequenceM<R>`	`flatMapCollection(java.util.function.Function<? super T,java.util.Collection<? extends R>> fn)` Convenience method & performance optimisation flatMapping to a Stream will result in the Stream being converted to a List, if the host Monad type is not a Stream.
`<R> SequenceM<R>`	`flatMapCompletableFuture(java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn)`
`<R> SequenceM<R>`	`flatMapLazySeq(java.util.function.Function<? super T,com.nurkiewicz.lazyseq.LazySeq<? extends R>> fn)`
`<R> SequenceM<R>`	`flatMapOptional(java.util.function.Function<? super T,java.util.Optional<? extends R>> fn)`
`<R> SequenceM<R>`	`flatMapStream(java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn)`
`java.util.stream.DoubleStream`	`flatMapToDouble(java.util.function.Function<? super T,? extends java.util.stream.DoubleStream> mapper)`
`java.util.stream.IntStream`	`flatMapToInt(java.util.function.Function<? super T,? extends java.util.stream.IntStream> mapper)`
`java.util.stream.LongStream`	`flatMapToLong(java.util.function.Function<? super T,? extends java.util.stream.LongStream> mapper)`
`<T1> SequenceM<T1>`	`flatten()` join / flatten one level of a nested hierarchy
`T`	`foldLeft(Monoid<T> reducer)`
`T`	`foldLeft(T identity, java.util.function.BinaryOperator<T> accumulator)`
`<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)`
`T`	`foldRight(T identity, java.util.function.BinaryOperator<T> accumulator)`
`<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
`void`	`forEach(java.util.function.Consumer<? super T> action)`
`void`	`forEachOrdered(java.util.function.Consumer<? super T> action)`
`static <T> SequenceM<T>`	`fromIterable(java.lang.Iterable<T> iterable)` Construct a Sequence from an Iterable
`static <T> SequenceM<T>`	`fromStream(java.util.stream.Stream<T> stream)` Construct a Sequence from a Stream
`<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
`java.util.Optional<HeadAndTail<T>>`	`headAndTailOptional()`
`SequenceM<T>`	`insertAt(int pos, T... values)` Insert data into a stream at given position
`SequenceM<T>`	`insertStreamAt(int pos, SequenceM<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.
`boolean`	`isParallel()`
`java.util.Iterator<T>`	`iterator()`
`java.lang.String`	`join()` `assertEquals("123".length(),of(1, 2, 3).join().length());`
`java.lang.String`	`join(java.lang.String sep)` `assertEquals("1, 2, 3".length(), 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());`
`SequenceM<java.lang.String>`	`liftAndBindBufferedReader(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>`	`liftAndBindCharSequence(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.
`SequenceM<java.lang.String>`	`liftAndBindFile(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.
`SequenceM<java.lang.String>`	`liftAndBindURL(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
`SequenceM<T>`	`limit(long num)` `assertThat(anyM(Stream.of(4,3,6,7)).asSequence().limit(2).toList(),equalTo(Arrays.asList(4,3)));`
`SequenceM<T>`	`limitUntil(java.util.function.Predicate<? super T> p)` `assertThat(anyM(Stream.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(anyM(Stream.of(4,3,6,7)).asSequence().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 Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
`java.util.stream.DoubleStream`	`mapToDouble(java.util.function.ToDoubleFunction<? super T> mapper)`
`java.util.stream.IntStream`	`mapToInt(java.util.function.ToIntFunction<? super T> mapper)`
`java.util.stream.LongStream`	`mapToLong(java.util.function.ToLongFunction<? super T> mapper)`
`java.util.Optional<T>`	`max(java.util.Comparator<? super T> comparator)`
`<C extends java.lang.Comparable<? super C>> java.util.Optional<T>`	`maxBy(java.util.function.Function<T,C> f)`
`java.util.Optional<T>`	`min(java.util.Comparator<? super T> comparator)`
`<C extends java.lang.Comparable<? super 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)` Construct a 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.
`java.util.stream.Stream<T>`	`onClose(java.lang.Runnable closeHandler)`
`SequenceM<T>`	`parallel()`
`Pair<SequenceM<T>,SequenceM<T>>`	`partition(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
`Quadruple<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.
`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)`
`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)`
`SequenceM<T>`	`reverse()`
`static <T> SequenceM<T>`	`reversedListOf(java.util.List<T> elements)` Construct a Reveresed Sequence from the provided elements
`static <T> SequenceM<T>`	`reversedOf(T... elements)` Construct a Reveresed Sequence from the provided elements
`SequenceM<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`SequenceM<T>`	`scanLeft(T identity, java.util.function.BiFunction<T,T,T> combiner)` Scan left
`SequenceM<T>`	`scanRight(Monoid<T> monoid)` Scan right
`<U> SequenceM<T>`	`scanRight(T identity, java.util.function.BiFunction<T,T,T> combiner)` Scan right
`SequenceM<T>`	`sequential()`
`SequenceM<T>`	`shuffle()`
`SequenceM<T>`	`skip(long num)` `assertThat(anyM(Stream.of(4,3,6,7)).asSequence().skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`SequenceM<T>`	`skipUntil(java.util.function.Predicate<? super T> p)` `assertThat(anyM(Stream.of(4,3,6,7)).asSequence().skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));`
`SequenceM<T>`	`skipWhile(java.util.function.Predicate<? super T> p)` `assertThat(anyM(Stream.of(4,3,6,7)).asSequence().sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));`
`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(anyM(Stream.of(4,3,6,7)).asSequence().sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));`
`Pair<SequenceM<T>,SequenceM<T>>`	`splitAt(int where)` Split at supplied location
`Pair<java.util.Optional<T>,SequenceM<T>>`	`splitAtHead()` Split a Stream at it's head (similar to headAndTail)
`Pair<SequenceM<T>,SequenceM<T>>`	`splitBy(java.util.function.Predicate<T> splitter)` Split stream at point where predicate no longer holds
`java.util.Spliterator<T>`	`spliterator()`
`boolean`	`startsWith(java.lang.Iterable<T> iterable)` `assertTrue(monad(Stream.of(1,2,3,4)).startsWith(Arrays.asList(1,2,3)));`
`boolean`	`startsWith(java.util.Iterator<T> iterator)` `assertTrue(monad(Stream.of(1,2,3,4)).startsWith(Arrays.asList(1,2,3).iterator()))`
`java.util.stream.Stream<T>`	`stream()` Unwrap this Monad into a Stream.
`java.lang.Object[]`	`toArray()`
`<A> A[]`	`toArray(java.util.function.IntFunction<A[]> generator)`
`<C extends java.util.Collection<T>> C`	`toCollection(java.util.function.Supplier<C> collectionFactory)`
`java.util.Collection<T>`	`toConcurrentLazyCollection()` Lazily converts this SequenceM into a Collection.
`Streamable<T>`	`toConcurrentLazyStreamable()`
`java.util.Collection<T>`	`toLazyCollection()` Lazily converts this SequenceM into a Collection.
`Streamable<T>`	`toLazyStreamable()`
`java.util.List<T>`	`toList()`
`java.util.Set<T>`	`toSet()`
`<T> java.util.stream.Stream<T>`	`toStream()`
`Streamable<T>`	`toStreamable()`
`Triple<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()`
`java.util.concurrent.CompletableFuture<java.util.List<T>>`	`unwrapCompletableFuture()` `CompletableFuture<List<String>> cf = anyM("hello","world") .asSequence() .unwrapCompletableFuture(); assertThat(cf.join(),equalTo(Arrays.asList("hello","world")));`
`java.util.Optional<java.util.List<T>>`	`unwrapOptional()` Type safe unwrap
`java.util.stream.Stream<T>`	`unwrapStream()` Type safe unwrap
`static <T,U> Pair<SequenceM<T>,SequenceM<U>>`	`unzip(SequenceM<Pair<T,U>> sequence)` Unzip a zipped Stream
`static <T1,T2,T3> Triple<SequenceM<T1>,SequenceM<T2>,SequenceM<T3>>`	`unzip3(SequenceM<Triple<T1,T2,T3>> sequence)` Unzip a zipped Stream into 3
`static <T1,T2,T3,T4> Quadruple<SequenceM<T1>,SequenceM<T2>,SequenceM<T3>,SequenceM<T4>>`	`unzip4(SequenceM<Quadruple<T1,T2,T3,T4>> sequence)` Unzip a zipped Stream into 4
`boolean`	`xMatch(int num, java.util.function.Predicate<? super T> c)` Check that there are specified number of matches of predicate in the Stream
`<S,R> SequenceM<R>`	`zip(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>`	`zip(SequenceM<? extends S> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper)` Generic zip function.
`<S> SequenceM<Pair<T,S>>`	`zip(java.util.stream.Stream<? extends S> second)` Zip 2 streams into one
`<S,U> SequenceM<Triple<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<Quadruple<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>`	`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
`SequenceM<Pair<T,java.lang.Long>>`	`zipWithIndex()` Add an index to the current Stream

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

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

Method Detail

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

unwrap in interface Unwrapable

flatten

public final <T1> SequenceM<T1> flatten()

join / flatten one level of a nested hierarchy

  
  assertThat(SequenceM.<Integer>of(Arrays.asList(1,2)).flatten().toList().size(),equalTo(asList(1,  2).size()));		
  
  // 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

unwrapStream

public final java.util.stream.Stream<T> unwrapStream()

Type safe unwrap

  
 Stream<String> stream = anyM("hello","world").asSequence().unwrapStream();
		assertThat(stream.collect(Collectors.toList()),equalTo(Arrays.asList("hello","world")));

Returns:: Stream with current wrapped values

unwrapOptional

public final java.util.Optional<java.util.List<T>> unwrapOptional()

Type safe unwrap

  
 Optional<List<String>> stream = anyM("hello","world")
											.asSequence()
											.unwrapOptional();
		assertThat(stream.get(),equalTo(Arrays.asList("hello","world")));

Returns:

unwrapCompletableFuture

public final java.util.concurrent.CompletableFuture<java.util.List<T>> unwrapCompletableFuture()

  
 CompletableFuture<List<String>> cf = anyM("hello","world")
											.asSequence()
											.unwrapCompletableFuture();
		assertThat(cf.join(),equalTo(Arrays.asList("hello","world")));

Returns:

cycle

public final SequenceM<T> cycle(int times)

Convert to a Stream with the values repeated specified times

  
 		assertThat(anyM(Stream.of(1,2,2)).asSequence()
											.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

public final SequenceM<T> cycle()

Convert to a Stream with the values infinitely cycled

  
   assertEquals(asList(1, 1, 1, 1, 1,1),of(1).cycle().limit(6).toList());

Returns:: Stream with values repeated

duplicate

public final Pair<SequenceM<T>,SequenceM<T>> duplicate()

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

  
  Pair<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

public final Triple<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.

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

quadruplicate

public final Quadruple<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.

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

Returns:

splitAtHead

public final Pair<java.util.Optional<T>,SequenceM<T>> splitAtHead()

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

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

splitAt

public final Pair<SequenceM<T>,SequenceM<T>> splitAt(int where)

Split at supplied location

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

splitBy

public final Pair<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]

partition

public final Pair<SequenceM<T>,SequenceM<T>> partition(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]

unzip

public static final <T,U> Pair<SequenceM<T>,SequenceM<U>> unzip(SequenceM<Pair<T,U>> sequence)

Unzip a zipped Stream

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

unzip3

public static final <T1,T2,T3> Triple<SequenceM<T1>,SequenceM<T2>,SequenceM<T3>> unzip3(SequenceM<Triple<T1,T2,T3>> sequence)

Unzip a zipped Stream into 3

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

unzip4

public static final <T1,T2,T3,T4> Quadruple<SequenceM<T1>,SequenceM<T2>,SequenceM<T3>,SequenceM<T4>> unzip4(SequenceM<Quadruple<T1,T2,T3,T4>> sequence)

Unzip a zipped Stream into 4

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

cycle

public final 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

public final <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

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

Repeat in a Stream while specified predicate holds

 
 count =0;
		assertThat(anyM(Stream.of(1,2,2)).asSequence()
											.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

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

Repeat in a Stream until specified predicate holds

  
 	count =0;
		assertThat(anyM(Stream.of(1,2,2)).asSequence()
											.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

zip

public final <S> SequenceM<Pair<T,S>> zip(java.util.stream.Stream<? extends S> second)

Zip 2 streams into one

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

zip3

public final <S,U> SequenceM<Triple<T,S,U>> zip3(java.util.stream.Stream<? extends S> second,
                                                 java.util.stream.Stream<? extends U> third)

zip 3 Streams into one

  
 List<Triple<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

public final <T2,T3,T4> SequenceM<Quadruple<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<Quadruple<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

public final SequenceM<Pair<T,java.lang.Long>> zipWithIndex()

Add an index to the current Stream

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

zip

public final <S,R> SequenceM<R> zip(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

zip

public final <S,R> SequenceM<R> zip(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

public final <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

public final 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

public final 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

public final 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

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

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

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

scanLeft

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

Scan left using supplied Monoid

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

Parameters:: monoid -
Returns:

scanLeft

public final SequenceM<T> scanLeft(T identity,
                                   java.util.function.BiFunction<T,T,T> combiner)

Scan left

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

scanRight

public final 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

public final <U> SequenceM<T> scanRight(T identity,
                                        java.util.function.BiFunction<T,T,T> 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()));

sorted

public final SequenceM<T> sorted()

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

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

sorted

public final SequenceM<T> sorted(java.util.Comparator<? super T> c)

  
 	assertThat(anyM(Stream.of(4,3,6,7)).asSequence().sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));

Specified by:: sorted in interface java.util.stream.Stream<T>
Parameters:: c - Compartor to sort with
Returns:: Sorted Monad

skip
```
public final SequenceM<T> skip(long num)
```
```
 assertThat(anyM(Stream.of(4,3,6,7)).asSequence().skip(2).toList(),equalTo(Arrays.asList(6,7))); 
 
```
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

public final SequenceM<T> skipWhile(java.util.function.Predicate<? super T> p)

 
 assertThat(anyM(Stream.of(4,3,6,7)).asSequence().sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));

Parameters:: p - Predicate to skip while true
Returns:: Monad converted to Stream with elements skipped while predicate holds

skipUntil

public final SequenceM<T> skipUntil(java.util.function.Predicate<? super T> p)

  assertThat(anyM(Stream.of(4,3,6,7)).asSequence().skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));

Parameters:: p - Predicate to skip until true
Returns:: Monad converted to Stream with elements skipped until predicate holds

limit
```
public final SequenceM<T> limit(long num)
```
```
 assertThat(anyM(Stream.of(4,3,6,7)).asSequence().limit(2).toList(),equalTo(Arrays.asList(4,3)));
 
```
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

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

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

Parameters:: p - Limit while predicate is true
Returns:: Monad converted to Stream with limited elements

limitUntil

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

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

Parameters:: p - Limit until predicate is true
Returns:: Monad converted to Stream with limited elements

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

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

Returns:

this monad converted to a Parallel Stream, via streamedMonad() wraped in the SequenceM interface

allMatch
```
public final boolean allMatch(java.util.function.Predicate<? super T> c)
```
True if predicate matches all elements when Monad converted to a Stream
```
 
 assertThat(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
```
public final boolean anyMatch(java.util.function.Predicate<? super T> c)
```
True if a single element matches when Monad converted to a Stream
```
 
 assertThat(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

public 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

public final boolean noneMatch(java.util.function.Predicate<? super T> c)

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

join

public final java.lang.String join()

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

Returns:: Stream as concatenated String

join

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

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

Returns:: Stream as concatenated String

join

public final 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

public final <C extends java.lang.Comparable<? super C>> java.util.Optional<T> minBy(java.util.function.Function<T,C> f)

Extract the minimum as determined by supplied function

min

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

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

maxBy

public final <C extends java.lang.Comparable<? super C>> java.util.Optional<T> maxBy(java.util.function.Function<T,C> f)

max

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

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

headAndTail

public final HeadAndTail<T> headAndTail()

extract head and tail together

 
  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

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

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

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

Returns:

First matching element in sequential order (deterministic)

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

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

Returns:

first matching element, but order is not guaranteed (non-deterministic)

mapReduce
```
public final <R> R mapReduce(Monoid<R> 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

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

mapReduce
```
public final <R> R mapReduce(java.util.function.Function<? super T,? extends R> mapper,
 Monoid<R> reducer)
```
Attempt to map this Monad to the same type as the supplied Monoid, using supplied function Then use Monoid to reduce values

Parameters:

mapper - Function to map Monad type

reducer - Monoid to reduce values

Returns:

Reduce result

collect
```
public final <R,A> R collect(java.util.stream.Collector<? super T,A,R> collector)
```
Mutable reduction / collection over this Monad converted to a Stream

Specified by:

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

Parameters:

collector - Collection operation definition

Returns:

Collected result

collect

public final <R> R collect(java.util.function.Supplier<R> supplier,
                           java.util.function.BiConsumer<R,? super T> accumulator,
                           java.util.function.BiConsumer<R,R> combiner)

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

collect

public final java.util.List collect(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

public <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
```
public final T reduce(Monoid<T> reducer)
```
Parameters:

reducer - Use supplied Monoid to reduce values

Returns:

reduced values

reduce

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

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

reduce

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

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

reduce

public final <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
```
public final 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)

Parameters:

reducers -

Returns:

reduce
```
public final 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. I.e. streamedMonad().reduce(reducer)

Parameters:

reducers -

Returns:

foldLeft
```
public final T foldLeft(Monoid<T> reducer)
```
Parameters:

reducer - Use supplied Monoid to reduce values starting via foldLeft

Returns:

Reduced result

foldLeft

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

foldLeftMapToType
```
public final <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

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

foldRight
```
public final T foldRight(Monoid<T> reducer)
```
Parameters:

reducer - Use supplied Monoid to reduce values starting via foldRight

Returns:

Reduced result

foldRight

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

foldRightMapToType
```
public final <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

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

toStreamable
```
public final Streamable<T> toStreamable()
```
Returns:

Underlying monad converted to a Streamable instance

toSet
```
public final java.util.Set<T> toSet()
```
Returns:

This monad converted to a set

toList
```
public final java.util.List<T> toList()
```
Returns:

this monad converted to a list

toCollection

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

toStream
```
public final <T> java.util.stream.Stream<T> toStream()
```
Returns:

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

stream
```
public final java.util.stream.Stream<T> stream()
```
Unwrap this Monad into a Stream. If the underlying monad is a Stream it is returned Otherwise we flatMap the underlying monad to a Stream type

startsWith

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

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

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

startsWith

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

 assertTrue(monad(Stream.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
```
public AnyM<T> anyM()
```

map

public final <R> SequenceM<R> map(java.util.function.Function<? super T,? extends R> fn)

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

peek

public final SequenceM<T> peek(java.util.function.Consumer<? super T> c)

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

flatMap

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

flatMap operation

Specified by:: flatMap in interface java.util.stream.Stream<T>
Parameters:: fn -
Returns:

flatMapAnyM

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

flatMapCollection

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

Convenience method & performance optimisation flatMapping to a Stream will result in the Stream being converted to a List, if the host Monad type is not a Stream. (i.e.

    
   AnyM<Integer> opt = anyM(Optional.of(20));
   Optional<List<Integer>> optionalList = opt.flatMap( i -> anyM(Stream.of(1,2,i))).unwrap();  
   
   //Optional [1,2,20]

In such cases using Arrays.asList would be more performant

    
   AnyM<Integer> opt = anyM(Optional.of(20));
   Optional<List<Integer>> optionalList = opt.flatMapCollection( i -> asList(1,2,i))).unwrap();  
   
   //Optional [1,2,20]

Parameters:: fn -
Returns:

flatMapStream

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

flatMapOptional

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

flatMapCompletableFuture

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

flatMapLazySeq

public final <R> SequenceM<R> flatMapLazySeq(java.util.function.Function<? super T,com.nurkiewicz.lazyseq.LazySeq<? extends R>> fn)

liftAndBindCharSequence

public final SequenceM<java.lang.Character> liftAndBindCharSequence(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 = anyM("input.file")
									.asSequence()
									.liftAndBindCharSequence(i->"hello world")
									.toList();
		
		assertThat(result,equalTo(Arrays.asList('h','e','l','l','o',' ','w','o','r','l','d')));

Parameters:: fn -
Returns:

liftAndBindFile

public final SequenceM<java.lang.String> liftAndBindFile(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 = anyM("input.file")
								.asSequence()
								.map(getClass().getClassLoader()::getResource)
								.peek(System.out::println)
								.map(URL::getFile)
								.liftAndBindFile(File::new)
								.toList();
		
		assertThat(result,equalTo(Arrays.asList("hello","world")));

Parameters:: fn -
Returns:

liftAndBindURL

public final SequenceM<java.lang.String> liftAndBindURL(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 = anyM("input.file")
								.asSequence()
								.liftAndBindURL(getClass().getClassLoader()::getResource)
								.toList();
		
		assertThat(result,equalTo(Arrays.asList("hello","world")));

Parameters:: fn -
Returns:

liftAndBindBufferedReader

public final SequenceM<java.lang.String> liftAndBindBufferedReader(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 = anyM("input.file")
                                                                .asSequence()
                                                                .map(getClass().getClassLoader()::getResourceAsStream)
                                                                .map(InputStreamReader::new)
                                                                .liftAndBindBufferedReader(BufferedReader::new)
                                                                .toList();
                
                assertThat(result,equalTo(Arrays.asList("hello","world")));

Parameters:: fn -
Returns:

filter

public final SequenceM<T> filter(java.util.function.Predicate<? super T> fn)

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

forEach
```
public void forEach(java.util.function.Consumer<? super T> action)
```
Specified by:

forEach in interface java.lang.Iterable<T>

Specified by:

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

iterator
```
public java.util.Iterator<T> iterator()
```
Specified by:

iterator in interface java.lang.Iterable<T>

Specified by:

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

spliterator
```
public java.util.Spliterator<T> spliterator()
```
Specified by:

spliterator in interface java.lang.Iterable<T>

Specified by:

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

isParallel
```
public boolean isParallel()
```
Specified by:

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

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

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

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

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

mapToInt

public java.util.stream.IntStream mapToInt(java.util.function.ToIntFunction<? super T> mapper)

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

mapToLong

public java.util.stream.LongStream mapToLong(java.util.function.ToLongFunction<? super T> mapper)

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

mapToDouble

public java.util.stream.DoubleStream mapToDouble(java.util.function.ToDoubleFunction<? super T> mapper)

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

flatMapToInt

public java.util.stream.IntStream flatMapToInt(java.util.function.Function<? super T,? extends java.util.stream.IntStream> mapper)

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

flatMapToLong

public java.util.stream.LongStream flatMapToLong(java.util.function.Function<? super T,? extends java.util.stream.LongStream> mapper)

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

flatMapToDouble

public java.util.stream.DoubleStream flatMapToDouble(java.util.function.Function<? super T,? extends java.util.stream.DoubleStream> mapper)

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

forEachOrdered
```
public void forEachOrdered(java.util.function.Consumer<? super T> action)
```
Specified by:

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

toArray
```
public java.lang.Object[] toArray()
```
Specified by:

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

toArray

public <A> A[] toArray(java.util.function.IntFunction<A[]> generator)

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

count
```
public long count()
```
Specified by:

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

intersperse
```
public 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)

ofType
```
public  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)

cast
```
public  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)

toLazyCollection

public 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

public 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:

toLazyStreamable
```
public Streamable<T> toLazyStreamable()
```
Returns:

Streamable that can replay this SequenceM

toConcurrentLazyStreamable
```
public Streamable<T> toConcurrentLazyStreamable()
```
Returns:

Streamable that replay this SequenceM

reverse
```
public SequenceM<T> reverse()
```

of
```
public static <T> SequenceM<T> of(T... elements)
```
Construct a Sequence from the provided elements

Specified by:

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

Parameters:

elements - To Construct sequence from

Returns:

reversedOf
```
public static <T> SequenceM<T> reversedOf(T... elements)
```
Construct a Reveresed Sequence from the provided elements

Parameters:

elements - To Construct sequence from

Returns:

reversedListOf
```
public static <T> SequenceM<T> reversedListOf(java.util.List<T> elements)
```
Construct a Reveresed Sequence from the provided elements

Parameters:

elements - To Construct sequence from

Returns:

fromStream
```
public 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:

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

Parameters:

iterable - to construct Sequence from

Returns:

SequenceM

onClose
```
public java.util.stream.Stream<T> onClose(java.lang.Runnable closeHandler)
```
Specified by:

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

close
```
public void close()
```
Specified by:

close in interface java.lang.AutoCloseable

Specified by:

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

empty
```
public static <T> SequenceM<T> empty()
```
Specified by:

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

shuffle
```
public SequenceM<T> shuffle()
```

appendStream

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

Append Stream to this SequenceM

  
 List<String> result = 	of(1,2,3).appendStream(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

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

Prepend Stream to this SequenceM

  
 List<String> result = 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

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

Append values to the end of this SequenceM

  
 List<String> result = 	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

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

Prepend given values to the start of the Stream

  
 List<String> result = 	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

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

Insert data into a stream at given position

  
 List<String> result = 	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

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

Delete elements between given indexes in a Stream

  
 List<String> result = 	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

public SequenceM<T> insertStreamAt(int pos,
                                   SequenceM<T> stream)

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

  
 List<String> result = 	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

Class SequenceM<T>

Nested Class Summary

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

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.stream.Stream

Method Detail

unwrap

flatten

unwrapStream

unwrapOptional

unwrapCompletableFuture

cycle

cycle

duplicate

triplicate

quadruplicate

splitAtHead

splitAt

splitBy

partition

unzip

unzip3

unzip4

cycle

cycle

cycleWhile

cycleUntil

zip

zip3

zip4

zipWithIndex

zip

zip

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

collect

collect

collect

collectIterable

reduce

reduce

reduce

reduce

reduce

reduce