flow

flow

Combines all of the functions given into a single function. This function takes a value and will accumulatively call it against all of the given functions left-to-right. The result of calling a function with the accumulated value will be given to the next function, and the result of the last function will be returned. If there are no functions given, then the combined function will return the value passed to it.

Returns

A function which takes a value and will return the result of accumulatively calling the value against all of the functions given left-to-right.

Signature - util.ts#L105

Copyfunction flow(): <T>(x: T) => T
1
function flow(): <T>(x: T) => T

Copyfunction flow<T, R>(f1: (x: T) => R): (x: T) => R
1
function flow<T, R>(f1: (x: T) => R): (x: T) => R

Copyfunction flow<T, A, R>(f1: (x: T) => A, f2: (x: A) => R): (x: T) => R
1
function flow<T, A, R>(f1: (x: T) => A, f2: (x: A) => R): (x: T) => R

Copyfunction flow<T, A, B, R>(
    f1: (x: T) => A,
    f2: (x: A) => B,
    f3: (x: B) => R,
): (x: T) => R
1
function flow<T, A, B, R>(
2
    f1: (x: T) => A,
3
    f2: (x: A) => B,
4
    f3: (x: B) => R,
5
): (x: T) => R

Copyfunction flow<T, A, B, C, R>(
    f1: (x: T) => A,
    f2: (x: A) => B,
    f3: (x: B) => C,
    f4: (x: C) => R,
): (x: T) => R
1
function flow<T, A, B, C, R>(
2
    f1: (x: T) => A,
3
    f2: (x: A) => B,
4
    f3: (x: B) => C,
5
    f4: (x: C) => R,
6
): (x: T) => R

Copyfunction flow<T, A, B, C, D, R>(
    f1: (x: T) => A,
    f2: (x: A) => B,
    f3: (x: B) => C,
    f4: (x: C) => D,
    f5: (x: D) => R,
): (x: T) => R
1
function flow<T, A, B, C, D, R>(
2
    f1: (x: T) => A,
3
    f2: (x: A) => B,
4
    f3: (x: B) => C,
5
    f4: (x: C) => D,
6
    f5: (x: D) => R,
7
): (x: T) => R

Copyfunction flow<T, A, B, C, D, E, R>(
    f1: (x: T) => A,
    f2: (x: A) => B,
    f3: (x: B) => C,
    f4: (x: C) => D,
    f5: (x: D) => E,
    f6: (x: E) => R,
): (x: T) => R
1
function flow<T, A, B, C, D, E, R>(
2
    f1: (x: T) => A,
3
    f2: (x: A) => B,
4
    f3: (x: B) => C,
5
    f4: (x: C) => D,
6
    f5: (x: D) => E,
7
    f6: (x: E) => R,
8
): (x: T) => R

Copyfunction flow<T, A, B, C, D, E, F, R>(
    f1: (x: T) => A,
    f2: (x: A) => B,
    f3: (x: B) => C,
    f4: (x: C) => D,
    f5: (x: D) => E,
    f6: (x: E) => F,
    f7: (x: F) => R,
): (x: T) => R
1
function flow<T, A, B, C, D, E, F, R>(
2
    f1: (x: T) => A,
3
    f2: (x: A) => B,
4
    f3: (x: B) => C,
5
    f4: (x: C) => D,
6
    f5: (x: D) => E,
7
    f6: (x: E) => F,
8
    f7: (x: F) => R,
9
): (x: T) => R

Copyfunction flow<T, A, B, C, D, E, F, G, R>(
    f1: (x: T) => A,
    f2: (x: A) => B,
    f3: (x: B) => C,
    f4: (x: C) => D,
    f5: (x: D) => E,
    f6: (x: E) => F,
    f7: (x: F) => G,
    f8: (x: G) => R,
): (x: T) => R
1
function flow<T, A, B, C, D, E, F, G, R>(
2
    f1: (x: T) => A,
3
    f2: (x: A) => B,
4
    f3: (x: B) => C,
5
    f4: (x: C) => D,
6
    f5: (x: D) => E,
7
    f6: (x: E) => F,
8
    f7: (x: F) => G,
9
    f8: (x: G) => R,
10
): (x: T) => R

Copyfunction flow<T, A, B, C, D, E, F, G, H, R>(
    f1: (x: T) => A,
    f2: (x: A) => B,
    f3: (x: B) => C,
    f4: (x: C) => D,
    f5: (x: D) => E,
    f6: (x: E) => F,
    f7: (x: F) => G,
    f8: (x: G) => H,
    f9: (x: H) => R,
): (x: T) => R
1
function flow<T, A, B, C, D, E, F, G, H, R>(
2
    f1: (x: T) => A,
3
    f2: (x: A) => B,
4
    f3: (x: B) => C,
5
    f4: (x: C) => D,
6
    f5: (x: D) => E,
7
    f6: (x: E) => F,
8
    f7: (x: F) => G,
9
    f8: (x: G) => H,
10
    f9: (x: H) => R,
11
): (x: T) => R

Copyfunction flow<T, A, B, C, D, E, F, G, H, R>(
    f1: (x: T) => A,
    f2: (x: A) => B,
    f3: (x: B) => C,
    f4: (x: C) => D,
    f5: (x: D) => E,
    f6: (x: E) => F,
    f7: (x: F) => G,
    f8: (x: G) => H,
    f9: (x: H) => R,
    ...funcs: Array<(x: any) => any>
): (x: T) => R
1
function flow<T, A, B, C, D, E, F, G, H, R>(
2
    f1: (x: T) => A,
3
    f2: (x: A) => B,
4
    f3: (x: B) => C,
5
    f4: (x: C) => D,
6
    f5: (x: D) => E,
7
    f6: (x: E) => F,
8
    f7: (x: F) => G,
9
    f8: (x: G) => H,
10
    f9: (x: H) => R,
11
    ...funcs: Array<(x: any) => any>
12
): (x: T) => R

Copyfunction flow<T>(...fns: Array<(x: T) => T>): (x: T) => T
1
function flow<T>(...fns: Array<(x: T) => T>): (x: T) => T