- pipe<A>(a: A): A
Returns A
- pipe<A, B>(a: A, ab: (a: A) => B): B
Returns B
- pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C
Parameters
- a: A
- ab: (a: A) => B
- bc: (b: B) => C
Returns C
- pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D
Parameters
- a: A
- ab: (a: A) => B
- bc: (b: B) => C
- cd: (c: C) => D
Returns D
- pipe<A, B, C, D, E>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
): E Parameters
- a: A
- ab: (a: A) => B
- bc: (b: B) => C
- cd: (c: C) => D
- de: (d: D) => E
Returns E
- pipe<A, B, C, D, E, F>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (ef: E) => F,
): F Parameters
- a: A
- ab: (a: A) => B
- bc: (b: B) => C
- cd: (c: C) => D
- de: (d: D) => E
- ef: (ef: E) => F
Returns F
- pipe<A, B, C, D, E, F, G>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (ef: E) => F,
fg: (f: F) => G,
): G Parameters
- a: A
- ab: (a: A) => B
- bc: (b: B) => C
- cd: (c: C) => D
- de: (d: D) => E
- ef: (ef: E) => F
- fg: (f: F) => G
Returns G
- pipe<A, B, C, D, E, F, G, H>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (ef: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
): H Parameters
- a: A
- ab: (a: A) => B
- bc: (b: B) => C
- cd: (c: C) => D
- de: (d: D) => E
- ef: (ef: E) => F
- fg: (f: F) => G
- gh: (g: G) => H
Returns H
- pipe<A, B, C, D, E, F, G, H, I>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (ef: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
): I Parameters
- a: A
- ab: (a: A) => B
- bc: (b: B) => C
- cd: (c: C) => D
- de: (d: D) => E
- ef: (ef: E) => F
- fg: (f: F) => G
- gh: (g: G) => H
- hi: (h: H) => I
Returns I
- pipe<A, B, C, D, E, F, G, H, I, J>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (ef: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (ij: I) => J,
): J Parameters
- a: A
- ab: (a: A) => B
- bc: (b: B) => C
- cd: (c: C) => D
- de: (d: D) => E
- ef: (ef: E) => F
- fg: (f: F) => G
- gh: (g: G) => H
- hi: (h: H) => I
- ij: (ij: I) => J
Returns J
Pipes a value through a series of functions from left to right. Currently supports up to 10 functions.
Param: a
The initial value to transform
Param: fs
Functions to apply sequentially
Returns
The final transformed value
Example