pipe

Call Signature

pipe<A>(a): A

Defined in: Composition/pipe.ts:39

Pipes a value through a series of functions from left to right. Each function receives the output of the previous function.

pipe is the primary way to compose operations in this library. It makes code read top-to-bottom, left-to-right, which is more intuitive for developers coming from imperative backgrounds.

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

Parameters

a

A

Returns

A

Example

// Basic usage
const result = pipe(
  5,
  n => n * 2,
  n => n + 1
); // 11

// With library functions
const greeting = pipe(
  Maybe.some("Alice"),
  Maybe.map(name => name.toUpperCase()),
  Maybe.map(name => `Hello, ${name}!`),
  Maybe.getOrElse("Hello!")
); // "Hello, ALICE!"

// Error handling with Result
const result = pipe(
  Result.tryCatch(() => JSON.parse(input), e => "Invalid JSON"),
  Result.map(data => data.value),
  Result.getOrElse(null)
);

See

flow for creating reusable pipelines without an initial value

Call Signature

pipe<A, B>(a, ab): B

Defined in: Composition/pipe.ts:40

Pipes a value through a series of functions from left to right. Each function receives the output of the previous function.

pipe is the primary way to compose operations in this library. It makes code read top-to-bottom, left-to-right, which is more intuitive for developers coming from imperative backgrounds.

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

B

B

Parameters

a

A

ab

(a) => B

Returns

B

Example

// Basic usage
const result = pipe(
  5,
  n => n * 2,
  n => n + 1
); // 11

// With library functions
const greeting = pipe(
  Maybe.some("Alice"),
  Maybe.map(name => name.toUpperCase()),
  Maybe.map(name => `Hello, ${name}!`),
  Maybe.getOrElse("Hello!")
); // "Hello, ALICE!"

// Error handling with Result
const result = pipe(
  Result.tryCatch(() => JSON.parse(input), e => "Invalid JSON"),
  Result.map(data => data.value),
  Result.getOrElse(null)
);

See

flow for creating reusable pipelines without an initial value

Call Signature

pipe<A, B, C>(a, ab, bc): C

Defined in: Composition/pipe.ts:41

Pipes a value through a series of functions from left to right. Each function receives the output of the previous function.

pipe is the primary way to compose operations in this library. It makes code read top-to-bottom, left-to-right, which is more intuitive for developers coming from imperative backgrounds.

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

B

B

C

C

Parameters

a

A

ab

(a) => B

bc

(b) => C

Returns

C

Example

// Basic usage
const result = pipe(
  5,
  n => n * 2,
  n => n + 1
); // 11

// With library functions
const greeting = pipe(
  Maybe.some("Alice"),
  Maybe.map(name => name.toUpperCase()),
  Maybe.map(name => `Hello, ${name}!`),
  Maybe.getOrElse("Hello!")
); // "Hello, ALICE!"

// Error handling with Result
const result = pipe(
  Result.tryCatch(() => JSON.parse(input), e => "Invalid JSON"),
  Result.map(data => data.value),
  Result.getOrElse(null)
);

See

flow for creating reusable pipelines without an initial value

Call Signature

pipe<A, B, C, D>(a, ab, bc, cd): D

Defined in: Composition/pipe.ts:42

Pipes a value through a series of functions from left to right. Each function receives the output of the previous function.

pipe is the primary way to compose operations in this library. It makes code read top-to-bottom, left-to-right, which is more intuitive for developers coming from imperative backgrounds.

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

B

B

C

C

D

D

Parameters

a

A

ab

(a) => B

bc

(b) => C

cd

(c) => D

Returns

D

Example

// Basic usage
const result = pipe(
  5,
  n => n * 2,
  n => n + 1
); // 11

// With library functions
const greeting = pipe(
  Maybe.some("Alice"),
  Maybe.map(name => name.toUpperCase()),
  Maybe.map(name => `Hello, ${name}!`),
  Maybe.getOrElse("Hello!")
); // "Hello, ALICE!"

// Error handling with Result
const result = pipe(
  Result.tryCatch(() => JSON.parse(input), e => "Invalid JSON"),
  Result.map(data => data.value),
  Result.getOrElse(null)
);

See

flow for creating reusable pipelines without an initial value

Call Signature

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

Defined in: Composition/pipe.ts:48

Pipes a value through a series of functions from left to right. Each function receives the output of the previous function.

pipe is the primary way to compose operations in this library. It makes code read top-to-bottom, left-to-right, which is more intuitive for developers coming from imperative backgrounds.

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

B

B

C

C

D

D

E

E

Parameters

a

A

ab

(a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

Returns

E

Example

// Basic usage
const result = pipe(
  5,
  n => n * 2,
  n => n + 1
); // 11

// With library functions
const greeting = pipe(
  Maybe.some("Alice"),
  Maybe.map(name => name.toUpperCase()),
  Maybe.map(name => `Hello, ${name}!`),
  Maybe.getOrElse("Hello!")
); // "Hello, ALICE!"

// Error handling with Result
const result = pipe(
  Result.tryCatch(() => JSON.parse(input), e => "Invalid JSON"),
  Result.map(data => data.value),
  Result.getOrElse(null)
);

See

flow for creating reusable pipelines without an initial value

Call Signature

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

Defined in: Composition/pipe.ts:55

Pipes a value through a series of functions from left to right. Each function receives the output of the previous function.

pipe is the primary way to compose operations in this library. It makes code read top-to-bottom, left-to-right, which is more intuitive for developers coming from imperative backgrounds.

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

B

B

C

C

D

D

E

E

F

F

Parameters

a

A

ab

(a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

ef

(e) => F

Returns

F

Example

// Basic usage
const result = pipe(
  5,
  n => n * 2,
  n => n + 1
); // 11

// With library functions
const greeting = pipe(
  Maybe.some("Alice"),
  Maybe.map(name => name.toUpperCase()),
  Maybe.map(name => `Hello, ${name}!`),
  Maybe.getOrElse("Hello!")
); // "Hello, ALICE!"

// Error handling with Result
const result = pipe(
  Result.tryCatch(() => JSON.parse(input), e => "Invalid JSON"),
  Result.map(data => data.value),
  Result.getOrElse(null)
);

See

flow for creating reusable pipelines without an initial value

Call Signature

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

Defined in: Composition/pipe.ts:63

Pipes a value through a series of functions from left to right. Each function receives the output of the previous function.

pipe is the primary way to compose operations in this library. It makes code read top-to-bottom, left-to-right, which is more intuitive for developers coming from imperative backgrounds.

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

B

B

C

C

D

D

E

E

F

F

G

G

Parameters

a

A

ab

(a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

ef

(e) => F

fg

(f) => G

Returns

G

Example

// Basic usage
const result = pipe(
  5,
  n => n * 2,
  n => n + 1
); // 11

// With library functions
const greeting = pipe(
  Maybe.some("Alice"),
  Maybe.map(name => name.toUpperCase()),
  Maybe.map(name => `Hello, ${name}!`),
  Maybe.getOrElse("Hello!")
); // "Hello, ALICE!"

// Error handling with Result
const result = pipe(
  Result.tryCatch(() => JSON.parse(input), e => "Invalid JSON"),
  Result.map(data => data.value),
  Result.getOrElse(null)
);

See

flow for creating reusable pipelines without an initial value

Call Signature

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

Defined in: Composition/pipe.ts:72

Pipes a value through a series of functions from left to right. Each function receives the output of the previous function.

pipe is the primary way to compose operations in this library. It makes code read top-to-bottom, left-to-right, which is more intuitive for developers coming from imperative backgrounds.

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

B

B

C

C

D

D

E

E

F

F

G

G

H

H

Parameters

a

A

ab

(a) => B

bc

(b) => C

cd

(c) => D

de

(d) => E

ef

(e) => F

fg

(f) => G

gh

(g) => H

Returns

H

Example

// Basic usage
const result = pipe(
  5,
  n => n * 2,
  n => n + 1
); // 11

// With library functions
const greeting = pipe(
  Maybe.some("Alice"),
  Maybe.map(name => name.toUpperCase()),
  Maybe.map(name => `Hello, ${name}!`),
  Maybe.getOrElse("Hello!")
); // "Hello, ALICE!"

// Error handling with Result
const result = pipe(
  Result.tryCatch(() => JSON.parse(input), e => "Invalid JSON"),
  Result.map(data => data.value),
  Result.getOrElse(null)
);

See

flow for creating reusable pipelines without an initial value

Call Signature

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

Defined in: Composition/pipe.ts:82

Pipes a value through a series of functions from left to right. Each function receives the output of the previous function.

pipe is the primary way to compose operations in this library. It makes code read top-to-bottom, left-to-right, which is more intuitive for developers coming from imperative backgrounds.

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

B

B

C

C

D

D

E

E

F

F

G

G

H

H

I

I

Parameters

a

A

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

I

Example

// Basic usage
const result = pipe(
  5,
  n => n * 2,
  n => n + 1
); // 11

// With library functions
const greeting = pipe(
  Maybe.some("Alice"),
  Maybe.map(name => name.toUpperCase()),
  Maybe.map(name => `Hello, ${name}!`),
  Maybe.getOrElse("Hello!")
); // "Hello, ALICE!"

// Error handling with Result
const result = pipe(
  Result.tryCatch(() => JSON.parse(input), e => "Invalid JSON"),
  Result.map(data => data.value),
  Result.getOrElse(null)
);

See

flow for creating reusable pipelines without an initial value

Call Signature

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

Defined in: Composition/pipe.ts:93

Pipes a value through a series of functions from left to right. Each function receives the output of the previous function.

pipe is the primary way to compose operations in this library. It makes code read top-to-bottom, left-to-right, which is more intuitive for developers coming from imperative backgrounds.

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

B

B

C

C

D

D

E

E

F

F

G

G

H

H

I

I

J

J

Parameters

a

A

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

J

Example

// Basic usage
const result = pipe(
  5,
  n => n * 2,
  n => n + 1
); // 11

// With library functions
const greeting = pipe(
  Maybe.some("Alice"),
  Maybe.map(name => name.toUpperCase()),
  Maybe.map(name => `Hello, ${name}!`),
  Maybe.getOrElse("Hello!")
); // "Hello, ALICE!"

// Error handling with Result
const result = pipe(
  Result.tryCatch(() => JSON.parse(input), e => "Invalid JSON"),
  Result.map(data => data.value),
  Result.getOrElse(null)
);

See

flow for creating reusable pipelines without an initial value

Call Signature

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

Defined in: Composition/pipe.ts:105

Pipes a value through a series of functions from left to right. Each function receives the output of the previous function.

pipe is the primary way to compose operations in this library. It makes code read top-to-bottom, left-to-right, which is more intuitive for developers coming from imperative backgrounds.

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

B

B

C

C

D

D

E

E

F

F

G

G

H

H

I

I

J

J

K

K

Parameters

a

A

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

K

Example

// Basic usage
const result = pipe(
  5,
  n => n * 2,
  n => n + 1
); // 11

// With library functions
const greeting = pipe(
  Maybe.some("Alice"),
  Maybe.map(name => name.toUpperCase()),
  Maybe.map(name => `Hello, ${name}!`),
  Maybe.getOrElse("Hello!")
); // "Hello, ALICE!"

// Error handling with Result
const result = pipe(
  Result.tryCatch(() => JSON.parse(input), e => "Invalid JSON"),
  Result.map(data => data.value),
  Result.getOrElse(null)
);

See

flow for creating reusable pipelines without an initial value