<A>(a: A): A
<A, B = never>(a: A, ab: (a: A) => B): B
<A, B = never, C = never>(a: A, ab: (a: A) => B, bc: (b: B) => C): C
<A, B = never, C = never, D = never>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D
): D
<A, B = never, C = never, D = never, E = never>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E
): E
<A, B = never, C = never, D = never, E = never, F = never>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F
): F
<A, B = never, C = never, D = never, E = never, F = never, G = never>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G
): G
<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H
): H
<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I
): I
<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J
): J
<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K
): K
<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never,
L = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K,
kl: (k: K) => L
): L
<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never,
L = never,
M = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K,
kl: (k: K) => L,
lm: (l: L) => M
): M
<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never,
L = never,
M = never,
N = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K,
kl: (k: K) => L,
lm: (l: L) => M,
mn: (m: M) => N
): N
<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never,
L = never,
M = never,
N = never,
O = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K,
kl: (k: K) => L,
lm: (l: L) => M,
mn: (m: M) => N,
no: (n: N) => O
): O
<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never,
L = never,
M = never,
N = never,
O = never,
P = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K,
kl: (k: K) => L,
lm: (l: L) => M,
mn: (m: M) => N,
no: (n: N) => O,
op: (o: O) => P
): P
<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never,
L = never,
M = never,
N = never,
O = never,
P = never,
Q = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K,
kl: (k: K) => L,
lm: (l: L) => M,
mn: (m: M) => N,
no: (n: N) => O,
op: (o: O) => P,
pq: (p: P) => Q
): Q
<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never,
L = never,
M = never,
N = never,
O = never,
P = never,
Q = never,
R = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K,
kl: (k: K) => L,
lm: (l: L) => M,
mn: (m: M) => N,
no: (n: N) => O,
op: (o: O) => P,
pq: (p: P) => Q,
qr: (q: Q) => R
): R
<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never,
L = never,
M = never,
N = never,
O = never,
P = never,
Q = never,
R = never,
S = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K,
kl: (k: K) => L,
lm: (l: L) => M,
mn: (m: M) => N,
no: (n: N) => O,
op: (o: O) => P,
pq: (p: P) => Q,
qr: (q: Q) => R,
rs: (r: R) => S
): S
<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never,
L = never,
M = never,
N = never,
O = never,
P = never,
Q = never,
R = never,
S = never,
T = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K,
kl: (k: K) => L,
lm: (l: L) => M,
mn: (m: M) => N,
no: (n: N) => O,
op: (o: O) => P,
pq: (p: P) => Q,
qr: (q: Q) => R,
rs: (r: R) => S,
st: (s: S) => T
): TPipes the value of an expression through a left-to-right sequence of functions.
When to use
Use when you need to compose data-last functions into readable transformation pipelines instead of method-style chains.
Details
Takes an initial value, passes it to the first function, then passes each result to the next function in order. The final function result is returned.
Gotchas
Each function passed after the initial value must accept a single argument,
because pipe calls each step with only the previous result.
Example (Piping values through functions)
In this example, 1 is passed to the first function, and each result becomes
the input for the next function.
import { pipe } from "effect"
const result = pipe(
1,
(n) => n + 1,
(n) => n * 2,
(n) => `result: ${n}`
)
console.log(result) // "result: 4"Example (Chaining methods before conversion)
const numbers = [1, 2, 3, 4]
const double = (n: number) => n * 2
const greaterThanFour = (n: number) => n > 4
const result = numbers.map(double).filter(greaterThanFour)
console.log(result) // [6, 8]Example (Rewriting method chains with pipe)
The same transformation can be written with data-last functions.
import { Array, pipe } from "effect"
const numbers = [1, 2, 3, 4]
const double = (n: number) => n * 2
const greaterThanFour = (n: number) => n > 4
const result = pipe(
numbers,
Array.map(double),
Array.filter(greaterThanFour)
)
console.log(result) // [6, 8]Example (Chaining arithmetic operations)
import { pipe } from "effect"
// Define simple arithmetic operations
const increment = (x: number) => x + 1
const double = (x: number) => x * 2
const subtractTen = (x: number) => x - 10
// Sequentially apply these operations using `pipe`
const result = pipe(5, increment, double, subtractTen)
console.log(result)
// Output: 2Example (Building a simple transformation pipeline)
import { pipe } from "effect"
// Simple transformation pipeline
const result = pipe(
5,
(x) => x * 2, // 10
(x) => x + 1, // 11
(x) => x.toString() // "11"
)
console.log(result) // "11"combinators
Source effect/Function.ts:677451 lines
export function pipe<A>(a: A): A
export function pipe<A, B = never>(a: A, ab: (a: A) => B): B
export function pipe<A, B = never, C = never>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C
): C
export function pipe<A, B = never, C = never, D = never>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D
): D
export function pipe<A, B = never, C = never, D = never, E = never>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E
): E
export function pipe<A, B = never, C = never, D = never, E = never, F = never>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F
): F
export function pipe<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G
): G
export function pipe<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H
): H
export function pipe<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I
): I
export function pipe<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J
): J
export function pipe<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K
): K
export function pipe<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never,
L = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K,
kl: (k: K) => L
): L
export function pipe<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never,
L = never,
M = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K,
kl: (k: K) => L,
lm: (l: L) => M
): M
export function pipe<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never,
L = never,
M = never,
N = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K,
kl: (k: K) => L,
lm: (l: L) => M,
mn: (m: M) => N
): N
export function pipe<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never,
L = never,
M = never,
N = never,
O = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K,
kl: (k: K) => L,
lm: (l: L) => M,
mn: (m: M) => N,
no: (n: N) => O
): O
export function pipe<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never,
L = never,
M = never,
N = never,
O = never,
P = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K,
kl: (k: K) => L,
lm: (l: L) => M,
mn: (m: M) => N,
no: (n: N) => O,
op: (o: O) => P
): P
export function pipe<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never,
L = never,
M = never,
N = never,
O = never,
P = never,
Q = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K,
kl: (k: K) => L,
lm: (l: L) => M,
mn: (m: M) => N,
no: (n: N) => O,
op: (o: O) => P,
pq: (p: P) => Q
): Q
export function pipe<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never,
L = never,
M = never,
N = never,
O = never,
P = never,
Q = never,
R = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K,
kl: (k: K) => L,
lm: (l: L) => M,
mn: (m: M) => N,
no: (n: N) => O,
op: (o: O) => P,
pq: (p: P) => Q,
qr: (q: Q) => R
): R
export function pipe<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never,
L = never,
M = never,
N = never,
O = never,
P = never,
Q = never,
R = never,
S = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K,
kl: (k: K) => L,
lm: (l: L) => M,
mn: (m: M) => N,
no: (n: N) => O,
op: (o: O) => P,
pq: (p: P) => Q,
qr: (q: Q) => R,
rs: (r: R) => S
): S
export function pipe<
A,
B = never,
C = never,
D = never,
E = never,
F = never,
G = never,
H = never,
I = never,
J = never,
K = never,
L = never,
M = never,
N = never,
O = never,
P = never,
Q = never,
R = never,
S = never,
T = never
>(
a: A,
ab: (a: A) => B,
bc: (b: B) => C,
cd: (c: C) => D,
de: (d: D) => E,
ef: (e: E) => F,
fg: (f: F) => G,
gh: (g: G) => H,
hi: (h: H) => I,
ij: (i: I) => J,
jk: (j: J) => K,
kl: (k: K) => L,
lm: (l: L) => M,
mn: (m: M) => N,
no: (n: N) => O,
op: (o: O) => P,
pq: (p: P) => Q,
qr: (q: Q) => R,
rs: (r: R) => S,
st: (s: S) => T
): T
export function pipe(a: unknown, ...args: Array<any>): unknown {
return pipeArguments(a, args as any)
}Referenced by 6 symbols