Typescript, combine object types of tuple elements

Question

Is it possible to take a tuple of different objects, and get a type of all of these objects combined? For example if i have a tuple like this:

const t = tuple({current: 1}, {old: 2}, {new: 3}); //this should be interpreted as [{current: number;}, {old: number;}, {new: number;}]

and then i combine those objects into a single one:

let newob = {};
for(let ob of t) {
  Object.assign(newob, ob);
}

can I somehow make typescript treat this new object as a

typeof t[0] & typeof t[1] & typeof t[2]

which in this case would be

{current: number; old: number; new: number;}

without manually typing that all?

I'd like it to work with any tuple and any objects inside tuple

Titian Cernicova-Dragomir · Accepted Answer · 2024-02-08 23:47:46Z

0

You can capture the parameters in a tuple type using a generic type parameter with a constraint of any[] for a rest parameter. You can the use UnionToIntersection described here to merge all tuple item types into a single intersection type

type UnionToIntersection<U> = 
  (U extends any ? (k: U)=>void : never) extends ((k: infer I)=>void) ? I : never
function tuple<T extends any[]>(...t: T) {
  let newob = {} ;
  for (let ob of t) {
    Object.assign(newob, ob);
  }
  return newob as UnionToIntersection<T[number]>;
}

Playground Link

edited Feb 8, 2024 at 23:47

answered Oct 29, 2020 at 13:45

Titian Cernicova-Dragomir

253k37 gold badges466 silver badges396 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

ncpa0cpl Over a year ago

Thanks, this does work. However I noticed a strange behavior, it isn't really a big problem, but if you try to put into tuple two class instance objects, and both of them have a private method of the same name, the whole thing return type of 'never'. Doesn't happen if methods are public or protected. Here's demo

Lin Du Over a year ago

There is a No overload matches this call error.

Titian Cernicova-Dragomir Over a year ago

@LinDu fixed the build error. Some type compatibility changed since posted this 4 years ago

user-id-14900042 · Accepted Answer · 2024-02-09 00:21:52Z

0

Following snippet types better your arguments and return types:

type Cast<From, To> = From extends To ? From : never;
type FoldIntoIntersection<T extends readonly {}[], Acc extends {} = {}> = T extends readonly [infer H, ...infer HS] 
    ? FoldIntoIntersection<Cast<HS, readonly {}[]>, Acc & H> 
    : Acc;

function tuple<const T extends readonly {}[]>(...t: T) {
  let newob: FoldIntoIntersection<T> = {} as any;
  for (let ob of t) {
    Object.assign(newob, ob);
  }
  return newob;
}

answered Feb 9, 2024 at 0:21

user-id-14900042

1,3448 silver badges19 bronze badges

1 Comment

Titian Cernicova-Dragomir Over a year ago

A good answer, I'd still choose UnionToIntersection. The behavior is built into the compiler and is probably faster than a recursive conditional type (even a tail recursive one)

Collectives™ on Stack Overflow

Typescript, combine object types of tuple elements

2 Answers 2

3 Comments

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

3 Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related