seedkit_core_dart library

Classes

Applicative<F>
ApplicativeOps<F, A>
ApplicativePlus<F>
ApplicativePlusOps<F, A>
Attempt<A>
AVLTree<A>
AVLTreeMonoid<A>
Bind<F, A, B>
BooleanConjunctionMonoid
BooleanDisjunctionMonoid
BoolList
A space-efficient list of boolean values.
CanonicalizedMap<C, K, V>
A map whose keys are converted to canonical values of type C.
CaseInsensitiveEquality
String equality that's insensitive to differences in ASCII case.
CloseFile
CollectionStyle
An enum of collection styles.
CombinedIterableView<T>
A view of several iterables combined sequentially into a single iterable.
CombinedListView<T>
A view of several lists combined into a single list.
CombinedMapView<K, V>
Returns a new map that represents maps flattened into a single map.
ComparableOrder<A extends Comparable>
ComposedFunctor<F, G>
Cons<A>
DeepCollectionEquality
Deep equality on collections.
DefaultEquality<E>
Equality of objects that compares only the natural equality of the objects.
Delay<A>
DelegatingIterable<E>
An Iterable that delegates all operations to a base iterable.
DelegatingList<E>
A List that delegates all operations to a base list.
DelegatingMap<K, V>
A Map that delegates all operations to a base map.
DelegatingQueue<E>
A Queue that delegates all operations to a base queue.
DelegatingSet<E>
A Set that delegates all operations to a base set.
DualMonoid<A>
DualSemigroup<A>
Either<L, R>
EitherLens<A, B, E>
EitherMonad<L>
Eq<A>
EqOps<A>
Equality<E>
A generic equality relation on objects.
EqualityBy<E, F>
Equality of objects based on derived values.
EqualityMap<K, V>
A Map whose key equality is determined by an Equality object.
EqualitySet<E>
A Set whose key equality is determined by an Equality object.
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>
HeapPriorityQueue<E>
Heap based priority queue.
IdentityEquality<E>
Equality of objects that compares only the identity of the objects.
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>
IterableEquality<E>
Equality on iterables.
IterableZip<T>
Iterable that iterates over lists of values from other iterables.
IteratorEq<A>
IVector<A>
IVectorMonoid<A>
Left<L, R>
LeftFreeComposer<LL, L, R>
Lens<AIn, AOut, BIn, BOut>
ListEquality<E>
Equality on lists.
ListMonoid<A>
ListSlice<E>
A list view of a range of another list.
ListTMonad<M>
ListTraversableMonadPlus
MapEquality<K, V>
Equality on maps.
MapKeySet<E>
An unmodifiable Set view of the keys of a Map.
MapValueSet<K, V>
Creates a modifiable Set view of the values of a Map.
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>
MultiEquality<E>
Combines several equalities into a single equality.
Nil<A>
None<A>
NonGrowableListMixin<E>
Mixin class that implements a throwing version of all list operations that change the List's length.
NonGrowableListView<E>
A fixed-length list.
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
PriorityQueue<E>
A priority queue is a priority based work-list of elements.
Pure<F, A>
QueueList<E>
A class that efficiently implements both Queue and List.
ReadBytes
Readln
RightFreeComposer<RR, L, R>
ScalarStyle
An enum of source scalar styles.
Semigroup<A>
SetEquality<E>
Equality of sets.
SimpleLens<A, B>
Some<A>
State<S, A>
StateMonad<S>
StateT<F, S, A>
StateTMonad<F, S>
StringMonoid
Suspend<F, A>
TagDirective
A directive describing a custom tag handle.
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>
UnionSet<E>
A single set that provides a view of the union over a set of sets.
UnionSetController<E>
A controller that exposes a view of the union of a collection of sets.
Unit
UnitMonoid
UnmodifiableListView<E>
An unmodifiable List view of another List.
UnmodifiableMapMixin<K, V>
Mixin class that implements a throwing version of all map operations that change the Map.
UnmodifiableMapView<K, V>
View of a Map that disallow modifying the map.
UnmodifiableSetMixin<E>
Mixin class that implements a throwing version of all set operations that change the Set.
UnmodifiableSetView<E>
An unmodifiable set.
UnorderedIterableEquality<E>
Equality of the elements of two iterables without considering order.
VersionDirective
A directive indicating which version of YAML a document was written to.
WriteBytes
YamlDocument
A YAML document, complete with metadata.
YamlList
A read-only List parsed from YAML.
YamlMap
A read-only Map parsed from YAML.
YamlNode
An interface for parsed nodes from a YAML source tree.
YamlScalar
A wrapped scalar value parsed from YAML.

Enums

Ordering

Extensions

ComparatorExtension on Comparator<T>
Extensions on comparator functions.
IterableComparableExtension on Iterable<T>
Extensions that apply to iterables of Comparable elements.
IterableDoubleExtension on Iterable<double>
Extension on iterables of double.
IterableExtension on Iterable<T>
Extensions that apply to all iterables.
IterableIntegerExtension on Iterable<int>
Extension on iterables of integers.
IterableIterableExtension on Iterable<Iterable<T>>
Extensions on iterables whose elements are also iterables.
IterableNullableExtension on Iterable<T?>
Extensions that apply to iterables with a nullable element type.
IterableNumberExtension on Iterable<num>
Extensions that apply to iterables of numbers.
ListComparableExtensions on List<E>
Various extensions on lists of comparable elements.
ListExtensions on List<E>
Various extensions on lists of arbitrary elements.
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
yamlWarningCallback ↔ YamlWarningCallback
A callback for emitting a warning.
getter/setter pair

Functions

binarySearch<E>(List<E> sortedList, E value, {int compare(E, E)?}) → int
Returns a position of the value in sortedList, if it is there.
cast<A>(dynamic a) → A
catching<A>(Function0<A> thunk) → Either<dynamic, A>
comparableOrder<A extends Comparable>() → Order<A>
compareAsciiLowerCase(String a, String b) → int
Compares a and b lexically, converting ASCII letters to lower case.
compareAsciiLowerCaseNatural(String a, String b) → int
Compares strings a and b according to lower-case natural sort ordering.
compareAsciiUpperCase(String a, String b) → int
Compares a and b lexically, converting ASCII letters to upper case.
compareAsciiUpperCaseNatural(String a, String b) → int
Compares strings a and b according to upper-case natural sort ordering.
compareNatural(String a, String b) → int
Compares strings a and b according to natural sort ordering.
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>
equalsIgnoreAsciiCase(String a, String b) → bool
Checks if strings a and b differ only on the case of ASCII letters.
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>>
groupBy<S, T>(Iterable<S> values, T key(S)) → Map<T, List<S>>
Groups the elements in values by the value returned by key.
hashIgnoreAsciiCase(String string) → int
Hash code for a string which is compatible with equalsIgnoreAsciiCase.
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>
insertionSort<E>(List<E> elements, {int compare(E, E)?, int start = 0, int? end}) → void
Sort a list between start (inclusive) and end (exclusive) using insertion sort.
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>>
lastBy<S, T>(Iterable<S> values, T key(S)) → Map<T, S>
Associates the elements in values by the value returned by key.
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>
loadYaml(String yaml, {Uri? sourceUrl, bool recover = false, ErrorListener? errorListener}) → dynamic
Loads a single document from a YAML string.
loadYamlDocument(String yaml, {Uri? sourceUrl, bool recover = false, ErrorListener? errorListener}) → YamlDocument
Loads a single document from a YAML string as a YamlDocument.
loadYamlDocuments(String yaml, {Uri? sourceUrl}) → List<YamlDocument>
Loads a stream of documents from a YAML string.
loadYamlNode(String yaml, {Uri? sourceUrl, bool recover = false, ErrorListener? errorListener}) → YamlNode
Loads a single document from a YAML string as a YamlNode.
loadYamlStream(String yaml, {Uri? sourceUrl}) → YamlList
Loads a stream of documents from a YAML string.
lowerBound<E>(List<E> sortedList, E value, {int compare(E, E)?}) → int
Returns the first position in sortedList that does not compare less than value.
mapMap<K1, V1, K2, V2>(Map<K1, V1> map, {K2 key(K1, V1)?, V2 value(K1, V1)?}) → Map<K2, V2>
Creates a new map from map with new keys and values.
maxBy<S, T>(Iterable<S> values, T orderBy(S), {int compare(T, T)?}) → S?
Returns the element of values for which orderBy returns the maximum value.
mergeMaps<K, V>(Map<K, V> map1, Map<K, V> map2, {V value(V, V)?}) → Map<K, V>
Returns a new map with all key/value pairs in both map1 and map2.
mergeSort<E>(List<E> elements, {int start = 0, int? end, int compare(E, E)?}) → void
Sorts a list between start (inclusive) and end (exclusive) using the merge sort algorithm.
minBy<S, T>(Iterable<S> values, T orderBy(S), {int compare(T, T)?}) → S?
Returns the element of values for which orderBy returns the minimum value.
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>
reverse<E>(List<E> elements, [int start = 0, int? end]) → void
Reverses a list, or a part of a list, in-place.
secondSemigroup<A>() → Semigroup<A>
semigroup<A>(A append(A a1, A a2)) → Semigroup<A>
shuffle(List elements, [int start = 0, int? end, Random? random]) → void
Shuffles a list randomly.
singletonMap<K extends Comparable, V>(K k, V v) → IMap<K, V>
some<A>(A a) → Option<A>
stateM<S>() → StateMonad<S>
stronglyConnectedComponents<T>(Map<T, Iterable<T>> graph) → List<Set<T>>
Returns the strongly connected components of graph, in topological order.
taskMC<A>() → MonadCatch<Task<A>>
tcall<T>(Function0<Trampoline<T>> thunk) → Trampoline<T>
transitiveClosure<T>(Map<T, Iterable<T>> graph) → Map<T, Set<T>>
Returns the transitive closure of graph.
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)
YamlWarningCallback = void Function(String message, [SourceSpan? span])
A callback for emitting a warning.

Exceptions / Errors

YamlException
An error thrown by the YAML processor.