FuncType - v1.4.1
    Preparing search index...

    Variable Tuple

    Tuple: <T extends unknown[]>(values: T) => Tuple<T> & {
        empty: () => Tuple<[]>;
        from: <T extends unknown[]>(values: T) => Tuple<T>;
        fromJSON: <T extends unknown[]>(json: string) => Tuple<T>;
        of: <T extends unknown[]>(...values: T) => Tuple<T>;
        pair: <A extends unknown, B extends unknown>(
            first: A,
            second: B,
        ) => Tuple<[A, B]>;
        triple: <A extends unknown, B extends unknown, C extends unknown>(
            first: A,
            second: B,
            third: C,
        ) => Tuple<[A, B, C]>;
    }

    Tuple provides a type-safe, fixed-length array with functional operations.

    Type Declaration

      • <T extends unknown[]>(values: T): Tuple<T>

      • Type Parameters

        • T extends unknown[]

        Parameters

        • values: T

        Returns Tuple<T>

    • empty: () => Tuple<[]>

      Create an empty Tuple

      const empty = Tuple.empty()
      // TypeScript infers: Tuple<[]>
    • from: <T extends unknown[]>(values: T) => Tuple<T>

      Create a Tuple from an array (alias for constructor)

      const t = Tuple.from([1, 2, 3])
    • fromJSON: <T extends unknown[]>(json: string) => Tuple<T>

      Reconstruct a Tuple from a JSON envelope emitted by serialize().toJSON() or instance toJSON(). Verifies @functype === "Tuple" if the marker is present (the marker became canonical in 1.2.0; older envelopes are accepted by leniently treating missing-marker as opt-in legacy).

    • of: <T extends unknown[]>(...values: T) => Tuple<T>

      Create a Tuple from multiple arguments

      const t = Tuple.of(1, "hello", true)
      // TypeScript infers: Tuple<[number, string, boolean]>
    • pair: <A extends unknown, B extends unknown>(first: A, second: B) => Tuple<[A, B]>

      Create a Tuple of size 2 (pair)

      const pair = Tuple.pair("key", 42)
      // TypeScript infers: Tuple<[string, number]>
    • triple: <A extends unknown, B extends unknown, C extends unknown>(
          first: A,
          second: B,
          third: C,
      ) => Tuple<[A, B, C]>

      Create a Tuple of size 3 (triple)

      const triple = Tuple.triple("x", 10, true)
      // TypeScript infers: Tuple<[string, number, boolean]>

    // Creating tuples
    const t1 = Tuple([1, "hello", true])
    const t2 = Tuple.of(1, "hello", true)
    const pair = Tuple.pair("key", 42)

    // Type-safe access
    const triple = Tuple.triple("x", 10, true)
    const first = triple.get(0)  // string
    const second = triple.get(1) // number
    const third = triple.get(2)  // boolean

    // Functional operations
    const doubled = Tuple([1, 2, 3])
      .map(arr => arr.map(x => x * 2))
      .toArray() // [2, 4, 6]

    Settings

    Member Visibility