Skip to content

Instantly share code, notes, and snippets.

@jjhiggz

jjhiggz/superpipe.ts

Last active July 16, 2025 11:54
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save jjhiggz/77c313e04fde61c1becf802b6bde81e9 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save jjhiggz/77c313e04fde61c1becf802b6bde81e9 to your computer and use it in GitHub Desktop.
Download ZIP
superpipe
Raw
superpipe.ts
/**
* Perform left-to-right function composition.
* @param value The initial value.
* @param operations the list of operations to apply.
* @signature R.pipe(data, op1, op2, op3)
* @example
* superpipe(
* [1, 2, 3, 4],
* R.map(x => x * 2),
* arr => [arr[0] + arr[1], arr[2] + arr[3]],
* ) // => [6, 14]
*
*
* @data_first
* @category Function
*/
import { type LazyResult } from "remeda";
export function superpipe<A, B>(value: A, op0: (input: A) => B): B;
export function superpipe<A, B, C>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
): C;
export function superpipe<A, B, C, D>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
): D;
export function superpipe<A, B, C, D, E>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
): E;
export function superpipe<A, B, C, D, E, F>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
): F;
export function superpipe<A, B, C, D, E, F, G>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
): G;
export function superpipe<A, B, C, D, E, F, G, H>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
): H;
export function superpipe<A, B, C, D, E, F, G, H, I>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
): I;
export function superpipe<A, B, C, D, E, F, G, H, I, J>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
): J;
export function superpipe<A, B, C, D, E, F, G, H, I, J, K>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
): K;
export function superpipe<A, B, C, D, E, F, G, H, I, J, K, L>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
): L;
export function superpipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
): M;
export function superpipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
): N;
export function superpipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
): O;
export function superpipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
): P;
export function superpipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
): Q;
export function superpipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
): R;
export function superpipe<
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
): S;
export function superpipe<
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
): T;
export function superpipe<
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
): U;
export function superpipe<
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
): V;
export function superpipe<
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
): W;
export function superpipe<
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
): X;
export function superpipe<
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,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
): Y;
export function superpipe<
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,
Z,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
): Z;
export function superpipe<
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,
Z,
AA,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
): AA;
export function superpipe<
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,
Z,
AA,
AB,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
): AB;
export function superpipe<
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,
Z,
AA,
AB,
AC,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
): AC;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
): AD;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
): AE;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
): AF;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
AG,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
op31: (input: AF) => AG,
): AG;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
AG,
AH,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
op31: (input: AF) => AG,
op32: (input: AG) => AH,
): AH;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
AG,
AH,
AI,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
op31: (input: AF) => AG,
op32: (input: AG) => AH,
op33: (input: AH) => AI,
): AI;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
AG,
AH,
AI,
AJ,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
op31: (input: AF) => AG,
op32: (input: AG) => AH,
op33: (input: AH) => AI,
op34: (input: AI) => AJ,
): AJ;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
AG,
AH,
AI,
AJ,
AK,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
op31: (input: AF) => AG,
op32: (input: AG) => AH,
op33: (input: AH) => AI,
op34: (input: AI) => AJ,
op35: (input: AJ) => AK,
): AK;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
AG,
AH,
AI,
AJ,
AK,
AL,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
op31: (input: AF) => AG,
op32: (input: AG) => AH,
op33: (input: AH) => AI,
op34: (input: AI) => AJ,
op35: (input: AJ) => AK,
op36: (input: AK) => AL,
): AL;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
AG,
AH,
AI,
AJ,
AK,
AL,
AM,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
op31: (input: AF) => AG,
op32: (input: AG) => AH,
op33: (input: AH) => AI,
op34: (input: AI) => AJ,
op35: (input: AJ) => AK,
op36: (input: AK) => AL,
op37: (input: AL) => AM,
): AM;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
AG,
AH,
AI,
AJ,
AK,
AL,
AM,
AN,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
op31: (input: AF) => AG,
op32: (input: AG) => AH,
op33: (input: AH) => AI,
op34: (input: AI) => AJ,
op35: (input: AJ) => AK,
op36: (input: AK) => AL,
op37: (input: AL) => AM,
op38: (input: AM) => AN,
): AN;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
AG,
AH,
AI,
AJ,
AK,
AL,
AM,
AN,
AO,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
op31: (input: AF) => AG,
op32: (input: AG) => AH,
op33: (input: AH) => AI,
op34: (input: AI) => AJ,
op35: (input: AJ) => AK,
op36: (input: AK) => AL,
op37: (input: AL) => AM,
op38: (input: AM) => AN,
op39: (input: AN) => AO,
): AO;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
AG,
AH,
AI,
AJ,
AK,
AL,
AM,
AN,
AO,
AP,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
op31: (input: AF) => AG,
op32: (input: AG) => AH,
op33: (input: AH) => AI,
op34: (input: AI) => AJ,
op35: (input: AJ) => AK,
op36: (input: AK) => AL,
op37: (input: AL) => AM,
op38: (input: AM) => AN,
op39: (input: AN) => AO,
op40: (input: AO) => AP,
): AP;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
AG,
AH,
AI,
AJ,
AK,
AL,
AM,
AN,
AO,
AP,
AQ,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
op31: (input: AF) => AG,
op32: (input: AG) => AH,
op33: (input: AH) => AI,
op34: (input: AI) => AJ,
op35: (input: AJ) => AK,
op36: (input: AK) => AL,
op37: (input: AL) => AM,
op38: (input: AM) => AN,
op39: (input: AN) => AO,
op40: (input: AO) => AP,
op41: (input: AP) => AQ,
): AQ;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
AG,
AH,
AI,
AJ,
AK,
AL,
AM,
AN,
AO,
AP,
AQ,
AR,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
op31: (input: AF) => AG,
op32: (input: AG) => AH,
op33: (input: AH) => AI,
op34: (input: AI) => AJ,
op35: (input: AJ) => AK,
op36: (input: AK) => AL,
op37: (input: AL) => AM,
op38: (input: AM) => AN,
op39: (input: AN) => AO,
op40: (input: AO) => AP,
op41: (input: AP) => AQ,
op42: (input: AQ) => AR,
): AR;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
AG,
AH,
AI,
AJ,
AK,
AL,
AM,
AN,
AO,
AP,
AQ,
AR,
AS,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
op31: (input: AF) => AG,
op32: (input: AG) => AH,
op33: (input: AH) => AI,
op34: (input: AI) => AJ,
op35: (input: AJ) => AK,
op36: (input: AK) => AL,
op37: (input: AL) => AM,
op38: (input: AM) => AN,
op39: (input: AN) => AO,
op40: (input: AO) => AP,
op41: (input: AP) => AQ,
op42: (input: AQ) => AR,
op43: (input: AR) => AS,
): AS;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
AG,
AH,
AI,
AJ,
AK,
AL,
AM,
AN,
AO,
AP,
AQ,
AR,
AS,
AT,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
op31: (input: AF) => AG,
op32: (input: AG) => AH,
op33: (input: AH) => AI,
op34: (input: AI) => AJ,
op35: (input: AJ) => AK,
op36: (input: AK) => AL,
op37: (input: AL) => AM,
op38: (input: AM) => AN,
op39: (input: AN) => AO,
op40: (input: AO) => AP,
op41: (input: AP) => AQ,
op42: (input: AQ) => AR,
op43: (input: AR) => AS,
op44: (input: AS) => AT,
): AT;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
AG,
AH,
AI,
AJ,
AK,
AL,
AM,
AN,
AO,
AP,
AQ,
AR,
AS,
AT,
AU,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
op31: (input: AF) => AG,
op32: (input: AG) => AH,
op33: (input: AH) => AI,
op34: (input: AI) => AJ,
op35: (input: AJ) => AK,
op36: (input: AK) => AL,
op37: (input: AL) => AM,
op38: (input: AM) => AN,
op39: (input: AN) => AO,
op40: (input: AO) => AP,
op41: (input: AP) => AQ,
op42: (input: AQ) => AR,
op43: (input: AR) => AS,
op44: (input: AS) => AT,
op45: (input: AT) => AU,
): AU;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
AG,
AH,
AI,
AJ,
AK,
AL,
AM,
AN,
AO,
AP,
AQ,
AR,
AS,
AT,
AU,
AV,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
op31: (input: AF) => AG,
op32: (input: AG) => AH,
op33: (input: AH) => AI,
op34: (input: AI) => AJ,
op35: (input: AJ) => AK,
op36: (input: AK) => AL,
op37: (input: AL) => AM,
op38: (input: AM) => AN,
op39: (input: AN) => AO,
op40: (input: AO) => AP,
op41: (input: AP) => AQ,
op42: (input: AQ) => AR,
op43: (input: AR) => AS,
op44: (input: AS) => AT,
op45: (input: AT) => AU,
op46: (input: AU) => AV,
): AV;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
AG,
AH,
AI,
AJ,
AK,
AL,
AM,
AN,
AO,
AP,
AQ,
AR,
AS,
AT,
AU,
AV,
AW,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
op31: (input: AF) => AG,
op32: (input: AG) => AH,
op33: (input: AH) => AI,
op34: (input: AI) => AJ,
op35: (input: AJ) => AK,
op36: (input: AK) => AL,
op37: (input: AL) => AM,
op38: (input: AM) => AN,
op39: (input: AN) => AO,
op40: (input: AO) => AP,
op41: (input: AP) => AQ,
op42: (input: AQ) => AR,
op43: (input: AR) => AS,
op44: (input: AS) => AT,
op45: (input: AT) => AU,
op46: (input: AU) => AV,
op47: (input: AV) => AW,
): AW;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
AG,
AH,
AI,
AJ,
AK,
AL,
AM,
AN,
AO,
AP,
AQ,
AR,
AS,
AT,
AU,
AV,
AW,
AX,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
op31: (input: AF) => AG,
op32: (input: AG) => AH,
op33: (input: AH) => AI,
op34: (input: AI) => AJ,
op35: (input: AJ) => AK,
op36: (input: AK) => AL,
op37: (input: AL) => AM,
op38: (input: AM) => AN,
op39: (input: AN) => AO,
op40: (input: AO) => AP,
op41: (input: AP) => AQ,
op42: (input: AQ) => AR,
op43: (input: AR) => AS,
op44: (input: AS) => AT,
op45: (input: AT) => AU,
op46: (input: AU) => AV,
op47: (input: AV) => AW,
op48: (input: AW) => AX,
): AX;
export function superpipe<
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,
Z,
AA,
AB,
AC,
AD,
AE,
AF,
AG,
AH,
AI,
AJ,
AK,
AL,
AM,
AN,
AO,
AP,
AQ,
AR,
AS,
AT,
AU,
AV,
AW,
AX,
AY,
>(
value: A,
op0: (input: A) => B,
op1: (input: B) => C,
op2: (input: C) => D,
op3: (input: D) => E,
op4: (input: E) => F,
op5: (input: F) => G,
op6: (input: G) => H,
op7: (input: H) => I,
op8: (input: I) => J,
op9: (input: J) => K,
op10: (input: K) => L,
op11: (input: L) => M,
op12: (input: M) => N,
op13: (input: N) => O,
op14: (input: O) => P,
op15: (input: P) => Q,
op16: (input: Q) => R,
op17: (input: R) => S,
op18: (input: S) => T,
op19: (input: T) => U,
op20: (input: U) => V,
op21: (input: V) => W,
op22: (input: W) => X,
op23: (input: X) => Y,
op24: (input: Y) => Z,
op25: (input: Z) => AA,
op26: (input: AA) => AB,
op27: (input: AB) => AC,
op28: (input: AC) => AD,
op29: (input: AD) => AE,
op30: (input: AE) => AF,
op31: (input: AF) => AG,
op32: (input: AG) => AH,
op33: (input: AH) => AI,
op34: (input: AI) => AJ,
op35: (input: AJ) => AK,
op36: (input: AK) => AL,
op37: (input: AL) => AM,
op38: (input: AM) => AN,
op39: (input: AN) => AO,
op40: (input: AO) => AP,
op41: (input: AP) => AQ,
op42: (input: AQ) => AR,
op43: (input: AR) => AS,
op44: (input: AS) => AT,
op45: (input: AT) => AU,
op46: (input: AU) => AV,
op47: (input: AV) => AW,
op48: (input: AW) => AX,
op49: (input: AX) => AY,
): AY;
export function superpipe(
value: any,
...operations: Array<(value: any) => any>
): any {
let ret = value;
const lazyOps = operations.map((op) => {
const { lazy, lazyArgs } = op as LazyOp;
if (lazy) {
const fn: any = lazy(...lazyArgs);
fn.indexed = lazy.indexed;
fn.single = lazy.single;
fn.index = 0;
fn.items = [];
return fn;
}
return null;
});
let opIdx = 0;
while (opIdx < operations.length) {
const op = operations[opIdx];
const lazyOp = lazyOps[opIdx];
if (!lazyOp) {
ret = op!(ret);
opIdx++;
continue;
}
const lazySeq: LazyFn[] = [];
for (let j = opIdx; j < operations.length; j++) {
if (lazyOps[j]) {
lazySeq.push(lazyOps[j]);
if (lazyOps[j].single) {
break;
}
} else {
break;
}
}
let acc: any[] = [];
for (let j = 0; j < ret.length; j++) {
let item = ret[j];
if (_processItem({ item, acc, lazySeq })) {
break;
}
}
const lastLazySeq = lazySeq[lazySeq.length - 1];
if ((lastLazySeq as any).single) {
ret = acc[0];
} else {
ret = acc;
}
opIdx += lazySeq.length;
}
return ret;
}
type LazyFn = (value: any, index?: number, items?: any) => LazyResult<any>;
type LazyOp = ((input: any) => any) & {
lazy: ((...args: any[]) => LazyFn) & {
indexed: boolean;
single: boolean;
};
lazyArgs: any[];
};
function _processItem({
item,
lazySeq,
acc,
}: {
item: any;
lazySeq: any[];
acc: any[];
}): boolean {
if (lazySeq.length === 0) {
acc.push(item);
return false;
}
let lazyResult: LazyResult<any> = { done: false, hasNext: false };
let isDone = false;
for (let i = 0; i < lazySeq.length; i++) {
const lazyFn = lazySeq[i];
const indexed = lazyFn.indexed;
const index = lazyFn.index;
const items = lazyFn.items;
items.push(item);
lazyResult = indexed ? lazyFn(item, index, items) : lazyFn(item);
lazyFn.index++;
if (lazyResult.hasNext) {
if (lazyResult.hasMany) {
const nextValues: readonly any[] = lazyResult.next;
for (const subItem of nextValues) {
const subResult = _processItem({
item: subItem,
acc,
lazySeq: lazySeq.slice(i + 1),
});
if (subResult) {
return true;
}
}
return false;
} else {
item = lazyResult.next;
}
}
if (!lazyResult.hasNext) {
break;
}
// process remaining functions in the pipe
// but don't process remaining elements in the input array
if (lazyResult.done) {
isDone = true;
}
}
if (lazyResult.hasNext) {
acc.push(item);
}
if (isDone) {
return true;
}
return false;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment