MaybeT (cyclops-react 1.0.0-FINAL API)

Type Parameters:

T - The type contained on the Maybe within

All Superinterfaces:

Filterable<T>, Functor<T>, org.reactivestreams.Publisher<T>

All Known Implementing Classes:

MaybeTSeq, MaybeTValue
```
public interface MaybeT<T>
extends org.reactivestreams.Publisher<T>, Functor<T>, Filterable<T>
```
Monad transformer for Maybe MaybeT consists of an AnyM instance that in turns wraps anoter Monad type that contains an Maybe
```
  
 
 The structure 
 MaybeT[*SOME_MONAD_TYPE*[Maybe[T]]]
 
 can be represented as
 MaybeT<T>
 
 
 MaybeT allows the deeply wrapped Maybe to be manipulating within it's nested
 /contained context
```

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default <B> MaybeT<B>`	`bind(java.util.function.Function<? super T,MaybeT<? extends B>> f)` Flat Map the wrapped Maybe
`default <U> MaybeT<U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`<R> MaybeT<R>`	`empty()`
`static <T> MaybeTSeq<T>`	`emptyList()`
`static <T> MaybeTValue<T>`	`emptyOptional()`
`MaybeT<T>`	`filter(java.util.function.Predicate<? super T> test)` Filter the wrapped Maybe
`default MaybeT<T>`	`filterNot(java.util.function.Predicate<? super T> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<B> MaybeT<B>`	`flatMap(java.util.function.Function<? super T,? extends MonadicValue<? extends B>> f)`
`static <A> MaybeT<A>`	`fromAnyM(AnyM<A> anyM)` Construct an MaybeT from an AnyM that contains a monad type that contains type other than Maybe The values in the underlying monad will be mapped to Maybe
`static <A> MaybeTSeq<A>`	`fromAnyMSeq(AnyMSeq<A> anyM)`
`static <A> MaybeTValue<A>`	`fromAnyMValue(AnyMValue<A> anyM)`
`static <A> MaybeTValue<A>`	`fromFuture(java.util.concurrent.CompletableFuture<Maybe<A>> future)`
`static <A> MaybeTSeq<A>`	`fromIterable(java.lang.Iterable<Maybe<A>> iterableOfMaybes)`
`static <A> MaybeTValue<A>`	`fromIterableValue(java.lang.Iterable<Maybe<A>> iterableOfMaybes)`
`static <A> MaybeTValue<A>`	`fromOptional(java.util.Optional<Maybe<A>> optional)`
`static <A> MaybeTSeq<A>`	`fromPublisher(org.reactivestreams.Publisher<Maybe<A>> publisherOfMaybes)`
`static <A> MaybeTSeq<A>`	`fromStream(java.util.stream.Stream<Maybe<A>> streamOfMaybes)`
`static <A,V extends MonadicValue<Maybe<A>>> MaybeTValue<A>`	`fromValue(V monadicValue)`
`static <U,R> java.util.function.Function<MaybeT<U>,MaybeT<R>>`	`lift(java.util.function.Function<? super U,? extends R> fn)` Lift a function into one that accepts and returns an MaybeT This allows multiple monad types to add functionality to existing functions and methods e.g.
`static <U1,U2,R> java.util.function.BiFunction<MaybeT<U1>,MaybeT<U2>,MaybeT<R>>`	`lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)` Lift a BiFunction into one that accepts and returns MaybeTs This allows multiple monad types to add functionality to existing functions and methods e.g.
`<B> MaybeT<B>`	`map(java.util.function.Function<? super T,? extends B> f)` Map the wrapped Maybe
`default MaybeT<T>`	`notNull()` Filter elements retaining only values which are not null
`static <A> MaybeT<A>`	`of(AnyM<Maybe<A>> monads)` Construct an MaybeT from an AnyM that wraps a monad containing Maybes
`default <U> MaybeT<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`default <R> MaybeT<R>`	`patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> case1, java.util.function.Supplier<? extends R> otherwise)` Transform the elements of this Stream with a Pattern Matching case and default value
`MaybeT<T>`	`peek(java.util.function.Consumer<? super T> peek)` Peek at the current value of the Maybe
`default <R> MaybeT<R>`	`trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)` Performs a map operation that can call a recursive method without running out of stack space
`<R> MaybeT<R>`	`unit(R value)`
`AnyM<Maybe<T>>`	`unwrap()`

Methods inherited from interface org.reactivestreams.Publisher
subscribe

Method Detail

unit
```
<R> MaybeT<R> unit(R value)
```

empty
```
<R> MaybeT<R> empty()
```

unwrap
```
AnyM<Maybe<T>> unwrap()
```
Returns:

The wrapped AnyM

peek

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

Peek at the current value of the Maybe

  
    MaybeT.of(AnyM.fromStream(Maybe.of(10))
             .peek(System.out::println);
             
     //prints 10

Specified by:: peek in interface Functor<T>
Parameters:: peek - Consumer to accept current value of Maybe
Returns:: MaybeT with peek call

filter

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

Filter the wrapped Maybe

  
    MaybeT.of(AnyM.fromStream(Maybe.of(10))
             .filter(t->t!=10);
             
     //MaybeT<AnyM<Stream<Maybe.empty>>>

Specified by:: filter in interface Filterable<T>
Parameters:: test - Predicate to filter the wrapped Maybe
Returns:: MaybeT that applies the provided filter

map

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

Map the wrapped Maybe

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

Specified by:: map in interface Functor<T>
Parameters:: f - Mapping function for the wrapped Maybe
Returns:: MaybeT that applies the map function to the wrapped Maybe

flatMap

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

bind

default <B> MaybeT<B> bind(java.util.function.Function<? super T,MaybeT<? extends B>> f)

Flat Map the wrapped Maybe

  
  MaybeT.of(AnyM.fromStream(Maybe.of(10))
             .bind(t->MaybeT.empty();
  
  
  //MaybeT<AnyM<Stream<Maybe.empty>>>

Parameters:: f - FlatMap function
Returns:: MaybeT that applies the flatMap function to the wrapped Maybe

lift

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

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

 
     
     Function<Integer, Integer> add2 = i -> i + 2;
     Function<MaybeT<Integer>, MaybeT<Integer>> optTAdd2 = MaybeT.lift(add2);
 
     Stream<Integer> withNulls = Stream.of(1, 2, null);
     AnyM<Integer> stream = AnyM.ofMonad(withNulls);
     AnyM<Maybe<Integer>> streamOpt = stream.map(Maybe::ofNullable);
     List<Integer> results = optTAdd2.apply(MaybeT.of(streamOpt)).unwrap().<Stream<Maybe<Integer>>> unwrap()
             .filter(Maybe::isPresent).map(Maybe::get).collect(Collectors.toList());
 
     // Arrays.asList(3,4);

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

lift2

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

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

  
     
     BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
     BiFunction<MaybeT<Integer>, MaybeT<Integer>, MaybeT<Integer>> optTAdd2 = MaybeT.lift2(add);
 
     Stream<Integer> withNulls = Stream.of(1, 2, null);
     AnyM<Integer> stream = AnyM.ofMonad(withNulls);
     AnyM<Maybe<Integer>> streamOpt = stream.map(Maybe::ofNullable);
 
     CompletableFuture<Maybe<Integer>> two = CompletableFuture.supplyAsync(() -> Maybe.of(2));
     AnyM<Maybe<Integer>> future = AnyM.ofMonad(two);
     List<Integer> results = optTAdd2.apply(MaybeT.of(streamOpt), MaybeT.of(future)).unwrap()
             .<Stream<Maybe<Integer>>> unwrap().filter(Maybe::isPresent).map(Maybe::get)
             .collect(Collectors.toList());
     // Arrays.asList(3,4);

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

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

Parameters:

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

Returns:

MaybeT

fromAnyMValue

static <A> MaybeTValue<A> fromAnyMValue(AnyMValue<A> anyM)

fromAnyMSeq

static <A> MaybeTSeq<A> fromAnyMSeq(AnyMSeq<A> anyM)

fromIterable

static <A> MaybeTSeq<A> fromIterable(java.lang.Iterable<Maybe<A>> iterableOfMaybes)

fromStream

static <A> MaybeTSeq<A> fromStream(java.util.stream.Stream<Maybe<A>> streamOfMaybes)

fromPublisher

static <A> MaybeTSeq<A> fromPublisher(org.reactivestreams.Publisher<Maybe<A>> publisherOfMaybes)

fromValue

static <A,V extends MonadicValue<Maybe<A>>> MaybeTValue<A> fromValue(V monadicValue)

fromOptional

static <A> MaybeTValue<A> fromOptional(java.util.Optional<Maybe<A>> optional)

fromFuture

static <A> MaybeTValue<A> fromFuture(java.util.concurrent.CompletableFuture<Maybe<A>> future)

fromIterableValue

static <A> MaybeTValue<A> fromIterableValue(java.lang.Iterable<Maybe<A>> iterableOfMaybes)

of
```
static <A> MaybeT<A> of(AnyM<Maybe<A>> monads)
```
Construct an MaybeT from an AnyM that wraps a monad containing Maybes

Parameters:

monads - AnyM that contains a monad wrapping an Maybe

Returns:

MaybeT

emptyOptional

static <T> MaybeTValue<T> emptyOptional()

emptyList
```
static <T> MaybeTSeq<T> emptyList()
```

cast
```
default <U> MaybeT<U> cast(java.lang.Class<? extends U> type)
```
Description copied from interface: Functor

Cast all elements in a stream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)

Specified by:

cast in interface Functor<T>

trampoline

default <R> MaybeT<R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)

Description copied from interface: Functor

Performs a map operation that can call a recursive method without running out of stack space

 
 ReactiveSeq.of(10,20,30,40)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println); 
    			 
    	Trampoline<Long> fibonacci(int i){
    		return fibonacci(i,1,0);
    	}
    	Trampoline<Long> fibonacci(int n, long a, long b) {
        	return n == 0 ? Trampoline.done(b) : Trampoline.more( ()->fibonacci(n-1, a+b, a));
    	}		 
    			 
 55
    	6765
    	832040
    	102334155
 
 
 ReactiveSeq.of(10_000,200_000,3_000_000,40_000_000)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println);
    			 
    			 
 completes successfully

Specified by:: trampoline in interface Functor<T>
Parameters:: mapper - TCO Transformation function
Returns:: Functor transformed by the supplied transformation function

patternMatch

default <R> MaybeT<R> patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> case1,
                                   java.util.function.Supplier<? extends R> otherwise)

Description copied from interface: Functor

Transform the elements of this Stream with a Pattern Matching case and default value

 
 List<String> result = CollectionX.of(1,2,3,4)
                                             .patternMatch(
                                                       c->c.valuesWhere(i->"even", (Integer i)->i%2==0 )
                                                     )
 
 // CollectionX["odd","even","odd","even"]

Specified by:: patternMatch in interface Functor<T>
Parameters:: case1 - Function to generate a case (or chain of cases as a single case); otherwise - Value if supplied case doesn't match
Returns:: CollectionX where elements are transformed by pattern matching

ofType

default <U> MaybeT<U> ofType(java.lang.Class<? extends U> type)

Description copied from interface: Filterable

Keep only those elements in a stream that are of a given type.

  
 
 // (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)

Specified by:: ofType in interface Filterable<T>

filterNot
```
default MaybeT<T> filterNot(java.util.function.Predicate<? super T> fn)
```
Description copied from interface: Filterable
Remove any elements for which the predicate holds (inverse operation to filter) e.g.
```
  
   
     of(1,2,3).filter(i->i>2);
     
     //[1,2]
   
 
 
```
Specified by:

filterNot in interface Filterable<T>

Parameters:

fn - to filter elements by, retaining matches

Returns:

Filterable with elements removed where the predicate does not hold

notNull
```
default MaybeT<T> notNull()
```
Description copied from interface: Filterable
Filter elements retaining only values which are not null
```
  
 
   of(1,2,null,4).nonNull();
 
   //[1,2,4]
   
 
```
Specified by:

notNull in interface Filterable<T>

Returns:

Filterable with nulls removed

Interface MaybeT<T>