effex-monorepo
    Preparing search index...

    Interface SignalArray<T>

    A reactive array that extends Signal with array-specific mutation methods. Mutations happen in-place without cloning, then trigger reactive updates.

    const todos = yield* Signal.Array.make<Todo>([]);

    // In-place mutations
    yield* todos.push({ id: 1, text: "Learn Effex", done: false });
    yield* todos.removeAt(0);

    // Transform entire array (inherited from Signal)
    yield* todos.update(arr => arr.filter(t => !t.done));

    // Use with Control.each
    each(todos, { container: () => $.ul(), key: t => t.id, render: renderTodo })
    interface SignalArray<T> {
        "[SignalTypeId]": typeof SignalTypeId;
        "[TypeId]": typeof ReadableTypeId;
        changes: Stream<readonly T[]>;
        clear: () => Effect<void>;
        get: Effect<readonly T[]>;
        insertAt: (index: number, item: T) => Effect<void>;
        length: Readable.Readable<number>;
        move: (fromIndex: number, toIndex: number) => Effect<void>;
        pop: () => Effect<Option<T>>;
        push: (...items: T[]) => Effect<void>;
        remove: (item: T) => Effect<boolean>;
        removeAt: (index: number) => Effect<Option<T>>;
        reverse: () => Effect<void>;
        set: (a: readonly T[]) => Effect<void>;
        shift: () => Effect<Option<T>>;
        sort: (compareFn?: (a: T, b: T) => number) => Effect<void>;
        splice: (
            start: number,
            deleteCount?: number,
            ...items: T[],
        ) => Effect<readonly T[]>;
        swap: (indexA: number, indexB: number) => Effect<void>;
        unshift: (...items: T[]) => Effect<void>;
        update: (f: (a: readonly T[]) => readonly T[]) => Effect<void>;
        values: Stream<readonly T[]>;
        pipe<A>(this: A): A;
        pipe<A, B = never>(this: A, ab: (_: A) => B): B;
        pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
        pipe<A, B = never, C = never, D = never>(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
        ): D;
        pipe<A, B = never, C = never, D = never, E = never>(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
        ): E;
        pipe<A, B = never, C = never, D = never, E = never, F = never>(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
        ): F;
        pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
        ): G;
        pipe<
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
        ): H;
        pipe<
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
        ): I;
        pipe<
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
        ): J;
        pipe<
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
        ): K;
        pipe<
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
        ): L;
        pipe<
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
        ): M;
        pipe<
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
            N = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
            mn: (_: M) => N,
        ): N;
        pipe<
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
            N = never,
            O = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
            mn: (_: M) => N,
            no: (_: N) => O,
        ): O;
        pipe<
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
            N = never,
            O = never,
            P = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
            mn: (_: M) => N,
            no: (_: N) => O,
            op: (_: O) => P,
        ): P;
        pipe<
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
            N = never,
            O = never,
            P = never,
            Q = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
            mn: (_: M) => N,
            no: (_: N) => O,
            op: (_: O) => P,
            pq: (_: P) => Q,
        ): Q;
        pipe<
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
            N = never,
            O = never,
            P = never,
            Q = never,
            R = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
            mn: (_: M) => N,
            no: (_: N) => O,
            op: (_: O) => P,
            pq: (_: P) => Q,
            qr: (_: Q) => R,
        ): R;
        pipe<
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
            N = never,
            O = never,
            P = never,
            Q = never,
            R = never,
            S = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
            mn: (_: M) => N,
            no: (_: N) => O,
            op: (_: O) => P,
            pq: (_: P) => Q,
            qr: (_: Q) => R,
            rs: (_: R) => S,
        ): S;
        pipe<
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
            N = never,
            O = never,
            P = never,
            Q = never,
            R = never,
            S = never,
            T = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
            mn: (_: M) => N,
            no: (_: N) => O,
            op: (_: O) => P,
            pq: (_: P) => Q,
            qr: (_: Q) => R,
            rs: (_: R) => S,
            st: (_: S) => T,
        ): T;
        pipe<
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
            N = never,
            O = never,
            P = never,
            Q = never,
            R = never,
            S = never,
            T = never,
            U = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
            mn: (_: M) => N,
            no: (_: N) => O,
            op: (_: O) => P,
            pq: (_: P) => Q,
            qr: (_: Q) => R,
            rs: (_: R) => S,
            st: (_: S) => T,
            tu: (_: T) => U,
        ): U;
        pipe<
            A,
            B = never,
            C = never,
            D = never,
            E = never,
            F = never,
            G = never,
            H = never,
            I = never,
            J = never,
            K = never,
            L = never,
            M = never,
            N = never,
            O = never,
            P = never,
            Q = never,
            R = never,
            S = never,
            T = never,
            U = never,
        >(
            this: A,
            ab: (_: A) => B,
            bc: (_: B) => C,
            cd: (_: C) => D,
            de: (_: D) => E,
            ef: (_: E) => F,
            fg: (_: F) => G,
            gh: (_: G) => H,
            hi: (_: H) => I,
            ij: (_: I) => J,
            jk: (_: J) => K,
            kl: (_: K) => L,
            lm: (_: L) => M,
            mn: (_: M) => N,
            no: (_: N) => O,
            op: (_: O) => P,
            pq: (_: P) => Q,
            qr: (_: Q) => R,
            rs: (_: R) => S,
            st: (_: S) => T,
            tu: (_: T) => U,
        ): U;
    }

    Type Parameters

    • T

      The type of array elements

    Hierarchy (View Summary)

    Index

    Properties

    [SignalTypeId] [TypeId] changes clear get insertAt length move pop push remove removeAt reverse set shift sort splice swap unshift update values

    Methods

    pipe

    Properties

    "[SignalTypeId]": typeof SignalTypeId
    "[TypeId]": typeof ReadableTypeId
    changes: Stream<readonly T[]>

    Stream of value changes (does not include current value)

    clear: () => Effect<void>

    Remove all elements from the array.

    get: Effect<readonly T[]>

    Get the current value

    insertAt: (index: number, item: T) => Effect<void>

    Insert an element at a specific index.

    length: Readable.Readable<number>

    Reactive length of the array.

    move: (fromIndex: number, toIndex: number) => Effect<void>

    Move an element from one index to another. Useful for drag-and-drop reordering.

    pop: () => Effect<Option<T>>

    Remove and return the last element, returning Option.none() if empty.

    push: (...items: T[]) => Effect<void>

    Add one or more elements to the end of the array.

    remove: (item: T) => Effect<boolean>

    Remove the first occurrence of an element (by reference equality). Returns true if the element was found and removed.

    removeAt: (index: number) => Effect<Option<T>>

    Remove the element at a specific index, returning Option.none() if out of bounds.

    reverse: () => Effect<void>

    Reverse the array in-place.

    set: (a: readonly T[]) => Effect<void>

    Set the signal to a new value

    shift: () => Effect<Option<T>>

    Remove and return the first element, returning Option.none() if empty.

    sort: (compareFn?: (a: T, b: T) => number) => Effect<void>

    Sort the array in-place.

    splice: (
        start: number,
        deleteCount?: number,
        ...items: T[],
    ) => Effect<readonly T[]>

    Insert, remove, or replace elements at a specific index. Mirrors Array.prototype.splice.

    swap: (indexA: number, indexB: number) => Effect<void>

    Swap two elements at the given indices.

    unshift: (...items: T[]) => Effect<void>

    Add one or more elements to the beginning of the array.

    update: (f: (a: readonly T[]) => readonly T[]) => Effect<void>

    Update the signal value using a function

    values: Stream<readonly T[]>

    Stream of all values (current value followed by changes)

    Methods

    • Type Parameters

      • A

      Parameters

      • this: A

      Returns A

    • Type Parameters

      • A
      • B = never

      Parameters

      • this: A
      • ab: (_: A) => B

      Returns B

    • Type Parameters

      • A
      • B = never
      • C = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C

      Returns C

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D

      Returns D

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E

      Returns E

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never
      • F = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F

      Returns F

    • Type Parameters

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

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G

      Returns G

    • Type Parameters

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

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H

      Returns H

    • Type Parameters

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

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I

      Returns I

    • Type Parameters

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

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J

      Returns J

    • Type Parameters

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

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K

      Returns K

    • Type Parameters

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

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L

      Returns L

    • Type Parameters

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

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M

      Returns M

    • Type Parameters

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

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M
      • mn: (_: M) => N

      Returns N

    • Type Parameters

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

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M
      • mn: (_: M) => N
      • no: (_: N) => O

      Returns O

    • Type Parameters

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

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M
      • mn: (_: M) => N
      • no: (_: N) => O
      • op: (_: O) => P

      Returns P

    • Type Parameters

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

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M
      • mn: (_: M) => N
      • no: (_: N) => O
      • op: (_: O) => P
      • pq: (_: P) => Q

      Returns Q

    • Type Parameters

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

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M
      • mn: (_: M) => N
      • no: (_: N) => O
      • op: (_: O) => P
      • pq: (_: P) => Q
      • qr: (_: Q) => R

      Returns R

    • Type Parameters

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

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M
      • mn: (_: M) => N
      • no: (_: N) => O
      • op: (_: O) => P
      • pq: (_: P) => Q
      • qr: (_: Q) => R
      • rs: (_: R) => S

      Returns S

    • Type Parameters

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

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M
      • mn: (_: M) => N
      • no: (_: N) => O
      • op: (_: O) => P
      • pq: (_: P) => Q
      • qr: (_: Q) => R
      • rs: (_: R) => S
      • st: (_: S) => T

      Returns T

    • Type Parameters

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

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M
      • mn: (_: M) => N
      • no: (_: N) => O
      • op: (_: O) => P
      • pq: (_: P) => Q
      • qr: (_: Q) => R
      • rs: (_: R) => S
      • st: (_: S) => T
      • tu: (_: T) => U

      Returns U

    • Type Parameters

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

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M
      • mn: (_: M) => N
      • no: (_: N) => O
      • op: (_: O) => P
      • pq: (_: P) => Q
      • qr: (_: Q) => R
      • rs: (_: R) => S
      • st: (_: S) => T
      • tu: (_: T) => U

      Returns U

    Settings

    Member Visibility

    On This Page

    Properties
    Methods