arrow-core-data / arrow.typeclasses

Package arrow.typeclasses


Align The Align type class extends the Semialign type class with a value empty(), which acts as a unit in regards to align.interface Align<F> : Semialign<F>
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>
Bicrosswalk interface Bicrosswalk<T> : Bifunctor<T>, Bifoldable<T>
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 A type to represent λ[α => KindF,α,C]interface Conested<out F, out B>
ConestedType typealias ConestedType<F, A, B> = Kind<Conested<F, B>, A>
Continuation interface Continuation<in T> : Continuation<T>
Contravariant interface Contravariant<F> : Invariant<F>
CounnestedType typealias CounnestedType<F, A, B> = Kind<Kind<F, A>, B>
Crosswalk interface Crosswalk<T> : Functor<T>, Foldable<T>
Decidable Decidable is a typeclass modeling contravariant decision. Decidable is the contravariant version of Alternative.interface Decidable<F> : Divisible<F>
Divide Divide is a typeclass that models the divide part of divide and conquer.interface Divide<F> : Contravariant<F>
Divisible Divisible extends Divide by providing an empty valueinterface Divisible<F> : Divide<F>
Eq interface Eq<in F>
EqK The EqK typeclass abstracts the ability to lift the Eq class to unary type constructors.interface EqK<F>
EqK2 The EqK2 typeclass abstracts the ability to lift the Eq class to binary type constructors.interface EqK2<F>
Foldable interface Foldable<F>
ForMonoid class ForMonoid
Functor interface Functor<F> : Invariant<F>
FunctorFilter interface FunctorFilter<F> : Functor<F>
Hash A type class used to represent hashing for objects of type Finterface Hash<in F> : Eq<F>
Inject Inject type class as described in “Data types a la carte” (Swierstra 2008).interface Inject<F, G>
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>
MonadLogic MonadLogic is a typeclass that extends a MonadPlus. It provides functions to control when computations should be performed.interface MonadLogic<F> : MonadPlus<F>
MonadPlus MonadPlus is a typeclass that extends a Monad by supporting choice and failure. It is equal to Alternative in its api, but provides additional laws for how flatMap and empty interact.interface MonadPlus<F> : Monad<F>, Alternative<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>
MonoidOf typealias MonoidOf<A> = Kind<ForMonoid, A>
NonEmptyReducible interface NonEmptyReducible<F, G> : Reducible<F>
Order interface Order<F> : Eq<F>
Profunctor interface Profunctor<F>
Reducible interface Reducible<F> : Foldable<F>
Repeat Repeat extends Zip by providing a repeat structure.interface Repeat<F> : Zip<F>
Selective interface Selective<F> : Applicative<F>
Semialign A type class used for aligning of functors with non-uniform shapes.interface Semialign<F> : Functor<F>
Semigroup interface Semigroup<A>
Semigroupal interface Semigroupal<F>
SemigroupK interface SemigroupK<F>
Semiring interface Semiring<A>
Show interface Show<in A>
Traverse interface Traverse<F> : Functor<F>, Foldable<F>
TraverseFilter interface TraverseFilter<F> : Traverse<F>, FunctorFilter<F>
Unalign Unalign extends Semialign thereby supporting an inverse function to align: It splits a union shape into a tuple representing the component parts.interface Unalign<F> : Semialign<F>
Unzip The Unzip typeclass extends Zip by providing an inverse operation to zip.interface Unzip<F> : Zip<F>
Zip Zip is a typeclass that extends a Functor by providing a zip operation that takes the intersection of non-uniform shapes.interface Zip<F> : Semialign<F>

Extensions for External Classes



altFold fun <T, F, A> Kind<T, A>.altFold(AF: Alternative<F>, FT: Foldable<T>): Kind<F, A>
altFromOption fun <F, A> Option<A>.altFromOption(AF: Alternative<F>): Kind<F, A>
altSum fun <T, F, A> Kind<T, Kind<F, A>>.altSum(AF: Alternative<F>, FT: Foldable<T>): Kind<F, A>
cobinding fun <F, B : Any> Comonad<F>.~~cobinding~~(c: suspend ComonadSyntax<F>.() -> B): B
conest fun <F, A, B> CounnestedType<F, A, B>.conest(): ConestedType<F, A, B>
counnest fun <F, A, B> ConestedType<F, A, B>.counnest(): CounnestedType<F, A, B>
fix fun <A> MonoidOf<A>.fix(): Monoid<A>
reflect The inverse of <F, A> Kind<ForOption, Tuple2<Kind<F, A>, A>>.reflect(ML: MonadLogic<F>): Kind<F, A>

Type Class Hierarchy

Do you like Arrow?

Arrow Org