ListT (cyclops-streams 7.3.1 API)

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

Type Parameters:

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

Returns:: The wrapped AnyM

peek

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

Peek at the current value of the List

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

Parameters:: peek - Consumer to accept current value of List
Returns:: ListT with peek call

filter

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

Filter the wrapped List

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

Parameters:: test - Predicate to filter the wrapped List
Returns:: ListT that applies the provided filter

map

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

Map the wrapped List

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

Parameters:: f - Mapping function for the wrapped List
Returns:: ListT that applies the map function to the wrapped List

flatMap

public <B> ListT<B> flatMap(org.jooq.lambda.function.Function1<T,ListT<B>> f)

Flat Map the wrapped List

  
  ListT.of(AnyM.fromStream(Arrays.asList(10))
             .flatMap(t->List.empty();
  
  
  //ListT<AnyM<Stream<List.empty>>>

Parameters:: f - FlatMap function
Returns:: ListT that applies the flatMap function to the wrapped List

lift

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

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

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

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

lift2

public static <U1,U2,R> java.util.function.BiFunction<ListT<U1>,ListT<U2>,ListT<R>> lift2(java.util.function.BiFunction<U1,U2,R> fn)

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

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

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

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

Parameters:

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

Returns:

ListT

of
```
public static <A> ListT<A> of(AnyM<java.util.List<A>> monads)
```
Construct an ListT from an AnyM that wraps a monad containing Lists

Parameters:

monads - AnyM that contains a monad wrapping an List

Returns:

ListT

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

Method Summary

Methods inherited from class java.lang.Object