T
- The type contained on the Maybe withinpublic class EvalTValue<T> extends java.lang.Object implements EvalT<T>, TransformerValue<T>, MonadicValue<T>, java.util.function.Supplier<T>, ConvertableFunctor<T>, Filterable<T>, Applicativable<T>, Matchable.ValueAndOptionalMatcher<T>
Applicativable.Applicatives, Applicativable.SemigroupApplyer<T>
Value.ValueImpl<T>
Convertable.SupplierToConvertable<T>
Modifier and Type | Method and Description |
---|---|
<U> EvalTValue<U> |
cast(java.lang.Class<? extends U> type)
Cast all elements in a stream to a given type, possibly throwing a
ClassCastException . |
<R> EvalTValue<R> |
empty() |
static <T> EvalTValue<T> |
emptyMaybe() |
MaybeTValue<T> |
filter(java.util.function.Predicate<? super T> test)
Filter the wrapped Maybe
|
MaybeTValue<T> |
filterNot(java.util.function.Predicate<? super T> fn)
Remove any elements for which the predicate holds (inverse operation to filter)
e.g.
|
<B> EvalTValue<B> |
flatMap(java.util.function.Function<? super T,? extends Eval<? extends B>> f) |
<B> EvalTValue<B> |
flatMapT(java.util.function.Function<? super T,EvalTValue<? extends B>> f)
Flat Map the wrapped Maybe
|
static <A> EvalTValue<A> |
fromAnyM(AnyMValue<A> anyM)
|
static <A,V extends MonadicValue<Eval<A>>> |
fromValue(V monadicValue) |
T |
get() |
boolean |
isValuePresent() |
java.util.Iterator<T> |
iterator() |
static <U,R> java.util.function.Function<EvalTValue<U>,EvalTValue<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<EvalTValue<U1>,EvalTValue<U2>,EvalTValue<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> EvalTValue<B> |
map(java.util.function.Function<? super T,? extends B> f)
Map the wrapped Maybe
|
MaybeTValue<T> |
notNull()
Filter elements retaining only values which are not null
|
static <A> EvalTValue<A> |
of(AnyMValue<Eval<A>> monads)
Construct an MaybeT from an AnyM that wraps a monad containing Maybes
|
static <T> EvalTValue<T> |
of(Eval<T> eval) |
<U> MaybeTValue<U> |
ofType(java.lang.Class<? extends U> type)
Keep only those elements in a stream that are of a given type.
|
<R> EvalTValue<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
|
EvalTValue<T> |
peek(java.util.function.Consumer<? super T> peek)
Peek at the current value of the Maybe
|
ReactiveSeq<T> |
stream() |
void |
subscribe(org.reactivestreams.Subscriber<? super T> s) |
boolean |
test(T t) |
java.lang.String |
toString() |
<R> EvalTValue<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> EvalTValue<R> |
unit(R value) |
AnyMValue<Eval<T>> |
unwrap() |
Eval<T> |
value() |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
bind, emptyList, fromAnyM, fromAnyMSeq, fromAnyMValue, fromFuture, fromIterable, fromIterableValue, fromOptional, fromPublisher, fromStream, of
futureStream, getStreamable, isEmpty, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStream
anyM, coflatMap, isPresent, nest
ap, ap, ap1, ap2, ap3, ap4, ap5
fold, fold, generate, iterate, mapReduce, mkString, newSubscriber, of, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFeatureToggle, toFutureStream, toFutureStream, toIor, toLazyImmutable, toListX, toMaybe, toMutable, toPBagX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toTry, toTry, toTry, toXor, toXor, unapply, visit
endsWith, endsWithIterable, findAny, findFirst, firstValue, foldable, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, headAndTail, join, join, join, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleOptional, startsWith, startsWithIterable, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, validate, visit, visit, xMatch
fromSupplier, orElse, orElseGet, orElseThrow, toAtomicReference, toCompletableFuture, toCompletableFutureAsync, toCompletableFutureAsync, toFutureW, toList, toOptional, toOptionalAtomicReference, toStream
toOptional, visit
matches
public Eval<T> value()
value
in interface TransformerValue<T>
public EvalTValue<T> peek(java.util.function.Consumer<? super T> peek)
MaybeT.of(AnyM.fromStream(Maybe.of(10))
.peek(System.out::println);
//prints 10
public MaybeTValue<T> filter(java.util.function.Predicate<? super T> test)
MaybeT.of(AnyM.fromStream(Maybe.of(10))
.filter(t->t!=10);
//MaybeT<AnyMValue<Stream<Maybe.empty>>>
filter
in interface EvalT<T>
filter
in interface TransformerValue<T>
filter
in interface Filterable<T>
test
- Predicate to filter the wrapped Maybepublic <B> EvalTValue<B> map(java.util.function.Function<? super T,? extends B> f)
MaybeT.of(AnyM.fromStream(Maybe.of(10))
.map(t->t=t+1);
//MaybeT<AnyMValue<Stream<Maybe[11]>>>
map
in interface EvalT<T>
map
in interface TransformerValue<T>
map
in interface ConvertableFunctor<T>
map
in interface Functor<T>
map
in interface MonadicValue<T>
f
- Mapping function for the wrapped Maybepublic <B> EvalTValue<B> flatMapT(java.util.function.Function<? super T,EvalTValue<? extends B>> f)
MaybeT.of(AnyM.fromStream(Maybe.of(10))
.flatMap(t->Maybe.empty();
//MaybeT<AnyMValue<Stream<Maybe.empty>>>
f
- FlatMap functionpublic <B> EvalTValue<B> flatMap(java.util.function.Function<? super T,? extends Eval<? extends B>> f)
public static <U,R> java.util.function.Function<EvalTValue<U>,EvalTValue<R>> lift(java.util.function.Function<? super U,? extends R> fn)
{ @code Functionadd2 = i -> i + 2; Function , MaybeT > optTAdd2 = MaybeT.lift(add2); Stream withNulls = Stream.of(1, 2, null); AnyMValue stream = AnyM.ofMonad(withNulls); AnyMValue > streamOpt = stream.map(Maybe::ofNullable); List results = optTAdd2.apply(MaybeT.of(streamOpt)).unwrap(). >> unwrap() .filter(Maybe::isPresent).map(Maybe::get).collect(Collectors.toList()); // Arrays.asList(3,4); }
public static <U1,U2,R> java.util.function.BiFunction<EvalTValue<U1>,EvalTValue<U2>,EvalTValue<R>> lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)
{ @code BiFunctionadd = (a, b) -> a + b; BiFunction , MaybeT , MaybeT > optTAdd2 = MaybeT.lift2(add); Stream withNulls = Stream.of(1, 2, null); AnyMValue stream = AnyM.ofMonad(withNulls); AnyMValue > streamOpt = stream.map(Maybe::ofNullable); CompletableFuture > two = CompletableFuture.supplyAsync(() -> Maybe.of(2)); AnyMValue > future = AnyM.ofMonad(two); List results = optTAdd2.apply(MaybeT.of(streamOpt), MaybeT.of(future)).unwrap() . >> unwrap().filter(Maybe::isPresent).map(Maybe::get) .collect(Collectors.toList()); // Arrays.asList(3,4); }
public static <A> EvalTValue<A> fromAnyM(AnyMValue<A> anyM)
anyM
- AnyM that doesn't contain a monad wrapping an Maybepublic static <A> EvalTValue<A> of(AnyMValue<Eval<A>> monads)
monads
- AnyM that contains a monad wrapping an Maybepublic static <A,V extends MonadicValue<Eval<A>>> EvalTValue<A> fromValue(V monadicValue)
public java.lang.String toString()
toString
in class java.lang.Object
public T get()
get
in interface Convertable<T>
get
in interface java.util.function.Supplier<T>
public boolean isValuePresent()
isValuePresent
in interface TransformerValue<T>
public ReactiveSeq<T> stream()
public java.util.Iterator<T> iterator()
iterator
in interface Matchable.MatchableOptional<T>
iterator
in interface Matchable.ValueAndOptionalMatcher<T>
iterator
in interface Convertable<T>
iterator
in interface ToStream<T>
iterator
in interface java.lang.Iterable<T>
public void subscribe(org.reactivestreams.Subscriber<? super T> s)
public boolean test(T t)
public <R> EvalTValue<R> unit(R value)
public <R> EvalTValue<R> empty()
public static <T> EvalTValue<T> of(Eval<T> eval)
public static <T> EvalTValue<T> emptyMaybe()
emptyMaybe
in interface EvalT<T>
public <U> EvalTValue<U> cast(java.lang.Class<? extends U> type)
Functor
ClassCastException
.
// ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)public <R> EvalTValue<R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)
Functor
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
trampoline
in interface EvalT<T>
trampoline
in interface TransformerValue<T>
trampoline
in interface Functor<T>
public <R> EvalTValue<R> patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> case1, java.util.function.Supplier<? extends R> otherwise)
Functor
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"]
patternMatch
in interface EvalT<T>
patternMatch
in interface TransformerValue<T>
patternMatch
in interface Functor<T>
case1
- Function to generate a case (or chain of cases as a single case)otherwise
- Value if supplied case doesn't matchpublic <U> MaybeTValue<U> ofType(java.lang.Class<? extends U> type)
Filterable
// (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)
public MaybeTValue<T> filterNot(java.util.function.Predicate<? super T> fn)
Filterable
of(1,2,3).filter(i->i>2);
//[1,2]
public MaybeTValue<T> notNull()
Filterable
of(1,2,null,4).nonNull();
//[1,2,4]