flow

Call Signature

flow<A, B>(ab): (…a) => B

Composes functions from left to right, returning a new function. Unlike pipe, flow doesn’t take an initial value - it creates a reusable pipeline that can be called later with arguments.

Use flow when you want to create a named, reusable transformation. Use pipe when you want to immediately transform a value.

Type Parameters

A

A extends readonly unknown[]

B

B

Parameters

ab

(…a) => B

Returns

(…a): B

Parameters

a

…A

Returns

B

Example

// Create a reusable transformation
const processUser = flow(
  (user: User) => user.name,
  name => name.toUpperCase(),
  name => `Hello, ${name}!`
);

processUser({ name: "Alice" }); // "Hello, ALICE!"
processUser({ name: "Bob" }); // "Hello, BOB!"

// Compare with pipe (one-time use):
pipe(
  user,
  u => u.name,
  name => name.toUpperCase()
);

// flow creates a function, pipe applies immediately:
const double = flow((n: number) => n * 2);
double(5); // 10

pipe(5, n => n * 2); // 10 (immediate result)

See

pipe for immediate value transformation

Call Signature

flow<A, B, C>(ab, bc): (…a) => C

Defined in: Composition/flow.ts:40

Composes functions from left to right, returning a new function. Unlike pipe, flow doesn’t take an initial value - it creates a reusable pipeline that can be called later with arguments.

Use flow when you want to create a named, reusable transformation. Use pipe when you want to immediately transform a value.

Type Parameters

A

A extends readonly unknown[]

B

B

C

C

Parameters

ab

(…a) => B

bc

(b) => C

Returns

(…a): C

Parameters

a

…A

Returns

C

Example

// Create a reusable transformation
const processUser = flow(
  (user: User) => user.name,
  name => name.toUpperCase(),
  name => `Hello, ${name}!`
);

processUser({ name: "Alice" }); // "Hello, ALICE!"
processUser({ name: "Bob" }); // "Hello, BOB!"

// Compare with pipe (one-time use):
pipe(
  user,
  u => u.name,
  name => name.toUpperCase()
);

// flow creates a function, pipe applies immediately:
const double = flow((n: number) => n * 2);
double(5); // 10

pipe(5, n => n * 2); // 10 (immediate result)

See

pipe for immediate value transformation

Call Signature

flow<A, B, C, D>(ab, bc, cd): (…a) => D

Defined in: Composition/flow.ts:44

Composes functions from left to right, returning a new function. Unlike pipe, flow doesn’t take an initial value - it creates a reusable pipeline that can be called later with arguments.

Use flow when you want to create a named, reusable transformation. Use pipe when you want to immediately transform a value.

Type Parameters

A

A extends readonly unknown[]

B

B

C

C

D

D

Parameters

ab

(…a) => B

bc

(b) => C

cd

(c) => D

Returns

(…a): D

Parameters

a

…A

Returns

D

Example

// Create a reusable transformation
const processUser = flow(
  (user: User) => user.name,
  name => name.toUpperCase(),
  name => `Hello, ${name}!`
);

processUser({ name: "Alice" }); // "Hello, ALICE!"
processUser({ name: "Bob" }); // "Hello, BOB!"

// Compare with pipe (one-time use):
pipe(
  user,
  u => u.name,
  name => name.toUpperCase()
);

// flow creates a function, pipe applies immediately:
const double = flow((n: number) => n * 2);
double(5); // 10

pipe(5, n => n * 2); // 10 (immediate result)

See

pipe for immediate value transformation

Call Signature

flow<A, B, C, D, E>(ab, bc, cd, de): (…a) => E

Defined in: Composition/flow.ts:49

Composes functions from left to right, returning a new function. Unlike pipe, flow doesn’t take an initial value - it creates a reusable pipeline that can be called later with arguments.

Use flow when you want to create a named, reusable transformation. Use pipe when you want to immediately transform a value.

Type Parameters

A

A extends readonly unknown[]

B

B

C

C

D

D

E

E

Parameters

ab

(…a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

Returns

(…a): E

Parameters

a

…A

Returns

E

Example

// Create a reusable transformation
const processUser = flow(
  (user: User) => user.name,
  name => name.toUpperCase(),
  name => `Hello, ${name}!`
);

processUser({ name: "Alice" }); // "Hello, ALICE!"
processUser({ name: "Bob" }); // "Hello, BOB!"

// Compare with pipe (one-time use):
pipe(
  user,
  u => u.name,
  name => name.toUpperCase()
);

// flow creates a function, pipe applies immediately:
const double = flow((n: number) => n * 2);
double(5); // 10

pipe(5, n => n * 2); // 10 (immediate result)

See

pipe for immediate value transformation

Call Signature

flow<A, B, C, D, E, F>(ab, bc, cd, de, ef): (…a) => F

Defined in: Composition/flow.ts:55

Composes functions from left to right, returning a new function. Unlike pipe, flow doesn’t take an initial value - it creates a reusable pipeline that can be called later with arguments.

Use flow when you want to create a named, reusable transformation. Use pipe when you want to immediately transform a value.

Type Parameters

A

A extends readonly unknown[]

B

B

C

C

D

D

E

E

F

F

Parameters

ab

(…a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

ef

(e) => F

Returns

(…a): F

Parameters

a

…A

Returns

F

Example

// Create a reusable transformation
const processUser = flow(
  (user: User) => user.name,
  name => name.toUpperCase(),
  name => `Hello, ${name}!`
);

processUser({ name: "Alice" }); // "Hello, ALICE!"
processUser({ name: "Bob" }); // "Hello, BOB!"

// Compare with pipe (one-time use):
pipe(
  user,
  u => u.name,
  name => name.toUpperCase()
);

// flow creates a function, pipe applies immediately:
const double = flow((n: number) => n * 2);
double(5); // 10

pipe(5, n => n * 2); // 10 (immediate result)

See

pipe for immediate value transformation

Call Signature

flow<A, B, C, D, E, F, G>(ab, bc, cd, de, ef, fg): (…a) => G

Defined in: Composition/flow.ts:62

Composes functions from left to right, returning a new function. Unlike pipe, flow doesn’t take an initial value - it creates a reusable pipeline that can be called later with arguments.

Use flow when you want to create a named, reusable transformation. Use pipe when you want to immediately transform a value.

Type Parameters

A

A extends readonly unknown[]

B

B

C

C

D

D

E

E

F

F

G

G

Parameters

ab

(…a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

ef

(e) => F

fg

(f) => G

Returns

(…a): G

Parameters

a

…A

Returns

G

Example

// Create a reusable transformation
const processUser = flow(
  (user: User) => user.name,
  name => name.toUpperCase(),
  name => `Hello, ${name}!`
);

processUser({ name: "Alice" }); // "Hello, ALICE!"
processUser({ name: "Bob" }); // "Hello, BOB!"

// Compare with pipe (one-time use):
pipe(
  user,
  u => u.name,
  name => name.toUpperCase()
);

// flow creates a function, pipe applies immediately:
const double = flow((n: number) => n * 2);
double(5); // 10

pipe(5, n => n * 2); // 10 (immediate result)

See

pipe for immediate value transformation

Call Signature

flow<A, B, C, D, E, F, G, H>(ab, bc, cd, de, ef, fg, gh): (…a) => H

Defined in: Composition/flow.ts:70

Composes functions from left to right, returning a new function. Unlike pipe, flow doesn’t take an initial value - it creates a reusable pipeline that can be called later with arguments.

Use flow when you want to create a named, reusable transformation. Use pipe when you want to immediately transform a value.

Type Parameters

A

A extends readonly unknown[]

B

B

C

C

D

D

E

E

F

F

G

G

H

H

Parameters

ab

(…a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

ef

(e) => F

fg

(f) => G

gh

(g) => H

Returns

(…a): H

Parameters

a

…A

Returns

H

Example

// Create a reusable transformation
const processUser = flow(
  (user: User) => user.name,
  name => name.toUpperCase(),
  name => `Hello, ${name}!`
);

processUser({ name: "Alice" }); // "Hello, ALICE!"
processUser({ name: "Bob" }); // "Hello, BOB!"

// Compare with pipe (one-time use):
pipe(
  user,
  u => u.name,
  name => name.toUpperCase()
);

// flow creates a function, pipe applies immediately:
const double = flow((n: number) => n * 2);
double(5); // 10

pipe(5, n => n * 2); // 10 (immediate result)

See

pipe for immediate value transformation

Call Signature

flow<A, B, C, D, E, F, G, H, I>(ab, bc, cd, de, ef, fg, gh, hi): (…a) => I

Defined in: Composition/flow.ts:79

Composes functions from left to right, returning a new function. Unlike pipe, flow doesn’t take an initial value - it creates a reusable pipeline that can be called later with arguments.

Use flow when you want to create a named, reusable transformation. Use pipe when you want to immediately transform a value.

Type Parameters

A

A extends readonly unknown[]

B

B

C

C

D

D

E

E

F

F

G

G

H

H

I

I

Parameters

ab

(…a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

ef

(e) => F

fg

(f) => G

gh

(g) => H

hi

(h) => I

Returns

(…a): I

Parameters

a

…A

Returns

I

Example

// Create a reusable transformation
const processUser = flow(
  (user: User) => user.name,
  name => name.toUpperCase(),
  name => `Hello, ${name}!`
);

processUser({ name: "Alice" }); // "Hello, ALICE!"
processUser({ name: "Bob" }); // "Hello, BOB!"

// Compare with pipe (one-time use):
pipe(
  user,
  u => u.name,
  name => name.toUpperCase()
);

// flow creates a function, pipe applies immediately:
const double = flow((n: number) => n * 2);
double(5); // 10

pipe(5, n => n * 2); // 10 (immediate result)

See

pipe for immediate value transformation

Call Signature

flow<A, B, C, D, E, F, G, H, I, J>(ab, bc, cd, de, ef, fg, gh, hi, ij): (…a) => J

Defined in: Composition/flow.ts:89

Composes functions from left to right, returning a new function. Unlike pipe, flow doesn’t take an initial value - it creates a reusable pipeline that can be called later with arguments.

Use flow when you want to create a named, reusable transformation. Use pipe when you want to immediately transform a value.

Type Parameters

A

A extends readonly unknown[]

B

B

C

C

D

D

E

E

F

F

G

G

H

H

I

I

J

J

Parameters

ab

(…a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

ef

(e) => F

fg

(f) => G

gh

(g) => H

hi

(h) => I

ij

(i) => J

Returns

(…a): J

Parameters

a

…A

Returns

J

Example

// Create a reusable transformation
const processUser = flow(
  (user: User) => user.name,
  name => name.toUpperCase(),
  name => `Hello, ${name}!`
);

processUser({ name: "Alice" }); // "Hello, ALICE!"
processUser({ name: "Bob" }); // "Hello, BOB!"

// Compare with pipe (one-time use):
pipe(
  user,
  u => u.name,
  name => name.toUpperCase()
);

// flow creates a function, pipe applies immediately:
const double = flow((n: number) => n * 2);
double(5); // 10

pipe(5, n => n * 2); // 10 (immediate result)

See

pipe for immediate value transformation

Call Signature

flow<A, B, C, D, E, F, G, H, I, J, K>(ab, bc, cd, de, ef, fg, gh, hi, ij, jk): (…a) => K

Defined in: Composition/flow.ts:111

Composes functions from left to right, returning a new function. Unlike pipe, flow doesn’t take an initial value - it creates a reusable pipeline that can be called later with arguments.

Use flow when you want to create a named, reusable transformation. Use pipe when you want to immediately transform a value.

Type Parameters

A

A extends readonly unknown[]

B

B

C

C

D

D

E

E

F

F

G

G

H

H

I

I

J

J

K

K

Parameters

ab

(…a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

ef

(e) => F

fg

(f) => G

gh

(g) => H

hi

(h) => I

ij

(i) => J

jk

(j) => K

Returns

(…a): K

Parameters

a

…A

Returns

K

Example

// Create a reusable transformation
const processUser = flow(
  (user: User) => user.name,
  name => name.toUpperCase(),
  name => `Hello, ${name}!`
);

processUser({ name: "Alice" }); // "Hello, ALICE!"
processUser({ name: "Bob" }); // "Hello, BOB!"

// Compare with pipe (one-time use):
pipe(
  user,
  u => u.name,
  name => name.toUpperCase()
);

// flow creates a function, pipe applies immediately:
const double = flow((n: number) => n * 2);
double(5); // 10

pipe(5, n => n * 2); // 10 (immediate result)

See

pipe for immediate value transformation

Call Signature

flow<A, B, C, D, E, F, G, H, I, J, K, L>(ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl): (…a) => L

Defined in: Composition/flow.ts:135

Composes functions from left to right, returning a new function. Unlike pipe, flow doesn’t take an initial value - it creates a reusable pipeline that can be called later with arguments.

Use flow when you want to create a named, reusable transformation. Use pipe when you want to immediately transform a value.

Type Parameters

A

A extends readonly unknown[]

B

B

C

C

D

D

E

E

F

F

G

G

H

H

I

I

J

J

K

K

L

L

Parameters

ab

(…a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

ef

(e) => F

fg

(f) => G

gh

(g) => H

hi

(h) => I

ij

(i) => J

jk

(j) => K

kl

(k) => L

Returns

(…a): L

Parameters

a

…A

Returns

L

Example

// Create a reusable transformation
const processUser = flow(
  (user: User) => user.name,
  name => name.toUpperCase(),
  name => `Hello, ${name}!`
);

processUser({ name: "Alice" }); // "Hello, ALICE!"
processUser({ name: "Bob" }); // "Hello, BOB!"

// Compare with pipe (one-time use):
pipe(
  user,
  u => u.name,
  name => name.toUpperCase()
);

// flow creates a function, pipe applies immediately:
const double = flow((n: number) => n * 2);
double(5); // 10

pipe(5, n => n * 2); // 10 (immediate result)

See

pipe for immediate value transformation

Call Signature

flow<A, B, C, D, E, F, G, H, I, J, K, L, M>(ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm): (…a) => M

Defined in: Composition/flow.ts:161

Composes functions from left to right, returning a new function. Unlike pipe, flow doesn’t take an initial value - it creates a reusable pipeline that can be called later with arguments.

Use flow when you want to create a named, reusable transformation. Use pipe when you want to immediately transform a value.

Type Parameters

A

A extends readonly unknown[]

B

B

C

C

D

D

E

E

F

F

G

G

H

H

I

I

J

J

K

K

L

L

M

M

Parameters

ab

(…a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

ef

(e) => F

fg

(f) => G

gh

(g) => H

hi

(h) => I

ij

(i) => J

jk

(j) => K

kl

(k) => L

lm

(l) => M

Returns

(…a): M

Parameters

a

…A

Returns

M

Example

// Create a reusable transformation
const processUser = flow(
  (user: User) => user.name,
  name => name.toUpperCase(),
  name => `Hello, ${name}!`
);

processUser({ name: "Alice" }); // "Hello, ALICE!"
processUser({ name: "Bob" }); // "Hello, BOB!"

// Compare with pipe (one-time use):
pipe(
  user,
  u => u.name,
  name => name.toUpperCase()
);

// flow creates a function, pipe applies immediately:
const double = flow((n: number) => n * 2);
double(5); // 10

pipe(5, n => n * 2); // 10 (immediate result)

See

pipe for immediate value transformation

Call Signature

flow<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn): (…a) => N

Defined in: Composition/flow.ts:189

Composes functions from left to right, returning a new function. Unlike pipe, flow doesn’t take an initial value - it creates a reusable pipeline that can be called later with arguments.

Use flow when you want to create a named, reusable transformation. Use pipe when you want to immediately transform a value.

Type Parameters

A

A extends readonly unknown[]

B

B

C

C

D

D

E

E

F

F

G

G

H

H

I

I

J

J

K

K

L

L

M

M

N

N

Parameters

ab

(…a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

ef

(e) => F

fg

(f) => G

gh

(g) => H

hi

(h) => I

ij

(i) => J

jk

(j) => K

kl

(k) => L

lm

(l) => M

mn

(m) => N

Returns

(…a): N

Parameters

a

…A

Returns

N

Example

// Create a reusable transformation
const processUser = flow(
  (user: User) => user.name,
  name => name.toUpperCase(),
  name => `Hello, ${name}!`
);

processUser({ name: "Alice" }); // "Hello, ALICE!"
processUser({ name: "Bob" }); // "Hello, BOB!"

// Compare with pipe (one-time use):
pipe(
  user,
  u => u.name,
  name => name.toUpperCase()
);

// flow creates a function, pipe applies immediately:
const double = flow((n: number) => n * 2);
double(5); // 10

pipe(5, n => n * 2); // 10 (immediate result)

See

pipe for immediate value transformation

Call Signature

flow<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no): (…a) => O

Defined in: Composition/flow.ts:219

Composes functions from left to right, returning a new function. Unlike pipe, flow doesn’t take an initial value - it creates a reusable pipeline that can be called later with arguments.

Use flow when you want to create a named, reusable transformation. Use pipe when you want to immediately transform a value.

Type Parameters

A

A extends readonly unknown[]

B

B

C

C

D

D

E

E

F

F

G

G

H

H

I

I

J

J

K

K

L

L

M

M

N

N

O

O

Parameters

ab

(…a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

ef

(e) => F

fg

(f) => G

gh

(g) => H

hi

(h) => I

ij

(i) => J

jk

(j) => K

kl

(k) => L

lm

(l) => M

mn

(m) => N

no

(n) => O

Returns

(…a): O

Parameters

a

…A

Returns

O

Example

// Create a reusable transformation
const processUser = flow(
  (user: User) => user.name,
  name => name.toUpperCase(),
  name => `Hello, ${name}!`
);

processUser({ name: "Alice" }); // "Hello, ALICE!"
processUser({ name: "Bob" }); // "Hello, BOB!"

// Compare with pipe (one-time use):
pipe(
  user,
  u => u.name,
  name => name.toUpperCase()
);

// flow creates a function, pipe applies immediately:
const double = flow((n: number) => n * 2);
double(5); // 10

pipe(5, n => n * 2); // 10 (immediate result)

See

pipe for immediate value transformation

Call Signature

flow<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op): (…a) => P

Defined in: Composition/flow.ts:251

Composes functions from left to right, returning a new function. Unlike pipe, flow doesn’t take an initial value - it creates a reusable pipeline that can be called later with arguments.

Use flow when you want to create a named, reusable transformation. Use pipe when you want to immediately transform a value.

Type Parameters

A

A extends readonly unknown[]

B

B

C

C

D

D

E

E

F

F

G

G

H

H

I

I

J

J

K

K

L

L

M

M

N

N

O

O

P

P

Parameters

ab

(…a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

ef

(e) => F

fg

(f) => G

gh

(g) => H

hi

(h) => I

ij

(i) => J

jk

(j) => K

kl

(k) => L

lm

(l) => M

mn

(m) => N

no

(n) => O

op

(o) => P

Returns

(…a): P

Parameters

a

…A

Returns

P

Example

// Create a reusable transformation
const processUser = flow(
  (user: User) => user.name,
  name => name.toUpperCase(),
  name => `Hello, ${name}!`
);

processUser({ name: "Alice" }); // "Hello, ALICE!"
processUser({ name: "Bob" }); // "Hello, BOB!"

// Compare with pipe (one-time use):
pipe(
  user,
  u => u.name,
  name => name.toUpperCase()
);

// flow creates a function, pipe applies immediately:
const double = flow((n: number) => n * 2);
double(5); // 10

pipe(5, n => n * 2); // 10 (immediate result)

See

pipe for immediate value transformation

Call Signature

flow<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq): (…a) => Q

Defined in: Composition/flow.ts:285

Composes functions from left to right, returning a new function. Unlike pipe, flow doesn’t take an initial value - it creates a reusable pipeline that can be called later with arguments.

Use flow when you want to create a named, reusable transformation. Use pipe when you want to immediately transform a value.

Type Parameters

A

A extends readonly unknown[]

B

B

C

C

D

D

E

E

F

F

G

G

H

H

I

I

J

J

K

K

L

L

M

M

N

N

O

O

P

P

Q

Q

Parameters

ab

(…a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

ef

(e) => F

fg

(f) => G

gh

(g) => H

hi

(h) => I

ij

(i) => J

jk

(j) => K

kl

(k) => L

lm

(l) => M

mn

(m) => N

no

(n) => O

op

(o) => P

pq

(p) => Q

Returns

(…a): Q

Parameters

a

…A

Returns

Q

Example

// Create a reusable transformation
const processUser = flow(
  (user: User) => user.name,
  name => name.toUpperCase(),
  name => `Hello, ${name}!`
);

processUser({ name: "Alice" }); // "Hello, ALICE!"
processUser({ name: "Bob" }); // "Hello, BOB!"

// Compare with pipe (one-time use):
pipe(
  user,
  u => u.name,
  name => name.toUpperCase()
);

// flow creates a function, pipe applies immediately:
const double = flow((n: number) => n * 2);
double(5); // 10

pipe(5, n => n * 2); // 10 (immediate result)

See

pipe for immediate value transformation

Call Signature

flow<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr): (…a) => R

Defined in: Composition/flow.ts:321

Composes functions from left to right, returning a new function. Unlike pipe, flow doesn’t take an initial value - it creates a reusable pipeline that can be called later with arguments.

Use flow when you want to create a named, reusable transformation. Use pipe when you want to immediately transform a value.

Type Parameters

A

A extends readonly unknown[]

B

B

C

C

D

D

E

E

F

F

G

G

H

H

I

I

J

J

K

K

L

L

M

M

N

N

O

O

P

P

Q

Q

R

R

Parameters

ab

(…a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

ef

(e) => F

fg

(f) => G

gh

(g) => H

hi

(h) => I

ij

(i) => J

jk

(j) => K

kl

(k) => L

lm

(l) => M

mn

(m) => N

no

(n) => O

op

(o) => P

pq

(p) => Q

qr

(q) => R

Returns

(…a): R

Parameters

a

…A

Returns

R

Example

// Create a reusable transformation
const processUser = flow(
  (user: User) => user.name,
  name => name.toUpperCase(),
  name => `Hello, ${name}!`
);

processUser({ name: "Alice" }); // "Hello, ALICE!"
processUser({ name: "Bob" }); // "Hello, BOB!"

// Compare with pipe (one-time use):
pipe(
  user,
  u => u.name,
  name => name.toUpperCase()
);

// flow creates a function, pipe applies immediately:
const double = flow((n: number) => n * 2);
double(5); // 10

pipe(5, n => n * 2); // 10 (immediate result)

See

pipe for immediate value transformation

Call Signature

flow<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs): (…a) => S

Defined in: Composition/flow.ts:359

Composes functions from left to right, returning a new function. Unlike pipe, flow doesn’t take an initial value - it creates a reusable pipeline that can be called later with arguments.

Use flow when you want to create a named, reusable transformation. Use pipe when you want to immediately transform a value.

Type Parameters

A

A extends readonly unknown[]

B

B

C

C

D

D

E

E

F

F

G

G

H

H

I

I

J

J

K

K

L

L

M

M

N

N

O

O

P

P

Q

Q

R

R

S

S

Parameters

ab

(…a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

ef

(e) => F

fg

(f) => G

gh

(g) => H

hi

(h) => I

ij

(i) => J

jk

(j) => K

kl

(k) => L

lm

(l) => M

mn

(m) => N

no

(n) => O

op

(o) => P

pq

(p) => Q

qr

(q) => R

rs

(r) => S

Returns

(…a): S

Parameters

a

…A

Returns

S

Example

// Create a reusable transformation
const processUser = flow(
  (user: User) => user.name,
  name => name.toUpperCase(),
  name => `Hello, ${name}!`
);

processUser({ name: "Alice" }); // "Hello, ALICE!"
processUser({ name: "Bob" }); // "Hello, BOB!"

// Compare with pipe (one-time use):
pipe(
  user,
  u => u.name,
  name => name.toUpperCase()
);

// flow creates a function, pipe applies immediately:
const double = flow((n: number) => n * 2);
double(5); // 10

pipe(5, n => n * 2); // 10 (immediate result)

See

pipe for immediate value transformation

Call Signature

flow<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st): (…a) => T

Defined in: Composition/flow.ts:399

Composes functions from left to right, returning a new function. Unlike pipe, flow doesn’t take an initial value - it creates a reusable pipeline that can be called later with arguments.

Use flow when you want to create a named, reusable transformation. Use pipe when you want to immediately transform a value.

Type Parameters

A

A extends readonly unknown[]

B

B

C

C

D

D

E

E

F

F

G

G

H

H

I

I

J

J

K

K

L

L

M

M

N

N

O

O

P

P

Q

Q

R

R

S

S

T

T

Parameters

ab

(…a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

ef

(e) => F

fg

(f) => G

gh

(g) => H

hi

(h) => I

ij

(i) => J

jk

(j) => K

kl

(k) => L

lm

(l) => M

mn

(m) => N

no

(n) => O

op

(o) => P

pq

(p) => Q

qr

(q) => R

rs

(r) => S

st

(s) => T

Returns

(…a): T

Parameters

a

…A

Returns

T

Example

// Create a reusable transformation
const processUser = flow(
  (user: User) => user.name,
  name => name.toUpperCase(),
  name => `Hello, ${name}!`
);

processUser({ name: "Alice" }); // "Hello, ALICE!"
processUser({ name: "Bob" }); // "Hello, BOB!"

// Compare with pipe (one-time use):
pipe(
  user,
  u => u.name,
  name => name.toUpperCase()
);

// flow creates a function, pipe applies immediately:
const double = flow((n: number) => n * 2);
double(5); // 10

pipe(5, n => n * 2); // 10 (immediate result)

See

pipe for immediate value transformation