flow

Call Signature

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

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.

Fully typed for up to 10 steps. Beyond that TypeScript raises a compile error — split into named intermediate functions or use a cast.

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:43

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.

Fully typed for up to 10 steps. Beyond that TypeScript raises a compile error — split into named intermediate functions or use a cast.

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:47

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.

Fully typed for up to 10 steps. Beyond that TypeScript raises a compile error — split into named intermediate functions or use a cast.

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:52

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.

Fully typed for up to 10 steps. Beyond that TypeScript raises a compile error — split into named intermediate functions or use a cast.

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:58

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.

Fully typed for up to 10 steps. Beyond that TypeScript raises a compile error — split into named intermediate functions or use a cast.

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:65

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.

Fully typed for up to 10 steps. Beyond that TypeScript raises a compile error — split into named intermediate functions or use a cast.

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:73

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.

Fully typed for up to 10 steps. Beyond that TypeScript raises a compile error — split into named intermediate functions or use a cast.

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:82

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.

Fully typed for up to 10 steps. Beyond that TypeScript raises a compile error — split into named intermediate functions or use a cast.

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:92

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.

Fully typed for up to 10 steps. Beyond that TypeScript raises a compile error — split into named intermediate functions or use a cast.

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:114

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.

Fully typed for up to 10 steps. Beyond that TypeScript raises a compile error — split into named intermediate functions or use a cast.

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