Uses of Interface
com.jnape.palatable.lambda.monad.MonadRec
-
-
Uses of MonadRec in com.jnape.palatable.lambda.adt
Classes in com.jnape.palatable.lambda.adt that implement MonadRec Modifier and Type Class Description class
Either<L,R>
The binary tagged union, implemented as a specializedCoProduct2
.private static class
Either.Left<L,R>
private static class
Either.Right<L,R>
class
Maybe<A>
The optional type, representing a potentially absent value.private static class
Maybe.Just<A>
private static class
Maybe.Nothing<A>
class
These<A,B>
The coproduct of a coproduct (
) and its product (CoProduct2
<A, B>
), represented as aTuple2
<A, B>
.CoProduct3
<A, B,Tuple2
<A, B>>private static class
These._A<A,B>
private static class
These._B<A,B>
private static class
These.Both<A,B>
class
Try<A>
AMonad
of the evaluation outcome of an expression that might throw.private static class
Try.Failure<A>
private static class
Try.Success<A>
Method parameters in com.jnape.palatable.lambda.adt with type arguments of type MonadRec Modifier and Type Method Description <B> Either<L,B>
Either. trampolineM(Fn1<? super R,? extends MonadRec<RecursiveResult<R,B>,Either<L,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<B> Maybe<B>
Maybe. trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,Maybe<?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<C> These<A,C>
These. trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,These<A,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<B> Try<B>
Try. trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,Try<?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction. -
Uses of MonadRec in com.jnape.palatable.lambda.adt.choice
Classes in com.jnape.palatable.lambda.adt.choice that implement MonadRec Modifier and Type Class Description class
Choice2<A,B>
Canonical ADT representation ofCoProduct2
.private static class
Choice2._A<A,B>
private static class
Choice2._B<A,B>
class
Choice3<A,B,C>
Canonical ADT representation ofCoProduct3
.private static class
Choice3._A<A,B,C>
private static class
Choice3._B<A,B,C>
private static class
Choice3._C<A,B,C>
class
Choice4<A,B,C,D>
Canonical ADT representation ofCoProduct4
.private static class
Choice4._A<A,B,C,D>
private static class
Choice4._B<A,B,C,D>
private static class
Choice4._C<A,B,C,D>
private static class
Choice4._D<A,B,C,D>
class
Choice5<A,B,C,D,E>
Canonical ADT representation ofCoProduct5
.private static class
Choice5._A<A,B,C,D,E>
private static class
Choice5._B<A,B,C,D,E>
private static class
Choice5._C<A,B,C,D,E>
private static class
Choice5._D<A,B,C,D,E>
private static class
Choice5._E<A,B,C,D,E>
class
Choice6<A,B,C,D,E,F>
Canonical ADT representation ofCoProduct6
.private static class
Choice6._A<A,B,C,D,E,F>
private static class
Choice6._B<A,B,C,D,E,F>
private static class
Choice6._C<A,B,C,D,E,F>
private static class
Choice6._D<A,B,C,D,E,F>
private static class
Choice6._E<A,B,C,D,E,F>
private static class
Choice6._F<A,B,C,D,E,F>
class
Choice7<A,B,C,D,E,F,G>
Canonical ADT representation ofCoProduct7
.private static class
Choice7._A<A,B,C,D,E,F,G>
private static class
Choice7._B<A,B,C,D,E,F,G>
private static class
Choice7._C<A,B,C,D,E,F,G>
private static class
Choice7._D<A,B,C,D,E,F,G>
private static class
Choice7._E<A,B,C,D,E,F,G>
private static class
Choice7._F<A,B,C,D,E,F,G>
private static class
Choice7._G<A,B,C,D,E,F,G>
class
Choice8<A,B,C,D,E,F,G,H>
Canonical ADT representation ofCoProduct8
.private static class
Choice8._A<A,B,C,D,E,F,G,H>
private static class
Choice8._B<A,B,C,D,E,F,G,H>
private static class
Choice8._C<A,B,C,D,E,F,G,H>
private static class
Choice8._D<A,B,C,D,E,F,G,H>
private static class
Choice8._E<A,B,C,D,E,F,G,H>
private static class
Choice8._F<A,B,C,D,E,F,G,H>
private static class
Choice8._G<A,B,C,D,E,F,G,H>
private static class
Choice8._H<A,B,C,D,E,F,G,H>
Method parameters in com.jnape.palatable.lambda.adt.choice with type arguments of type MonadRec Modifier and Type Method Description <C> Choice2<A,C>
Choice2. trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,Choice2<A,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<D> Choice3<A,B,D>
Choice3. trampolineM(Fn1<? super C,? extends MonadRec<RecursiveResult<C,D>,Choice3<A,B,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<E> Choice4<A,B,C,E>
Choice4. trampolineM(Fn1<? super D,? extends MonadRec<RecursiveResult<D,E>,Choice4<A,B,C,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<F> Choice5<A,B,C,D,F>
Choice5. trampolineM(Fn1<? super E,? extends MonadRec<RecursiveResult<E,F>,Choice5<A,B,C,D,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<G> Choice6<A,B,C,D,E,G>
Choice6. trampolineM(Fn1<? super F,? extends MonadRec<RecursiveResult<F,G>,Choice6<A,B,C,D,E,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<H> Choice7<A,B,C,D,E,F,H>
Choice7. trampolineM(Fn1<? super G,? extends MonadRec<RecursiveResult<G,H>,Choice7<A,B,C,D,E,F,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<I> Choice8<A,B,C,D,E,F,G,I>
Choice8. trampolineM(Fn1<? super H,? extends MonadRec<RecursiveResult<H,I>,Choice8<A,B,C,D,E,F,G,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction. -
Uses of MonadRec in com.jnape.palatable.lambda.adt.hlist
Classes in com.jnape.palatable.lambda.adt.hlist that implement MonadRec Modifier and Type Class Description class
SingletonHList<_1>
A singleton HList.class
Tuple2<_1,_2>
A 2-element tuple product type, implemented as a specialized HList.class
Tuple3<_1,_2,_3>
A 3-element tuple product type, implemented as a specialized HList.class
Tuple4<_1,_2,_3,_4>
A 4-element tuple product type, implemented as a specialized HList.class
Tuple5<_1,_2,_3,_4,_5>
A 5-element tuple product type, implemented as a specialized HList.class
Tuple6<_1,_2,_3,_4,_5,_6>
A 6-element tuple product type, implemented as a specialized HList.class
Tuple7<_1,_2,_3,_4,_5,_6,_7>
A 7-element tuple product type, implemented as a specialized HList.class
Tuple8<_1,_2,_3,_4,_5,_6,_7,_8>
An 8-element tuple product type, implemented as a specialized HList.Method parameters in com.jnape.palatable.lambda.adt.hlist with type arguments of type MonadRec Modifier and Type Method Description <_1Prime> SingletonHList<_1Prime>
SingletonHList. trampolineM(Fn1<? super _1,? extends MonadRec<RecursiveResult<_1,_1Prime>,SingletonHList<?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<_2Prime> Tuple2<_1,_2Prime>
Tuple2. trampolineM(Fn1<? super _2,? extends MonadRec<RecursiveResult<_2,_2Prime>,Tuple2<_1,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<_3Prime> Tuple3<_1,_2,_3Prime>
Tuple3. trampolineM(Fn1<? super _3,? extends MonadRec<RecursiveResult<_3,_3Prime>,Tuple3<_1,_2,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<_4Prime> Tuple4<_1,_2,_3,_4Prime>
Tuple4. trampolineM(Fn1<? super _4,? extends MonadRec<RecursiveResult<_4,_4Prime>,Tuple4<_1,_2,_3,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<_5Prime> Tuple5<_1,_2,_3,_4,_5Prime>
Tuple5. trampolineM(Fn1<? super _5,? extends MonadRec<RecursiveResult<_5,_5Prime>,Tuple5<_1,_2,_3,_4,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<_6Prime> Tuple6<_1,_2,_3,_4,_5,_6Prime>
Tuple6. trampolineM(Fn1<? super _6,? extends MonadRec<RecursiveResult<_6,_6Prime>,Tuple6<_1,_2,_3,_4,_5,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<_7Prime> Tuple7<_1,_2,_3,_4,_5,_6,_7Prime>
Tuple7. trampolineM(Fn1<? super _7,? extends MonadRec<RecursiveResult<_7,_7Prime>,Tuple7<_1,_2,_3,_4,_5,_6,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<_8Prime> Tuple8<_1,_2,_3,_4,_5,_6,_7,_8Prime>
Tuple8. trampolineM(Fn1<? super _8,? extends MonadRec<RecursiveResult<_8,_8Prime>,Tuple8<_1,_2,_3,_4,_5,_6,_7,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction. -
Uses of MonadRec in com.jnape.palatable.lambda.adt.hmap
Subinterfaces of MonadRec in com.jnape.palatable.lambda.adt.hmap Modifier and Type Interface Description interface
Schema<Values extends HList>
A lens that focuses on theheterogeneous list
of values pointed at by one or moretypesafe keys
that must all exist in the sameHMap
to be collectively extracted.interface
TypeSafeKey<A,B>
An interface representing a parametrized key for use inHMap
s.static interface
TypeSafeKey.Simple<A>
-
Uses of MonadRec in com.jnape.palatable.lambda.functions
Subinterfaces of MonadRec in com.jnape.palatable.lambda.functions Modifier and Type Interface Description interface
Effect<A>
A function returning "no result", and therefore only useful as a side-effect.interface
Fn0<A>
interface
Fn1<A,B>
A function taking a single argument.interface
Fn2<A,B,C>
A function taking two arguments.interface
Fn3<A,B,C,D>
A function taking three arguments.interface
Fn4<A,B,C,D,E>
A function taking four arguments.interface
Fn5<A,B,C,D,E,F>
A function taking five arguments.interface
Fn6<A,B,C,D,E,F,G>
A function taking six arguments.interface
Fn7<A,B,C,D,E,F,G,H>
A function taking seven arguments.interface
Fn8<A,B,C,D,E,F,G,H,I>
A function taking eight arguments.Method parameters in com.jnape.palatable.lambda.functions with type arguments of type MonadRec Modifier and Type Method Description default <C> Fn1<A,C>
Fn1. trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,Fn1<A,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction. -
Uses of MonadRec in com.jnape.palatable.lambda.functions.builtin.fn1
Classes in com.jnape.palatable.lambda.functions.builtin.fn1 that implement MonadRec Modifier and Type Class Description class
CatMaybes<A>
Given an
, return anIterable
<Maybe
<A>>
of only the present values.Iterable
<A>class
Coalesce<L,R>
class
Constantly<A,B>
A function that takes two arguments and always returns the first argument.class
Cycle<A>
Given anIterable
, return an infiniteIterable
that repeatedly cycles its elements, in order.class
Distinct<A>
Return anIterable
of the distinct values from the given inputIterable
.class
Downcast<A extends B,B>
Covariantly cast a value of typeB
to a value of subtypeA
.class
Empty<A>
A predicate that returns true ifas
is empty; false otherwise.class
Flatten<A>
Given a nestedIterable
ofIterable
s, return a lazily flatteningIterable
of the nested elements.class
Force<A>
Deprecated.in favor oftraversing
into anIO
and running itclass
Head<A>
Retrieve the head element of anIterable
, wrapped in anMaybe
.class
Id<A>
The identity function.class
Init<A>
Given an
, produce anIterable
<A>
of all elements but the last one.Iterable
<A>class
Inits<A>
Given an
, produce anIterable
<A>
, representing all of the subsequences of initial elements, ordered by size, starting with the emptyIterable
<Iterable
<A>>Iterable
.class
Last<A>
Retrieve the last element of anIterable
, wrapped in aMaybe
.class
Magnetize<A>
Magnetize
anIterable
using value equality as the magnetizing function.class
Not<A>
Negate a predicate function.class
Occurrences<A>
Given an
, return aIterable
<A>
representing each unique element in theMap
<A, Long>Iterable
paired with its number of occurrences.class
Repeat<A>
Given a value, return an infiniteIterable
that repeatedly iterates that value.class
Reverse<A>
Given anIterable
, return a reversed representation of thatIterable
.class
Size
class
Sort<A extends java.lang.Comparable<A>>
Given anIterable
ofComparable
elements, return aList
of the sorted elements.class
Tail<A>
Returns the tail of anIterable
; the is, anIterable
of all the elements except for the head element.class
Tails<A>
Given an
, produce anIterable
<A>
, representing all of the subsequences of tail elements, ordered by size, starting with the fullIterable
<Iterable
<A>>Iterable
.class
Uncons<A>
class
Upcast<A extends B,B>
Upcast a value of typeB
to a value of typeA
thatB
extends. -
Uses of MonadRec in com.jnape.palatable.lambda.functions.builtin.fn2
Classes in com.jnape.palatable.lambda.functions.builtin.fn2 that implement MonadRec Modifier and Type Class Description class
$<A,B>
class
All<A>
Eagerly apply a predicate to each element in anIterable
, returningtrue
if every element satisfies the predicate, andfalse
otherwise.class
Alter<A>
class
Any<A>
Eagerly apply a predicate to each element in anIterable
, returningtrue
if any element satisfies the predicate, andfalse
otherwise.class
AutoBracket<A extends java.lang.AutoCloseable,B>
class
Both<A,B,C>
class
CartesianProduct<A,B>
Lazily compute the cartesian product of anIterable<A>
andIterable<B>
, returning anIterable<Tuple2<A, B>>
, the products as tuples of multiplicandA
s and multiplierB
s.class
CmpEq<A extends java.lang.Comparable<A>>
Given twoComparable
values of typeA
, returntrue
if the first value is strictly equal to the second value (according toComparable.compareTo(Object)
; otherwise, return false.class
Cons<A>
Prepend an element to anIterable
.class
Difference<A>
class
Drop<A>
Lazily skip the firstn
elements from anIterable
by returning anIterable
that begins iteration after thenth
element.class
DropWhile<A>
Lazily limit theIterable
by skipping the first contiguous group of elements that satisfy the predicate, beginning iteration at the first element for which the predicate evaluates tofalse
.class
Eq<A>
Type-safe equality in function form; usesObject.equals(java.lang.Object)
, not==
.class
Filter<A>
Lazily apply a predicate to each element in anIterable
, returning anIterable
of just the elements for which the predicate evaluated totrue
.class
Find<A>
Iterate the elements in anIterable
, applying a predicate to each one, returning the first element that matches the predicate, wrapped in aMaybe
.class
GroupBy<K,V>
Given anIterable<V>
vs
and a key functionV -> K
f
, foldvs
into aMap<K, List<V>>
by applyingf
to each element ofvs
, retaining values that map to the same key in a list, in the order they were iterated in.class
GT<A extends java.lang.Comparable<A>>
Given twoComparable
values of typeA
, returntrue
if the second value is strictly greater than the first value; otherwise, return false.class
GTE<A extends java.lang.Comparable<A>>
Given twoComparable
values of typeA
, returntrue
if the second value is greater than or equal to the first value according toComparable.compareTo(Object)
; otherwise, return false.class
InGroupsOf<A>
Lazily group theIterable
by returning anIterable
of smallerIterable
s of sizek
.class
Intersperse<A>
Lazily inject the provided separator value between each value in the suppliedIterable
.class
Into<A,B,C>
Given an
and aFn2
<A, B, C>
, destructure the entry and apply the key and value as arguments to the function, returning the result.Map.Entry
<A, B>class
Into1<A,B>
Given an
and aFn1
<A, B>
, pop the head and apply it to the function, returning the result.SingletonHList
<A>class
Into3<A,B,C,D>
class
Into4<A,B,C,D,E>
class
Into5<A,B,C,D,E,F>
class
Into6<A,B,C,D,E,F,G>
class
Into7<A,B,C,D,E,F,G,H>
class
Into8<A,B,C,D,E,F,G,H,I>
class
Iterate<A>
Lazily generate an infiniteIterable
from the successive applications of the function first to the initial seed value, then to the result, and so on; i.e., the result ofiterate(x -> x + 1, 0)
would produce an infiniteIterable
over the elements0, 1, 2, 3, ...
class
LazyRec<A,B>
class
LT<A extends java.lang.Comparable<A>>
Given twoComparable
values of typeA
, returntrue
if the second value is strictly less than the first value; otherwise, return false.class
LTE<A extends java.lang.Comparable<A>>
Given twoComparable
values of typeA
, returntrue
if the second value is less than or equal to the first value according toComparable.compareTo(Object)
otherwise, return false.class
MagnetizeBy<A>
Given a binary predicate and an
, return anIterable
<A>
of the contiguous groups of elements that match the predicate pairwise.Iterable
<Iterable
<A>>class
Map<A,B>
Lazily apply a function to each element in anIterable
, producing anIterable
of the mapped results.class
Partition<A,B,C>
Given anIterable<A>
as
and a disjoint mapping functiona -> CoProduct2<A, B>
, return aTuple2
over the lazily unwrapped leftA
and rightB
values in the first and second slots, respectively.class
Peek<A,FA extends Functor<A,?>>
class
Peek2<A,B,FAB extends BoundedBifunctor<A,B,? super A,? super B,?>>
Deprecated.in favor of producing anIO
from the givenBoundedBifunctor
and explicitly running itclass
PrependAll<A>
Lazily prepend each value with of theIterable
with the supplied separator value.class
ReduceLeft<A>
class
ReduceRight<A>
class
Replicate<A>
Produce anIterable
of a valuen
times.class
Sequence<A,App extends Applicative<?,App>,Trav extends Traversable<?,Trav>,TravA extends Traversable<A,Trav>,AppTrav extends Applicative<TravA,App>>
Given aTraversable
ofApplicative
s and a pureApplicative
constructor, traverse the elements from left to right, zipping theApplicative
s together and collecting the results.class
Slide<A>
Given an
, "slide" a window ofIterable
<A>k
elements across theIterable
by one element at a time, returning an
.Iterable
<Iterable
<A>>class
Snoc<A>
Opposite ofCons
: lazily append an element to the end of the givenIterable
.class
SortBy<A,B extends java.lang.Comparable<B>>
Given anIterable
and some mapping function from theIterable
element type to someComparable
type, produce a sortedList
of the original elements based on sorting applied to the result of the mapping function.class
SortWith<A>
Given anIterable
and aComparator
over theIterable
element type, produce a sortedList
of the original elements based on sorting applied by theComparator
.class
Span<A>
Given a predicate, return aTuple2
where the first slot is the front contiguous elements of anIterable
matching the predicate and the second slot is all the remaining elements.class
Take<A>
Lazily limit theIterable
ton
elements by returning anIterable
that stops iteration after thenth
element, or the last element of theIterable
, whichever comes first.class
TakeWhile<A>
Lazily limit theIterable
to the first group of contiguous elements that satisfy the predicate by iterating up to, but not including, the first element for which the predicate evaluates tofalse
.class
ToArray<A>
Write all the elements of anIterable
directly into an array of the specified type.class
ToCollection<A,C extends java.util.Collection<A>>
Given anFn0
of someCollection
C
, create an instance ofC
and add all of the elements in the providedIterable
to the instance.class
ToMap<K,V,M extends java.util.Map<K,V>>
Given anFn0
of someMap
M
, create an instance ofM
and put all of the entries in the providedIterable
into the instance.class
Tupler2<A,B>
Creates aTuple2
from two values.class
Unfoldr<A,B>
class
Until<A>
Given apredicate function
for a value of some typeA
and anIO
that yields a value of typeA
, produce anIO
that repeatedly executes the originalIO
until the predicate returns true when applied to the yielded value.class
Zip<A,B>
Zip together twoIterable
s into a singleIterable
ofTuple2<A, B>
. -
Uses of MonadRec in com.jnape.palatable.lambda.functions.builtin.fn3
Classes in com.jnape.palatable.lambda.functions.builtin.fn3 that implement MonadRec Modifier and Type Class Description class
Between<A extends java.lang.Comparable<A>>
Given two bounds and a value, return whether or not the value is greater than or equal to the lower bound and less than or equal to the upper bound.class
Bracket<A,B>
Given anIO
that yields some typeA
, a cleanup operation to run if a value of that type could be provisioned, and a kleisli arrow from that type to a newIO
of typeB
, produce an
that, when run, will provision theIO
<B>A
,flatMap
it toB
, and clean up the original value if it was produced in the first place.class
Clamp<A extends java.lang.Comparable<A>>
Given two bounds and a value, "clamp" the value between the bounds via the following algorithm: - if the value is strictly less than the lower bound, return the lower bound - if the value is strictly greater than the upper bound, return the upper bound - otherwise, return the valueclass
CmpEqBy<A,B extends java.lang.Comparable<B>>
Given a mapping function from some typeA
to someComparable
typeB
and two values of typeA
, returntrue
if the first value is strictly equal to the second value (according toComparable.compareTo(Object)
in terms of their mappedB
results; otherwise, return false.class
CmpEqWith<A>
Given aComparator
from some typeA
and two values of typeA
, returntrue
if the first value is strictly equal to the second value (according toComparator.compare(Object, Object)
otherwise, return false.class
Compare<A>
Given aComparator
from some typeA
and two values of typeA
, return aComparisonRelation
of the first value with reference to the second value (according toComparator.compare(Object, Object)
.class
FoldLeft<A,B>
Given anIterable
ofA
s, a starting valueB
, and a
, iteratively accumulate over theFn2
<B, A, B>Iterable
, ultimately returning a finalB
value.class
FoldRight<A,B>
class
GTBy<A,B extends java.lang.Comparable<B>>
Given a mapping function from some typeA
to someComparable
typeB
and two values of typeA
, returntrue
if the second value is strictly greater than the first value in terms of their mappedB
results; otherwise, return false.class
GTEBy<A,B extends java.lang.Comparable<B>>
Given a mapping function from some typeA
to someComparable
typeB
and two values of typeA
, returntrue
if the second value is greater than or equal to the first value in terms of their mappedB
results according toComparable.compareTo(Object)
; otherwise, return false.class
GTEWith<A>
Given aComparator
from some typeA
and two values of typeA
, returntrue
if the second value is greater than or equal to the first value in terms of their mappedB
results according toComparator.compare(Object, Object)
; otherwise, return false.class
GTWith<A>
Given aComparator
from some typeA
and two values of typeA
, returntrue
if the second value is strictly greater than the first value in terms of their mappedB
results; otherwise, return false.class
LiftA2<A,B,C,App extends Applicative<?,App>,AppC extends Applicative<C,App>>
Lift into and apply anFn2
to twoApplicative
values, returning the result inside the sameApplicative
context.class
LTBy<A,B extends java.lang.Comparable<B>>
Given a mapping function from some typeA
to someComparable
typeB
and two values of typeA
, returntrue
if the second value is strictly less than the first value in terms of their mappedB
results; otherwise, return false.class
LTEBy<A,B extends java.lang.Comparable<B>>
Given a mapping function from some typeA
to someComparable
typeB
and two values of typeA
, returntrue
if the second value is less than or equal to the first value in terms of their mappedB
results according toComparable.compareTo(Object)
; otherwise, return false.class
LTEWith<A>
Given aComparator
from some typeA
and two values of typeA
, returntrue
if the second value is less than or equal to the first value in terms of their mappedB
results according toComparator.compare(Object, Object)
; otherwise, return false.class
LTWith<A>
Given a comparator for some typeA
and two values of typeA
, returntrue
if the second value is strictly less than than the first value in terms of their mappedB
results; otherwise, return false.class
ScanLeft<A,B>
Given anIterable
ofA
s, a starting valueB
, and a
, iteratively accumulate over theFn2
<B, A, B>Iterable
, collecting each function application result, finally returning anIterable
of all the results.class
Times<A>
Given some number of timesn
to invoke a functionA -> A
, and given an inputA
, iteratively apply the function to the input, and then to the result of the invocation, a total ofn
times, returning the result.class
ZipWith<A,B,C>
Zip together twoIterable
s by applying a zipping function to the successive elements of eachIterable
until one of them runs out of elements. -
Uses of MonadRec in com.jnape.palatable.lambda.functions.builtin.fn4
Classes in com.jnape.palatable.lambda.functions.builtin.fn4 that implement MonadRec Modifier and Type Class Description class
IfThenElse<A,B>
class
LiftA3<A,B,C,D,App extends Applicative<?,App>,AppD extends Applicative<D,App>>
Lift into and apply anFn3
to threeApplicative
values, returning the result inside the sameApplicative
context.class
RateLimit<A>
-
Uses of MonadRec in com.jnape.palatable.lambda.functions.builtin.fn5
Classes in com.jnape.palatable.lambda.functions.builtin.fn5 that implement MonadRec Modifier and Type Class Description class
LiftA4<A,B,C,D,E,App extends Applicative<?,App>,AppE extends Applicative<E,App>>
Lift into and apply anFn4
to fourApplicative
values, returning the result inside the sameApplicative
context. -
Uses of MonadRec in com.jnape.palatable.lambda.functions.builtin.fn6
Classes in com.jnape.palatable.lambda.functions.builtin.fn6 that implement MonadRec Modifier and Type Class Description class
LiftA5<A,B,C,D,E,F,App extends Applicative<?,App>,AppF extends Applicative<F,App>>
Lift into and apply anFn5
to fiveApplicative
values, returning the result inside the sameApplicative
context. -
Uses of MonadRec in com.jnape.palatable.lambda.functions.builtin.fn7
Classes in com.jnape.palatable.lambda.functions.builtin.fn7 that implement MonadRec Modifier and Type Class Description class
LiftA6<A,B,C,D,E,F,G,App extends Applicative<?,App>,AppG extends Applicative<G,App>>
Lift into and apply anFn6
to sixApplicative
values, returning the result inside the sameApplicative
context. -
Uses of MonadRec in com.jnape.palatable.lambda.functions.builtin.fn8
Classes in com.jnape.palatable.lambda.functions.builtin.fn8 that implement MonadRec Modifier and Type Class Description class
LiftA7<A,B,C,D,E,F,G,H,App extends Applicative<?,App>,AppH extends Applicative<H,App>>
Lift into and apply anFn7
to sevenApplicative
values, returning the result inside the sameApplicative
context. -
Uses of MonadRec in com.jnape.palatable.lambda.functions.recursion
Classes in com.jnape.palatable.lambda.functions.recursion that implement MonadRec Modifier and Type Class Description class
RecursiveResult<A,B>
SpecializedCoProduct2
representing the possible results of a primitive recursive function.(package private) static class
RecursiveResult.Recurse<A,B>
(package private) static class
RecursiveResult.Terminate<A,B>
class
Trampoline<A,B>
Given an
(analogous to "recurse" and "return" tail position instructions, respectively), produce aFn1
<A,CoProduct2
<A, B, ?>>
that unrolls the original function by iteratively passing each result that matches the input (Fn1
<A, B>A
) back to the original function, and then terminating on and returning the first output (B
).Method parameters in com.jnape.palatable.lambda.functions.recursion with type arguments of type MonadRec Modifier and Type Method Description <C> RecursiveResult<A,C>
RecursiveResult. trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,RecursiveResult<A,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction. -
Uses of MonadRec in com.jnape.palatable.lambda.functions.specialized
Subinterfaces of MonadRec in com.jnape.palatable.lambda.functions.specialized Modifier and Type Interface Description interface
BiMonoidFactory<A,B,C>
interface
BiPredicate<A,B>
interface
BiSemigroupFactory<A,B,C>
interface
Kleisli<A,B,M extends Monad<?,M>,MB extends Monad<B,M>>
interface
MonoidFactory<A,B>
interface
Predicate<A>
A specializedFn1
that returns aBoolean
.interface
SemigroupFactory<A,B>
Methods in com.jnape.palatable.lambda.functions.specialized with type parameters of type MonadRec Modifier and Type Method Description default <A,M extends MonadRec<?,M>,MBA extends MonadBase<M,A,B>>
MBALift. apply(MonadRec<A,M> ma)
<A,M extends MonadRec<?,M>>
MonadBase<M,A,B>Lift. checkedApply(MonadRec<A,M> ga)
Methods in com.jnape.palatable.lambda.functions.specialized with parameters of type MonadRec Modifier and Type Method Description default <A,M extends MonadRec<?,M>,MBA extends MonadBase<M,A,B>>
MBALift. apply(MonadRec<A,M> ma)
<A,M extends MonadRec<?,M>>
MonadBase<M,A,B>Lift. checkedApply(MonadRec<A,M> ga)
-
Uses of MonadRec in com.jnape.palatable.lambda.functor.builtin
Classes in com.jnape.palatable.lambda.functor.builtin that implement MonadRec Modifier and Type Class Description class
Const<A,B>
A (surprisingly useful) functor over some phantom typeB
, retaining a value of typeA
that can be retrieved later.class
Identity<A>
A functor over some value of typeA
that can be mapped over and retrieved later.class
Lazy<A>
AMonad
representing a lazily-computed value.private static class
Lazy.Compose<A>
private static class
Lazy.Later<A>
class
Market<A,B,S,T>
A profunctor used to extract the isomorphic functions aPrism
is composed of.class
State<S,A>
The stateMonad
, useful for iteratively building up state and state-contextualized result.class
Tagged<S,B>
LikeConst
, but the phantom parameter is in the contravariant position, and the value is in covariant position.class
Writer<W,A>
The lazy writer monad, a monad capturing some accumulation (eventually to be folded in terms of a given monoid) and a value.Method parameters in com.jnape.palatable.lambda.functor.builtin with type arguments of type MonadRec Modifier and Type Method Description <C> Const<A,C>
Const. trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,Const<A,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<B> Identity<B>
Identity. trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,Identity<?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<B> Lazy<B>
Lazy. trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,Lazy<?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<U> Market<A,B,S,U>
Market. trampolineM(Fn1<? super T,? extends MonadRec<RecursiveResult<T,U>,Market<A,B,S,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<B> State<S,B>
State. trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,State<S,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<C> Tagged<S,C>
Tagged. trampolineM(Fn1<? super B,? extends MonadRec<RecursiveResult<B,C>,Tagged<S,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<B> Writer<W,B>
Writer. trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,Writer<W,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction. -
Uses of MonadRec in com.jnape.palatable.lambda.io
Classes in com.jnape.palatable.lambda.io that implement MonadRec Modifier and Type Class Description class
IO<A>
AMonad
representing some side-effecting computation to be performed.private static class
IO.Compose<A>
Method parameters in com.jnape.palatable.lambda.io with type arguments of type MonadRec Modifier and Type Method Description <B> IO<B>
IO. trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,IO<?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction. -
Uses of MonadRec in com.jnape.palatable.lambda.monad
Classes in com.jnape.palatable.lambda.monad with type parameters of type MonadRec Modifier and Type Interface Description interface
MonadBase<M extends MonadRec<?,M>,A,MB extends MonadBase<?,?,MB>>
interface
MonadRec<A,M extends MonadRec<?,M>>
A class ofmonads
that offer a stack-safe interface for performing arbitrarily manyflatmap-like
operations viatrampolineM(Fn1)
.class
SafeT<M extends MonadRec<?,M>,A>
A stack-safemonad transformer
that can safely interpret deeply nested left- or right-associated binds for anyMonadRec
.private static class
SafeT.Body<M extends MonadRec<?,M>,A>
private static class
SafeT.Body.Done<M extends MonadRec<?,M>,A>
private static class
SafeT.Body.More<M extends MonadRec<?,M>,A>
private static class
SafeT.Body.Suspended<M extends MonadRec<?,M>,A,B>
private static interface
SafeT.Body.Suspended.Φ<M extends MonadRec<?,M>,B,R>
Classes in com.jnape.palatable.lambda.monad that implement MonadRec Modifier and Type Class Description class
SafeT<M extends MonadRec<?,M>,A>
A stack-safemonad transformer
that can safely interpret deeply nested left- or right-associated binds for anyMonadRec
.Fields in com.jnape.palatable.lambda.monad declared as MonadRec Modifier and Type Field Description private MonadRec<SafeT.Body<M,A>,M>
SafeT.Body.More. mfa
Methods in com.jnape.palatable.lambda.monad with type parameters of type MonadRec Modifier and Type Method Description private static <M extends MonadRec<?,M>,A>
SafeT.Body<M,A>SafeT.Body. done(A a)
<C,N extends MonadRec<?,N>>
MonadBase<N,C,MB>MonadBase. lift(MonadRec<C,N> nc)
<B,N extends MonadRec<?,N>>
SafeT<N,B>SafeT. lift(MonadRec<B,N> nb)
private static <M extends MonadRec<?,M>,A>
SafeT.Body<M,A>SafeT.Body. more(MonadRec<SafeT.Body<M,A>,M> mb)
static <M extends MonadRec<?,M>>
Pure<SafeT<M,?>>SafeT. pureSafeT(Pure<M> pureM)
<MA extends MonadRec<A,M>>
MASafeT. runSafeT()
Recover the full structure of the embeddedMonad
in a stack-safe way.static <M extends MonadRec<?,M>,A>
SafeT<M,A>SafeT. safeT(MonadRec<A,M> ma)
private static <M extends MonadRec<?,M>,A,B>
SafeT.Body<M,B>SafeT.Body. suspend(SafeT.Body<M,A> freeA, Fn1<A,SafeT.Body<M,B>> fn)
Methods in com.jnape.palatable.lambda.monad that return MonadRec Modifier and Type Method Description default <B> MonadRec<B,M>
MonadRec. discardL(Applicative<B,M> appB)
Sequence both thisApplicative
andappB
, discarding thisApplicative's
result and returningappB
.default <B> MonadRec<A,M>
MonadRec. discardR(Applicative<B,M> appB)
Sequence both thisApplicative
andappB
, discardingappB's
result and returning thisApplicative
.<B> MonadRec<B,M>
MonadRec. flatMap(Fn1<? super A,? extends Monad<B,M>> f)
Chain dependent computations that may continue or short-circuit based on previous results.default <B> MonadRec<B,M>
MonadRec. fmap(Fn1<? super A,? extends B> fn)
Covariantly transmute this functor's parameter using the given mapping function.<B> MonadRec<B,M>
MonadRec. pure(B b)
Lift the valueb
into this applicative functor.<B> MonadRec<B,M>
MonadRec. trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,M>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.default <B> MonadRec<B,M>
MonadRec. zip(Applicative<Fn1<? super A,? extends B>,M> appFn)
Given another instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.Methods in com.jnape.palatable.lambda.monad that return types with arguments of type MonadRec Modifier and Type Method Description private <Z> Fn1<SafeT.Body.Suspended<M,?,Z>,RecursiveResult<SafeT.Body<M,B>,Either<MonadRec<SafeT.Body<M,B>,M>,B>>>
SafeT.Body.Suspended. associateRight(Fn1<Z,SafeT.Body<M,B>> f)
default <B> Lazy<? extends MonadRec<B,M>>
MonadRec. lazyZip(Lazy<? extends Applicative<Fn1<? super A,? extends B>,M>> lazyAppFn)
Given alazy
instance of this applicative over a mapping function, "zip" the two instances together using whatever application semantics the current applicative supports.Either<MonadRec<SafeT.Body<M,A>,M>,A>
SafeT.Body.Done. resume()
Either<MonadRec<SafeT.Body<M,A>,M>,A>
SafeT.Body.More. resume()
abstract Either<MonadRec<SafeT.Body<M,A>,M>,A>
SafeT.Body. resume()
Either<MonadRec<SafeT.Body<M,B>,M>,B>
SafeT.Body.Suspended. resume()
Methods in com.jnape.palatable.lambda.monad with parameters of type MonadRec Modifier and Type Method Description <C,N extends MonadRec<?,N>>
MonadBase<N,C,MB>MonadBase. lift(MonadRec<C,N> nc)
<B,N extends MonadRec<?,N>>
SafeT<N,B>SafeT. lift(MonadRec<B,N> nb)
private static <M extends MonadRec<?,M>,A>
SafeT.Body<M,A>SafeT.Body. more(MonadRec<SafeT.Body<M,A>,M> mb)
static <M extends MonadRec<?,M>,A>
SafeT<M,A>SafeT. safeT(MonadRec<A,M> ma)
Method parameters in com.jnape.palatable.lambda.monad with type arguments of type MonadRec Modifier and Type Method Description <R> R
SafeT.Body.Done. match(Fn1<? super Either<MonadRec<SafeT.Body<M,A>,M>,A>,? extends R> aFn, Fn1<? super SafeT.Body.Suspended<M,?,A>,? extends R> bFn)
<R> R
SafeT.Body.More. match(Fn1<? super Either<MonadRec<SafeT.Body<M,A>,M>,A>,? extends R> aFn, Fn1<? super SafeT.Body.Suspended<M,?,A>,? extends R> bFn)
<R> R
SafeT.Body.Suspended. match(Fn1<? super Either<MonadRec<SafeT.Body<M,B>,M>,B>,? extends R> aFn, Fn1<? super SafeT.Body.Suspended<M,?,B>,? extends R> bFn)
<B> MonadRec<B,M>
MonadRec. trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,M>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<B> SafeT<M,B>
SafeT. trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,SafeT<M,?>>> bounce)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.Constructors in com.jnape.palatable.lambda.monad with parameters of type MonadRec Constructor Description More(MonadRec<SafeT.Body<M,A>,M> mfa)
-
Uses of MonadRec in com.jnape.palatable.lambda.monad.transformer
Classes in com.jnape.palatable.lambda.monad.transformer with type parameters of type MonadRec Modifier and Type Interface Description interface
MonadT<M extends MonadRec<?,M>,A,MT extends MonadT<M,?,MT,T>,T extends MonadT<?,?,?,T>>
Subinterfaces of MonadRec in com.jnape.palatable.lambda.monad.transformer Modifier and Type Interface Description interface
MonadT<M extends MonadRec<?,M>,A,MT extends MonadT<M,?,MT,T>,T extends MonadT<?,?,?,T>>
Methods in com.jnape.palatable.lambda.monad.transformer with type parameters of type MonadRec Modifier and Type Method Description <B,N extends MonadRec<?,N>>
MonadT<N,B,?,T>MonadT. lift(MonadRec<B,N> mb)
Methods in com.jnape.palatable.lambda.monad.transformer with parameters of type MonadRec Modifier and Type Method Description <B,N extends MonadRec<?,N>>
MonadT<N,B,?,T>MonadT. lift(MonadRec<B,N> mb)
-
Uses of MonadRec in com.jnape.palatable.lambda.monad.transformer.builtin
Classes in com.jnape.palatable.lambda.monad.transformer.builtin with type parameters of type MonadRec Modifier and Type Class Description class
EitherT<M extends MonadRec<?,M>,L,R>
Amonad transformer
forEither
.class
IdentityT<M extends MonadRec<?,M>,A>
Amonad transformer
forIdentity
.class
IterateT<M extends MonadRec<?,M>,A>
Amonad transformer
over a co-inductive, singly-linked spine of values embedded in effects.class
LazyT<M extends MonadRec<?,M>,A>
Amonad transformer
forLazy
.class
MaybeT<M extends MonadRec<?,M>,A>
Amonad transformer
forMaybe
.class
ReaderT<R,M extends MonadRec<?,M>,A>
class
StateT<S,M extends MonadRec<?,M>,A>
TheState
monad transformer
.class
WriterT<W,M extends MonadRec<?,M>,A>
Amonad transformer
forWriter
.Classes in com.jnape.palatable.lambda.monad.transformer.builtin that implement MonadRec Modifier and Type Class Description class
EitherT<M extends MonadRec<?,M>,L,R>
Amonad transformer
forEither
.class
IdentityT<M extends MonadRec<?,M>,A>
Amonad transformer
forIdentity
.class
IterateT<M extends MonadRec<?,M>,A>
Amonad transformer
over a co-inductive, singly-linked spine of values embedded in effects.class
LazyT<M extends MonadRec<?,M>,A>
Amonad transformer
forLazy
.class
MaybeT<M extends MonadRec<?,M>,A>
Amonad transformer
forMaybe
.class
ReaderT<R,M extends MonadRec<?,M>,A>
class
StateT<S,M extends MonadRec<?,M>,A>
TheState
monad transformer
.class
WriterT<W,M extends MonadRec<?,M>,A>
Amonad transformer
forWriter
.Fields in com.jnape.palatable.lambda.monad.transformer.builtin declared as MonadRec Modifier and Type Field Description private MonadRec<Either<L,R>,M>
EitherT. melr
private MonadRec<Identity<A>,M>
IdentityT. mia
private MonadRec<Lazy<A>,M>
LazyT. mla
private MonadRec<Maybe<A>,M>
MaybeT. mma
Fields in com.jnape.palatable.lambda.monad.transformer.builtin with type parameters of type MonadRec Modifier and Type Field Description private Fn1<? super R,? extends MonadRec<A,M>>
ReaderT. f
private ImmutableQueue<Choice2<Fn0<MonadRec<Maybe<Tuple2<A,IterateT<M,A>>>,M>>,MonadRec<A,M>>>
IterateT. spine
private ImmutableQueue<Choice2<Fn0<MonadRec<Maybe<Tuple2<A,IterateT<M,A>>>,M>>,MonadRec<A,M>>>
IterateT. spine
private Fn1<? super S,? extends MonadRec<Tuple2<A,S>,M>>
StateT. stateFn
private Fn1<? super Monoid<W>,? extends MonadRec<Tuple2<A,W>,M>>
WriterT. writerFn
Methods in com.jnape.palatable.lambda.monad.transformer.builtin with type parameters of type MonadRec Modifier and Type Method Description static <R,M extends MonadRec<?,M>>
ReaderT<R,M,R>ReaderT. ask(Pure<M> pureM)
Given aPure
ask will give you access to the input within the monadic embeddingstatic <M extends MonadRec<?,M>,L,R>
EitherT<M,L,R>EitherT. eitherT(MonadRec<Either<L,R>,M> melr)
static <M extends MonadRec<?,M>,A>
IterateT<M,A>IterateT. empty(Pure<M> pureM)
Static factory method for creating an emptyIterateT
.<MA extends MonadRec<A,M>>
MAWriterT. evalWriterT(Monoid<W> monoid)
Given aMonoid
for the accumulation, run the computation represented by thisWriterT
inside themonadic effect
, ignoring the resulting accumulation, yielding the value in isolation.<MW extends MonadRec<W,M>>
MWWriterT. execWriterT(Monoid<W> monoid)
Given aMonoid
for the accumulation, run the computation represented by thisWriterT
inside themonadic effect
, ignoring the value, yielding the accumulation in isolation.<B,MB extends MonadRec<B,M>>
MBIterateT. fold(Fn2<? super B,? super A,? extends MonadRec<B,M>> fn, MonadRec<B,M> acc)
Monolithically fold the spine of thisIterateT
bytrampolining
the underlying effects (for iterative folding, usetrampolineM
directly).<B,MB extends MonadRec<B,M>>
MBIterateT. foldCut(Fn2<? super B,? super A,? extends MonadRec<RecursiveResult<B,B>,M>> fn, MonadRec<B,M> acc)
Monolithically fold the spine of thisIterateT
(with the possibility of early termination) bytrampolining
the underlying effects (for iterative folding, usetrampolineM
directly).<MU extends MonadRec<Unit,M>>
MUIterateT. forEach(Fn1<? super A,? extends MonadRec<Unit,M>> fn)
static <A,M extends MonadRec<?,M>>
StateT<A,M,A>StateT. get(Pure<M> pureM)
static <S,M extends MonadRec<?,M>,A>
StateT<S,M,A>StateT. gets(Fn1<? super S,? extends MonadRec<A,M>> fn)
Given a function that produces a value inside amonadic effect
from a state, produce aStateT
that simply passes its state to the function and applies it.static <M extends MonadRec<?,M>,A>
IdentityT<M,A>IdentityT. identityT(MonadRec<Identity<A>,M> mia)
static <M extends MonadRec<?,M>,A>
IterateT<M,A>IterateT. iterateT(MonadRec<Maybe<Tuple2<A,IterateT<M,A>>>,M> unwrapped)
static <M extends MonadRec<?,M>,A>
LazyT<M,A>LazyT. lazyT(MonadRec<Lazy<A>,M> mla)
<R2,N extends MonadRec<?,N>>
EitherT<N,L,R2>EitherT. lift(MonadRec<R2,N> mb)
<B,N extends MonadRec<?,N>>
IdentityT<N,B>IdentityT. lift(MonadRec<B,N> mb)
<B,N extends MonadRec<?,N>>
IterateT<N,B>IterateT. lift(MonadRec<B,N> nb)
<B,N extends MonadRec<?,N>>
LazyT<N,B>LazyT. lift(MonadRec<B,N> mb)
<B,N extends MonadRec<?,N>>
MaybeT<N,B>MaybeT. lift(MonadRec<B,N> mb)
<B,N extends MonadRec<?,N>>
ReaderT<R,N,B>ReaderT. lift(MonadRec<B,N> mb)
<B,N extends MonadRec<?,N>>
StateT<S,N,B>StateT. lift(MonadRec<B,N> mb)
<B,N extends MonadRec<?,N>>
WriterT<W,N,B>WriterT. lift(MonadRec<B,N> mb)
static <W,M extends MonadRec<?,M>,A>
WriterT<W,M,A>WriterT. listen(MonadRec<A,M> ma)
<MA extends MonadRec<A,M>,N extends MonadRec<?,N>,B>
ReaderT<R,N,B>ReaderT. mapReaderT(Fn1<? super MA,? extends MonadRec<B,N>> fn)
<MA extends MonadRec<A,M>,N extends MonadRec<?,N>,B>
ReaderT<R,N,B>ReaderT. mapReaderT(Fn1<? super MA,? extends MonadRec<B,N>> fn)
<N extends MonadRec<?,N>,B>
StateT<S,N,B>StateT. mapStateT(Fn1<? super MonadRec<Tuple2<A,S>,M>,? extends MonadRec<Tuple2<B,S>,N>> fn)
Map both the result and the final state to a new result and final state inside theMonad
.static <M extends MonadRec<?,M>,A>
MaybeT<M,A>MaybeT. maybeT(MonadRec<Maybe<A>,M> mma)
static <S,M extends MonadRec<?,M>>
StateT<S,M,Unit>StateT. modify(Fn1<? super S,? extends MonadRec<S,M>> updateFn)
static <M extends MonadRec<?,M>,A>
IterateT<M,A>IterateT. of(MonadRec<A,M> ma, MonadRec<A,M>... mas)
Static factory method for creating anIterateT
from a spine represented by one or more elements.static <M extends MonadRec<?,M>,L>
Pure<EitherT<M,L,?>>EitherT. pureEitherT(Pure<M> pureM)
static <M extends MonadRec<?,M>>
Pure<IdentityT<M,?>>IdentityT. pureIdentityT(Pure<M> pureM)
static <M extends MonadRec<?,M>>
Pure<IterateT<M,?>>IterateT. pureIterateT(Pure<M> pureM)
static <M extends MonadRec<?,M>>
Pure<LazyT<M,?>>LazyT. pureLazyT(Pure<M> pureM)
static <M extends MonadRec<?,M>>
Pure<MaybeT<M,?>>MaybeT. pureMaybeT(Pure<M> pureM)
static <R,M extends MonadRec<?,M>>
Pure<ReaderT<R,M,?>>ReaderT. pureReaderT(Pure<M> pureM)
static <S,M extends MonadRec<?,M>>
Pure<StateT<S,M,?>>StateT. pureStateT(Pure<M> pureM)
static <W,M extends MonadRec<?,M>>
Pure<WriterT<W,M,?>>WriterT. pureWriterT(Pure<M> pureM)
static <S,M extends MonadRec<?,M>>
StateT<S,M,Unit>StateT. put(MonadRec<S,M> ms)
Lift amonadic state
intoStateT
.static <R,M extends MonadRec<?,M>,A>
ReaderT<R,M,A>ReaderT. readerT(Fn1<? super R,? extends MonadRec<A,M>> fn)
<MELR extends MonadRec<Either<L,R>,M>>
MELREitherT. runEitherT()
Recover the full structure of the embeddedMonad
.<MIA extends MonadRec<Identity<A>,M>>
MIAIdentityT. runIdentityT()
Recover the full structure of the embeddedMonad
.<MMTA extends MonadRec<Maybe<Tuple2<A,IterateT<M,A>>>,M>>
MMTAIterateT. runIterateT()
Recover the full structure of the embeddedMonad
.<MLA extends MonadRec<Lazy<A>,M>>
MLALazyT. runLazyT()
Recover the full structure of the embeddedMonad
.<MMA extends MonadRec<Maybe<A>,M>>
MMAMaybeT. runMaybeT()
Recover the full structure of the embeddedMonad
.<MA extends MonadRec<A,M>>
MAReaderT. runReaderT(R r)
Run the computation represented by thisReaderT
.<MAS extends MonadRec<Tuple2<A,S>,M>>
MASStateT. runStateT(S s)
<MStep extends MonadRec<Maybe<Tuple2<Maybe<A>,IterateT<M,A>>>,M>>
MStepIterateT. runStep()
<MAW extends MonadRec<Tuple2<A,W>,M>>
MAWWriterT. runWriterT(Monoid<W> monoid)
Given aMonoid
for the accumulation, run the computation represented by thisWriterT
inside themonadic effect
, accumulate the written output in terms of theMonoid
, and produce the accumulation and the result inside theMonad
.static <M extends MonadRec<?,M>,A>
IterateT<M,A>IterateT. singleton(MonadRec<A,M> ma)
Static factory method for creating anIterateT
from a single element.static <S,M extends MonadRec<?,M>,A>
StateT<S,M,A>StateT. stateT(Fn1<? super S,? extends MonadRec<Tuple2<A,S>,M>> stateFn)
Lift a state-sensitivemonadically embedded
computation intoStateT
.static <S,M extends MonadRec<?,M>,A>
StateT<S,M,A>StateT. stateT(MonadRec<A,M> ma)
Lift amonadic value
intoStateT
.static <M extends MonadRec<?,M>,A>
IterateT<M,A>IterateT. suspended(Fn0<MonadRec<Maybe<Tuple2<A,IterateT<M,A>>>,M>> thunk, Pure<M> pureM)
static <W,M extends MonadRec<?,M>>
WriterT<W,M,Unit>WriterT. tell(MonadRec<W,M> mw)
<C extends java.util.Collection<A>,MAS extends MonadRec<C,M>>
MASIterateT. toCollection(Fn0<C> cFn0)
Force the underlying spine of thisIterateT
into aCollection
of typeC
inside the context of the monadic effect, using the providedcFn0
to construct the initial instance.static <M extends MonadRec<?,M>,A,B>
IterateT<M,A>IterateT. unfold(Fn1<? super B,? extends MonadRec<Maybe<Tuple2<A,B>>,M>> fn, MonadRec<B,M> mb)
static <W,M extends MonadRec<?,M>,A>
WriterT<W,M,A>WriterT. writerT(MonadRec<Tuple2<A,W>,M> maw)
Methods in com.jnape.palatable.lambda.monad.transformer.builtin with parameters of type MonadRec Modifier and Type Method Description IterateT<M,A>
IterateT. cons(MonadRec<A,M> head)
Add an element inside an effect to the front of thisIterateT
.static <M extends MonadRec<?,M>,L,R>
EitherT<M,L,R>EitherT. eitherT(MonadRec<Either<L,R>,M> melr)
<B,MB extends MonadRec<B,M>>
MBIterateT. fold(Fn2<? super B,? super A,? extends MonadRec<B,M>> fn, MonadRec<B,M> acc)
Monolithically fold the spine of thisIterateT
bytrampolining
the underlying effects (for iterative folding, usetrampolineM
directly).<B,MB extends MonadRec<B,M>>
MBIterateT. foldCut(Fn2<? super B,? super A,? extends MonadRec<RecursiveResult<B,B>,M>> fn, MonadRec<B,M> acc)
Monolithically fold the spine of thisIterateT
(with the possibility of early termination) bytrampolining
the underlying effects (for iterative folding, usetrampolineM
directly).static <M extends MonadRec<?,M>,A>
IdentityT<M,A>IdentityT. identityT(MonadRec<Identity<A>,M> mia)
static <M extends MonadRec<?,M>,A>
IterateT<M,A>IterateT. iterateT(MonadRec<Maybe<Tuple2<A,IterateT<M,A>>>,M> unwrapped)
static <M extends MonadRec<?,M>,A>
LazyT<M,A>LazyT. lazyT(MonadRec<Lazy<A>,M> mla)
<R2,N extends MonadRec<?,N>>
EitherT<N,L,R2>EitherT. lift(MonadRec<R2,N> mb)
<B,N extends MonadRec<?,N>>
IdentityT<N,B>IdentityT. lift(MonadRec<B,N> mb)
<B,N extends MonadRec<?,N>>
IterateT<N,B>IterateT. lift(MonadRec<B,N> nb)
<B,N extends MonadRec<?,N>>
LazyT<N,B>LazyT. lift(MonadRec<B,N> mb)
<B,N extends MonadRec<?,N>>
MaybeT<N,B>MaybeT. lift(MonadRec<B,N> mb)
<B,N extends MonadRec<?,N>>
ReaderT<R,N,B>ReaderT. lift(MonadRec<B,N> mb)
<B,N extends MonadRec<?,N>>
StateT<S,N,B>StateT. lift(MonadRec<B,N> mb)
<B,N extends MonadRec<?,N>>
WriterT<W,N,B>WriterT. lift(MonadRec<B,N> mb)
static <W,M extends MonadRec<?,M>,A>
WriterT<W,M,A>WriterT. listen(MonadRec<A,M> ma)
static <M extends MonadRec<?,M>,A>
MaybeT<M,A>MaybeT. maybeT(MonadRec<Maybe<A>,M> mma)
static <M extends MonadRec<?,M>,A>
IterateT<M,A>IterateT. of(MonadRec<A,M> ma, MonadRec<A,M>... mas)
Static factory method for creating anIterateT
from a spine represented by one or more elements.static <S,M extends MonadRec<?,M>>
StateT<S,M,Unit>StateT. put(MonadRec<S,M> ms)
Lift amonadic state
intoStateT
.static <M extends MonadRec<?,M>,A>
IterateT<M,A>IterateT. singleton(MonadRec<A,M> ma)
Static factory method for creating anIterateT
from a single element.IterateT<M,A>
IterateT. snoc(MonadRec<A,M> last)
Add an element inside an effect to the back of thisIterateT
.static <S,M extends MonadRec<?,M>,A>
StateT<S,M,A>StateT. stateT(MonadRec<A,M> ma)
Lift amonadic value
intoStateT
.static <W,M extends MonadRec<?,M>>
WriterT<W,M,Unit>WriterT. tell(MonadRec<W,M> mw)
static <M extends MonadRec<?,M>,A,B>
IterateT<M,A>IterateT. unfold(Fn1<? super B,? extends MonadRec<Maybe<Tuple2<A,B>>,M>> fn, MonadRec<B,M> mb)
static <W,M extends MonadRec<?,M>,A>
WriterT<W,M,A>WriterT. writerT(MonadRec<Tuple2<A,W>,M> maw)
Method parameters in com.jnape.palatable.lambda.monad.transformer.builtin with type arguments of type MonadRec Modifier and Type Method Description <B,MB extends MonadRec<B,M>>
MBIterateT. fold(Fn2<? super B,? super A,? extends MonadRec<B,M>> fn, MonadRec<B,M> acc)
Monolithically fold the spine of thisIterateT
bytrampolining
the underlying effects (for iterative folding, usetrampolineM
directly).<B,MB extends MonadRec<B,M>>
MBIterateT. foldCut(Fn2<? super B,? super A,? extends MonadRec<RecursiveResult<B,B>,M>> fn, MonadRec<B,M> acc)
Monolithically fold the spine of thisIterateT
(with the possibility of early termination) bytrampolining
the underlying effects (for iterative folding, usetrampolineM
directly).<MU extends MonadRec<Unit,M>>
MUIterateT. forEach(Fn1<? super A,? extends MonadRec<Unit,M>> fn)
static <S,M extends MonadRec<?,M>,A>
StateT<S,M,A>StateT. gets(Fn1<? super S,? extends MonadRec<A,M>> fn)
Given a function that produces a value inside amonadic effect
from a state, produce aStateT
that simply passes its state to the function and applies it.<MA extends MonadRec<A,M>,N extends MonadRec<?,N>,B>
ReaderT<R,N,B>ReaderT. mapReaderT(Fn1<? super MA,? extends MonadRec<B,N>> fn)
<N extends MonadRec<?,N>,B>
StateT<S,N,B>StateT. mapStateT(Fn1<? super MonadRec<Tuple2<A,S>,M>,? extends MonadRec<Tuple2<B,S>,N>> fn)
Map both the result and the final state to a new result and final state inside theMonad
.<N extends MonadRec<?,N>,B>
StateT<S,N,B>StateT. mapStateT(Fn1<? super MonadRec<Tuple2<A,S>,M>,? extends MonadRec<Tuple2<B,S>,N>> fn)
Map both the result and the final state to a new result and final state inside theMonad
.static <S,M extends MonadRec<?,M>>
StateT<S,M,Unit>StateT. modify(Fn1<? super S,? extends MonadRec<S,M>> updateFn)
static <R,M extends MonadRec<?,M>,A>
ReaderT<R,M,A>ReaderT. readerT(Fn1<? super R,? extends MonadRec<A,M>> fn)
static <S,M extends MonadRec<?,M>,A>
StateT<S,M,A>StateT. stateT(Fn1<? super S,? extends MonadRec<Tuple2<A,S>,M>> stateFn)
Lift a state-sensitivemonadically embedded
computation intoStateT
.static <M extends MonadRec<?,M>,A>
IterateT<M,A>IterateT. suspended(Fn0<MonadRec<Maybe<Tuple2<A,IterateT<M,A>>>,M>> thunk, Pure<M> pureM)
<R2> EitherT<M,L,R2>
EitherT. trampolineM(Fn1<? super R,? extends MonadRec<RecursiveResult<R,R2>,EitherT<M,L,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<B> IdentityT<M,B>
IdentityT. trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,IdentityT<M,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<B> IterateT<M,B>
IterateT. trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,IterateT<M,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<B> LazyT<M,B>
LazyT. trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,LazyT<M,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<B> MaybeT<M,B>
MaybeT. trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,MaybeT<M,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<B> ReaderT<R,M,B>
ReaderT. trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,ReaderT<R,M,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<B> StateT<S,M,B>
StateT. trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,StateT<S,M,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.<B> WriterT<W,M,B>
WriterT. trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,WriterT<W,M,?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.static <M extends MonadRec<?,M>,A,B>
IterateT<M,A>IterateT. unfold(Fn1<? super B,? extends MonadRec<Maybe<Tuple2<A,B>>,M>> fn, MonadRec<B,M> mb)
StateT<S,M,A>
StateT. withStateT(Fn1<? super S,? extends MonadRec<S,M>> fn)
Map the final state to a new final state inside the samemonadic effect
using the provided function.Constructors in com.jnape.palatable.lambda.monad.transformer.builtin with parameters of type MonadRec Constructor Description EitherT(MonadRec<Either<L,R>,M> melr)
IdentityT(MonadRec<Identity<A>,M> mia)
LazyT(MonadRec<Lazy<A>,M> mla)
MaybeT(MonadRec<Maybe<A>,M> mma)
Constructor parameters in com.jnape.palatable.lambda.monad.transformer.builtin with type arguments of type MonadRec Constructor Description IterateT(Pure<M> pureM, ImmutableQueue<Choice2<Fn0<MonadRec<Maybe<Tuple2<A,IterateT<M,A>>>,M>>,MonadRec<A,M>>> spine)
IterateT(Pure<M> pureM, ImmutableQueue<Choice2<Fn0<MonadRec<Maybe<Tuple2<A,IterateT<M,A>>>,M>>,MonadRec<A,M>>> spine)
ReaderT(Fn1<? super R,? extends MonadRec<A,M>> f)
StateT(Fn1<? super S,? extends MonadRec<Tuple2<A,S>,M>> stateFn)
WriterT(Pure<M> pureM, Fn1<? super Monoid<W>,? extends MonadRec<Tuple2<A,W>,M>> writerFn)
-
Uses of MonadRec in com.jnape.palatable.lambda.monoid
Subinterfaces of MonadRec in com.jnape.palatable.lambda.monoid Modifier and Type Interface Description interface
Monoid<A>
-
Uses of MonadRec in com.jnape.palatable.lambda.monoid.builtin
Classes in com.jnape.palatable.lambda.monoid.builtin with type parameters of type MonadRec Modifier and Type Class Description class
EndoK<M extends MonadRec<?,M>,A,MA extends MonadRec<A,M>>
The monoid formed under monadic endomorphism.class
EndoK<M extends MonadRec<?,M>,A,MA extends MonadRec<A,M>>
The monoid formed under monadic endomorphism.Classes in com.jnape.palatable.lambda.monoid.builtin that implement MonadRec Modifier and Type Class Description class
AddAll<A,C extends java.util.Collection<A>>
TheMonoid
instance formed under mutative concatenation for an arbitraryCollection
.class
And
AMonoid
instance formed byBoolean
.class
Collapse<_1,_2>
class
Compose<A>
class
Concat<A>
TheMonoid
instance formed under concatenation for an arbitraryIterable
.class
Endo<A>
class
EndoK<M extends MonadRec<?,M>,A,MA extends MonadRec<A,M>>
The monoid formed under monadic endomorphism.class
First<A>
class
Join
AMonoid
instance formed byString
that concats two strings together.class
Last<A>
class
LeftAll<L,R>
class
LeftAny<L,R>
class
Merge<L,R>
AMonoid
instance formed byEither.merge(com.jnape.palatable.lambda.functions.Fn2<? super L, ? super L, ? extends L>, com.jnape.palatable.lambda.functions.Fn2<? super R, ? super R, ? extends R>, com.jnape.palatable.lambda.adt.Either<L, R>...)
, a semigroup overL
, and a monoid overR
.class
MergeHMaps
AMonoid
instance formed by mergingHMaps
using the chosenTypeSafeKey
->Semigroup
mappings
, defaulting toLast
in case noSemigroup
has been chosen for a givenTypeSafeKey
.class
MergeMaps<K,V>
class
Or
AMonoid
instance formed byBoolean
.class
Present<A>
class
PutAll
class
RightAll<L,R>
class
RightAny<L,R>
class
RunAll<A>
class
Trivial
class
Union<A>
class
Xor
Logical exclusive-or.Methods in com.jnape.palatable.lambda.monoid.builtin with type parameters of type MonadRec Modifier and Type Method Description static <M extends MonadRec<?,M>,A,MA extends MonadRec<A,M>>
EndoK<M,A,MA>EndoK. endoK()
static <M extends MonadRec<?,M>,A,MA extends MonadRec<A,M>>
EndoK<M,A,MA>EndoK. endoK()
static <M extends MonadRec<?,M>,A,MA extends MonadRec<A,M>>
Monoid<Fn1<A,MA>>EndoK. endoK(Pure<M> pureM)
static <M extends MonadRec<?,M>,A,MA extends MonadRec<A,M>>
Monoid<Fn1<A,MA>>EndoK. endoK(Pure<M> pureM)
-
Uses of MonadRec in com.jnape.palatable.lambda.optics
Subinterfaces of MonadRec in com.jnape.palatable.lambda.optics Modifier and Type Interface Description interface
Iso<S,T,A,B>
static interface
Iso.Simple<S,A>
A convenience type with a simplified type signature for common isos with both unified "larger" values and unified "smaller" values.interface
Lens<S,T,A,B>
An approximation of van Laarhoven lenses.static interface
Lens.Simple<S,A>
A convenience type with a simplified type signature for common lenses with both unified "larger" values and unified "smaller" values.interface
Prism<S,T,A,B>
Prisms areIsos
that can fail in one direction.static interface
Prism.Simple<S,A>
A convenience type with a simplified type signature for commonprism
with unifiedS/T
andA/B
types.Method parameters in com.jnape.palatable.lambda.optics with type arguments of type MonadRec Modifier and Type Method Description default <U> Iso<S,U,A,B>
Iso. trampolineM(Fn1<? super T,? extends MonadRec<RecursiveResult<T,U>,Iso<S,?,A,B>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.default <U> Lens<S,U,A,B>
Lens. trampolineM(Fn1<? super T,? extends MonadRec<RecursiveResult<T,U>,Lens<S,?,A,B>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.default <U> Prism<S,U,A,B>
Prism. trampolineM(Fn1<? super T,? extends MonadRec<RecursiveResult<T,U>,Prism<S,?,A,B>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction. -
Uses of MonadRec in com.jnape.palatable.lambda.optics.functions
Classes in com.jnape.palatable.lambda.optics.functions that implement MonadRec Modifier and Type Class Description class
Matching<S,T,A,B>
class
Over<S,T,A,B>
Given anOptic
, a function fromA
toB
, and a "larger" valueS
, produce aT
by retrieving theA
from theS
, applying the function, and updating theS
with theB
resulting from the function.class
Pre<P extends Profunctor<?,?,? extends P>,S,T,A,B>
class
Re<S,T,A,B>
Turn anOptic
with a unary mapping that can be used for setting (e.g.class
Set<S,T,A,B>
class
Under<S,T,A,B>
class
View<S,T,A,B>
-
Uses of MonadRec in com.jnape.palatable.lambda.semigroup
Subinterfaces of MonadRec in com.jnape.palatable.lambda.semigroup Modifier and Type Interface Description interface
Semigroup<A>
ASemigroup
is a closed, associative category. -
Uses of MonadRec in com.jnape.palatable.lambda.semigroup.builtin
Classes in com.jnape.palatable.lambda.semigroup.builtin that implement MonadRec Modifier and Type Class Description class
Absent<A>
class
Collapse<_1,_2>
class
Compose<A>
class
Intersection<A>
Given twoIterables
xs
andys
, return thedistinct
elements ofxs
that are also inys
in order of their unique occurrence inxs
.class
LeftAll<L,R>
class
LeftAny<L,R>
class
Max<A extends java.lang.Comparable<A>>
ASemigroup
overA
that chooses between two valuesx
andy
via the following rules: Ifx
is strictly less thany
, returny
Otherwise, returnx
class
MaxBy<A,B extends java.lang.Comparable<B>>
Given a mapping function from some typeA
to someComparable
typeB
, produce aSemigroup
overA
that chooses between two valuesx
andy
via the following rules: Ifx
is strictly less thany
in terms ofB
, returny
Otherwise, returnx
class
MaxWith<A>
Given a comparator for some typeA
, produce aSemigroup
overA
that chooses between two valuesx
andy
via the following rules: Ifx
is strictly less thany
in terms ofB
, returny
Otherwise, returnx
class
Merge<L,R>
class
Min<A extends java.lang.Comparable<A>>
ASemigroup
overA
that chooses between two valuesx
andy
via the following rules: Ifx
is strictly greater thany
, returny
Otherwise, returnx
class
MinBy<A,B extends java.lang.Comparable<B>>
Given a mapping function from some typeA
to someComparable
typeB
, produce aSemigroup
overA
that chooses between two valuesx
andy
via the following rules: Ifx
is strictly greater thany
in terms ofB
, returny
Otherwise, returnx
class
MinWith<A>
Given a comparator for some typeA
, produce aSemigroup
overA
that chooses between two valuesx
andy
via the following rules: Ifx
is strictly greater thany
in terms ofB
, returny
Otherwise, returnx
class
RightAll<L,R>
class
RightAny<L,R>
class
RunAll<A>
-
Uses of MonadRec in com.jnape.palatable.lambda.traversable
Classes in com.jnape.palatable.lambda.traversable that implement MonadRec Modifier and Type Class Description class
LambdaIterable<A>
Method parameters in com.jnape.palatable.lambda.traversable with type arguments of type MonadRec Modifier and Type Method Description <B> LambdaIterable<B>
LambdaIterable. trampolineM(Fn1<? super A,? extends MonadRec<RecursiveResult<A,B>,LambdaIterable<?>>> fn)
Given some operation yielding aRecursiveResult
inside thisMonadRec
, internally trampoline the operation until it yields atermination
instruction.
-