Skip to main content
Module

x/fun/mod.ts>fn.pipe

A collection of algebraic data types, lenses, and schemables based on a light weight higher kinded type implementation. Written for deno.
baetheus/fun
Latest
function fn.pipe
import { fn } from "https://deno.land/x/fun@v2.0.0/mod.ts";
const { pipe } = fn;

The pipe takes a value as the first argument and composes it with subsequent function arguments, returning the result of the last function passed in. It handles and correctly types up to 10 unary functions. Beyond 10 it makes sense to break up pipe into multiple pipes.

Examples

Example 1

import { pipe } from "./fn.ts";

const add = (n: number) => (m: number) => m + n;
const multiply = (n: number) => (m: number) => m * n;

const result = pipe(
  1,
  add(1), // 2
  multiply(2), // 4
  add(1), // 5
  multiply(2), // 10
); // 10

Parameters

a: A
ab: (a: A) => B
bc: (b: B) => C

Parameters

a: A
ab: (a: A) => B
bc: (b: B) => C
cd: (c: C) => D

Parameters

a: A
ab: (a: A) => B
bc: (b: B) => C
cd: (c: C) => D
de: (d: D) => E

Parameters

a: A
ab: (a: A) => B
bc: (b: B) => C
cd: (c: C) => D
de: (d: D) => E
ef: (e: E) => F

Parameters

a: A
ab: (a: A) => B
bc: (b: B) => C
cd: (c: C) => D
de: (d: D) => E
ef: (e: E) => F
fg: (f: F) => G

Parameters

a: A
ab: (a: A) => B
bc: (b: B) => C
cd: (c: C) => D
de: (d: D) => E
ef: (e: E) => F
fg: (f: F) => G
gh: (g: G) => H

Parameters

a: A
ab: (a: A) => B
bc: (b: B) => C
cd: (c: C) => D
de: (d: D) => E
ef: (e: E) => F
fg: (f: F) => G
gh: (g: G) => H
hi: (h: H) => I

Type Parameters

A
B
C
D
E
F
G
H
I
J

Parameters

a: A
ab: (a: A) => B
bc: (b: B) => C
cd: (c: C) => D
de: (d: D) => E
ef: (e: E) => F
fg: (f: F) => G
gh: (g: G) => H
hi: (h: H) => I
ij: (i: I) => J

Type Parameters

A
B
C
D
E
F
G
H
I
J
K

Parameters

a: A
ab: (a: A) => B
bc: (b: B) => C
cd: (c: C) => D
de: (d: D) => E
ef: (e: E) => F
fg: (f: F) => G
gh: (g: G) => H
hi: (h: H) => I
ij: (i: I) => J
jk: (j: J) => K

Type Parameters

A
B
C
D
E
F
G
H
I
J
K
L

Parameters

a: A
ab: (a: A) => B
bc: (b: B) => C
cd: (c: C) => D
de: (d: D) => E
ef: (e: E) => F
fg: (f: F) => G
gh: (g: G) => H
hi: (h: H) => I
ij: (i: I) => J
jk: (j: J) => K
kl: (K: K) => L

Type Parameters

A
B
C
D
E
F
G
H
I
J
K
L

Parameters

a: A
ab: (a: A) => B
bc: (b: B) => C
cd: (c: C) => D
de: (d: D) => E
ef: (e: E) => F
fg: (f: F) => G
gh: (g: G) => H
hi: (h: H) => I
ij: (i: I) => J
jk: (j: J) => K
kl: (K: K) => L
end: never