com.aol.cyclops.lambda.monads

Class SequenceM<T>

java.lang.Object

com.aol.cyclops.lambda.monads.SequenceM<T>

All Implemented Interfaces:

Unwrapable

public class SequenceM<T>
extends java.lang.Object
implements Unwrapable

Method Summary

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
<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)
long	count()
<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>	distinct()
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,SequenceM<? 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)
T	foldLeft(Monoid<T> reducer)
<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> 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)
SequenceM<java.util.List<T>>	grouped(int groupSize) Group elements in a Monad into a Stream
HeadAndTail<T>	headAndTail()
java.util.Optional<HeadAndTail<T>>	headAndTailOptional()
boolean	isParallel()
java.util.Iterator<T>	iterator()
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(int 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) NB to access nested collections in non-Stream monads as a stream use streamedMonad() first
SequenceM<T>	limitWhile(java.util.function.Predicate<? super T> p) NB to access nested collections in non-Stream monads as a stream use streamedMonad() first
<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)
java.lang.String	mkString(java.lang.String sep)
java.lang.String	mkString(java.lang.String start, java.lang.String sep, java.lang.String end)
java.lang.String	mkString(java.lang.String start, java.lang.String sep, java.lang.String end, boolean lazy)
boolean	noneMatch(java.util.function.Predicate<? super T> c)
SequenceM<T>	parallel()
SequenceM<T>	peek(java.util.function.Consumer<? super T> c)
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) 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.
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>	scanLeft(Monoid<T> monoid) Scan left using supplied Monoid
SequenceM<T>	sequential()
SequenceM<T>	skip(int 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 monad
SequenceM<T>	sorted()
SequenceM<T>	sorted(java.util.Comparator<? super T> c) e.g.
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)
java.util.List<T>	toList()
java.util.Set<T>	toSet()
<T> java.util.stream.Stream<T>	toStream()
Streamable<T>	toStreamable()
SequenceM<T>	unordered()
<R> R	unwrap()
java.util.concurrent.CompletableFuture<java.util.List<T>>	unwrapCompletableFuture()
java.util.Optional<java.util.List<T>>	unwrapOptional()
java.util.stream.Stream<T>	unwrapStream() Type safe unwrap
boolean	xMatch(int num, java.util.function.Predicate<? super T> c)
<S,R> SequenceM<R>	zip(AnyM<? extends S> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper)
<S,R> SequenceM<R>	zip(SequenceM<? extends S> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper) Generic zip function.
<S,R> SequenceM<R>	zip(java.util.stream.Stream<? extends S> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper) Zip this Monad with a Stream

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

unwrap

public final <R> R unwrap()

Specified by:

unwrap in interface Unwrapable

unwrapStream

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

Type safe unwrap

Returns:

Stream with current wrapped values

unwrapOptional

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

unwrapCompletableFuture

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

cycle

public final SequenceM<T> cycle(int times)

Convert to a Stream with the values repeated specified times

Parameters:

times - Times values should be repeated within a Stream

Returns:

Stream with values repeated

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

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

Parameters:

predicate - repeat while true

Returns:

Repeating Stream

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

public final <S,R> SequenceM<R> zip(java.util.stream.Stream<? 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 monad

Parameters:

windowSize - Size of sliding window

Returns:

Stream with sliding view over monad

grouped

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

Group elements in a Monad into 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

distinct

public final SequenceM<T> distinct()

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:

sorted

public final SequenceM<T> sorted()

Returns:

Monad converted to Stream via stream() and sorted - to access nested collections in non-Stream monads as a stream use streamedMonad() first e.g.

  
    monad(Optional.of(Arrays.asList(1,2,3))).sorted()  // Monad[Stream[List[1,2,3]]]
    
     monad(Optional.of(Arrays.asList(1,2,3))).streamedMonad().sorted() // Monad[Stream[1,2,3]]
  
 

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

sorted

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

e.g.

  
    anyM(Optional.of(Arrays.asList(1,2,3))).asSequence().sorted( (a,b)->b-a)  // Monad[Stream[List[1,2,3]]]
    
     anyM(Optional.of(Arrays.asList(1,2,3))).toSequence().sorted( (a,b)->b-a) // Monad[Stream[3,2,1]]
  
 

Parameters:

c - Compartor to sort with

Returns:

Sorted Monad

skip

public final SequenceM<T> skip(int num)

  assertThat(anyM(Stream.of(4,3,6,7)).asSequence().skip(2).toList(),equalTo(Arrays.asList(6,7))); 
 

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(int num)

  assertThat(anyM(Stream.of(4,3,6,7)).asSequence().limit(2).toList(),equalTo(Arrays.asList(4,3)));
 

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)

NB to access nested collections in non-Stream monads as a stream use streamedMonad() first

  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)

NB to access nested collections in non-Stream monads as a stream use streamedMonad() first

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

Returns:

this monad converted to a Parallel Stream, via streamedMonad() wraped in Monad 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

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

Parameters:

c - Predicate to check if any match

xMatch

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

noneMatch

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

mkString

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

mkString

public final java.lang.String mkString(java.lang.String start,
                                       java.lang.String sep,
                                       java.lang.String end)

mkString

public final java.lang.String mkString(java.lang.String start,
                                       java.lang.String sep,
                                       java.lang.String end,
                                       boolean lazy)

minBy

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

min

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

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)

headAndTail

public final HeadAndTail<T> headAndTail()

Returns:

headAndTailOptional

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

findFirst

public final java.util.Optional<T> findFirst()

Returns:

First matching element in sequential order (deterministic)

findAny

public final java.util.Optional<T> findAny()

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

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)

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 = monad(Stream.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));
		

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().collect(collectors);

Parameters:

collectors - Stream of Collectors to apply

Returns:

List of results

reduce

public final T reduce(Monoid<T> reducer)

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:

reducer - Use supplied Monoid to reduce values

Returns:

reduced values

reduce

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

reduce

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

reduce

public final <U> U reduce(U identity,
                          java.util.function.BiFunction<U,? super T,U> accumulator,
                          java.util.function.BinaryOperator<U> combiner)

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

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

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

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)

peek

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

flatMap

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

flatMap operation

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)

forEach

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

iterator

public java.util.Iterator<T> iterator()

spliterator

public java.util.Spliterator<T> spliterator()

isParallel

public boolean isParallel()

sequential

public SequenceM<T> sequential()

unordered

public SequenceM<T> unordered()

mapToInt

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

mapToLong

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

mapToDouble

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

flatMapToInt

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

flatMapToLong

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

flatMapToDouble

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

forEachOrdered

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

toArray

public java.lang.Object[] toArray()

toArray

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

count

public long count()