compose

Call Signature

compose<A, B>(ab): (a) => B

Composes functions from right to left, returning a new function. This is the traditional mathematical function composition: (f . g)(x) = f(g(x))

Unlike flow which reads left-to-right, compose reads right-to-left, matching how nested function calls would be written.

Type Parameters

A

A

B

B

Parameters

ab

(a) => B

Returns

(a): B

Parameters

a

A

Returns

B

Example

const addOne = (n: number) => n + 1;
const double = (n: number) => n * 2;

// compose: right-to-left (double first, then addOne)
const composed = compose(addOne, double);
composed(5); // 11 (5 * 2 + 1)

// flow: left-to-right (addOne first, then double)
const flowed = flow(addOne, double);
flowed(5); // 12 ((5 + 1) * 2)

See

flow for left-to-right composition

Call Signature

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

Defined in: Composition/compose.ts:25

Composes functions from right to left, returning a new function. This is the traditional mathematical function composition: (f . g)(x) = f(g(x))

Unlike flow which reads left-to-right, compose reads right-to-left, matching how nested function calls would be written.

Type Parameters

A

A

B

B

C

C

Parameters

bc

(b) => C

ab

(a) => B

Returns

(a): C

Parameters

a

A

Returns

C

Example

const addOne = (n: number) => n + 1;
const double = (n: number) => n * 2;

// compose: right-to-left (double first, then addOne)
const composed = compose(addOne, double);
composed(5); // 11 (5 * 2 + 1)

// flow: left-to-right (addOne first, then double)
const flowed = flow(addOne, double);
flowed(5); // 12 ((5 + 1) * 2)

See

flow for left-to-right composition

Call Signature

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

Defined in: Composition/compose.ts:26

Composes functions from right to left, returning a new function. This is the traditional mathematical function composition: (f . g)(x) = f(g(x))

Unlike flow which reads left-to-right, compose reads right-to-left, matching how nested function calls would be written.

Type Parameters

A

A

B

B

C

C

D

D

Parameters

cd

(c) => D

bc

(b) => C

ab

(a) => B

Returns

(a): D

Parameters

a

A

Returns

D

Example

const addOne = (n: number) => n + 1;
const double = (n: number) => n * 2;

// compose: right-to-left (double first, then addOne)
const composed = compose(addOne, double);
composed(5); // 11 (5 * 2 + 1)

// flow: left-to-right (addOne first, then double)
const flowed = flow(addOne, double);
flowed(5); // 12 ((5 + 1) * 2)

See

flow for left-to-right composition

Call Signature

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

Defined in: Composition/compose.ts:31

Composes functions from right to left, returning a new function. This is the traditional mathematical function composition: (f . g)(x) = f(g(x))

Unlike flow which reads left-to-right, compose reads right-to-left, matching how nested function calls would be written.

Type Parameters

A

A

B

B

C

C

D

D

E

E

Parameters

de

(d) => E

cd

(c) => D

bc

(b) => C

ab

(a) => B

Returns

(a): E

Parameters

a

A

Returns

E

Example

const addOne = (n: number) => n + 1;
const double = (n: number) => n * 2;

// compose: right-to-left (double first, then addOne)
const composed = compose(addOne, double);
composed(5); // 11 (5 * 2 + 1)

// flow: left-to-right (addOne first, then double)
const flowed = flow(addOne, double);
flowed(5); // 12 ((5 + 1) * 2)

See

flow for left-to-right composition

Call Signature

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

Defined in: Composition/compose.ts:37

Composes functions from right to left, returning a new function. This is the traditional mathematical function composition: (f . g)(x) = f(g(x))

Unlike flow which reads left-to-right, compose reads right-to-left, matching how nested function calls would be written.

Type Parameters

A

A

B

B

C

C

D

D

E

E

F

F

Parameters

ef

(e) => F

de

(d) => E

cd

(c) => D

bc

(b) => C

ab

(a) => B

Returns

(a): F

Parameters

a

A

Returns

F

Example

const addOne = (n: number) => n + 1;
const double = (n: number) => n * 2;

// compose: right-to-left (double first, then addOne)
const composed = compose(addOne, double);
composed(5); // 11 (5 * 2 + 1)

// flow: left-to-right (addOne first, then double)
const flowed = flow(addOne, double);
flowed(5); // 12 ((5 + 1) * 2)

See

flow for left-to-right composition

Call Signature

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

Defined in: Composition/compose.ts:44

Composes functions from right to left, returning a new function. This is the traditional mathematical function composition: (f . g)(x) = f(g(x))

Unlike flow which reads left-to-right, compose reads right-to-left, matching how nested function calls would be written.

Type Parameters

A

A

B

B

C

C

D

D

E

E

F

F

G

G

Parameters

fg

(f) => G

ef

(e) => F

de

(d) => E

cd

(c) => D

bc

(b) => C

ab

(a) => B

Returns

(a): G

Parameters

a

A

Returns

G

Example

const addOne = (n: number) => n + 1;
const double = (n: number) => n * 2;

// compose: right-to-left (double first, then addOne)
const composed = compose(addOne, double);
composed(5); // 11 (5 * 2 + 1)

// flow: left-to-right (addOne first, then double)
const flowed = flow(addOne, double);
flowed(5); // 12 ((5 + 1) * 2)

See

flow for left-to-right composition

Call Signature

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

Defined in: Composition/compose.ts:52

Composes functions from right to left, returning a new function. This is the traditional mathematical function composition: (f . g)(x) = f(g(x))

Unlike flow which reads left-to-right, compose reads right-to-left, matching how nested function calls would be written.

Type Parameters

A

A

B

B

C

C

D

D

E

E

F

F

G

G

H

H

Parameters

gh

(g) => H

fg

(f) => G

ef

(e) => F

de

(d) => E

cd

(c) => D

bc

(b) => C

ab

(a) => B

Returns

(a): H

Parameters

a

A

Returns

H

Example

const addOne = (n: number) => n + 1;
const double = (n: number) => n * 2;

// compose: right-to-left (double first, then addOne)
const composed = compose(addOne, double);
composed(5); // 11 (5 * 2 + 1)

// flow: left-to-right (addOne first, then double)
const flowed = flow(addOne, double);
flowed(5); // 12 ((5 + 1) * 2)

See

flow for left-to-right composition

Call Signature

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

Defined in: Composition/compose.ts:61

Composes functions from right to left, returning a new function. This is the traditional mathematical function composition: (f . g)(x) = f(g(x))

Unlike flow which reads left-to-right, compose reads right-to-left, matching how nested function calls would be written.

Type Parameters

A

A

B

B

C

C

D

D

E

E

F

F

G

G

H

H

I

I

Parameters

hi

(h) => I

gh

(g) => H

fg

(f) => G

ef

(e) => F

de

(d) => E

cd

(c) => D

bc

(b) => C

ab

(a) => B

Returns

(a): I

Parameters

a

A

Returns

I

Example

const addOne = (n: number) => n + 1;
const double = (n: number) => n * 2;

// compose: right-to-left (double first, then addOne)
const composed = compose(addOne, double);
composed(5); // 11 (5 * 2 + 1)

// flow: left-to-right (addOne first, then double)
const flowed = flow(addOne, double);
flowed(5); // 12 ((5 + 1) * 2)

See

flow for left-to-right composition

Call Signature

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

Defined in: Composition/compose.ts:71

Composes functions from right to left, returning a new function. This is the traditional mathematical function composition: (f . g)(x) = f(g(x))

Unlike flow which reads left-to-right, compose reads right-to-left, matching how nested function calls would be written.

Type Parameters

A

A

B

B

C

C

D

D

E

E

F

F

G

G

H

H

I

I

J

J

Parameters

ij

(i) => J

hi

(h) => I

gh

(g) => H

fg

(f) => G

ef

(e) => F

de

(d) => E

cd

(c) => D

bc

(b) => C

ab

(a) => B

Returns

(a): J

Parameters

a

A

Returns

J

Example

const addOne = (n: number) => n + 1;
const double = (n: number) => n * 2;

// compose: right-to-left (double first, then addOne)
const composed = compose(addOne, double);
composed(5); // 11 (5 * 2 + 1)

// flow: left-to-right (addOne first, then double)
const flowed = flow(addOne, double);
flowed(5); // 12 ((5 + 1) * 2)

See

flow for left-to-right composition