pure library

Classes

Tram<T>
Class that exposes recursion trampoline functionality, allowing to emulate a tail call optimization.

Mixins

ImportPure

Extensions

Apply2X on F2<A, B, T>
Partially applies the first argument to the function without currying it.
Apply3X on F3<A, B, C, T>
Partially applies the first argument to the function without currying it.
Apply4X on F4<A, B, C, D, T>
Partially applies the first argument to the function without currying it.
Apply5X on F5<A, B, C, D, E, T>
Partially applies the first argument to the function without currying it.
Apply6X on F6<A, B, C, D, E, F, T>
Partially applies the first argument to the function without currying it.
Apply7X on F7<A, B, C, D, E, F, G, T>
Partially applies the first argument to the function without currying it.
Apply8X on F8<A, B, C, D, E, F, G, H, T>
Partially applies the first argument to the function without currying it.
Apply9X on F9<A, B, C, D, E, F, G, H, I, T>
Partially applies the first argument to the function without currying it.
Bounce0X on F0<Tram<T>>
Runs the function, "bouncing" on the recursion trampoline, returning the result of the wrapped computations.
Bounce1X on F1<A, Tram<T>>
Runs the function, "bouncing" on the recursion trampoline, returning the result of the wrapped computations.
Bounce2X on F2<A, B, Tram<T>>
Runs the function, "bouncing" on the recursion trampoline, returning the result of the wrapped computations.
Bounce3X on F3<A, B, C, Tram<T>>
Runs the function, "bouncing" on the recursion trampoline, returning the result of the wrapped computations.
Bounce4X on F4<A, B, C, D, Tram<T>>
Runs the function, "bouncing" on the recursion trampoline, returning the result of the wrapped computations.
Bounce5X on F5<A, B, C, D, E, Tram<T>>
Runs the function, "bouncing" on the recursion trampoline, returning the result of the wrapped computations.
Bounce6X on F6<A, B, C, D, E, F, Tram<T>>
Runs the function, "bouncing" on the recursion trampoline, returning the result of the wrapped computations.
Bounce7X on F7<A, B, C, D, E, F, G, Tram<T>>
Runs the function, "bouncing" on the recursion trampoline, returning the result of the wrapped computations.
Bounce8X on F8<A, B, C, D, E, F, G, H, Tram<T>>
Runs the function, "bouncing" on the recursion trampoline, returning the result of the wrapped computations.
Bounce9X on F9<A, B, C, D, E, F, G, H, I, Tram<T>>
Runs the function, "bouncing" on the recursion trampoline, returning the result of the wrapped computations.
ComposeX on C Function(B)
Composes two functions following the rules of mathematical function composition.
ConstantX on A
Takes a single argument, discards it and return the value that it was called on.
Curry2X on F2<A, B, T>
Curries the function.
Curry3X on F3<A, B, C, T>
Curries the function.
Curry4X on F4<A, B, C, D, T>
Curries the function.
Curry5X on F5<A, B, C, D, E, T>
Curries the function.
Curry6X on F6<A, B, C, D, E, F, T>
Curries the function.
Curry7X on F7<A, B, C, D, E, F, G, T>
Curries the function.
Curry8X on F8<A, B, C, D, E, F, G, H, T>
Curries the function.
Curry9X on F9<A, B, C, D, E, F, G, H, I, T>
Curries the function.
Flip2X on F2<A, B, T>
Returns a new function with flipped arguments, reversing their order.
Flip3X on F3<A, B, C, T>
Returns a new function with flipped arguments, reversing their order.
Flip4X on F4<A, B, C, D, T>
Returns a new function with flipped arguments, reversing their order.
Flip5X on F5<A, B, C, D, E, T>
Returns a new function with flipped arguments, reversing their order.
Flip6X on F6<A, B, C, D, E, F, T>
Returns a new function with flipped arguments, reversing their order.
Flip7X on F7<A, B, C, D, E, F, G, T>
Returns a new function with flipped arguments, reversing their order.
Flip8X on F8<A, B, C, D, E, F, G, H, T>
Returns a new function with flipped arguments, reversing their order.
Flip9X on F9<A, B, C, D, E, F, G, H, I, T>
Returns a new function with flipped arguments, reversing their order.
Memoize0X on F0<T>
Returns a memoized version of the function.
Memoize1X on F1<A, T>
Returns a memoized version of the function.
Memoize2X on F2<A, B, T>
Returns a memoized version of the function.
Memoize3X on F3<A, B, C, T>
Returns a memoized version of the function.
Memoize4X on F4<A, B, C, D, T>
Returns a memoized version of the function.
Memoize5X on F5<A, B, C, D, E, T>
Returns a memoized version of the function.
Memoize6X on F6<A, B, C, D, E, F, T>
Returns a memoized version of the function.
Memoize7X on F7<A, B, C, D, E, F, G, T>
Returns a memoized version of the function.
Memoize8X on F8<A, B, C, D, E, F, G, H, T>
Returns a memoized version of the function.
Memoize9X on F9<A, B, C, D, E, F, G, H, I, T>
Returns a memoized version of the function.
Nullable1X on F1<A, T>
Takes nullable versions of arguments and runs the computation if all of them are not null.
Nullable2X on F2<A, B, T>
Takes nullable versions of arguments and runs the computation if all of them are not null.
Nullable3X on F3<A, B, C, T>
Takes nullable versions of arguments and runs the computation if all of them are not null.
Nullable4X on F4<A, B, C, D, T>
Takes nullable versions of arguments and runs the computation if all of them are not null.
Nullable5X on F5<A, B, C, D, E, T>
Takes nullable versions of arguments and runs the computation if all of them are not null.
Nullable6X on F6<A, B, C, D, E, F, T>
Takes nullable versions of arguments and runs the computation if all of them are not null.
Nullable7X on F7<A, B, C, D, E, F, G, T>
Takes nullable versions of arguments and runs the computation if all of them are not null.
Nullable8X on F8<A, B, C, D, E, F, G, H, T>
Takes nullable versions of arguments and runs the computation if all of them are not null.
Nullable9X on F9<A, B, C, D, E, F, G, H, I, T>
Takes nullable versions of arguments and runs the computation if all of them are not null.
PipeX on A
Feeds the value into a given function, returning the result of the computation.
Uncurry2X on CF2<A, B, T>
Uncurries the function, returning a new function that takes multiple arguments instead of a single one, and acts as a normal function that returns a single value.
Uncurry3X on CF3<A, B, C, T>
Uncurries the function, returning a new function that takes multiple arguments instead of a single one, and acts as a normal function that returns a single value.
Uncurry4X on CF4<A, B, C, D, T>
Uncurries the function, returning a new function that takes multiple arguments instead of a single one, and acts as a normal function that returns a single value.
Uncurry5X on CF5<A, B, C, D, E, T>
Uncurries the function, returning a new function that takes multiple arguments instead of a single one, and acts as a normal function that returns a single value.
Uncurry6X on CF6<A, B, C, D, E, F, T>
Uncurries the function, returning a new function that takes multiple arguments instead of a single one, and acts as a normal function that returns a single value.
Uncurry7X on CF7<A, B, C, D, E, F, G, T>
Uncurries the function, returning a new function that takes multiple arguments instead of a single one, and acts as a normal function that returns a single value.
Uncurry8X on CF8<A, B, C, D, E, F, G, H, T>
Uncurries the function, returning a new function that takes multiple arguments instead of a single one, and acts as a normal function that returns a single value.
Uncurry9X on CF9<A, B, C, D, E, F, G, H, I, T>
Uncurries the function, returning a new function that takes multiple arguments instead of a single one, and acts as a normal function that returns a single value.

Functions

asyncNothing() → Future<void>
Literally does nothing, but asynchronously.
id<A>(A a) → A
Returns the value that was passed as an argument.
idFirst<A, B>(A a, B b) → A
Returns the first argument from passed two.
idSecond<A, B>(A a, B b) → B
Returns the second argument from passed two.
minus<A extends num>(A a, A b) → A
Subtracts the second argument from the first one.
negate(bool a) → bool
Inverts of the passed argument.
negateNum<A extends num>(A a) → A
Inverts the sign of the passed argument.
nothing() → void
Literally does nothing.
plus<A extends num>(A a, A b) → A
Adds two arguments together.
pred<A extends num>(A x) → A
Decrements the given value by one.
succ<A extends num>(A x) → A
Increment the given value by one.

Typedefs

CF2<A, B, T> = T Function(B b) Function(A a)
Typedef for a curried function that takes 2 arguments.
CF3<A, B, C, T> = T Function(C c) Function(B b) Function(A a)
Typedef for a curried function that takes 3 arguments.
CF4<A, B, C, D, T> = T Function(D d) Function(C c) Function(B b) Function(A a)
Typedef for a curried function that takes 4 arguments.
CF5<A, B, C, D, E, T> = T Function(E e) Function(D d) Function(C c) Function(B b) Function(A a)
Typedef for a curried function that takes 5 arguments.
CF6<A, B, C, D, E, F, T> = T Function(F f) Function(E e) Function(D d) Function(C c) Function(B b) Function(A a)
Typedef for a curried function that takes 6 arguments.
CF7<A, B, C, D, E, F, G, T> = T Function(G g) Function(F f) Function(E e) Function(D d) Function(C c) Function(B b) Function(A a)
Typedef for a curried function that takes 7 arguments.
CF8<A, B, C, D, E, F, G, H, T> = T Function(H h) Function(G g) Function(F f) Function(E e) Function(D d) Function(C c) Function(B b) Function(A a)
Typedef for a curried function that takes 8 arguments.
CF9<A, B, C, D, E, F, G, H, I, T> = T Function(I i) Function(H h) Function(G g) Function(F f) Function(E e) Function(D d) Function(C c) Function(B b) Function(A a)
Typedef for a curried function that takes 9 arguments.
F0<T> = T Function()
Typedef for a function that takes 0 arguments
F1<A, T> = T Function(A a)
Typedef for a function that takes 1 argument.
F2<A, B, T> = T Function(A a, B b)
Typedef for a function that takes 2 arguments
F3<A, B, C, T> = T Function(A a, B b, C c)
Typedef for a function that takes 3 arguments
F4<A, B, C, D, T> = T Function(A a, B b, C c, D d)
Typedef for a function that takes 4 arguments
F5<A, B, C, D, E, T> = T Function(A a, B b, C c, D d, E e)
Typedef for a function that takes 5 arguments
F6<A, B, C, D, E, F, T> = T Function(A a, B b, C c, D d, E e, F f)
Typedef for a function that takes 6 arguments
F7<A, B, C, D, E, F, G, T> = T Function(A a, B b, C c, D d, E e, F f, G g)
Typedef for a function that takes 7 arguments
F8<A, B, C, D, E, F, G, H, T> = T Function(A a, B b, C c, D d, E e, F f, G g, H h)
Typedef for a function that takes 8 arguments
F9<A, B, C, D, E, F, G, H, I, T> = T Function(A a, B b, C c, D d, E e, F f, G g, H h, I i)
Typedef for a function that takes 9 arguments