StreamableT (simple-react 1.0.0-RC2.2 API)

java.lang.Object
- com.aol.cyclops.control.monads.transformers.StreamableT<T>

Type Parameters:

T -
```
public class StreamableT<T>
extends java.lang.Object
```
Monad Transformer for Cyclops Streamables StreamableT consists of an AnyM instance that in turns wraps anoter Monad type that contains an Streamable StreamableT>>> StreamableT allows the deeply wrapped Streamable 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
`StreamableT<T>`	`filter(java.util.function.Predicate<? super T> test)` Filter the wrapped Streamable
`<B> StreamableT<B>`	`flatMap(java.util.function.Function<? super T,StreamableT<? extends B>> f)` Flat Map the wrapped Streamable
`static <A> StreamableT<A>`	`fromAnyM(AnyM<A> anyM)` Construct an StreamableT from an AnyM that contains a monad type that contains type other than Streamable The values in the underlying monad will be mapped to Streamable
`static <A> StreamableT<A>`	`fromStream(AnyM<java.util.stream.Stream<A>> monads)` Create a StreamableT from an AnyM that wraps a monad containing a Stream
`static <U,R> java.util.function.Function<StreamableT<U>,StreamableT<R>>`	`lift(java.util.function.Function<? super U,? extends R> fn)` Lift a function into one that accepts and returns an StreamableT This allows multiple monad types to add functionality to existing functions and methods e.g.
`static <U1,U2,R> java.util.function.BiFunction<StreamableT<U1>,StreamableT<U2>,StreamableT<R>>`	`lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)` Lift a BiFunction into one that accepts and returns StreamableTs This allows multiple monad types to add functionality to existing functions and methods e.g.
`<B> StreamableT<B>`	`map(java.util.function.Function<? super T,? extends B> f)` Map the wrapped Streamable
`static <A> StreamableT<A>`	`of(AnyM<Streamable<A>> monads)` Construct an StreamableT from an AnyM that wraps a monad containing Streamables
`StreamableT<T>`	`peek(java.util.function.Consumer<? super T> peek)` Peek at the current value of the Streamable
`java.lang.String`	`toString()`
`AnyM<Streamable<T>>`	`unwrap()`

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

Method Detail

unwrap
```
public AnyM<Streamable<T>> unwrap()
```
Returns:

The wrapped AnyM

peek

public StreamableT<T> peek(java.util.function.Consumer<? super T> peek)

Peek at the current value of the Streamable

  
    StreamableT.of(AnyM.fromStream(Streamable.of(10))
             .peek(System.out::println);
             
     //prints 10

Parameters:: peek - Consumer to accept current value of Streamable
Returns:: StreamableT with peek call

filter

public StreamableT<T> filter(java.util.function.Predicate<? super T> test)

Filter the wrapped Streamable

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

Parameters:: test - Predicate to filter the wrapped Streamable
Returns:: StreamableT that applies the provided filter

map

public <B> StreamableT<B> map(java.util.function.Function<? super T,? extends B> f)

Map the wrapped Streamable

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

Parameters:: f - Mapping function for the wrapped Streamable
Returns:: StreamableT that applies the map function to the wrapped Streamable

flatMap

public <B> StreamableT<B> flatMap(java.util.function.Function<? super T,StreamableT<? extends B>> f)

Flat Map the wrapped Streamable

  
  StreamableT.of(AnyM.fromStream(Arrays.asStreamable(10))
             .flatMap(t->Streamable.of(2));
  
  
  //StreamableT<AnyM<Stream<Streamable.[2]>>>

Parameters:: f - FlatMap function
Returns:: StreamableT that applies the flatMap function to the wrapped Streamable

lift

public static <U,R> java.util.function.Function<StreamableT<U>,StreamableT<R>> lift(java.util.function.Function<? super U,? extends R> fn)

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

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

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

lift2

public static <U1,U2,R> java.util.function.BiFunction<StreamableT<U1>,StreamableT<U2>,StreamableT<R>> lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)

Lift a BiFunction into one that accepts and returns StreamableTs This allows multiple monad types to add functionality to existing functions and methods e.g. to add list handling / iteration (via Streamable), iteration (via Stream) and asynchronous execution (CompletableFuture) to an existing function

  
 BiFunction<Integer,Integer,Integer> add = (a,b) -> a+b;
		BiFunction<StreamableT<Integer>,StreamableT<Integer>, StreamableT<Integer>> optTAdd2 = StreamableT.lift2(add);
		
		Streamable<Integer> threeValues = Streamable.of(1,2,3);
		AnyM<Integer> stream = AnyM.ofMonad(threeValues);
		AnyM<Streamable<Integer>> streamOpt = stream.map(Streamable::of);
		
		CompletableFuture<Streamable<Integer>> two = CompletableFuture.completedFuture(Streamable.of(2));
		AnyM<Streamable<Integer>> future=  AnyM.fromCompletableFuture(two);
		List<Integer> results = optTAdd2.apply(StreamableT.of(streamOpt),StreamableT.of(future))
										.unwrap()
										.<Stream<Streamable<Integer>>>unwrap()
										.flatMap(i->i.sequenceM())
										.collect(Collectors.toList());
  			//Streamable.of(3,4);

Parameters:: fn - BiFunction to enhance with functionality from Streamable and another monad type
Returns:: Function that accepts and returns an StreamableT

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

Parameters:

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

Returns:

StreamableT

of
```
public static <A> StreamableT<A> of(AnyM<Streamable<A>> monads)
```
Construct an StreamableT from an AnyM that wraps a monad containing Streamables

Parameters:

monads - AnyM that contains a monad wrapping an Streamable

Returns:

StreamableT

fromStream
```
public static <A> StreamableT<A> fromStream(AnyM<java.util.stream.Stream<A>> monads)
```
Create a StreamableT 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 StreamableT<T>

Method Summary

Methods inherited from class java.lang.Object

Method Detail

unwrap

peek

filter

map

flatMap

lift

lift2

fromAnyM

of

fromStream

toString