arrow-core-extensions / arrow.core.extensions

Package arrow.core.extensions

Types

BooleanEq interface BooleanEq : Eq<Boolean>
BooleanHash interface BooleanHash : Hash<Boolean>, BooleanEq
BooleanShow interface BooleanShow : Show<Boolean>
ByteEq interface ByteEq : Eq<Byte>
ByteHash interface ByteHash : Hash<Byte>, ByteEq
ByteMonoid interface ByteMonoid : Monoid<Byte>, ByteSemigroup
ByteOrder interface ByteOrder : Order<Byte>
ByteSemigroup interface ByteSemigroup : Semigroup<Byte>
ByteSemiring interface ByteSemiring : Semiring<Byte>
ByteShow interface ByteShow : Show<Byte>
CharEq interface CharEq : Eq<Char>
CharHash interface CharHash : Hash<Char>, CharEq
CharOrder interface CharOrder : Order<Char>
CharShow interface CharShow : Show<Char>
ConstApplicative interface ConstApplicative<A> : Applicative<ConstPartialOf<A>>
ConstContravariant interface ConstContravariant<A> : Contravariant<ConstPartialOf<A>>
ConstDivideInstance interface ConstDivideInstance<O> : Divide<ConstPartialOf<O>>, ConstContravariant<O>
ConstDivisibleInstance interface ConstDivisibleInstance<O> : Divisible<ConstPartialOf<O>>, ConstDivideInstance<O>
ConstEq interface ConstEq<A, T> : Eq<Const<A, T>>
ConstFoldable interface ConstFoldable<A> : Foldable<ConstPartialOf<A>>
ConstFunctor interface ConstFunctor<A> : Functor<ConstPartialOf<A>>
ConstHash interface ConstHash<A, T> : Hash<Const<A, T>>, ConstEq<A, T>
ConstInvariant interface ConstInvariant<A> : Invariant<ConstPartialOf<A>>
ConstMonoid interface ConstMonoid<A, T> : Monoid<ConstOf<A, T>>, ConstSemigroup<A, T>
ConstSemigroup interface ConstSemigroup<A, T> : Semigroup<ConstOf<A, T>>
ConstShow interface ConstShow<A, T> : Show<Const<A, T>>
ConstTraverse interface ConstTraverse<X> : Traverse<ConstPartialOf<X>>, ConstFoldable<X>
DoubleEq interface DoubleEq : Eq<Double>
DoubleHash interface DoubleHash : Hash<Double>, DoubleEq
DoubleMonoid interface DoubleMonoid : Monoid<Double>, DoubleSemigroup
DoubleOrder interface DoubleOrder : Order<Double>
DoubleSemigroup interface DoubleSemigroup : Semigroup<Double>
DoubleSemiring interface DoubleSemiring : Semiring<Double>
DoubleShow interface DoubleShow : Show<Double>
EitherApplicative interface EitherApplicative<L> : Applicative<EitherPartialOf<L>>, EitherFunctor<L>
EitherApplicativeError interface EitherApplicativeError<L> : ApplicativeError<EitherPartialOf<L>, L>, EitherApplicative<L>
EitherBifunctor interface EitherBifunctor : Bifunctor<ForEither>
EitherEq interface EitherEq<in L, in R> : Eq<Either<L, R>>
EitherFoldable interface EitherFoldable<L> : Foldable<EitherPartialOf<L>>
EitherFunctor interface EitherFunctor<L> : Functor<EitherPartialOf<L>>
EitherFx interface EitherFx<L> : Fx<EitherPartialOf<L>>
EitherHash interface EitherHash<L, R> : Hash<Either<L, R>>, EitherEq<L, R>
EitherMonad interface EitherMonad<L> : Monad<EitherPartialOf<L>>, EitherApplicative<L>
EitherMonadError interface EitherMonadError<L> : MonadError<EitherPartialOf<L>, L>, EitherApplicativeError<L>, EitherMonad<L>
EitherMonoid interface EitherMonoid<L, R> : Monoid<Either<L, R>>, EitherSemigroup<L, R>
EitherSemigroup interface EitherSemigroup<L, R> : Semigroup<Either<L, R>>
EitherSemigroupK interface EitherSemigroupK<L> : SemigroupK<EitherPartialOf<L>>
EitherShow interface EitherShow<L, R> : Show<Either<L, R>>
EitherTraverse interface EitherTraverse<L> : Traverse<EitherPartialOf<L>>, EitherFoldable<L>
EvalApplicative interface EvalApplicative : Applicative<ForEval>
EvalBimonad interface EvalBimonad : Bimonad<ForEval>
EvalComonad interface EvalComonad : Comonad<ForEval>
EvalFunctor interface EvalFunctor : Functor<ForEval>
EvalFx interface EvalFx<A> : Fx<ForEval>
EvalMonad interface EvalMonad : Monad<ForEval>
FloatEq interface FloatEq : Eq<Float>
FloatHash interface FloatHash : Hash<Float>, FloatEq
FloatMonoid interface FloatMonoid : Monoid<Float>, FloatSemigroup
FloatOrder interface FloatOrder : Order<Float>
FloatSemigroup interface FloatSemigroup : Semigroup<Float>
FloatSemiring interface FloatSemiring : Semiring<Float>
FloatShow interface FloatShow : Show<Float>
ForString object ForString
Function0Applicative interface Function0Applicative : Applicative<ForFunction0>
Function0Bimonad interface Function0Bimonad : Bimonad<ForFunction0>
Function0Comonad interface Function0Comonad : Comonad<ForFunction0>
Function0Functor interface Function0Functor : Functor<ForFunction0>
Function0Fx interface Function0Fx<A> : Fx<ForFunction0>
Function0Monad interface Function0Monad : Monad<ForFunction0>
Function0Monoid interface Function0Monoid<A> : Monoid<() -> A>, Function0Semigroup<A>
Function0Selective interface Function0Selective : Selective<ForFunction0>, Function0Applicative
Function0Semigroup interface Function0Semigroup<A> : Semigroup<() -> A>
Function1Applicative interface Function1Applicative<I> : Applicative<Function1PartialOf<I>>, Function1Functor<I>
Function1Category interface Function1Category : Category<ForFunction1>
Function1Contravariant interface Function1Contravariant<O> : Contravariant<Conested<ForFunction1, O>>
Function1Decidable interface Function1Decidable<O> : Decidable<Conested<ForFunction1, O>>, Function1Divisible<O>
Function1Divide interface Function1Divide<O> : Divide<Conested<ForFunction1, O>>, Function1Contravariant<O>
Function1Divisible interface Function1Divisible<O> : Divisible<Conested<ForFunction1, O>>, Function1Divide<O>
Function1Functor interface Function1Functor<I> : Functor<Function1PartialOf<I>>
Function1Fx interface Function1Fx<A> : Fx<Function1PartialOf<A>>
Function1Monad interface Function1Monad<I> : Monad<Function1PartialOf<I>>, Function1Applicative<I>
Function1Monoid interface Function1Monoid<A, B> : Monoid<(A) -> B>, Function1Semigroup<A, B>
Function1Profunctor interface Function1Profunctor : Profunctor<ForFunction1>
Function1Semigroup interface Function1Semigroup<A, B> : Semigroup<(A) -> B>
IdApplicative interface IdApplicative : Applicative<ForId>
IdBimonad interface IdBimonad : Bimonad<ForId>
IdComonad interface IdComonad : Comonad<ForId>
IdEq interface IdEq<A> : Eq<Id<A>>
IdFoldable interface IdFoldable : Foldable<ForId>
IdFunctor interface IdFunctor : Functor<ForId>
IdFx interface IdFx<A> : Fx<ForId>
IdHash interface IdHash<A> : Hash<Id<A>>, IdEq<A>
IdMonad interface IdMonad : Monad<ForId>
IdMonoid interface IdMonoid<A> : Monoid<Id<A>>, IdSemigroup<A>
IdSelective interface IdSelective : Selective<ForId>, IdApplicative
IdSemigroup interface IdSemigroup<A> : Semigroup<Id<A>>
IdShow interface IdShow<A> : Show<Id<A>>
IdTraverse interface IdTraverse : Traverse<ForId>
IntEq interface IntEq : Eq<Int>
IntHash interface IntHash : Hash<Int>, IntEq
IntMonoid interface IntMonoid : Monoid<Int>, IntSemigroup
IntOrder interface IntOrder : Order<Int>
IntSemigroup interface IntSemigroup : Semigroup<Int>
IntSemiring interface IntSemiring : Semiring<Int>
IntShow interface IntShow : Show<Int>
LongEq interface LongEq : Eq<Long>
LongHash interface LongHash : Hash<Long>, LongEq
LongMonoid interface LongMonoid : Monoid<Long>, LongSemigroup
LongOrder interface LongOrder : Order<Long>
LongSemigroup interface LongSemigroup : Semigroup<Long>
LongSemiring interface LongSemiring : Semiring<Long>
LongShow interface LongShow : Show<Long>
MonoidInvariant interface MonoidInvariant<A> : Invariant<ForMonoid>
OptionApplicative interface OptionApplicative : Applicative<ForOption>
OptionApplicativeError interface OptionApplicativeError : ApplicativeError<ForOption, Unit>, OptionApplicative
OptionEq interface OptionEq<A> : Eq<Option<A>>
OptionFoldable interface OptionFoldable : Foldable<ForOption>
OptionFunctor interface OptionFunctor : Functor<ForOption>
OptionFx interface OptionFx : Fx<ForOption>
OptionHash interface OptionHash<A> : Hash<Option<A>>, OptionEq<A>
OptionMonad interface OptionMonad : Monad<ForOption>
OptionMonadError interface OptionMonadError : MonadError<ForOption, Unit>, OptionMonad
OptionMonoid interface OptionMonoid<A> : Monoid<Option<A>>, OptionSemigroup<A>
OptionMonoidK interface OptionMonoidK : MonoidK<ForOption>
OptionSelective interface OptionSelective : Selective<ForOption>, OptionApplicative
OptionSemigroup interface OptionSemigroup<A> : Semigroup<Option<A>>
OptionSemigroupK interface OptionSemigroupK : SemigroupK<ForOption>
OptionSemigroupal interface OptionSemigroupal : Semigroupal<ForOption>
OptionSemiring interface OptionSemiring<A> : Semiring<Option<A>>
OptionShow interface OptionShow<A> : Show<Option<A>>
OptionTraverse interface OptionTraverse : Traverse<ForOption>
ShortEq interface ShortEq : Eq<Short>
ShortHash interface ShortHash : Hash<Short>, ShortEq
ShortMonoid interface ShortMonoid : Monoid<Short>, ShortSemigroup
ShortOrder interface ShortOrder : Order<Short>
ShortSemigroup interface ShortSemigroup : Semigroup<Short>
ShortSemiring interface ShortSemiring : Semiring<Short>
ShortShow interface ShortShow : Show<Short>
StringContext object StringContext : StringShow, StringOrder, StringMonoid
StringEq interface StringEq : Eq<String>
StringHash interface StringHash : Hash<String>, StringEq
StringMonoid interface StringMonoid : Monoid<String>, StringSemigroup
StringOrder interface StringOrder : Order<String>
StringSemigroup interface StringSemigroup : Semigroup<String>
StringShow interface StringShow : Show<String>
TryApplicative interface TryApplicative : Applicative<ForTry>
TryApplicativeError interface TryApplicativeError : ApplicativeError<ForTry, Throwable>, TryApplicative
TryEq interface TryEq<A> : Eq<Try<A>>
TryFoldable interface TryFoldable : Foldable<ForTry>
TryFunctor interface TryFunctor : Functor<ForTry>
TryFx interface TryFx : Fx<ForTry>
TryHash interface TryHash<A> : Hash<Try<A>>, TryEq<A>
TryMonad interface TryMonad : Monad<ForTry>
TryMonadError interface TryMonadError : MonadError<ForTry, Throwable>, TryMonad
TryMonadThrow interface TryMonadThrow : MonadThrow<ForTry>, TryMonadError
TryMonoid interface TryMonoid<A> : Monoid<Try<A>>, TrySemigroup<A>
TrySemigroup interface TrySemigroup<A> : Semigroup<Try<A>>
TryShow interface TryShow<A> : Show<Try<A>>
TryTraverse interface TryTraverse : Traverse<ForTry>
Tuple10Eq interface Tuple10Eq<A, B, C, D, E, F, G, H, I, J> : Eq<Tuple10<A, B, C, D, E, F, G, H, I, J>>
Tuple10Hash interface Tuple10Hash<A, B, C, D, E, F, G, H, I, J> : Hash<Tuple10<A, B, C, D, E, F, G, H, I, J>>, Tuple10Eq<A, B, C, D, E, F, G, H, I, J>
Tuple10Show interface Tuple10Show<A, B, C, D, E, F, G, H, I, J> : Show<Tuple10<A, B, C, D, E, F, G, H, I, J>>
Tuple2Applicative interface Tuple2Applicative<F> : Applicative<Tuple2PartialOf<F>>, Tuple2Functor<F>
Tuple2Bifunctor interface Tuple2Bifunctor : Bifunctor<ForTuple2>
Tuple2Comonad interface Tuple2Comonad<F> : Comonad<Tuple2PartialOf<F>>, Tuple2Functor<F>
Tuple2Eq interface Tuple2Eq<A, B> : Eq<Tuple2<A, B>>
Tuple2Foldable interface Tuple2Foldable<F> : Foldable<Tuple2PartialOf<F>>
Tuple2Functor interface Tuple2Functor<F> : Functor<Tuple2PartialOf<F>>
Tuple2Hash interface Tuple2Hash<A, B> : Hash<Tuple2<A, B>>, Tuple2Eq<A, B>
Tuple2Monad interface Tuple2Monad<F> : Monad<Tuple2PartialOf<F>>, Tuple2Applicative<F>
Tuple2Monoid interface Tuple2Monoid<A, B> : Monoid<Tuple2<A, B>>, Tuple2Semigroup<A, B>
Tuple2Semigroup interface Tuple2Semigroup<A, B> : Semigroup<Tuple2<A, B>>
Tuple2Show interface Tuple2Show<A, B> : Show<Tuple2<A, B>>
Tuple2Traverse interface Tuple2Traverse<F> : Traverse<Tuple2PartialOf<F>>, Tuple2Foldable<F>
Tuple3Eq interface Tuple3Eq<A, B, C> : Eq<Tuple3<A, B, C>>
Tuple3Hash interface Tuple3Hash<A, B, C> : Hash<Tuple3<A, B, C>>, Tuple3Eq<A, B, C>
Tuple3Show interface Tuple3Show<A, B, C> : Show<Tuple3<A, B, C>>
Tuple4Eq interface Tuple4Eq<A, B, C, D> : Eq<Tuple4<A, B, C, D>>
Tuple4Hash interface Tuple4Hash<A, B, C, D> : Hash<Tuple4<A, B, C, D>>, Tuple4Eq<A, B, C, D>
Tuple4Show interface Tuple4Show<A, B, C, D> : Show<Tuple4<A, B, C, D>>
Tuple5Eq interface Tuple5Eq<A, B, C, D, E> : Eq<Tuple5<A, B, C, D, E>>
Tuple5Hash interface Tuple5Hash<A, B, C, D, E> : Hash<Tuple5<A, B, C, D, E>>, Tuple5Eq<A, B, C, D, E>
Tuple5Show interface Tuple5Show<A, B, C, D, E> : Show<Tuple5<A, B, C, D, E>>
Tuple6Eq interface Tuple6Eq<A, B, C, D, E, F> : Eq<Tuple6<A, B, C, D, E, F>>
Tuple6Hash interface Tuple6Hash<A, B, C, D, E, F> : Hash<Tuple6<A, B, C, D, E, F>>, Tuple6Eq<A, B, C, D, E, F>
Tuple6Show interface Tuple6Show<A, B, C, D, E, F> : Show<Tuple6<A, B, C, D, E, F>>
Tuple7Eq interface Tuple7Eq<A, B, C, D, E, F, G> : Eq<Tuple7<A, B, C, D, E, F, G>>
Tuple7Hash interface Tuple7Hash<A, B, C, D, E, F, G> : Hash<Tuple7<A, B, C, D, E, F, G>>, Tuple7Eq<A, B, C, D, E, F, G>
Tuple7Show interface Tuple7Show<A, B, C, D, E, F, G> : Show<Tuple7<A, B, C, D, E, F, G>>
Tuple8Eq interface Tuple8Eq<A, B, C, D, E, F, G, H> : Eq<Tuple8<A, B, C, D, E, F, G, H>>
Tuple8Hash interface Tuple8Hash<A, B, C, D, E, F, G, H> : Hash<Tuple8<A, B, C, D, E, F, G, H>>, Tuple8Eq<A, B, C, D, E, F, G, H>
Tuple8Show interface Tuple8Show<A, B, C, D, E, F, G, H> : Show<Tuple8<A, B, C, D, E, F, G, H>>
Tuple9Eq interface Tuple9Eq<A, B, C, D, E, F, G, H, I> : Eq<Tuple9<A, B, C, D, E, F, G, H, I>>
Tuple9Hash interface Tuple9Hash<A, B, C, D, E, F, G, H, I> : Hash<Tuple9<A, B, C, D, E, F, G, H, I>>, Tuple9Eq<A, B, C, D, E, F, G, H, I>
Tuple9Show interface Tuple9Show<A, B, C, D, E, F, G, H, I> : Show<Tuple9<A, B, C, D, E, F, G, H, I>>

Extensions for External Classes

arrow.Kind  
arrow.core.Either  
arrow.core.Try  
kotlin.Byte  
kotlin.Char  
kotlin.Double  
kotlin.Float  
kotlin.Int  
kotlin.Long  
kotlin.Short  
kotlin.String  

Functions

eq fun <ERROR CLASS>.eq(): Eq<Boolean>
hash fun <ERROR CLASS>.hash(): Hash<Boolean>
show fun <ERROR CLASS>.show(): Show<Boolean>