public class AnyMValueImpl<T> extends java.lang.Object implements AnyMValue<T>
AnyM.AnyMFactory
FlatMap.Apply2<T1,T2>, FlatMap.Apply2Impl<T1,T2>, FlatMap.Apply3<T1,T2,T3>, FlatMap.Apply3Impl<T1,T2,T3>
ToStream.FromStreamable<T>
Applicativable.Applicatives, Applicativable.SemigroupApplyer<T>
Value.ValueImpl<T>
Matchable.AsMatchable, Matchable.AutoCloseableMatchableIterable<TYPE>, Matchable.CheckValue1<T,R>, Matchable.CheckValue2<T1,T2,R>, Matchable.CheckValue3<T1,T2,T3,R>, Matchable.CheckValue4<T1,T2,T3,T4,R>, Matchable.CheckValue5<T1,T2,T3,T4,T5,R>, Matchable.CheckValues<T,R>, Matchable.MatchableIterable<TYPE>, Matchable.MatchableTuple1<T1>, Matchable.MatchableTuple2<TYPE,T1 extends TYPE,T2 extends TYPE>, Matchable.MatchableTuple3<TYPE,T1 extends TYPE,T2 extends TYPE,T3 extends TYPE>, Matchable.MatchableTuple4<TYPE,T1 extends TYPE,T2 extends TYPE,T3 extends TYPE,T4 extends TYPE>, Matchable.MatchableTuple5<TYPE,T1 extends TYPE,T2 extends TYPE,T3 extends TYPE,T4 extends TYPE,T5 extends TYPE>, Matchable.MatchSelf<TYPE>, Matchable.MTuple1<T1>, Matchable.MTuple2<T1,T2>, Matchable.MTuple3<T1,T2,T3>, Matchable.MTuple4<T1,T2,T3,T4>, Matchable.MTuple5<T1,T2,T3,T4,T5>
Convertable.SupplierToConvertable<T>
Constructor and Description |
---|
AnyMValueImpl() |
Modifier and Type | Method and Description |
---|---|
AnyMValue<java.util.List<T>> |
aggregate(AnyM<T> next)
Aggregate the contents of this Monad and the supplied Monad
|
<R> AnyMValue<R> |
applyM(AnyMValue<java.util.function.Function<? super T,? extends R>> fn)
Apply function/s inside supplied Monad to data in current Monad
e.g.
|
ReactiveSeq<T> |
asSequence()
Wrap this Monad's contents as a Sequence without disaggreating it.
|
<R> AnyMValue<R> |
bind(java.util.function.Function<? super T,?> fn)
Perform a looser typed flatMap / bind operation
The return type can be another type other than the host type
Note the modified javaslang monad laws are not applied during the looser typed bind operation
The modification being used to work around the limits of the Java type system.
|
<R,A> R |
collect(java.util.stream.Collector<? super T,A,R> collector) |
<T> AnyMValue<T> |
empty()
Construct an AnyM wrapping an empty instance of the wrapped type
e.g.
|
<T> AnyMValue<T> |
emptyUnit() |
AnyMValue<T> |
filter(java.util.function.Predicate<? super T> p)
Perform a filter operation on the wrapped monad instance e.g.
|
<R> AnyMValue<R> |
flatMap(java.util.function.Function<? super T,? extends AnyMValue<? extends R>> fn)
flatMap operation
AnyM follows the javaslang modified 'monad' laws https://gist.github.com/danieldietrich/71be006b355d6fbc0584
In particular left-identity becomes
Left identity: unit(a).flatMap(f) ≡ select(f.apply(a))
Or in plain English, if your flatMap function returns multiple values (such as flatMap by Stream) but the current Monad only can only hold one value,
only the first value is accepted.
|
<T1> AnyMValue<T1> |
flatten()
join / flatten one level of a nested hierarchy
|
<R1,R> AnyMValue<R> |
forEach2(java.util.function.Function<? super T,? extends AnyMValue<R1>> monad,
java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
Perform a two level nested internal iteration over this Stream and the supplied monad (allowing null handling, exception handling
etc to be injected, for example)
|
<R1,R> AnyMValue<R> |
forEach2(java.util.function.Function<? super T,? extends AnyMValue<R1>> monad,
java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction,
java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
Perform a two level nested internal iteration over this Stream and the supplied monad (allowing null handling, exception handling
etc to be injected, for example)
|
<R1,R2,R> AnyMValue<R> |
forEach3(java.util.function.Function<? super T,? extends AnyMValue<R1>> monad1,
java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends AnyMValue<R2>>> monad2,
java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
Perform a three level nested internal iteration over this AnyM and the supplied monads
|
<R1,R2,R> AnyMValue<R> |
forEach3(java.util.function.Function<? super T,? extends AnyMValue<R1>> monad1,
java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends AnyMValue<R2>>> monad2,
java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,java.lang.Boolean>>> filterFunction,
java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
Perform a three level nested internal iteration over this Stream and the supplied streams
|
static <T> AnyMValue<T> |
from(AnyM<T> anyM) |
T |
get() |
T |
getMatchable() |
java.util.Iterator<T> |
iterator() |
<R> AnyMValue<R> |
liftAndBind(java.util.function.Function<? super T,?> fn)
Perform a bind operation (@see #bind) but also lift the return value into a Monad using configured
MonadicConverters
Note the modified javaslang monad laws are not applied during the looser typed bind operation
The modification being used to work around the limits of the Java type system.
|
<R> AnyMValue<R> |
map(java.util.function.Function<? super T,? extends R> fn)
Perform a map operation on the wrapped monad instance e.g.
|
<X> X |
monad() |
AnyMValue<T> |
peek(java.util.function.Consumer<? super T> c)
Perform a peek operation on the wrapped monad e.g.
|
ReactiveSeq<T> |
reactiveSeq() |
AnyMValue<T> |
reduceM(Monoid<AnyM<T>> reducer)
Perform a reduction where NT is a (native) Monad type
e.g.
|
AnyMValue<T> |
reduceMCompletableFuture(Monoid<java.util.concurrent.CompletableFuture<T>> reducer)
Perform a reduction where NT is a (native) Monad type
e.g.
|
AnyMValue<T> |
reduceMEval(Monoid<Eval<T>> reducer) |
AnyMSeq<T> |
reduceMIterable(Monoid<java.lang.Iterable<T>> reducer)
Perform a reduction where NT is a (native) Monad type
e.g.
|
AnyMValue<T> |
reduceMMaybe(Monoid<Maybe<T>> reducer) |
AnyMValue<T> |
reduceMOptional(Monoid<java.util.Optional<T>> reducer)
Perform a reduction where NT is a (native) Monad type
e.g.
|
AnyMSeq<T> |
reduceMStream(Monoid<java.util.stream.Stream<T>> reducer)
Perform a reduction where NT is a (native) Monad type
e.g.
|
AnyMSeq<T> |
reduceMStreamable(Monoid<Streamable<T>> reducer)
Perform a reduction where NT is a (native) Monad type
e.g.
|
AnyMValue<T> |
reduceMXor(Monoid<Xor<?,T>> reducer) |
AnyMValue<java.util.List<T>> |
replicateM(int times)
Replicate given Monad
|
ReactiveSeq<T> |
stream() |
<T> ReactiveSeq<T> |
toSequence()
Optional<List<Integer>> into Stream<Integer> |
<NT> ReactiveSeq<NT> |
toSequence(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends NT>> fn)
Sequence the contents of a Monad.
|
<T> AnyMValue<T> |
unit(T value)
Construct a new instanceof AnyM using the type of the underlying wrapped monad
|
<T> T |
unwrap() |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
liftM, liftM2, liftM2, liftM3, liftM3, liftM3Cyclops, liftM4, liftM4, liftM4Cyclops, liftM5, liftM5, liftM5Cyclops, sequence, sequence, toFirstValue, traverse
fromArray, fromCollection, fromCompletableFuture, fromDoubleStream, fromEval, fromFile, fromFutureW, fromIntStream, fromIor, fromIterable, fromList, fromLongStream, fromMaybe, fromOptional, fromOptionalDouble, fromOptionalInt, fromOptionalLong, fromRange, fromRangeLong, fromSet, fromStream, fromStreamable, fromURL, fromXor, listFromCollection, listFromCompletableFuture, listFromEval, listFromFutureW, listFromIor, listFromIterable, listFromIterator, listFromMaybe, listFromOptional, listFromStream, listFromStreamable, listFromXor, ofConvertable, ofMonad, ofMonadList, ofNullable, ofSeq, ofValue, sequence, sequence, streamOf, toString, traverse, traverse
getStreamable, isEmpty, reveresedSequenceM, reveresedStream
ap, ap, ap1, ap2, ap3, ap4, ap5
convertTo, convertToAsync, fold, fold, generate, iterate, mkString, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFutureStream, toFutureStream, toIor, toIorSecondary, toLazyImmutable, toListX, toMaybe, toMutable, toPBagX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toTry, toTry, toXor, toXorSecondary, unapply
foldRight, foldRight, foldRightMapToType, join, join, join, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce
from, from, from, from, from, from, from, from, from, from, fromCharSequence, fromValue, listOfValues, matches, mayMatch, ofDecomposable, ofIterable, otherwise, otherwise, then, then, when, when, when, when, when, when, when, when, when, when, when, when, when, when, when, whenGuard
fromSupplier, orElse, orElseGet, orElseThrow, toAtomicReference, toCompletableFuture, toCompletableFutureAsync, toCompletableFutureAsync, toFutureW, toList, toOptional, toOptionalAtomicReference, toStream, visit
cast, patternMatch, trampoline
public ReactiveSeq<T> reactiveSeq()
reactiveSeq
in interface ConvertableToReactiveSeq<T>
reactiveSeq
in interface ToStream<T>
public T get()
get
in interface Convertable<T>
get
in interface java.util.function.Supplier<T>
public <T> AnyMValue<T> emptyUnit()
public AnyMValue<T> reduceMOptional(Monoid<java.util.Optional<T>> reducer)
ReduceM
Monoid<Optional<Integer>> optionalAdd = Monoid.of(Optional.of(0), (a,b)-> Optional.of(a.get()+b.get()));
AnyM.fromStream(Stream.of(2,8,3,1)).reduceM(optionalAdd);
//AnyM[Optional(14)];
reduceMOptional
in interface AnyMValue<T>
reduceMOptional
in interface ReduceM<T>
reducer
- An identity value (approx. a seed) and BiFunction with a single type to reduce this anyMpublic AnyMValue<T> reduceMEval(Monoid<Eval<T>> reducer)
reduceMEval
in interface AnyMValue<T>
reduceMEval
in interface ReduceM<T>
public AnyMValue<T> reduceMMaybe(Monoid<Maybe<T>> reducer)
reduceMMaybe
in interface AnyMValue<T>
reduceMMaybe
in interface ReduceM<T>
public AnyMValue<T> reduceMXor(Monoid<Xor<?,T>> reducer)
reduceMXor
in interface AnyMValue<T>
reduceMXor
in interface ReduceM<T>
public AnyMSeq<T> reduceMStream(Monoid<java.util.stream.Stream<T>> reducer)
ReduceM
Monoid<Optional<Integer>> streamableAdd = Monoid.of(Stream.of(0), (a,b)-> Stream.of(a.get()+b.get()));
AnyM.fromStream(Stream.of(2,8,3,1)).reduceM(streamableAdd);
//AnyM[Optional(14)];
reduceMStream
in interface ReduceM<T>
reducer
- An identity value (approx. a seed) and BiFunction with a single type to reduce this anyMpublic AnyMSeq<T> reduceMStreamable(Monoid<Streamable<T>> reducer)
ReduceM
Monoid<Optional<Integer>> streamableAdd = Monoid.of(Streamable.of(0), (a,b)-> Streamable.of(a.get()+b.get()));
AnyM.fromStream(Stream.of(2,8,3,1)).reduceM(streamableAdd);
//AnyM[Optional(14)];
reduceMStreamable
in interface ReduceM<T>
reducer
- An identity value (approx. a seed) and BiFunction with a single type to reduce this anyMpublic AnyMSeq<T> reduceMIterable(Monoid<java.lang.Iterable<T>> reducer)
ReduceM
Monoid<Optional<Integer>> streamableAdd = Monoid.of(Streamable.of(0), (a,b)-> Streamable.of(a.get()+b.get()));
AnyM.fromStream(Stream.of(2,8,3,1)).reduceM(streamableAdd);
//AnyM[Optional(14)];
reduceMIterable
in interface ReduceM<T>
reducer
- An identity value (approx. a seed) and BiFunction with a single type to reduce this anyMpublic AnyMValue<T> reduceMCompletableFuture(Monoid<java.util.concurrent.CompletableFuture<T>> reducer)
ReduceM
Monoid<Optional<Integer>> streamableAdd = Monoid.of(CompletableFuture.completedFuture(0), (a,b)-> CompletableFuture.supplyAsync(()->a.get()+b.get()));
AnyM.fromStream(Stream.of(2,8,3,1)).reduceM(streamableAdd);
//AnyM[Optional(14)];
reduceMCompletableFuture
in interface ReduceM<T>
reducer
- An identity value (approx. a seed) and BiFunction with a single type to reduce this anyMpublic AnyMValue<T> filter(java.util.function.Predicate<? super T> p)
AnyM
AnyM.fromOptional(Optional.of(10)).filter(i->i<10);
//AnyM[Optional.empty()]
AnyM.fromStream(Stream.of(5,10)).filter(i->i<10);
//AnyM[Stream[5]]
public AnyMValue<T> peek(java.util.function.Consumer<? super T> c)
AnyM
AnyM.fromCompletableFuture(CompletableFuture.supplyAsync(()->loadData())
.peek(System.out::println)
public AnyMValue<java.util.List<T>> aggregate(AnyM<T> next)
AnyM
AnyM.fromStream(Stream.of(1,2,3,4))
.aggregate(anyM(Optional.of(5)))
AnyM[Stream[List[1,2,3,4,5]]
List<Integer> result = AnyM.fromStream(Stream.of(1,2,3,4))
.aggregate(anyM(Optional.of(5)))
.toSequence()
.flatten()
.toList();
assertThat(result,equalTo(Arrays.asList(1,2,3,4,5)));
public <T> AnyMValue<T> unit(T value)
AnyM
AnyM<Integer> ints = AnyM.fromList(Arrays.asList(1,2,3);
AnyM<String> string = ints.unit("hello");
public <T> AnyMValue<T> empty()
AnyM
Any<Integer> ints = AnyM.fromStream(Stream.of(1,2,3));
AnyM<Integer> empty=ints.empty();
public AnyMValue<java.util.List<T>> replicateM(int times)
AnyM
AnyM<Optional<Integer>> applied =AnyM.fromOptional(Optional.of(2)).replicateM(5);
//AnyM[Optional[List(2,2,2,2,2)]]
replicateM
in interface AnyM<T>
replicateM
in interface AnyMValue<T>
times
- number of times to replicatepublic AnyMValue<T> reduceM(Monoid<AnyM<T>> reducer)
AnyM
Monoid<Optional<Integer>> optionalAdd = Monoid.of(AnyM.fromOptional(Optional.of(0)), (a,b)-> AnyM.fromOptional(Optional.of(a.get()+b.get())));
AnyM.fromStream(Stream.of(2,8,3,1)).reduceM(optionalAdd);
//AnyM[Optional(14)];
public <NT> ReactiveSeq<NT> toSequence(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends NT>> fn)
AnyM
Optional<List<Integer>> into Stream<Integer>
List<Integer> list = anyM(Optional.of(Arrays.asList(1,2,3,4,5,6)))
.<Integer>toSequence(c->c.stream())
.collect(Collectors.toList());
assertThat(list,hasItems(1,2,3,4,5,6));
toSequence
in interface AnyM<T>
public <T> ReactiveSeq<T> toSequence()
AnyM
Optional<List<Integer>> into Stream<Integer>
Less type safe equivalent, but may be more accessible than toSequence(fn) i.e.
toSequence(Function<T,Stream<NT>> fn)
List<Integer> list = anyM(Optional.of(Arrays.asList(1,2,3,4,5,6)))
.<Integer>toSequence()
.collect(Collectors.toList());
toSequence
in interface AnyM<T>
public java.util.Iterator<T> iterator()
public T getMatchable()
getMatchable
in interface Matchable<T>
getMatchable
in interface Value<T>
public ReactiveSeq<T> stream()
public <X> X monad()
public <R> AnyMValue<R> map(java.util.function.Function<? super T,? extends R> fn)
AnyM
AnyM.fromIterable(Try.runWithCatch(this::loadData))
.map(data->transform(data))
AnyM.fromStream(Stream.of(1,2,3))
.map(i->i+2);
AnyM[Stream[3,4,5]]
public <R> AnyMValue<R> bind(java.util.function.Function<? super T,?> fn)
AnyM
AnyM<List<Integer>> m = AnyM.fromStream(Stream.of(Arrays.asList(1,2,3),Arrays.asList(1,2,3)));
AnyM<Integer> intM = m.bind(Collection::stream);
public <R> AnyMValue<R> liftAndBind(java.util.function.Function<? super T,?> fn)
AnyM
liftAndBind
in interface AnyM<T>
liftAndBind
in interface AnyMValue<T>
fn
- flatMap functionpublic <T1> AnyMValue<T1> flatten()
AnyM
public <R1,R> AnyMValue<R> forEach2(java.util.function.Function<? super T,? extends AnyMValue<R1>> monad, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
AnyMValue
AnyM.fromArray(1,2,3)
.forEachAnyM2(a->AnyM.fromIntStream(IntStream.range(10,13)),
a->b->a+b);
//AnyM[11,14,12,15,13,16]
public <R1,R> AnyMValue<R> forEach2(java.util.function.Function<? super T,? extends AnyMValue<R1>> monad, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
AnyMValue
AnyM.fromArray(1,2,3)
.forEach2(a->AnyM.fromIntStream(IntStream.range(10,13)),
a->b-> a<3 && b>10,
a->b->a+b);
//AnyM[14,15]
forEach2
in interface AnyMValue<T>
monad
- Nested Monad to iterate overfilterFunction
- Filter to apply over elements before passing non-filtered values to the yielding functionyieldingFunction
- Function with pointers to the current element from both monads that generates the new elementspublic <R1,R2,R> AnyMValue<R> forEach3(java.util.function.Function<? super T,? extends AnyMValue<R1>> monad1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends AnyMValue<R2>>> monad2, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,java.lang.Boolean>>> filterFunction, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
AnyMValue
AnyM.fromArray(1,2)
.forEach2(a->AnyM.fromIntStream(IntStream.range(10,13)),
(a->b->AnyM.fromArray(""+(a+b),"hello world"),
a->b->c->c+":"a+":"+b);
//AnyM[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]
public <R1,R2,R> AnyMValue<R> forEach3(java.util.function.Function<? super T,? extends AnyMValue<R1>> monad1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends AnyMValue<R2>>> monad2, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
AnyMValue
AnyM.fromArray(1,2,3)
.forEach3(a->AnyM.fromStream(IntStream.range(10,13)),
a->b->AnyM.fromArray(""+(a+b),"hello world"),
a->b->c-> c!=3,
a->b->c->c+":"a+":"+b);
//SequenceM[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]
forEach3
in interface AnyMValue<T>
monad1
- Nested Stream to iterate overmonad2
- Nested Stream to iterate overyieldingFunction
- Function with pointers to the current element from both Monads that generates the new elementspublic <R> AnyMValue<R> flatMap(java.util.function.Function<? super T,? extends AnyMValue<? extends R>> fn)
AnyMValue
AnyM<Integer> anyM = AnyM.fromStream(Stream.of(1,2,3)).flatMap(i->AnyM.fromArray(i+1,i+2));
//AnyM[Stream[2,3,3,4,4,5]]
Example 2 : multi-values are not supported (AnyM wraps a Stream, List, Set etc)
AnyM<Integer> anyM = AnyM.fromOptional(Optional.of(1)).flatMap(i->AnyM.fromArray(i+1,i+2));
//AnyM[Optional[2]]
public ReactiveSeq<T> asSequence()
AnyM
Optional<List<Integer>> into Stream<List<Integer>>
If the underlying monad is a Stream it is returned
Otherwise we flatMap the underlying monad to a Stream typeasSequence
in interface AnyM<T>
asSequence
in interface AnyMValue<T>
public <R> AnyMValue<R> applyM(AnyMValue<java.util.function.Function<? super T,? extends R>> fn)
AnyMValue
AnyM<Integer> applied =AnyM.fromStream(Stream.of(1,2,3))
.applyM(AnyM.fromStreamable(Streamable.of( (Integer a)->a+1 ,(Integer a) -> a*2)));
assertThat(applied.toList(),equalTo(Arrays.asList(2, 2, 3, 4, 4, 6)));
with Optionals
Any<Integer> applied =AnyM.fromOptional(Optional.of(2)).applyM(AnyM.fromOptional(Optional.of( (Integer a)->a+1)) );
assertThat(applied.toList(),equalTo(Arrays.asList(3)));
public <R,A> R collect(java.util.stream.Collector<? super T,A,R> collector)
public <T> T unwrap()
unwrap
in interface AnyM<T>
unwrap
in interface Unwrapable