StreamT (cyclops-streams 7.3.1 API)

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

Type Parameters:

T -
```
public class StreamT<T>
extends java.lang.Object
```
Monad Transformer for Cyclops Streams StreamT consists of an AnyM instance that in turns wraps anoter Monad type that contains an Stream StreamT>>> StreamT allows the deeply wrapped Stream to be manipulating within it's nested /contained context

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`StreamT<T>`	`filter(java.util.function.Predicate<T> test)` Filter the wrapped Stream
`<B> StreamT<B>`	`flatMap(java.util.function.Function<T,StreamT<B>> f)` Flat Map the wrapped Stream
`static <A> StreamT<A>`	`fromAnyM(AnyM<A> anyM)` Construct an StreamT from an AnyM that contains a monad type that contains type other than Stream The values in the underlying monad will be mapped to Stream
`static <U,R> java.util.function.Function<StreamT<U>,StreamT<R>>`	`lift(java.util.function.Function<U,R> fn)` Lift a function into one that accepts and returns an StreamT This allows multiple monad types to add functionality to existing functions and methods e.g.
`<B> StreamT<B>`	`map(java.util.function.Function<T,B> f)` Map the wrapped Stream
`static <A> StreamT<A>`	`of(AnyM<java.util.stream.Stream<A>> monads)` Create a StreamT from an AnyM that wraps a monad containing a Stream
`StreamT<T>`	`peek(java.util.function.Consumer<T> peek)` Peek at the current value of the Stream
`java.lang.String`	`toString()`
`AnyM<java.util.stream.Stream<T>>`	`unwrap()`

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

Method Detail

unwrap

public AnyM<java.util.stream.Stream<T>> unwrap()

Returns:: The wrapped AnyM

peek

public StreamT<T> peek(java.util.function.Consumer<T> peek)

Peek at the current value of the Stream

  
    StreamT.of(AnyM.fromStream(Arrays.asStream(10))
             .peek(System.out::println);
             
     //prints 10

Parameters:: peek - Consumer to accept current value of Stream
Returns:: StreamT with peek call

filter

public StreamT<T> filter(java.util.function.Predicate<T> test)

Filter the wrapped Stream

  
    StreamT.of(AnyM.fromStream(Arrays.asStream(10,11))
             .filter(t->t!=10);
             
     //StreamT<AnyM<Stream<Stream[11]>>>

Parameters:: test - Predicate to filter the wrapped Stream
Returns:: StreamT that applies the provided filter

map

public <B> StreamT<B> map(java.util.function.Function<T,B> f)

Map the wrapped Stream

  
  StreamT.of(AnyM.fromStream(Arrays.asStream(10))
             .map(t->t=t+1);
  
  
  //StreamT<AnyM<Stream<Stream[11]>>>

Parameters:: f - Mapping function for the wrapped Stream
Returns:: StreamT that applies the map function to the wrapped Stream

flatMap

public <B> StreamT<B> flatMap(java.util.function.Function<T,StreamT<B>> f)

Flat Map the wrapped Stream

  
  StreamT.of(AnyM.fromStream(Arrays.asStream(10))
             .flatMap(t->Stream.empty();
  
  
  //StreamT<AnyM<Stream<Stream.empty>>>

Parameters:: f - FlatMap function
Returns:: StreamT that applies the flatMap function to the wrapped Stream

lift

public static <U,R> java.util.function.Function<StreamT<U>,StreamT<R>> lift(java.util.function.Function<U,R> fn)

Lift a function into one that accepts and returns an StreamT This allows multiple monad types to add functionality to existing functions and methods e.g. to add iteration handling (via Stream) and nullhandling (via Optional) to an existing function

  
 		Function<Integer,Integer> add2 = i -> i+2;
		Function<StreamT<Integer>, StreamT<Integer>> optTAdd2 = StreamT.lift(add2);
		
		Stream<Integer> nums = Stream.of(1,2);
		AnyM<Stream<Integer>> stream = AnyM.fromOptional(Optional.of(nums));
		
		List<Integer> results = optTAdd2.apply(StreamT.of(stream))
										.unwrap()
										.<Optional<Stream<Integer>>>unwrap()
										.get()
										.collect(Collectors.toList());
 		//Stream.of(3,4);

Parameters:: fn - Function to enhance with functionality from Stream and another monad type
Returns:: Function that accepts and returns an StreamT

fromAnyM
```
public static <A> StreamT<A> fromAnyM(AnyM<A> anyM)
```
Construct an StreamT from an AnyM that contains a monad type that contains type other than Stream The values in the underlying monad will be mapped to Stream

Parameters:

anyM - AnyM that doesn't contain a monad wrapping an Stream

Returns:

StreamT

of
```
public static <A> StreamT<A> of(AnyM<java.util.stream.Stream<A>> monads)
```
Create a StreamT from an AnyM that wraps a monad containing a Stream

Parameters:

monads -

Returns:

toString
```
public java.lang.String toString()
```
Overrides:

toString in class java.lang.Object

Class StreamT<T>