core/packages/dartz/dartz library

Classes

Applicative<F>

ApplicativeOps<F, A>

ApplicativePlus<F>

ApplicativePlusOps<F, A>

Attempt<A>

AVLTree<A>

AVLTreeMonoid<A>

Bind<F, A, B>

BooleanConjunctionMonoid

BooleanDisjunctionMonoid

CloseFile

ComparableOrder<A extends Comparable>

ComposedFunctor<F, G>

Cons<A>

Delay<A>

DualMonoid<A>

DualSemigroup<A>

Either<L, R>

EitherLens<A, B, E>

EitherMonad<L>

Eq<A>

EqOps<A>

Evaluation<E, R, W, S, A>

EvaluationMonad<E, R, W, S>

Execute

ExecutionResult

Fail<A>

FileRef

Foldable<F>

FoldableOps<F, A>

FoldableOpsFoldable<F extends FoldableOps>

Free<F, A>

Free2<First, Second>

Free3<First, Second, Third>

FreeComposer<F, C>

FreeMonad<F>

FreeOps<F, O>

Function0TraversableMonad

Functor<F>

FunctorOps<F, A>

FutureMonad

Gather<A>

IdFreeComposer<F>

IdMonad

IdTraversable

IHashMap<K, V>

IList<A>

IListMonoid<A>

IListTMonad<M>

IMap<K, V>

IMapMonoid<K, V>

IntSumMonoid

IOMonad

IOOp<A>

IOOps<F>

ISet<A>

ISetMonoid<A>

IteratorEq<A>

IVector<A>

IVectorMonoid<A>

Left<L, R>

LeftFreeComposer<LL, L, R>

Lens<AIn, AOut, BIn, BOut>

ListMonoid<A>

ListTMonad<M>

ListTraversableMonadPlus

MaxSemigroup<A>

MinSemigroup<A>

Monad<F>

MonadCatch<F>

MonadCatchOps<F, A>

MonadOps<F, A>

MonadOpsMonad<F extends MonadOps>

MonadPlus<F>

MonadPlusOps<F, A>

MonadPlusOpsMonadPlus<F extends MonadPlusOps>

Monoid<A>

Nil<A>

None<A>

NumMaxSemigroup

NumMinSemigroup

NumProductMonoid

NumSumMonoid

OpenFile

Option<A>

OptionLens<A, B>

OptionMonadPlus

OptionMonoid<A>

OptionTraversable

Order<A>

Plus<F>

PlusEmpty<F>

PlusEmptyOps<F, A>

PlusOps<F, A>

Println

Pure<F, A>

ReadBytes

Readln

Right<L, R>

RightFreeComposer<RR, L, R>

Semigroup<A>

SimpleLens<A, B>

Some<A>

State<S, A>

StateMonad<S>

StateT<F, S, A>

StateTMonad<F, S>

StringMonoid

Suspend<F, A>

Task<A>

TaskMonadCatch

ToStringOrder<A extends Object>

Trampoline<A>

Traversable<F>

TraversableMonad<F>

TraversableMonadOps<F, A>

TraversableMonadPlus<F>

TraversableMonadPlusOps<F, A>

TraversableOps<F, A>

TraversableOpsTraversable<F extends TraversableOps>

Tuple10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>

Tuple11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>

Tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>

Tuple13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>

Tuple14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>

Tuple15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>

Tuple16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>

Tuple17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>

Tuple18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>

Tuple19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>

Tuple2<T1, T2>

Tuple20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>

Tuple2Monoid<T1, T2>

Tuple2Semigroup<T1, T2>

Tuple3<T1, T2, T3>

Tuple3Monoid<T1, T2, T3>

Tuple3Semigroup<T1, T2, T3>

Tuple4<T1, T2, T3, T4>

Tuple4Monoid<T1, T2, T3, T4>

Tuple4Semigroup<T1, T2, T3, T4>

Tuple5<T1, T2, T3, T4, T5>

Tuple6<T1, T2, T3, T4, T5, T6>

Tuple7<T1, T2, T3, T4, T5, T6, T7>

Tuple8<T1, T2, T3, T4, T5, T6, T7, T8>

Tuple9<T1, T2, T3, T4, T5, T6, T7, T8, T9>

Unit

UnitMonoid

WriteBytes

Enums

Ordering

Extensions

TaskBoolOps on Task<bool>

TaskFlattenOps on Task<Task<A>>

Constants

unit → const Unit

Properties

AVLTreeFo → Foldable<AVLTree>

final

BoolAndMi → Monoid<bool>

final

BoolOrMi → Monoid<bool>

final

DoubleOrder → Order<double>

final

DualEndoMi → Monoid<Endo>

final

EitherM → EitherMonad

final

EitherTr → Traversable<Either>

final

EndoMi → Monoid<Endo>

final

FirstSemigroup → Semigroup

final

FreeM → FreeMonad

final

Function0TrM → Function0TraversableMonad

final

FutureM → FutureMonad

final

IdM → IdMonad

final

IdTr → IdTraversable

final

IHashMapTr → Traversable<IHashMap>

final

IListMi → Monoid<IList>

final

IListMP → MonadPlus<IList>

final

IListTr → Traversable<IList>

final

IMapMi → Monoid<IMap>

final

IMapTr → Traversable<IMap>

final

IntOrder → Order<int>

final

IntSumMi → Monoid<int>

final

io → IOOps<IOOp>

final

IOM → IOMonad

final

IOMC → MonadCatch<Free<IOOp, dynamic>>

final

ISetFo → Foldable<ISet>

final

IVectorMi → Monoid<IVector>

final

IVectorMP → MonadPlus<IVector>

final

IVectorTr → Traversable<IVector>

final

ListMi → Monoid<List>

final

ListMP → ListTraversableMonadPlus

final

ListTr → Traversable<List>

final

NumMaxSi → Semigroup<num>

final

NumMinSi → Semigroup<num>

final

NumOrder → Order<num>

final

NumProductMi → Monoid<num>

final

NumSumMi → Monoid<num>

final

ObjectEq → Eq<Object>

final

ObjectIteratorEq → Eq<Iterator>

final

SecondSemigroup → Semigroup

final

StateM → StateMonad

final

StringMi → Monoid<String>

final

StringOrder → Order<String>

final

TaskMC → MonadCatch<Task>

final

toStringOrder → Order

final

TrampolineM → Monad<Trampoline>

final

TStateM → StateTMonad<Trampoline, dynamic>

final

tunit → Trampoline<Unit>

final

UnitMi → Monoid<Unit>

final

Functions

cast<A>(dynamic a) → A

catching<A>(Function0<A> thunk) → Either<dynamic, A>

comparableOrder<A extends Comparable>() → Order<A>

composeF<A, B, C>(Function1<B, C> f, Function1<A, B> g) → Function1<A, C>

composeInterpreters<L, R, O>(O lInterpreter(L l), O rInterpreter(R r)) → Function1<Either<L, R>, O>

cons<A>(A head, IList<A> tail) → IList<A>

constF<A, B>(B b) → Function1<A, B>

curry2<A, B, C>(Function2<A, B, C> fun) → Function1<A, Function1<B, C>>

curry3<A, B, C, D>(Function3<A, B, C, D> fun) → Function1<A, Function1<B, Function1<C, D>>>

curry4<A, B, C, D, E>(Function4<A, B, C, D, E> fun) → Function1<A, Function1<B, Function1<C, Function1<D, E>>>>

curry5<A, B, C, D, E, F>(Function5<A, B, C, D, E, F> fun) → Function1<A, Function1<B, Function1<C, Function1<D, Function1<E, F>>>>>

curry6<A, B, C, D, E, F, G>(Function6<A, B, C, D, E, F, G> fun) → Function1<A, Function1<B, Function1<C, Function1<D, Function1<E, Function1<F, G>>>>>>

dualEndoMi<A>() → Monoid<Endo<A>>

dualMonoid<A>(Monoid<A> mi) → Monoid<A>

dualSemigroup<A>(Semigroup<A> si) → Semigroup<A>

eitherM<L>() → EitherMonad<L>

eitherTr<L, R>() → Traversable<Either<L, R>>

emptyAVLNode<A>() → _AVLNode<A>

emptyMap<K extends Comparable, V>() → IMap<K, V>

emptySet<A extends Comparable>() → ISet<A>

emptySetWithOrder<A>(Order<A> order) → ISet<A>

emptyVector<A>() → IVector<A>

endoMi<A>() → Monoid<Endo<A>>

eq<A>(EqF<A> f) → Eq<A>

firstSemigroup<A>() → Semigroup<A>

flip<A, B, C>(Function2<A, B, C> f) → Function2<B, A, C>

freeM<F>() → FreeMonad<F>

function0TrM<A>() → TraversableMonad<Function0<A>>

futureM<A>() → Monad<Future<A>>

id<A>(A a) → A

idF<A>() → Endo<A>

ihashmap<K, V>(Map<K, V> m) → IHashMap<K, V>

ilist<A>(Iterable<A> iterable) → IList<A>

ilistMi<A>() → Monoid<IList<A>>

ilistMP<A>() → MonadPlus<IList<A>>

ilistTMonad(Monad mmonad) → Monad

imap<K extends Comparable, V>(Map<K, V> m) → IMap<K, V>

imapLensE<K, V, E>(K k, E eF()) → EitherLens<IMap<K, V>, V, E>

imapLensO<K, V>(K k) → OptionLens<IMap<K, V>, V>

imapMi<K extends Comparable, V>() → Monoid<IMap<K, V>>

imapMonoid<K extends Comparable, V>(Semigroup<V> si) → Monoid<IMap<K, V>>

imapMonoidWithOrder<K, V>(Semigroup<V> si, Order<K> order) → Monoid<IMap<K, V>>

imapWithOrder<K, K2 extends K, V>(Order<K> o, Map<K2, V> m) → IMap<K, V>

iomc<A>() → MonadCatch<Free<IOOp, A>>

iota(int n) → IList<int>

iset<A extends Comparable>(Iterable<A> i) → ISet<A>

isetMi<A>(Order<A> o) → Monoid<ISet<A>>

isetWithOrder<A, A2 extends A>(Order<A> order, Iterable<A2> i) → ISet<A>

iteratorEq<A>(Eq<A> aEq) → Eq<Iterator<A>>

ivector<A>(Iterable<A> iterable) → IVector<A>

ivectorLensE<A, E>(int i, E eF()) → EitherLens<IVector<A>, A, E>

ivectorLensO<A>(int i) → OptionLens<IVector<A>, A>

ivectorMi<A>() → Monoid<IVector<A>>

ivectorMP<A>() → MonadPlus<IVector<A>>

left<L, R>(L l) → Either<L, R>

lens<AIn, AOut, BIn, BOut>(Function1<AIn, BOut> getter, Function2<AIn, BIn, AOut> setter) → Lens<AIn, AOut, BIn, BOut>

lensE<A, B, E>(Function1<A, Either<E, B>> getter, Function2<A, B, Either<E, A>> setter) → EitherLens<A, B, E>

lensEtoO<A, B>(EitherLens<A, B, dynamic> aLens) → OptionLens<A, B>

lensO<A, B>(Function1<A, Option<B>> getter, Function2<A, B, Option<A>> setter) → OptionLens<A, B>

lensOToE<A, B, E>(OptionLens<A, B> aLens, E eF()) → EitherLens<A, B, E>

lensS<A, B>(Function1<A, B> getter, Function2<A, B, A> setter) → SimpleLens<A, B>

liftF<F, A>(F fa) → Free<F, A>

listMi<A>() → Monoid<List<A>>

listMP<A>() → MonadPlus<List<A>>

listTMonad<M>(Monad<M> mmonad) → Monad<M>

monoid<A>(A zero(), A append(A t1, A t2)) → Monoid<A>

nil<A>() → IList<A>

none<A>() → Option<A>

objectEq<A>() → Eq<A>

option<A>(bool test, A value) → Option<A>

optionMi<A>(Semigroup<A> si) → Monoid<Option<A>>

optionOf<A>(A? value) → Option<A>

order<A>(OrderF<A> f) → Order<A>

orderBy<A, B>(Order<B> o, B by(A a)) → Order<A>

right<L, R>(R r) → Either<L, R>

secondSemigroup<A>() → Semigroup<A>

semigroup<A>(A append(A a1, A a2)) → Semigroup<A>

singletonMap<K extends Comparable, V>(K k, V v) → IMap<K, V>

some<A>(A a) → Option<A>

stateM<S>() → StateMonad<S>

taskMC<A>() → MonadCatch<Task<A>>

tcall<T>(Function0<Trampoline<T>> thunk) → Trampoline<T>

treturn<T>(T t) → Trampoline<T>

tstateM<F, S>() → StateTMonad<Trampoline<F>, S>

tuple10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) → Tuple10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>

tuple11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11) → Tuple11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>

tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12) → Tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>

tuple13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13) → Tuple13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>

tuple14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) → Tuple14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>

tuple15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) → Tuple15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>

tuple16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16) → Tuple16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>

tuple17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17) → Tuple17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>

tuple18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18) → Tuple18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>

tuple19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19) → Tuple19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>

tuple2<T1, T2>(T1 v1, T2 v2) → Tuple2<T1, T2>

tuple20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20) → Tuple20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>

tuple2Monoid<T1, T2>(Monoid<T1> value1Monoid, Monoid<T2> value2Monoid) → Monoid<Tuple2<T1, T2>>

tuple2Semigroup<T1, T2>(Semigroup<T1> value1Semigroup, Semigroup<T2> value2Semigroup) → Semigroup<Tuple2<T1, T2>>

tuple3<T1, T2, T3>(T1 v1, T2 v2, T3 v3) → Tuple3<T1, T2, T3>

tuple3Monoid<T1, T2, T3>(Monoid<T1> value1Monoid, Monoid<T2> value2Monoid, Monoid<T3> value3Monoid) → Monoid<Tuple3<T1, T2, T3>>

tuple3Semigroup<T1, T2, T3>(Semigroup<T1> value1Semigroup, Semigroup<T2> value2Semigroup, Semigroup<T3> value3Semigroup) → Semigroup<Tuple3<T1, T2, T3>>

tuple4<T1, T2, T3, T4>(T1 v1, T2 v2, T3 v3, T4 v4) → Tuple4<T1, T2, T3, T4>

tuple4Monoid<T1, T2, T3, T4>(Monoid<T1> value1Monoid, Monoid<T2> value2Monoid, Monoid<T3> value3Monoid, Monoid<T4> value4Monoid) → Monoid<Tuple4<T1, T2, T3, T4>>

tuple4Semigroup<T1, T2, T3, T4>(Semigroup<T1> value1Semigroup, Semigroup<T2> value2Semigroup, Semigroup<T3> value3Semigroup, Semigroup<T4> value4Semigroup) → Semigroup<Tuple4<T1, T2, T3, T4>>

tuple5<T1, T2, T3, T4, T5>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) → Tuple5<T1, T2, T3, T4, T5>

tuple6<T1, T2, T3, T4, T5, T6>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) → Tuple6<T1, T2, T3, T4, T5, T6>

tuple7<T1, T2, T3, T4, T5, T6, T7>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) → Tuple7<T1, T2, T3, T4, T5, T6, T7>

tuple8<T1, T2, T3, T4, T5, T6, T7, T8>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) → Tuple8<T1, T2, T3, T4, T5, T6, T7, T8>

tuple9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) → Tuple9<T1, T2, T3, T4, T5, T6, T7, T8, T9>

tuplize2<A, B, C>(Function2<A, B, C> fun) → Function1<Tuple2<A, B>, C>

tuplize3<A, B, C, D>(Function3<A, B, C, D> fun) → Function1<Tuple3<A, B, C>, D>

tuplize4<A, B, C, D, E>(Function4<A, B, C, D, E> fun) → Function1<Tuple4<A, B, C, D>, E>

uncurry2<A, B, C>(Function1<A, Function1<B, C>> fun) → Function2<A, B, C>

uncurry3<A, B, C, D>(Function1<A, Function1<B, Function1<C, D>>> fun) → Function3<A, B, C, D>

uncurry4<A, B, C, D, E>(Function1<A, Function1<B, Function1<C, Function1<D, E>>>> fun) → Function4<A, B, C, D, E>

uncurry5<A, B, C, D, E, F>(Function1<A, Function1<B, Function1<C, Function1<D, Function1<E, F>>>>> fun) → Function5<A, B, C, D, E, F>

uncurry6<A, B, C, D, E, F, G>(Function1<A, Function1<B, Function1<C, Function1<D, Function1<E, Function1<F, G>>>>>> fun) → Function6<A, B, C, D, E, F, G>

Typedefs

Endo<A> = A Function(A a)

EqF<A> = bool Function(A a1, A a2)

Function0<A> = A Function()

Function1<A, B> = B Function(A a)

Function10<A, B, C, D, E, F, G, H, I, J, K> = K Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j)

Function11<A, B, C, D, E, F, G, H, I, J, K, L> = L Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k)

Function12<A, B, C, D, E, F, G, H, I, J, K, L, M> = M Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l)

Function13<A, B, C, D, E, F, G, H, I, J, K, L, M, N> = N Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m)

Function14<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> = O Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n)

Function15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> = P Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o)

Function16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> = Q Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o, P p)

Function17<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> = R Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o, P p, Q q)

Function18<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> = S Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o, P p, Q q, R r)

Function19<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> = T Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o, P p, Q q, R r, S s)

Function2<A, B, C> = C Function(A a, B b)

Function20<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> = U Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o, P p, Q q, R r, S s, T t)

Function3<A, B, C, D> = D Function(A a, B b, C c)

Function4<A, B, C, D, E> = E Function(A a, B b, C c, D d)

Function5<A, B, C, D, E, F> = F Function(A a, B b, C c, D d, E e)

Function6<A, B, C, D, E, F, G> = G Function(A a, B b, C c, D d, E e, F f)

Function7<A, B, C, D, E, F, G, H> = H Function(A a, B b, C c, D d, E e, F f, G g)

Function8<A, B, C, D, E, F, G, H, I> = I Function(A a, B b, C c, D d, E e, F f, G g, H h)

Function9<A, B, C, D, E, F, G, H, I, J> = J Function(A a, B b, C c, D d, E e, F f, G g, H h, I i)

OrderF<A> = Ordering Function(A a1, A a2)