All Classes Interface Summary Class Summary Exception Summary
Class |
Description |
$<A,B> |
Function application, represented as a higher-order Fn2 that receives an Fn1 and its argument, and
applies it.
|
Absent<A> |
|
AddAll<A,C extends java.util.Collection<A>> |
The Monoid instance formed under mutative concatenation for an arbitrary Collection .
|
All<A> |
Eagerly apply a predicate to each element in an Iterable , returning true if every element
satisfies the predicate, and false otherwise.
|
Alter<A> |
Given an Effect <A>
and some A , produce an IO that, when run, performs
the effect on A and returns it.
|
And |
A Monoid instance formed by Boolean .
|
Any<A> |
Eagerly apply a predicate to each element in an Iterable , returning true if any element
satisfies the predicate, and false otherwise.
|
Applicative<A,App extends Applicative<?,App>> |
An interface representing applicative functors - functors that can have their results combined with other functors
of the same instance in a context-free manner.
|
AutoBracket<A extends java.lang.AutoCloseable,B> |
Given an IO yielding some AutoCloseable type A and a kleisli arrow from that type to a
new IO of type B , attempt to provision the A , applying the body operation if
provisioning was successful and ensuring that AutoCloseable.close() is called regardless of whether the body
succeeds or fails.
|
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.
|
Bifunctor<A,B,BF extends Bifunctor<?,?,BF>> |
A dually-parametric functor that maps covariantly over both parameters.
|
BiMonoidFactory<A,B,C> |
|
BiPredicate<A,B> |
A specialized Fn2 that returns a Boolean when fully applied, or a Predicate when partially applied.
|
BiSemigroupFactory<A,B,C> |
|
Both<A,B,C> |
Given two functions f and g , produce a
Fn1 <A, Tuple2 <B, C>>
(the dual application of both functions).
|
BoundedBifunctor<A extends ContraA,B extends ContraB,ContraA,ContraB,BF extends BoundedBifunctor<?,?,?,?,BF>> |
A Bifunctor that has both parameter types upper bounded; that is, neither parameters can be mapped to a value
that is not covariant to their respective upper bounds
|
Bracket<A,B> |
Given an IO that yields some type A , a cleanup operation to run if a value of that type could be
provisioned, and a kleisli arrow from that type to a new IO of type B , produce an
IO <B>
that, when run, will provision the A ,
flatMap it to B , and clean up the original value if it was produced in the
first place.
|
Cartesian<A,B,P extends Cartesian<?,?,P>> |
Profunctor strength in the cartesian product sense: p a b -> p (c ^ a) (c ^ b) for any type
c .
|
CartesianProduct<A,B> |
Lazily compute the cartesian product of an Iterable<A> and Iterable<B> ,
returning an Iterable<Tuple2<A, B>> , the products as tuples of
multiplicand A s and multiplier B s.
|
CatMaybes<A> |
Given an Iterable <Maybe <A>>
, return an
Iterable <A>
of only the present values.
|
Choice2<A,B> |
|
Choice2._A<A,B> |
|
Choice2._B<A,B> |
|
Choice3<A,B,C> |
|
Choice3._A<A,B,C> |
|
Choice3._B<A,B,C> |
|
Choice3._C<A,B,C> |
|
Choice4<A,B,C,D> |
|
Choice4._A<A,B,C,D> |
|
Choice4._B<A,B,C,D> |
|
Choice4._C<A,B,C,D> |
|
Choice4._D<A,B,C,D> |
|
Choice5<A,B,C,D,E> |
|
Choice5._A<A,B,C,D,E> |
|
Choice5._B<A,B,C,D,E> |
|
Choice5._C<A,B,C,D,E> |
|
Choice5._D<A,B,C,D,E> |
|
Choice5._E<A,B,C,D,E> |
|
Choice6<A,B,C,D,E,F> |
|
Choice6._A<A,B,C,D,E,F> |
|
Choice6._B<A,B,C,D,E,F> |
|
Choice6._C<A,B,C,D,E,F> |
|
Choice6._D<A,B,C,D,E,F> |
|
Choice6._E<A,B,C,D,E,F> |
|
Choice6._F<A,B,C,D,E,F> |
|
Choice7<A,B,C,D,E,F,G> |
|
Choice7._A<A,B,C,D,E,F,G> |
|
Choice7._B<A,B,C,D,E,F,G> |
|
Choice7._C<A,B,C,D,E,F,G> |
|
Choice7._D<A,B,C,D,E,F,G> |
|
Choice7._E<A,B,C,D,E,F,G> |
|
Choice7._F<A,B,C,D,E,F,G> |
|
Choice7._G<A,B,C,D,E,F,G> |
|
Choice8<A,B,C,D,E,F,G,H> |
|
Choice8._A<A,B,C,D,E,F,G,H> |
|
Choice8._B<A,B,C,D,E,F,G,H> |
|
Choice8._C<A,B,C,D,E,F,G,H> |
|
Choice8._D<A,B,C,D,E,F,G,H> |
|
Choice8._E<A,B,C,D,E,F,G,H> |
|
Choice8._F<A,B,C,D,E,F,G,H> |
|
Choice8._G<A,B,C,D,E,F,G,H> |
|
Choice8._H<A,B,C,D,E,F,G,H> |
|
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 value
|
CmpEq<A extends java.lang.Comparable<A>> |
Given two Comparable values of type A , return true if the first value is strictly
equal to the second value (according to Comparable.compareTo(Object) ; otherwise, return false.
|
CmpEqBy<A,B extends java.lang.Comparable<B>> |
Given a mapping function from some type A to some Comparable type B and two values
of type A , return true if the first value is strictly equal to the second value (according
to Comparable.compareTo(Object) in terms of their mapped B results; otherwise, return false.
|
CmpEqWith<A> |
Given a Comparator from some type A and two values of type A , return
true if the first value is strictly equal to the second value (according to
Comparator.compare(Object, Object) otherwise, return false.
|
Coalesce<L,R> |
Fold an Iterable <Either <L, R>>
into an Either <Iterable <L>, Iterable <R>>
, preserving all results of the side that's returned.
|
Cocartesian<A,B,P extends Cocartesian<?,?,P>> |
Profunctor strength in the cocartesian coproduct sense: p a b -> p (c v a) (c v b) for any
type c .
|
Collapse<_1,_2> |
A Monoid instance formed by a Tuple2 <_1, _2>
and monoids over _1 and
_2 .
|
Collapse<_1,_2> |
A Semigroup instance formed by a Tuple2 <_1, _2>
and semigroups over
_1 and _2 .
|
CollectionLens |
Lenses that operate on Collection s.
|
CombinatorialIterator<A,B> |
|
Compare<A> |
Given a Comparator from some type A and two values of type A , return a
ComparisonRelation of the first value with reference to the second value (according to
Comparator.compare(Object, Object) .
|
ComparisonRelation |
Specialized CoProduct3 representing the possible results of a ordered comparison.
|
ComparisonRelation.Equal |
|
ComparisonRelation.GreaterThan |
|
ComparisonRelation.LessThan |
|
Compose<F extends Applicative<?,F>,G extends Applicative<?,G>,A> |
A functor representing the type-level composition of two Applicative functors; useful for preserving nested
type-level transformations during traversal of a Traversable .
|
Compose<A> |
A Monoid instance formed by CompletableFuture <A>
and a monoid over
A .
|
Compose<A> |
A Semigroup instance formed by CompletableFuture <A>
and a semigroup over
A .
|
Concat<A> |
The Monoid instance formed under concatenation for an arbitrary Iterable .
|
ConcatenatingIterable<A> |
|
Cons<A> |
Prepend an element to an Iterable .
|
ConsingIterator<A> |
|
Const<A,B> |
A (surprisingly useful) functor over some phantom type B , retaining a value of type A that
can be retrieved later.
|
Constantly<A,B> |
A function that takes two arguments and always returns the first argument.
|
Contravariant<A,C extends Contravariant<?,C>> |
The contravariant functor (or "co-functor"); that is, a functor that maps contravariantly (A <- B )
over its parameter.
|
CoProduct2<A,B,CP2 extends CoProduct2<A,B,?>> |
A generalization of the coproduct of two types.
|
CoProduct3<A,B,C,CP3 extends CoProduct3<A,B,C,?>> |
A generalization of the coproduct of three types.
|
CoProduct4<A,B,C,D,CP4 extends CoProduct4<A,B,C,D,?>> |
A generalization of the coproduct of four types.
|
CoProduct5<A,B,C,D,E,CP5 extends CoProduct5<A,B,C,D,E,?>> |
A generalization of the coproduct of five types.
|
CoProduct6<A,B,C,D,E,F,CP6 extends CoProduct6<A,B,C,D,E,F,?>> |
A generalization of the coproduct of six types.
|
CoProduct7<A,B,C,D,E,F,G,CP7 extends CoProduct7<A,B,C,D,E,F,G,?>> |
A generalization of the coproduct of seven types.
|
CoProduct8<A,B,C,D,E,F,G,H,CP8 extends CoProduct8<A,B,C,D,E,F,G,H,?>> |
A generalization of the coproduct of eight types.
|
Cycle<A> |
Given an Iterable , return an infinite Iterable that repeatedly cycles its elements, in
order.
|
CyclicIterable<A> |
|
CyclicIterator<A> |
|
Difference<A> |
Given two Iterables xs and ys , return the distinct
elements of xs that are not in ys .
|
Distinct<A> |
Return an Iterable of the distinct values from the given input Iterable .
|
DistinctIterable<A> |
|
Downcast<A extends B,B> |
Covariantly cast a value of type B to a value of subtype A .
|
Drop<A> |
Lazily skip the first n elements from an Iterable by returning an Iterable
that begins iteration after the nth element.
|
DroppingIterable<A> |
|
DroppingIterator<A> |
|
DropWhile<A> |
Lazily limit the Iterable by skipping the first contiguous group of elements that satisfy the predicate,
beginning iteration at the first element for which the predicate evaluates to false .
|
Effect<A> |
A function returning "no result", and therefore only useful as a side-effect.
|
Either<L,R> |
The binary tagged union, implemented as a specialized CoProduct2 .
|
Either.Left<L,R> |
|
Either.Right<L,R> |
|
EitherLens |
|
EitherPrism |
|
EitherT<M extends MonadRec<?,M>,L,R> |
|
Empty<A> |
A predicate that returns true if as is empty; false otherwise.
|
Endo<A> |
|
EndoK<M extends MonadRec<?,M>,A,MA extends MonadRec<A,M>> |
The monoid formed under monadic endomorphism.
|
Eq<A> |
Type-safe equality in function form; uses Object.equals(java.lang.Object) , not == .
|
Exchange<A,B,S,T> |
A profunctor used to extract the isomorphic functions an Iso is composed of.
|
Filter<A> |
Lazily apply a predicate to each element in an Iterable , returning an Iterable of just the
elements for which the predicate evaluated to true .
|
FilteringIterable<A> |
|
FilteringIterator<A> |
|
Find<A> |
Iterate the elements in an Iterable , applying a predicate to each one, returning the first element that
matches the predicate, wrapped in a Maybe .
|
First<A> |
|
Flatten<A> |
Given a nested Iterable of Iterable s, return a lazily flattening Iterable
of the nested elements.
|
FlatteningIterator<A> |
|
Fn0<A> |
A function taking "no arguments", implemented as an Fn1 <Unit , A>
.
|
Fn1<A,B> |
A function taking a single argument.
|
Fn2<A,B,C> |
A function taking two arguments.
|
Fn3<A,B,C,D> |
A function taking three arguments.
|
Fn4<A,B,C,D,E> |
A function taking four arguments.
|
Fn5<A,B,C,D,E,F> |
A function taking five arguments.
|
Fn6<A,B,C,D,E,F,G> |
A function taking six arguments.
|
Fn7<A,B,C,D,E,F,G,H> |
A function taking seven arguments.
|
Fn8<A,B,C,D,E,F,G,H,I> |
A function taking eight arguments.
|
FoldLeft<A,B> |
Given an Iterable of A s, a starting value B , and a
Fn2 <B, A, B>
, iteratively accumulate over the Iterable , ultimately returning
a final B value.
|
FoldRight<A,B> |
Given an Iterable of A s, a starting lazy value B , and a
Fn2 <A, Lazy <B>, Lazy <B>>
, iteratively accumulate over the
Iterable , ultimately returning a final Lazy <B>
value.
|
Force<A> |
Deprecated.
|
Functor<A,F extends Functor<?,F>> |
An interface for the generic covariant functorial operation map over some parameter A .
|
GroupBy<K,V> |
Given an Iterable<V> vs and a key function V -> K f ,
fold vs into a Map<K, List<V>> by applying f to each element of
vs , retaining values that map to the same key in a list, in the order they were iterated in.
|
GroupingIterator<A> |
|
GT<A extends java.lang.Comparable<A>> |
Given two Comparable values of type A , return true if the second value is strictly
greater than the first value; otherwise, return false.
|
GTBy<A,B extends java.lang.Comparable<B>> |
Given a mapping function from some type A to some Comparable type B and two values
of type A , return true if the second value is strictly greater than the first value in
terms of their mapped B results; otherwise, return false.
|
GTE<A extends java.lang.Comparable<A>> |
Given two Comparable values of type A , return true if the second value is greater
than or equal to the first value according to Comparable.compareTo(Object) ; otherwise, return false.
|
GTEBy<A,B extends java.lang.Comparable<B>> |
Given a mapping function from some type A to some Comparable type B and two values
of type A , return true if the second value is greater than or equal to the first value in
terms of their mapped B results according to Comparable.compareTo(Object) ; otherwise, return
false.
|
GTEWith<A> |
Given a Comparator from some type A and two values of type A ,
return true if the second value is greater than or equal to the first value in
terms of their mapped B results according to Comparator.compare(Object, Object) ;
otherwise, return false.
|
GTWith<A> |
Given a Comparator from some type A and two values of type A ,
return true if the second value is strictly greater than the first value in
terms of their mapped B results; otherwise, return false.
|
Head<A> |
Retrieve the head element of an Iterable , wrapped in an Maybe .
|
HList |
An immutable heterogeneous list supporting arbitrary depth type-safety via a linearly recursive type signature.
|
HList.HCons<Head,Tail extends HList> |
The consing of a head element to a tail HList .
|
HList.HNil |
The empty HList .
|
HListLens |
Lenses that operate on HList s.
|
HMap |
An immutable heterogeneous mapping from a parametrized type-safe key to any value, supporting a minimal mapping
interface.
|
HMapLens |
Lenses that operate on HMap s.
|
Id<A> |
The identity function.
|
Identity<A> |
A functor over some value of type A that can be mapped over and retrieved later.
|
IdentityT<M extends MonadRec<?,M>,A> |
|
IfThenElse<A,B> |
|
ImmutableIterator<Element> |
|
ImmutableQueue<A> |
Internal API.
|
ImmutableQueue.Empty<A> |
|
ImmutableQueue.NonEmpty<A> |
|
ImmutableStack<A> |
Internal API.
|
ImmutableStack.Empty<A> |
|
ImmutableStack.Node<A> |
|
Index<Target,TargetList extends HList.HCons<?,?>> |
HList indexes representing a value at arbitrary depth in some compatible HList.
|
Index.N<Target,Head,List extends HList.HCons<?,?>,PreviousIndex extends Index<Target,List>> |
|
Index.Z<Target> |
|
InfiniteIterator<A> |
|
InGroupsOf<A> |
Lazily group the Iterable by returning an Iterable of smaller Iterable s of
size k .
|
Init<A> |
Given an Iterable <A> , produce an
Iterable <A> of all elements but the last one.
|
InitIterator<A> |
|
Inits<A> |
Given an Iterable <A> , produce an
Iterable <Iterable <A>> , representing all of the subsequences of initial
elements, ordered by size, starting with the empty Iterable .
|
Intersection<A> |
Given two Iterables xs and ys , return the distinct
elements of xs that are also in ys in order of their unique occurrence in xs .
|
Intersperse<A> |
Lazily inject the provided separator value between each value in the supplied Iterable .
|
Into<A,B,C> |
Given an Fn2 <A, B, C>
and a Map.Entry <A, B>
, destructure the
entry and apply the key and value as arguments to the function, returning the result.
|
Into1<A,B> |
Given an Fn1 <A, B>
and a SingletonHList <A>
, pop the head and
apply it to the function, returning the result.
|
Into3<A,B,C,D> |
Given an Fn3 <A, B, C, D>
and a Product3 <A, B, C>
, destructure
the product and apply the slots as arguments to the function, returning the result.
|
Into4<A,B,C,D,E> |
Given an Fn4 <A, B, C, D, E>
and a Product4 <A, B, C, D>
,
destructure the product and apply the slots as arguments to the function, returning the result.
|
Into5<A,B,C,D,E,F> |
Given an Fn5 <A, B, C, D, E, F>
and a Product5 <A, B, C, D, E>
,
destructure the product and apply the slots as arguments to the function, returning the result.
|
Into6<A,B,C,D,E,F,G> |
Given an Fn6 <A, B, C, D, E, F, G>
and a
Product6 <A, B, C, D, E, F>
, destructure the product and apply the slots as arguments to
the function, returning the result.
|
Into7<A,B,C,D,E,F,G,H> |
Given an Fn7 <A, B, C, D, E, F, G, H>
and a
Product7 <A, B, C, D, E, F, G>
, destructure the product and apply the slots as arguments to
the function, returning the result.
|
Into8<A,B,C,D,E,F,G,H,I> |
Given an Fn8 <A, B, C, D, E, F, G, H, I>
and a
Product8 <A, B, C, D, E, F, G, H>
, destructure the product and apply the slots as arguments
to the function, returning the result.
|
IO<A> |
A Monad representing some side-effecting computation to be performed.
|
IO.Compose<A> |
|
Iso<S,T,A,B> |
An Iso (short for "isomorphism") is an invertible Lens : an Optic encoding of a
bi-directional focusing of two types, and like Lens es
, can be View ed
,
Set , and updated
.
|
Iso.Simple<S,A> |
A convenience type with a simplified type signature for common isos with both unified "larger" values and
unified "smaller" values.
|
IterableLens |
Lenses that operate on Iterable s.
|
Iterate<A> |
Lazily generate an infinite Iterable from the successive applications of the function first to the initial
seed value, then to the result, and so on; i.e., the result of iterate(x -> x + 1, 0) would produce
an infinite Iterable over the elements 0, 1, 2, 3, ...
|
IterateT<M extends MonadRec<?,M>,A> |
A monad transformer over a co-inductive, singly-linked spine of values embedded in effects.
|
IterationInterruptedException |
An exception thrown when a thread is interrupted while an Iterator was blocked.
|
Join |
A Monoid instance formed by String that concats two strings together.
|
Kleisli<A,B,M extends Monad<?,M>,MB extends Monad<B,M>> |
The Kleisli arrow of a Monad , manifest as simply an Fn1 <A, MB>
.
|
LambdaIterable<A> |
Extension point for Iterable to adapt lambda core types like Monad and Traversable .
|
LambdaMap<A,B> |
|
Last<A> |
Retrieve the last element of an Iterable , wrapped in a Maybe .
|
Last<A> |
|
Lazy<A> |
A Monad representing a lazily-computed value.
|
Lazy.Compose<A> |
|
Lazy.Later<A> |
|
LazyRec<A,B> |
Given a Fn2 that receives a recursive function and an input and yields a lazy result, and an
input, produce a lazy result that, when forced, will recursively invoke the function until it terminates
in a stack-safe way.
|
LazyT<M extends MonadRec<?,M>,A> |
|
LeftAll<L,R> |
A Monoid instance formed by Either <L,R>
and a monoid over L .
|
LeftAll<L,R> |
|
LeftAny<L,R> |
A Monoid instance formed by Either <L,R>
and a monoid over L .
|
LeftAny<L,R> |
|
Lens<S,T,A,B> |
|
Lens.Simple<S,A> |
A convenience type with a simplified type signature for common lenses with both unified "larger" values and
unified "smaller" values.
|
Lift<B extends MonadBase<?,?,B>> |
|
LiftA2<A,B,C,App extends Applicative<?,App>,AppC extends Applicative<C,App>> |
|
LiftA3<A,B,C,D,App extends Applicative<?,App>,AppD extends Applicative<D,App>> |
|
LiftA4<A,B,C,D,E,App extends Applicative<?,App>,AppE extends Applicative<E,App>> |
|
LiftA5<A,B,C,D,E,F,App extends Applicative<?,App>,AppF extends Applicative<F,App>> |
|
LiftA6<A,B,C,D,E,F,G,App extends Applicative<?,App>,AppG extends Applicative<G,App>> |
|
LiftA7<A,B,C,D,E,F,G,H,App extends Applicative<?,App>,AppH extends Applicative<H,App>> |
|
ListLens |
Lenses that operate on List s.
|
LT<A extends java.lang.Comparable<A>> |
Given two Comparable values of type A , return true if the second value is strictly
less than the first value; otherwise, return false.
|
LTBy<A,B extends java.lang.Comparable<B>> |
Given a mapping function from some type A to some Comparable type B and two values
of type A , return true if the second value is strictly less than the first value in terms
of their mapped B results; otherwise, return false.
|
LTE<A extends java.lang.Comparable<A>> |
Given two Comparable values of type A , return true if the second value is less than
or equal to the first value according to Comparable.compareTo(Object) otherwise, return false.
|
LTEBy<A,B extends java.lang.Comparable<B>> |
Given a mapping function from some type A to some Comparable type B and two values
of type A , return true if the second value is less than or equal to the first value in
terms of their mapped B results according to Comparable.compareTo(Object) ; otherwise, return
false.
|
LTEWith<A> |
Given a Comparator from some type A and two values of type A ,
return true if the second value is less than or equal to the first value in
terms of their mapped B results according to Comparator.compare(Object, Object) ;
otherwise, return false.
|
LTWith<A> |
Given a comparator for some type A and two values of type A ,
return true if the second value is strictly less than than the first value in
terms of their mapped B results; otherwise, return false.
|
Magnetize<A> |
Magnetize an Iterable using value equality as the magnetizing function.
|
MagnetizeBy<A> |
Given a binary predicate and an Iterable <A> , return an Iterable <Iterable <A>> of the contiguous groups of elements that match the predicate pairwise.
|
Map<A,B> |
Lazily apply a function to each element in an Iterable , producing an Iterable of the mapped
results.
|
MapLens |
Lenses that operate on Map s.
|
MappingIterable<A,B> |
|
MappingIterator<A,B> |
|
MapPrism |
|
Market<A,B,S,T> |
A profunctor used to extract the isomorphic functions a Prism is composed of.
|
Matching<S,T,A,B> |
|
Max<A extends java.lang.Comparable<A>> |
A Semigroup over A that chooses between two values x and y via the
following rules:
If x is strictly less than y , return y
Otherwise, return x
|
MaxBy<A,B extends java.lang.Comparable<B>> |
Given a mapping function from some type A to some Comparable type B , produce a
Semigroup over A that chooses between two values x and y via the
following rules:
If x is strictly less than y in terms of B , return y
Otherwise, return x
|
MaxWith<A> |
Given a comparator for some type A , produce a Semigroup over A that chooses
between two values x and y via the following rules:
If x is strictly less than y in terms of B , return y
Otherwise, return x
|
Maybe<A> |
The optional type, representing a potentially absent value.
|
Maybe.Just<A> |
|
Maybe.Nothing<A> |
|
MaybeLens |
Lenses that operate on Maybe .
|
MaybePrism |
|
MaybeT<M extends MonadRec<?,M>,A> |
|
Merge<L,R> |
|
Merge<L,R> |
|
MergeHMaps |
|
MergeHMaps.Φ<R> |
|
MergeMaps<K,V> |
A Monoid instance formed by Map.merge(Object, Object, BiFunction) and a semigroup over
V .
|
Min<A extends java.lang.Comparable<A>> |
A Semigroup over A that chooses between two values x and y via the
following rules:
If x is strictly greater than y , return y
Otherwise, return x
|
MinBy<A,B extends java.lang.Comparable<B>> |
Given a mapping function from some type A to some Comparable type B , produce a
Semigroup over A that chooses between two values x and y via the
following rules:
If x is strictly greater than y in terms of B , return y
Otherwise, return x
|
MinWith<A> |
Given a comparator for some type A , produce a Semigroup over A that chooses
between two values x and y via the following rules:
If x is strictly greater than y in terms of B , return y
Otherwise, return x
|
Monad<A,M extends Monad<?,M>> |
Monads are Applicative functors that support a flattening operation to unwrap M<M<A>>
-> M<A> .
|
MonadBase<M extends MonadRec<?,M>,A,MB extends MonadBase<?,?,MB>> |
A type into which a MonadRec is embedded whilst internally preserving the MonadRec structure.
|
MonadError<E,A,M extends MonadError<E,?,M>> |
An interface for monads that can be interrupted with some type of error.
|
MonadReader<R,A,MR extends MonadReader<R,?,MR>> |
A monad that is capable of reading an environment R and producing a lifted value A .
|
MonadRec<A,M extends MonadRec<?,M>> |
|
MonadT<M extends MonadRec<?,M>,A,MT extends MonadT<M,?,MT,T>,T extends MonadT<?,?,?,T>> |
The generic type representing a Monad transformer, exposing the argument Monad as a type parameter.
|
MonadWriter<W,A,MW extends MonadWriter<W,?,MW>> |
A Monad that is capable of writing and accumulating state alongside a value, but is not necessarily capable
of simultaneously accessing the state and the value.
|
Monoid<A> |
|
MonoidFactory<A,B> |
|
Not<A> |
Negate a predicate function.
|
Occurrences<A> |
Given an Iterable <A> , return a Map <A, Long> representing each
unique element in the Iterable paired with its number of occurrences.
|
Optic<P extends Profunctor<?,?,? extends P>,F extends Functor<?,? extends F>,S,T,A,B> |
A generic supertype representation for profunctor optics.
|
Optic.Simple<P extends Profunctor<?,?,? extends P>,F extends Functor<?,? extends F>,S,A> |
An convenience type with a simplified signature for optics with unified S/T and
A/B types.
|
Or |
A Monoid instance formed by Boolean .
|
Over<S,T,A,B> |
Given an Optic , a function from A to B , and a "larger" value S ,
produce a T by retrieving the A from the S , applying the function, and
updating the S with the B resulting from the function.
|
Partition<A,B,C> |
Given an Iterable<A> as and a disjoint mapping function a ->
CoProduct2<A, B> , return a Tuple2 over the lazily unwrapped left A and right
B values in the first and second slots, respectively.
|
Peek<A,FA extends Functor<A,?>> |
Deprecated.
|
Peek2<A,B,FAB extends BoundedBifunctor<A,B,? super A,? super B,?>> |
Deprecated.
|
Pre<P extends Profunctor<?,?,? extends P>,S,T,A,B> |
Turn an Optic with a unary mapping that can be used for viewing some number of values into an Optic
that views the first value, if it exists.
|
Predicate<A> |
A specialized Fn1 that returns a Boolean .
|
PredicatedDroppingIterable<A> |
|
PredicatedDroppingIterator<A> |
|
PredicatedTakingIterable<A> |
|
PredicatedTakingIterator<A> |
|
PrependAll<A> |
Lazily prepend each value with of the Iterable with the supplied separator value.
|
PrependingIterator<A> |
|
Present<A> |
A Monoid instance formed by Maybe <A>
and a semigroup over A .
|
Prism<S,T,A,B> |
Prisms are Isos that can fail in one direction.
|
Prism.Simple<S,A> |
A convenience type with a simplified type signature for common prism with unified S/T
and A/B types.
|
Product2<_1,_2> |
The minimal shape of the combination of two potentially distinctly typed values, supporting destructuring via
explicitly named indexing methods, as well as via a combining function.
|
Product3<_1,_2,_3> |
A product with three values.
|
Product4<_1,_2,_3,_4> |
A product with four values.
|
Product5<_1,_2,_3,_4,_5> |
A product with five values.
|
Product6<_1,_2,_3,_4,_5,_6> |
A product with six values.
|
Product7<_1,_2,_3,_4,_5,_6,_7> |
A product with seven values.
|
Product8<_1,_2,_3,_4,_5,_6,_7,_8> |
A product with eight values.
|
Profunctor<A,B,PF extends Profunctor<?,?,PF>> |
A dually-parametric functor that maps contravariantly over the left parameter and covariantly over the right.
|
ProtoOptic<P extends Profunctor<?,?,? extends P>,S,T,A,B> |
A generic supertype representation for a profunctor Optic that requires a Pure implementation to
derive its Functor constraint and graduate to a full-fledge Optic , equipped with a default
Optic instance for the profunctor constraint and Identity .
|
Pure<F extends Functor<?,? extends F>> |
|
PutAll |
A Monoid instance formed by HMap that simply combines all the mappings.
|
RateLimit<A> |
Given an Fn0 of Instants (presumably backed by a clock), a limit , a
Duration , and an Iterable as , return an Iterable that iterates as
according to the threshold specified by the limit per duration, using the Fn0 to advance time.
|
RateLimitingIterable<A> |
|
RateLimitingIterator<A> |
|
Re<S,T,A,B> |
Turn an Optic with a unary mapping that can be used for setting (e.g.
|
ReaderT<R,M extends MonadRec<?,M>,A> |
|
RecursiveResult<A,B> |
Specialized CoProduct2 representing the possible results of a primitive recursive function.
|
RecursiveResult.Recurse<A,B> |
|
RecursiveResult.Terminate<A,B> |
|
ReduceLeft<A> |
Given an Iterable <A>
and a Fn2 <A, A, A>
, iteratively
accumulate over the Iterable , returning Maybe <A>
.
|
ReduceRight<A> |
Given an Iterable <A>
and a Fn2 <A, A, A>
, iteratively
accumulate over the Iterable , returning Maybe <A>
.
|
Repeat<A> |
Given a value, return an infinite Iterable that repeatedly iterates that value.
|
RepetitiousIterator<A> |
|
Replicate<A> |
Produce an Iterable of a value n times.
|
Reverse<A> |
Given an Iterable , return a reversed representation of that Iterable .
|
ReversingIterable<A> |
|
ReversingIterator<A> |
|
RewindableIterator<A> |
|
RewindableIterator.Cache<A> |
|
RightAll<L,R> |
A Monoid instance formed by Either <L,R>
and a monoid over R .
|
RightAll<L,R> |
|
RightAny<L,R> |
A Monoid instance formed by Either <L,R>
and a monoid over R .
|
RightAny<L,R> |
|
RunAll<A> |
Run IO operations, aggregating their results in terms of the provided Monoid .
|
RunAll<A> |
Run IO operations, aggregating their results in terms of the provided Semigroup .
|
Runtime |
|
SafeT<M extends MonadRec<?,M>,A> |
|
SafeT.Body<M extends MonadRec<?,M>,A> |
|
SafeT.Body.Done<M extends MonadRec<?,M>,A> |
|
SafeT.Body.More<M extends MonadRec<?,M>,A> |
|
SafeT.Body.Suspended<M extends MonadRec<?,M>,A,B> |
|
SafeT.Body.Suspended.Φ<M extends MonadRec<?,M>,B,R> |
|
ScanLeft<A,B> |
Given an Iterable of A s, a starting value B , and a
Fn2 <B, A, B>
, iteratively accumulate over the Iterable , collecting each
function application result, finally returning an Iterable of all the results.
|
ScanningIterator<A,B> |
|
Schema<Values extends HList> |
|
Semigroup<A> |
A Semigroup is a closed, associative category.
|
SemigroupFactory<A,B> |
|
Sequence<A,App extends Applicative<?,App>,Trav extends Traversable<?,Trav>,TravA extends Traversable<A,Trav>,AppTrav extends Applicative<TravA,App>> |
|
Set<S,T,A,B> |
Given an Optic , a "smaller" value B , and a "larger" value S , produce a
T by lifting the Optic into the Identity functor.
|
SetLens |
Lenses that operate on Set s.
|
SideEffect |
An interface used to represent an effect that requires no input and produces no output, and therefore is only
perceivable through inspection of some unreported state.
|
SingletonHList<_1> |
A singleton HList.
|
Size |
|
Slide<A> |
Given an Iterable <A> , "slide" a window of k elements across the Iterable by one element at a time, returning an Iterable <Iterable <A>> .
|
Snoc<A> |
Opposite of Cons : lazily append an element to the end of the given Iterable .
|
SnocIterable<A> |
|
SnocIterator<A> |
|
Sort<A extends java.lang.Comparable<A>> |
Given an Iterable of Comparable elements, return a List of the sorted elements.
|
SortBy<A,B extends java.lang.Comparable<B>> |
Given an Iterable and some mapping function from the Iterable element type to some
Comparable type, produce a sorted List of the original elements based on sorting applied to the
result of the mapping function.
|
SortWith<A> |
Given an Iterable and a Comparator over the Iterable element type, produce a
sorted List of the original elements based on sorting applied by the Comparator .
|
Span<A> |
Given a predicate, return a Tuple2 where the first slot is the front contiguous elements of an Iterable matching the predicate and the second slot is all the remaining elements.
|
State<S,A> |
The state Monad , useful for iteratively building up state and state-contextualized result.
|
StateT<S,M extends MonadRec<?,M>,A> |
|
Tagged<S,B> |
Like Const , but the phantom parameter is in the contravariant position, and the value is in covariant
position.
|
Tail<A> |
Returns the tail of an Iterable ; the is, an Iterable of all the elements except for the
head element.
|
Tails<A> |
Given an Iterable <A> , produce an
Iterable <Iterable <A>> , representing all of the subsequences of tail
elements, ordered by size, starting with the full Iterable .
|
Take<A> |
Lazily limit the Iterable to n elements by returning an Iterable that stops
iteration after the nth element, or the last element of the Iterable , whichever comes
first.
|
TakeWhile<A> |
Lazily limit the Iterable 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 to false .
|
TakingIterable<A> |
|
TakingIterator<A> |
|
These<A,B> |
|
These._A<A,B> |
|
These._B<A,B> |
|
These.Both<A,B> |
|
Times<A> |
Given some number of times n to invoke a function A -> A , and given an input
A , iteratively apply the function to the input, and then to the result of the invocation, a total of
n times, returning the result.
|
ToArray<A> |
Write all the elements of an Iterable directly into an array of the specified type.
|
ToCollection<A,C extends java.util.Collection<A>> |
Given an Fn0 of some Collection C , create an instance of C and add all of
the elements in the provided Iterable to the instance.
|
ToMap<K,V,M extends java.util.Map<K,V>> |
Given an Fn0 of some Map M , create an instance of M and put all of the
entries in the provided Iterable into the instance.
|
Trampoline<A,B> |
Given an Fn1 <A, CoProduct2 <A, B, ?>>
(analogous to "recurse" and "return"
tail position instructions, respectively), produce a Fn1 <A, B>
that unrolls the original
function by iteratively passing each result that matches the input ( A ) back to the original function,
and then terminating on and returning the first output ( B ).
|
TrampoliningIterator<A,B> |
|
Traversable<A,T extends Traversable<?,T>> |
An interface for a class of data structures that can be "traversed from left to right" in a structure-preserving
way, successively applying some applicative computation to each element and collapsing the results into a single
resulting applicative.
|
Trivial |
|
Try<A> |
A Monad of the evaluation outcome of an expression that might throw.
|
Try.Failure<A> |
|
Try.Success<A> |
|
Tuple2<_1,_2> |
A 2-element tuple product type, implemented as a specialized HList.
|
Tuple3<_1,_2,_3> |
A 3-element tuple product type, implemented as a specialized HList.
|
Tuple4<_1,_2,_3,_4> |
A 4-element tuple product type, implemented as a specialized HList.
|
Tuple5<_1,_2,_3,_4,_5> |
A 5-element tuple product type, implemented as a specialized HList.
|
Tuple6<_1,_2,_3,_4,_5,_6> |
A 6-element tuple product type, implemented as a specialized HList.
|
Tuple7<_1,_2,_3,_4,_5,_6,_7> |
A 7-element tuple product type, implemented as a specialized HList.
|
Tuple8<_1,_2,_3,_4,_5,_6,_7,_8> |
An 8-element tuple product type, implemented as a specialized HList.
|
Tupler2<A,B> |
Creates a Tuple2 from two values.
|
TypeSafeKey<A,B> |
An interface representing a parametrized key for use in HMap s.
|
TypeSafeKey.Simple<A> |
A simplified TypeSafeKey that can only view a value of type A as an A .
|
Uncons<A> |
Destructure an Iterable into a Tuple2 of its head and tail, wrapped in an Maybe .
|
Under<S,T,A,B> |
The inverse of Over : given an Iso , a function from T to S , and a "smaller"
value B , return a "smaller" value A by traversing around the type ring ( B -> T
-> S -> A ).
|
UnfoldingIterator<A,B> |
|
Unfoldr<A,B> |
Given an initial seed value and a function that takes the seed type and produces an Maybe <Tuple2 <X, Seed>>
, where the tuple's first slot represents the next Iterable element,
and the second slot represents the next input to the unfolding function, unfold an Iterable of
X s.
|
Union<A> |
|
UnioningIterable<A> |
|
Unit |
The empty return type.
|
Until<A> |
Given a predicate function for a value of some type A and an IO that yields a value
of type A , produce an IO that repeatedly executes the original IO until the predicate
returns true when applied to the yielded value.
|
Upcast<A extends B,B> |
Upcast a value of type B to a value of type A that B extends.
|
UUIDPrism |
|
View<S,T,A,B> |
Given an Optic and a "larger" value S , retrieve a "smaller" value A by lifting the
Optic into the Const functor.
|
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.
|
WriterT<W,M extends MonadRec<?,M>,A> |
|
Xor |
Logical exclusive-or.
|
Zip<A,B> |
Zip together two Iterable s into a single Iterable of Tuple2<A, B> .
|
ZippingIterator<C,A,B> |
|
ZipWith<A,B,C> |
Zip together two Iterable s by applying a zipping function to the successive elements of each
Iterable until one of them runs out of elements.
|