pipe

Call Signature

pipe<A>(a): A

Defined in: Composition/pipe.ts:36

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.

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(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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:37

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.

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(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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:38

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.

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(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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: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.

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(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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:45

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.

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(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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:52

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.

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(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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:60

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.

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(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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:69

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.

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(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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:79

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.

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(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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:90

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.

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(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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:102

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.

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(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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, L>(a, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl): L

Defined in: Composition/pipe.ts:115

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.

Type Parameters

A

A

B

B

C

C

D

D

E

E

F

F

G

G

H

H

I

I

J

J

K

K

L

L

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

kl

(k) => L

Returns

L

Example

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

// With library functions
const greeting = pipe(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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, L, M>(a, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm): M

Defined in: Composition/pipe.ts:129

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.

Type Parameters

A

A

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

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

kl

(k) => L

lm

(l) => M

Returns

M

Example

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

// With library functions
const greeting = pipe(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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, L, M, N>(a, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn): N

Defined in: Composition/pipe.ts:144

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.

Type Parameters

A

A

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

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

kl

(k) => L

lm

(l) => M

mn

(m) => N

Returns

N

Example

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

// With library functions
const greeting = pipe(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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, L, M, N, O>(a, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no): O

Defined in: Composition/pipe.ts:160

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.

Type Parameters

A

A

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

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

kl

(k) => L

lm

(l) => M

mn

(m) => N

no

(n) => O

Returns

O

Example

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

// With library functions
const greeting = pipe(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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, L, M, N, O, P>(a, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op): P

Defined in: Composition/pipe.ts:177

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.

Type Parameters

A

A

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

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

kl

(k) => L

lm

(l) => M

mn

(m) => N

no

(n) => O

op

(o) => P

Returns

P

Example

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

// With library functions
const greeting = pipe(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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, L, M, N, O, P, Q>(a, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq): Q

Defined in: Composition/pipe.ts:195

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.

Type Parameters

A

A

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

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

kl

(k) => L

lm

(l) => M

mn

(m) => N

no

(n) => O

op

(o) => P

pq

(p) => Q

Returns

Q

Example

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

// With library functions
const greeting = pipe(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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, L, M, N, O, P, Q, R>(a, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr): R

Defined in: Composition/pipe.ts:214

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.

Type Parameters

A

A

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

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

kl

(k) => L

lm

(l) => M

mn

(m) => N

no

(n) => O

op

(o) => P

pq

(p) => Q

qr

(q) => R

Returns

R

Example

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

// With library functions
const greeting = pipe(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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, L, M, N, O, P, Q, R, S>(a, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs): S

Defined in: Composition/pipe.ts:234

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.

Type Parameters

A

A

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

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

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

S

Example

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

// With library functions
const greeting = pipe(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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, L, M, N, O, P, Q, R, S, T>(a, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st): T

Defined in: Composition/pipe.ts:255

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.

Type Parameters

A

A

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

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

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

T

Example

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

// With library functions
const greeting = pipe(
  Option.of("Alice"),
  Option.map(name => name.toUpperCase()),
  Option.map(name => `Hello, ${name}!`),
  Option.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