Prelude API
    Preparing search index...

    Type Alias Pipe0

    Pipe0: {
        <A>(): (a: A) => A;
        <A, B>(b: Z<A, B>): (a: A) => B;
        <A, B, C>(b: Z<A, B>, c: Z<B, C>): (a: A) => C;
        <A, B, C, D>(b: Z<A, B>, c: Z<B, C>, d: Z<C, D>): (a: A) => D;
        <A, B, C, D, E>(
            b: Z<A, B>,
            c: Z<B, C>,
            d: Z<C, D>,
            e: Z<D, E>,
        ): (a: A) => E;
        <A, B, C, D, E, F>(
            b: Z<A, B>,
            c: Z<B, C>,
            d: Z<C, D>,
            e: Z<D, E>,
            f: Z<E, F>,
        ): (a: A) => F;
        <A, B, C, D, E, F, G>(
            b: Z<A, B>,
            c: Z<B, C>,
            d: Z<C, D>,
            e: Z<D, E>,
            f: Z<E, F>,
            g: Z<F, G>,
        ): (a: A) => G;
        <A, B, C, D, E, F, G, H>(
            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>,
        ): (a: A) => H;
        <A, B, C, D, E, F, G, H, I>(
            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>,
        ): (a: A) => I;
        <A, B, C, D, E, F, G, H, I, J>(
            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>,
        ): (a: A) => J;
        <A, B, C, D, E, F, G, H, I, J, K>(
            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>,
        ): (a: A) => K;
        <A, B, C, D, E, F, G, H, I, J, K, L>(
            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>,
        ): (a: A) => L;
        <A, B, C, D, E, F, G, H, I, J, K, L, M>(
            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>,
        ): (a: A) => M;
        <A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
            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>,
        ): (a: A) => N;
        <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
            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>,
        ): (a: A) => O;
        <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
            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>,
        ): (a: A) => P;
        <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
            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>,
        ): (a: A) => Q;
        <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
            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>,
        ): (a: A) => R;
        <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(
            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>,
        ): (a: A) => S;
        <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(
            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>,
        ): (a: A) => T;
        <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(
            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>,
        ): (a: A) => U;
        <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V>(
            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>,
        ): (a: A) => V;
        <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W>(
            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>,
        ): (a: A) => W;
        <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>(
            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>,
        ): (a: A) => X;
        <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>(
            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>,
        ): (a: A) => Y;
    }

    Type definition for pipe0 with various arities

    Type Declaration

      • <A>(): (a: A) => A

      • Type Parameters

        • A

        Returns (a: A) => A

      • <A, B>(b: Z<A, B>): (a: A) => B

      • Type Parameters

        • A
        • B

        Parameters

        • b: Z<A, B>

        Returns (a: A) => B

      • <A, B, C>(b: Z<A, B>, c: Z<B, C>): (a: A) => C

      • Type Parameters

        • A
        • B
        • C

        Parameters

        • b: Z<A, B>
        • c: Z<B, C>

        Returns (a: A) => C

      • <A, B, C, D>(b: Z<A, B>, c: Z<B, C>, d: Z<C, D>): (a: A) => D

      • Type Parameters

        • A
        • B
        • C
        • D

        Parameters

        • b: Z<A, B>
        • c: Z<B, C>
        • d: Z<C, D>

        Returns (a: A) => D

      • <A, B, C, D, E>(b: Z<A, B>, c: Z<B, C>, d: Z<C, D>, e: Z<D, E>): (a: A) => E

      • Type Parameters

        • A
        • B
        • C
        • D
        • E

        Parameters

        • b: Z<A, B>
        • c: Z<B, C>
        • d: Z<C, D>
        • e: Z<D, E>

        Returns (a: A) => E

      • <A, B, C, D, E, F>(
            b: Z<A, B>,
            c: Z<B, C>,
            d: Z<C, D>,
            e: Z<D, E>,
            f: Z<E, F>,
        ): (a: A) => F

      • Type Parameters

        • A
        • B
        • C
        • D
        • E
        • F

        Parameters

        • b: Z<A, B>
        • c: Z<B, C>
        • d: Z<C, D>
        • e: Z<D, E>
        • f: Z<E, F>

        Returns (a: A) => F

      • <A, B, C, D, E, F, G>(
            b: Z<A, B>,
            c: Z<B, C>,
            d: Z<C, D>,
            e: Z<D, E>,
            f: Z<E, F>,
            g: Z<F, G>,
        ): (a: A) => G

      • Type Parameters

        • A
        • B
        • C
        • D
        • E
        • F
        • G

        Parameters

        • 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 (a: A) => G

      • <A, B, C, D, E, F, G, H>(
            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>,
        ): (a: A) => H

      • Type Parameters

        • A
        • B
        • C
        • D
        • E
        • F
        • G
        • H

        Parameters

        • 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 (a: A) => H

      • <A, B, C, D, E, F, G, H, I>(
            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>,
        ): (a: A) => I

      • Type Parameters

        • A
        • B
        • C
        • D
        • E
        • F
        • G
        • H
        • I

        Parameters

        • 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 (a: A) => I

      • <A, B, C, D, E, F, G, H, I, J>(
            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>,
        ): (a: A) => J

      • Type Parameters

        • A
        • B
        • C
        • D
        • E
        • F
        • G
        • H
        • I
        • J

        Parameters

        • 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 (a: A) => J

      • <A, B, C, D, E, F, G, H, I, J, K>(
            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>,
        ): (a: A) => K

      • Type Parameters

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

        Parameters

        • 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 (a: A) => K

      • <A, B, C, D, E, F, G, H, I, J, K, L>(
            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>,
        ): (a: A) => L

      • Type Parameters

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

        Parameters

        • 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 (a: A) => L

      • <A, B, C, D, E, F, G, H, I, J, K, L, M>(
            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>,
        ): (a: A) => M

      • Type Parameters

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

        Parameters

        • 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 (a: A) => M

      • <A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
            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>,
        ): (a: A) => N

      • Type Parameters

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

        Parameters

        • 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 (a: A) => N

      • <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
            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>,
        ): (a: A) => O

      • Type Parameters

        • A
        • B
        • C
        • D
        • E
        • F
        • G
        • H
        • I
        • J
        • K
        • L
        • M
        • N
        • O

        Parameters

        • 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 (a: A) => O

      • <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
            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>,
        ): (a: A) => P

      • Type Parameters

        • A
        • B
        • C
        • D
        • E
        • F
        • G
        • H
        • I
        • J
        • K
        • L
        • M
        • N
        • O
        • P

        Parameters

        • 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 (a: A) => P

      • <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
            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>,
        ): (a: A) => Q

      • Type Parameters

        • A
        • B
        • C
        • D
        • E
        • F
        • G
        • H
        • I
        • J
        • K
        • L
        • M
        • N
        • O
        • P
        • Q

        Parameters

        • 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 (a: A) => Q

      • <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
            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>,
        ): (a: A) => R

      • Type Parameters

        • A
        • B
        • C
        • D
        • E
        • F
        • G
        • H
        • I
        • J
        • K
        • L
        • M
        • N
        • O
        • P
        • Q
        • R

        Parameters

        • 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 (a: A) => R

      • <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(
            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>,
        ): (a: A) => S

      • Type Parameters

        • A
        • B
        • C
        • D
        • E
        • F
        • G
        • H
        • I
        • J
        • K
        • L
        • M
        • N
        • O
        • P
        • Q
        • R
        • S

        Parameters

        • 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 (a: A) => S

      • <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(
            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>,
        ): (a: A) => T

      • Type Parameters

        • A
        • B
        • C
        • D
        • E
        • F
        • G
        • H
        • I
        • J
        • K
        • L
        • M
        • N
        • O
        • P
        • Q
        • R
        • S
        • T

        Parameters

        • 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 (a: A) => T

      • <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(
            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>,
        ): (a: A) => U

      • Type Parameters

        • A
        • B
        • C
        • D
        • E
        • F
        • G
        • H
        • I
        • J
        • K
        • L
        • M
        • N
        • O
        • P
        • Q
        • R
        • S
        • T
        • U

        Parameters

        • 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 (a: A) => U

      • <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V>(
            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>,
        ): (a: A) => V

      • 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

        • 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 (a: A) => V

      • <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W>(
            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>,
        ): (a: A) => W

      • 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

        • 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 (a: A) => W

      • <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>(
            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>,
        ): (a: A) => X

      • 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

        • 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 (a: A) => X

      • <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>(
            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>,
        ): (a: A) => Y

      • 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

        • 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 (a: A) => Y

    Settings
    Member Visibility