Tuple iteration and merging

[dead-claudia]

Edit: Remove indexing part
Edit 2: Replace tuple mapping syntax with normal mapped types

Search Terms

Concatentate and merge tuples' entries.

Suggestion

1. I would like to be able to extract and spread in positions other than the last part of a tuple.
2. I would like to merge a tuple into an intersection or concatenation of its members.

Use Cases

• Converting a tuple to its intersection, such as with Object.assign's assignee.
• Typing Array.prototype.concat correctly for tuples.

Syntax

The syntax comes in a few new forms:

• [...A, B] appends B to the tuple A. Similarly, [...infer A, any] extends B ? A : [] drops the last item of the tuple and [...any[], infer A] extends B ? A : never extracts the first.
• {... ...T} for an n-ary merge and [... ...T] an n-ary concatenation.

Examples

Here's the types for each method I mentioned above.

interface Array<T> {
 concat<U extends any[]>(...others: U): [...this, ... ...{[I in keyof U]: (
 U[I] extends any[] ? N : U[I] extends ArrayLike<infer R> ? R[] : [U[I]]
 )}];
}

interface ObjectConstructor {
 assign(target: {... ...typeof sources}, ...sources: object[]): typeof target;
}

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. new expression-level syntax)

[ajafff]

And finally, merging is just syntax sugar now: {...A, ...B} ↔ (& ...[A, B])

I don't think this is correct. It should behave like object spread in JS and override existing properties.

type T = {... {a: string}, ...{a: number}};
// should result in
type T = {a: number};
// instead of
type T = {a: string} & {a: number};

[dead-claudia]

Klaus Meinhardt (@ajafff) Fixed by removing the line. I forgot about that bit.

[AlCalzone]

The 1st part:

I would like to be able to extract and spread in positions other than the last part of a tuple.

Seems to be a duplicate of: #25717 and therefore #1360

[dead-claudia]

AlCalzone For the first half, probably, but the second half is likely not.

[bterlson]

See also #5453 for part 1.

[dead-claudia]

BTW, I updated the proposal to leverage this recently-merged PR.

[weswigham]

Converting a tuple to its union, such as with Promise.race's return value.

Doesn't

type TupleTypes<T extends unknown[]> = T[number]

?
work for that?

[dead-claudia]

Wesley Wigham (@weswigham) Good catch - no clue how that escaped me. I updated the proposal comment to drop that (and those covered by #26063), but the issue with concatenation and Object.assign still remains.

I changed up the proposed syntax a little, too, to better fit in:

• Merge all: {... ...T}
• Concatenate all: [... ...T]

Of course, that space in the middle isn't significant, just explains how it's tokenized.

[weswigham]

Converting a tuple to its intersection, such as with Object.assign's assignee.

Ignoring tuples for a second, I want a way to easily convert any union to an intersection. But y'know, I think it is doable, if cumbersome:

type MergeArguments<T, K extends string = "whatever"> =
 {
 [Key in K]: T extends (first: infer A) => void ? A :
 MergeOnePlus<T, K>
 }[K];

type MergeOnePlus<T, K extends string> =
 {
 [Key in K]: T extends (first: infer A, ...args: infer U) => void ? A & MergeArguments<(...args: U) => void, K> :
 never
 }[K];

type IntoSignature<T extends unknown[]> = (...args: T) => void;

type MergeTupleMembers<T extends unknown[]> = MergeArguments<IntoSignature<T>>;

type SomeTuple = [{ x: 1 }, { y: 2 }, { z: 3 }];

type Merged = MergeTupleMembers<SomeTuple>;

const x: Merged = {
 x: 1,
 y: 2,
 z: 3
};

It's a bit ridiculous, but.... possible.

[dead-claudia]

Wesley Wigham (@weswigham) That might very well solve the issue of both concatenation and merging, if I'm reading it correctly.

By any chance, would that still work if you did this to do concatenation?

type ConcatenateOnePlus<T, K extends string> =
 {
 [Key in K]: T extends (first: infer A, ...args: infer U) => void ? [A, ...ConcatenateArguments<(...args: U) => void, K>] :
 never
 }[K];

Or would that be dependent on #25717 / #1360?