Function pipe

pipe<A>(a: A): A
Composes functions from left to right.
Type Parameters
- A
Parameters
- a: A
  The initial value to pipe through the functions
Returns A
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:22
pipe<A, B>(a: A, b: Z<A, B>): B
Composes functions from left to right.
Type Parameters
- A
- B
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
Returns B
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:23
pipe<A, B, C>(a: A, b: Z<A, B>, c: Z<B, C>): C
Composes functions from left to right.
Type Parameters
- A
- B
- C
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
Returns C
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:24
pipe<A, B, C, D>(a: A, b: Z<A, B>, c: Z<B, C>, d: Z<C, D>): D
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
Returns D
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:25
pipe<A, B, C, D, E>(a: A, b: Z<A, B>, c: Z<B, C>, d: Z<C, D>, e: Z<D, E>): E
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
Returns E
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:26
pipe<A, B, C, D, E, F>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
): F
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
Returns F
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:27
pipe<A, B, C, D, E, F, G>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
    g: Z<F, G>,
): G
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
- G
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
- g: Z<F, G>
Returns G
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:28
pipe<A, B, C, D, E, F, G, H>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
    g: Z<F, G>,
    h: Z<G, H>,
): H
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
- g: Z<F, G>
- h: Z<G, H>
Returns H
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:29
pipe<A, B, C, D, E, F, G, H, I>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
    g: Z<F, G>,
    h: Z<G, H>,
    i: Z<H, I>,
): I
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
- I
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
- g: Z<F, G>
- h: Z<G, H>
- i: Z<H, I>
Returns I
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:30
pipe<A, B, C, D, E, F, G, H, I, J>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
    g: Z<F, G>,
    h: Z<G, H>,
    i: Z<H, I>,
    j: Z<I, J>,
): J
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
- g: Z<F, G>
- h: Z<G, H>
- i: Z<H, I>
- j: Z<I, J>
Returns J
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:31
pipe<A, B, C, D, E, F, G, H, I, J, K>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
    g: Z<F, G>,
    h: Z<G, H>,
    i: Z<H, I>,
    j: Z<I, J>,
    k: Z<J, K>,
): K
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
- g: Z<F, G>
- h: Z<G, H>
- i: Z<H, I>
- j: Z<I, J>
- k: Z<J, K>
Returns K
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:32
pipe<A, B, C, D, E, F, G, H, I, J, K, L>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
    g: Z<F, G>,
    h: Z<G, H>,
    i: Z<H, I>,
    j: Z<I, J>,
    k: Z<J, K>,
    l: Z<K, L>,
): L
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
- g: Z<F, G>
- h: Z<G, H>
- i: Z<H, I>
- j: Z<I, J>
- k: Z<J, K>
- l: Z<K, L>
Returns L
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:33
pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
    g: Z<F, G>,
    h: Z<G, H>,
    i: Z<H, I>,
    j: Z<I, J>,
    k: Z<J, K>,
    l: Z<K, L>,
    m: Z<L, M>,
): M
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
- g: Z<F, G>
- h: Z<G, H>
- i: Z<H, I>
- j: Z<I, J>
- k: Z<J, K>
- l: Z<K, L>
- m: Z<L, M>
Returns M
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:34
pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
    g: Z<F, G>,
    h: Z<G, H>,
    i: Z<H, I>,
    j: Z<I, J>,
    k: Z<J, K>,
    l: Z<K, L>,
    m: Z<L, M>,
    n: Z<M, N>,
): N
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- N
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
- g: Z<F, G>
- h: Z<G, H>
- i: Z<H, I>
- j: Z<I, J>
- k: Z<J, K>
- l: Z<K, L>
- m: Z<L, M>
- n: Z<M, N>
Returns N
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:35
pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
    g: Z<F, G>,
    h: Z<G, H>,
    i: Z<H, I>,
    j: Z<I, J>,
    k: Z<J, K>,
    l: Z<K, L>,
    m: Z<L, M>,
    n: Z<M, N>,
    o: Z<N, O>,
): O
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- N
- O
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
- g: Z<F, G>
- h: Z<G, H>
- i: Z<H, I>
- j: Z<I, J>
- k: Z<J, K>
- l: Z<K, L>
- m: Z<L, M>
- n: Z<M, N>
- o: Z<N, O>
Returns O
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:36
pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
    g: Z<F, G>,
    h: Z<G, H>,
    i: Z<H, I>,
    j: Z<I, J>,
    k: Z<J, K>,
    l: Z<K, L>,
    m: Z<L, M>,
    n: Z<M, N>,
    o: Z<N, O>,
    p: Z<O, P>,
): P
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- N
- O
- P
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
- g: Z<F, G>
- h: Z<G, H>
- i: Z<H, I>
- j: Z<I, J>
- k: Z<J, K>
- l: Z<K, L>
- m: Z<L, M>
- n: Z<M, N>
- o: Z<N, O>
- p: Z<O, P>
Returns P
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:37
pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
    g: Z<F, G>,
    h: Z<G, H>,
    i: Z<H, I>,
    j: Z<I, J>,
    k: Z<J, K>,
    l: Z<K, L>,
    m: Z<L, M>,
    n: Z<M, N>,
    o: Z<N, O>,
    p: Z<O, P>,
    q: Z<P, Q>,
): Q
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- N
- O
- P
- Q
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
- g: Z<F, G>
- h: Z<G, H>
- i: Z<H, I>
- j: Z<I, J>
- k: Z<J, K>
- l: Z<K, L>
- m: Z<L, M>
- n: Z<M, N>
- o: Z<N, O>
- p: Z<O, P>
- q: Z<P, Q>
Returns Q
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:38
pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
    g: Z<F, G>,
    h: Z<G, H>,
    i: Z<H, I>,
    j: Z<I, J>,
    k: Z<J, K>,
    l: Z<K, L>,
    m: Z<L, M>,
    n: Z<M, N>,
    o: Z<N, O>,
    p: Z<O, P>,
    q: Z<P, Q>,
    r: Z<Q, R>,
): R
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- N
- O
- P
- Q
- R
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
- g: Z<F, G>
- h: Z<G, H>
- i: Z<H, I>
- j: Z<I, J>
- k: Z<J, K>
- l: Z<K, L>
- m: Z<L, M>
- n: Z<M, N>
- o: Z<N, O>
- p: Z<O, P>
- q: Z<P, Q>
- r: Z<Q, R>
Returns R
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:39
pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
    g: Z<F, G>,
    h: Z<G, H>,
    i: Z<H, I>,
    j: Z<I, J>,
    k: Z<J, K>,
    l: Z<K, L>,
    m: Z<L, M>,
    n: Z<M, N>,
    o: Z<N, O>,
    p: Z<O, P>,
    q: Z<P, Q>,
    r: Z<Q, R>,
    s: Z<R, S>,
): S
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- N
- O
- P
- Q
- R
- S
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
- g: Z<F, G>
- h: Z<G, H>
- i: Z<H, I>
- j: Z<I, J>
- k: Z<J, K>
- l: Z<K, L>
- m: Z<L, M>
- n: Z<M, N>
- o: Z<N, O>
- p: Z<O, P>
- q: Z<P, Q>
- r: Z<Q, R>
- s: Z<R, S>
Returns S
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:40
pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
    g: Z<F, G>,
    h: Z<G, H>,
    i: Z<H, I>,
    j: Z<I, J>,
    k: Z<J, K>,
    l: Z<K, L>,
    m: Z<L, M>,
    n: Z<M, N>,
    o: Z<N, O>,
    p: Z<O, P>,
    q: Z<P, Q>,
    r: Z<Q, R>,
    s: Z<R, S>,
    t: Z<S, T>,
): T
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- N
- O
- P
- Q
- R
- S
- T
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
- g: Z<F, G>
- h: Z<G, H>
- i: Z<H, I>
- j: Z<I, J>
- k: Z<J, K>
- l: Z<K, L>
- m: Z<L, M>
- n: Z<M, N>
- o: Z<N, O>
- p: Z<O, P>
- q: Z<P, Q>
- r: Z<Q, R>
- s: Z<R, S>
- t: Z<S, T>
Returns T
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:41
pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
    g: Z<F, G>,
    h: Z<G, H>,
    i: Z<H, I>,
    j: Z<I, J>,
    k: Z<J, K>,
    l: Z<K, L>,
    m: Z<L, M>,
    n: Z<M, N>,
    o: Z<N, O>,
    p: Z<O, P>,
    q: Z<P, Q>,
    r: Z<Q, R>,
    s: Z<R, S>,
    t: Z<S, T>,
    u: Z<T, U>,
): U
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- N
- O
- P
- Q
- R
- S
- T
- U
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
- g: Z<F, G>
- h: Z<G, H>
- i: Z<H, I>
- j: Z<I, J>
- k: Z<J, K>
- l: Z<K, L>
- m: Z<L, M>
- n: Z<M, N>
- o: Z<N, O>
- p: Z<O, P>
- q: Z<P, Q>
- r: Z<Q, R>
- s: Z<R, S>
- t: Z<S, T>
- u: Z<T, U>
Returns U
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:42
pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
    g: Z<F, G>,
    h: Z<G, H>,
    i: Z<H, I>,
    j: Z<I, J>,
    k: Z<J, K>,
    l: Z<K, L>,
    m: Z<L, M>,
    n: Z<M, N>,
    o: Z<N, O>,
    p: Z<O, P>,
    q: Z<P, Q>,
    r: Z<Q, R>,
    s: Z<R, S>,
    t: Z<S, T>,
    u: Z<T, U>,
    v: Z<U, V>,
): V
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- N
- O
- P
- Q
- R
- S
- T
- U
- V
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
- g: Z<F, G>
- h: Z<G, H>
- i: Z<H, I>
- j: Z<I, J>
- k: Z<J, K>
- l: Z<K, L>
- m: Z<L, M>
- n: Z<M, N>
- o: Z<N, O>
- p: Z<O, P>
- q: Z<P, Q>
- r: Z<Q, R>
- s: Z<R, S>
- t: Z<S, T>
- u: Z<T, U>
- v: Z<U, V>
Returns V
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:43
pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
    g: Z<F, G>,
    h: Z<G, H>,
    i: Z<H, I>,
    j: Z<I, J>,
    k: Z<J, K>,
    l: Z<K, L>,
    m: Z<L, M>,
    n: Z<M, N>,
    o: Z<N, O>,
    p: Z<O, P>,
    q: Z<P, Q>,
    r: Z<Q, R>,
    s: Z<R, S>,
    t: Z<S, T>,
    u: Z<T, U>,
    v: Z<U, V>,
    w: Z<V, W>,
): W
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- N
- O
- P
- Q
- R
- S
- T
- U
- V
- W
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
- g: Z<F, G>
- h: Z<G, H>
- i: Z<H, I>
- j: Z<I, J>
- k: Z<J, K>
- l: Z<K, L>
- m: Z<L, M>
- n: Z<M, N>
- o: Z<N, O>
- p: Z<O, P>
- q: Z<P, Q>
- r: Z<Q, R>
- s: Z<R, S>
- t: Z<S, T>
- u: Z<T, U>
- v: Z<U, V>
- w: Z<V, W>
Returns W
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:44
pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
    g: Z<F, G>,
    h: Z<G, H>,
    i: Z<H, I>,
    j: Z<I, J>,
    k: Z<J, K>,
    l: Z<K, L>,
    m: Z<L, M>,
    n: Z<M, N>,
    o: Z<N, O>,
    p: Z<O, P>,
    q: Z<P, Q>,
    r: Z<Q, R>,
    s: Z<R, S>,
    t: Z<S, T>,
    u: Z<T, U>,
    v: Z<U, V>,
    w: Z<V, W>,
    x: Z<W, X>,
): X
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- N
- O
- P
- Q
- R
- S
- T
- U
- V
- W
- X
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
- g: Z<F, G>
- h: Z<G, H>
- i: Z<H, I>
- j: Z<I, J>
- k: Z<J, K>
- l: Z<K, L>
- m: Z<L, M>
- n: Z<M, N>
- o: Z<N, O>
- p: Z<O, P>
- q: Z<P, Q>
- r: Z<Q, R>
- s: Z<R, S>
- t: Z<S, T>
- u: Z<T, U>
- v: Z<U, V>
- w: Z<V, W>
- x: Z<W, X>
Returns X
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:45
pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y>(
    a: A,
    b: Z<A, B>,
    c: Z<B, C>,
    d: Z<C, D>,
    e: Z<D, E>,
    f: Z<E, F>,
    g: Z<F, G>,
    h: Z<G, H>,
    i: Z<H, I>,
    j: Z<I, J>,
    k: Z<J, K>,
    l: Z<K, L>,
    m: Z<L, M>,
    n: Z<M, N>,
    o: Z<N, O>,
    p: Z<O, P>,
    q: Z<P, Q>,
    r: Z<Q, R>,
    s: Z<R, S>,
    t: Z<S, T>,
    u: Z<T, U>,
    v: Z<U, V>,
    w: Z<V, W>,
    x: Z<W, X>,
    y: Z<X, Y>,
): Y
Composes functions from left to right.
Type Parameters
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- N
- O
- P
- Q
- R
- S
- T
- U
- V
- W
- X
- Y
Parameters
- a: A
  The initial value to pipe through the functions
- b: Z<A, B>
- c: Z<B, C>
- d: Z<C, D>
- e: Z<D, E>
- f: Z<E, F>
- g: Z<F, G>
- h: Z<G, H>
- i: Z<H, I>
- j: Z<I, J>
- k: Z<J, K>
- l: Z<K, L>
- m: Z<L, M>
- n: Z<M, N>
- o: Z<N, O>
- p: Z<O, P>
- q: Z<P, Q>
- r: Z<Q, R>
- s: Z<R, S>
- t: Z<S, T>
- u: Z<T, U>
- v: Z<U, V>
- w: Z<V, W>
- x: Z<W, X>
- y: Z<X, Y>
Returns Y
The result of applying all functions in sequence
Description
Takes a value and pipes it through a series of functions. Each function takes the output of the previous function as its input.
Example
```
pipe(
  G.ofIterable([1, 2, 3]),
  G.map(x => x * 2),
  G.filter(x => x > 2),
  G.array
) // => Promise<[4, 6]>
```
- Defined in pipe.ts:46

Function pipe

Type Parameters

Parameters

Returns A

Description

Example

Type Parameters

Parameters

Returns B

Description

Example

Type Parameters

Parameters

Returns C

Description

Example

Type Parameters

Parameters

Returns D

Description

Example

Type Parameters

Parameters

Returns E

Description

Example

Type Parameters

Parameters

Returns F

Description

Example

Type Parameters

Parameters

Returns G

Description

Example

Type Parameters

Parameters

Returns H

Description

Example

Type Parameters

Parameters

Returns I

Description

Example

Type Parameters

Parameters

Returns J

Description

Example

Type Parameters

Parameters

Returns K

Description

Example

Type Parameters

Parameters

Returns L

Description

Example

Type Parameters

Parameters

Returns M

Description

Example

Type Parameters

Parameters

Returns N

Description

Example

Type Parameters

Parameters

Returns O

Description

Example

Type Parameters

Parameters

Returns P

Description