arrow-core-data / arrow.typeclasses

Package arrow.typeclasses


Alternative interface Alternative<F> : Applicative<F>, MonoidK<F>
Applicative interface Applicative<F> : Apply<F>
ApplicativeError interface ApplicativeError<F, E> : Applicative<F>
Apply interface Apply<F> : Functor<F>
Bifoldable interface Bifoldable<F>
Bifunctor interface Bifunctor<F>
Bimonad interface Bimonad<F> : Monad<F>, Comonad<F>
BiMonadFx interface BiMonadFx<F> : MonadFx<F>, ComonadFx<F>
Bitraverse interface Bitraverse<F> : Bifunctor<F>, Bifoldable<F>
Category interface Category<F>
CocomposedFunctor interface CocomposedFunctor<F, X> : Functor<Conested<F, X>>
Comonad interface Comonad<F> : Functor<F>
ComonadContinuation open class ComonadContinuation<F, A : Any> : Serializable, Continuation<A>, Comonad<F>, ComonadSyntax<F>
ComonadFx interface ComonadFx<F>
ComonadSyntax interface ComonadSyntax<F> : Comonad<F>
Conested interface Conested<out F, out B>
A type to represent λ[α => KindF,α,C]
Const data class Const<A, out T> : ConstOf<A, T>
Continuation interface Continuation<in T> : Continuation<T>
Contravariant interface Contravariant<F> : Invariant<F>
Decidable interface Decidable<F> : Divisible<F>
Decidable is a typeclass modeling contravariant decision. Decidable is the contravariant version of Alternative.
Divide interface Divide<F> : Contravariant<F>
Divide is a typeclass that models the divide part of divide and conquer.
Divisible interface Divisible<F> : Divide<F>
Divisible extends Divide by providing an empty value
Eq interface Eq<in F>
Foldable interface Foldable<F>
ForConst class ForConst
ForMonoid class ForMonoid
Functor interface Functor<F> : Invariant<F>
FunctorFilter interface FunctorFilter<F> : Functor<F>
Hash interface Hash<in F> : Eq<F>
A type class used to represent hashing for objects of type F
Inject interface Inject<F, G>
Inject type class as described in “Data types a la carte” (Swierstra 2008).
Invariant interface Invariant<F>
Monad interface Monad<F> : Selective<F>
MonadCombine interface MonadCombine<F> : MonadFilter<F>, Alternative<F>
MonadContinuation open class MonadContinuation<F, A> : Continuation<Kind<F, A>>, Monad<F>, BindSyntax<F>, MonadSyntax<F>
MonadError interface MonadError<F, E> : ApplicativeError<F, E>, Monad<F>
MonadFilter interface MonadFilter<F> : Monad<F>, FunctorFilter<F>
MonadFilterContinuation open class MonadFilterContinuation<F, A> : MonadContinuation<F, A>, MonadFilterSyntax<F>
MonadFilterFx interface MonadFilterFx<F> : MonadFx<F>
MonadFilterSyntax interface MonadFilterSyntax<F> : MonadSyntax<F>
MonadFx interface MonadFx<F>
MonadSyntax interface MonadSyntax<F> : Monad<F>, BindSyntax<F>
MonadThrow interface MonadThrow<F> : MonadError<F, Throwable>
MonadThrowContinuation open class MonadThrowContinuation<F, A> : MonadContinuation<F, A>, MonadThrow<F>, MonadThrowSyntax<F>
MonadThrowFx interface MonadThrowFx<F> : MonadFx<F>
MonadThrowSyntax interface MonadThrowSyntax<F> : MonadSyntax<F>, MonadThrow<F>
Monoid interface Monoid<A> : Semigroup<A>, MonoidOf<A>
Monoidal interface Monoidal<F> : Semigroupal<F>
MonoidK interface MonoidK<F> : SemigroupK<F>
NonEmptyReducible interface NonEmptyReducible<F, G> : Reducible<F>
Order interface Order<F> : Eq<F>
Profunctor interface Profunctor<F>
Reducible interface Reducible<F> : Foldable<F>
Selective interface Selective<F> : Applicative<F>
Semigroup interface Semigroup<A>
Semigroupal interface Semigroupal<F>
SemigroupK interface SemigroupK<F>
Semiring interface Semiring<A> : Monoid<A>
Show interface Show<in A>
Traverse interface Traverse<F> : Functor<F>, Foldable<F>
TraverseFilter interface TraverseFilter<F> : Traverse<F>, FunctorFilter<F>

Type Aliases

ConestedType typealias ConestedType<F, A, B> = Kind<Conested<F, B>, A>
ConstOf typealias ConstOf<A, T> = Kind2<ForConst, A, T>
ConstPartialOf typealias ConstPartialOf<A> = Kind<ForConst, A>
CounnestedType typealias CounnestedType<F, A, B> = Kind<Kind<F, A>, B>
MonoidOf typealias MonoidOf<A> = Kind<ForMonoid, A>

Extensions for External Classes



ap fun <A, T, U> ConstOf<A, T>.ap(SG: Semigroup<A>, ff: ConstOf<A, (T) -> U>): Const<A, U>
cobinding fun <F, B : Any> Comonad<F>.~~cobinding~~(c: suspend ComonadSyntax<F>.() -> B): B
combine fun <A, T> ConstOf<A, T>.combine(SG: Semigroup<A>, that: ConstOf<A, T>): Const<A, T>
conest fun <F, A, B> CounnestedType<F, A, B>.conest(): ConestedType<F, A, B>
const fun <A> A.const(): Const<A, Nothing>
counnest fun <F, A, B> ConestedType<F, A, B>.counnest(): CounnestedType<F, A, B>
fix fun <A, T> ConstOf<A, T>.fix(): Const<A, T>
fun <A> MonoidOf<A>.fix(): Monoid<A>
sequence fun <T, A, G> ConstOf<A, Kind<G, T>>.sequence(GA: Applicative<G>): Kind<G, Const<A, T>>
value fun <A, T> ConstOf<A, T>.value(): A

Type Class Hierarchy