@hyperjump/pact
    Preparing search index...

    Variable pipeConst

    pipe: <A, B>(initialValue: A, ...fns: [(a: A) => B]) => B & <A, B, C>(
        initialValue: A,
        ...fns: [(a: A) => B, (b: B) => C],
    ) => C & <A, B, C, D>(
        initialValue: A,
        ...fns: [(a: A) => B, (b: B) => C, (c: C) => D],
    ) => D & <A, B, C, D, E>(
        initialValue: A,
        ...fns: [(a: A) => B, (b: B) => C, (c: C) => D, (c: D) => E],
    ) => E & <A, B, C, D, E, F>(
        initialValue: A,
        ...fns: [(a: A) => B, (b: B) => C, (c: C) => D, (d: D) => E, (e: E) => F],
    ) => F & <A, B, C, D, E, F, G>(
        initialValue: A,
        ...fns: [
            (a: A) => B,
            (b: B) => C,
            (c: C) => D,
            (d: D) => E,
            (e: E) => F,
            (f: F) => G,
        ],
    ) => G & <A, B, C, D, E, F, G, H>(
        initialValue: A,
        ...fns: [
            (a: A) => B,
            (b: B) => C,
            (c: C) => D,
            (d: D) => E,
            (e: E) => F,
            (f: F) => G,
            (g: G) => H,
        ],
    ) => H & <A, B, C, D, E, F, G, H, I>(
        initialValue: A,
        ...fns: [
            (a: A) => B,
            (b: B) => C,
            (c: C) => D,
            (d: D) => E,
            (e: E) => F,
            (f: F) => G,
            (g: G) => H,
            (h: H) => I,
        ],
    ) => I & <A, B, C, D, E, F, G, H, I, J extends ((j: any) => any)[]>(
        initialValue: A,
        ...fns: [
            (a: A) => B,
            (b: B) => C,
            (c: C) => D,
            (d: D) => E,
            (e: E) => F,
            (f: F) => G,
            (g: G) => H,
            (h: H) => I,
            ...J,
        ],
    ) => LastReturnType<J>

    Starting with an iterator, apply any number of functions to transform the values and return the result.