Convert named tuple into object literal type.

Search Terms

refactor

Suggestion

Provide a refactor that convert named tuple into object literal type.

Use Cases

Now we have named tuple. It’s common to write a tuple to pass multiple value. As time goes on, you may add many other fields into tuple. You cannot take a subsequence in the middle or the end of the tuple. If we could convert that into an object, That would be useful.

Examples

type Tuple = [number, number]

function aggregate(items: number[]): Tuple {
  // ...
  return [min, max]
}

const [ min, max ] = aggregate(items)

Growth to

type Tuple = [number, number, number, number, number, number]

function aggregate(items: number[]): Tuple {
  // ...
  return [min, max, avg, mid, first, last]
}

const [ min, max, avg, mid, first, last ] = aggregate(items)

If we want first and last only

const [ , , , , first, last ] = aggregate(items) // too many '.'

const result = aggregate(items);
const first = result[4] // magic number
const last = result[5]  // magic number

If we have the refactor

// add names into tuple
type Tuple = [min: number, max: number, avg: number, mid: number, first: number, last: number]

// apply refactor
type Tuple = {min: number, max: number, avg: number, mid: number, first: number, last: number}

function aggregate(items: number[]): Tuple {
  // ...
  return {min, max, avg, mid, first, last}
}

const { first, last } = aggregate(items)

Checklist

My suggestion meets these guidelines:

• This wouldn’t be a breaking change in existing TypeScript/JavaScript code
• This wouldn’t change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn’t a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript’s Design Goals.

[Rycochet]

Another use-case is the Parameters<fn> utility call - it returns a named tuple, but occasionally I want to change a long list of arguments (for a library so out of my control) into an object for a wrapper - if I could just do a single extra wrapper for TupleToObject<Parameters<fn>> then this would simplify the typings slightly, and ensure that they’re always correct if the arguments change (while currently they might change, but the types might not change enough to trigger a compiler warning).

[harrysolovay]

A good solution might depend on an intrinsic utility type for tuple label access.

type X = [first: string, second: number];
type Label0 = Label<X, 0>; // "first"
type Label0 = Label<X, 1>; // "second"

One could perform the mapping like so:

type XAsRec = {
  [I in Extract<keyof X, number> as Label<X, I>]: X[I];
} // {first: string; second: number}