Methods
(static) compose(...args) → {Func}
Name | Type | Description |
---|---|---|
...args |
Func[] |
compose<A, B, C, D, E>(a, b, c, d) → {Func<A, E>}
compose<A, B, C, D>(a, b, c) → {Func<A, D>}
compose<A, B, C>(a, b) → {Func<A, C>}
Returns:
- Type
- Func
(static) curry(f) → {any}
Name | Type | Description |
---|---|---|
f |
CallbackType | ... |
curry<A>(f) → {() => A}
Name | Type | Description |
---|---|---|
f |
() => A |
curry<A, B>(f) → {Curry1<A, B>}
Name | Type | Description |
---|---|---|
f |
Curry1CallbackType<A, B> |
curry<A, B, C>(f) → {Curry2<A, B, C>}
Name | Type | Description |
---|---|---|
f |
Curry2CallbackType<A, B, C> |
curry<A, B, C, D>(f) → {Curry3<A, B, C, D>}
Name | Type | Description |
---|---|---|
f |
Curry3CallbackType<A, B, C, D> |
curry<A, B, C, D, E>(f) → {Curry4<A, B, C, D, E>}
Name | Type | Description |
---|---|---|
f |
Curry4CallbackType<A, B, C, D, E> |
Returns:
- Type
- any
(static) exec<T, U = T>(f, v) → {Promise<U>|...}
Name | Type | Description |
---|---|---|
f |
(pv: T) => U | |
v |
T | Promise<T> | ... |
exec<T, U = T>(f, v) → {Promise<U>}
Name | Type | Description |
---|---|---|
f |
(pv: T) => U | |
v |
Promise<T> |
exec<T, U = T>(f, v) → {U}
Name | Type | Description |
---|---|---|
f |
(pv: T) => U | |
v |
NoPromise<T> |
exec<T, U = T>(f, v) → {Promise<U> | U}
Name | Type | Description |
---|---|---|
f |
(pv: T) => U | |
v |
Promise<T> | T |
Returns:
- Type
- Promise<U> | ...
(static) isIterable<T = any>(iter) → {iter is Iterable<T> | AsyncIterable<T>}
Name | Type | Description |
---|---|---|
iter |
any |
Returns:
- Type
- iter is Iterable<T> | AsyncIterable<T>
(static) isIterator<T = any>(iter) → {iter is Iterator<T>}
Name | Type | Description |
---|---|---|
iter |
any |
Returns:
- Type
- iter is Iterator<T>
(static) isPromise<T = any>(value) → {value is Promise<any>}
Name | Type | Description |
---|---|---|
value |
any |
Returns:
- Type
- value is Promise<any>
(static) pipe(...args) → {Func}
Name | Type | Description |
---|---|---|
...args |
Func[] |
pipe<A, B, C, D, E>(a, b, c, d) → {Func<A, E>}
pipe<A, B, C, D>(a, b, c) → {Func<A, D>}
pipe<A, B, C>(a, b) → {Func<A, C>}
Returns:
- Type
- Func