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
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>
Tuple2<T1, T2>
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>
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>
Tuple20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
Unit
UnitMonoid
WriteBytes

Constants

unit → const Unit
const Unit._internal()

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<Object>>
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 extends Object>() 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>
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>
tuple2<T1, T2>(T1 v1, T2 v2) Tuple2<T1, T2>
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>
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>
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>
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>

Enums

Ordering

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)
Function2<A, B, C> = C Function(A a, B b)
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)
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)
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)
OrderF<A> = Ordering Function(A a1, A a2)