Is it possible to create a type with a generic rest type?

Question

Following the question on creating a choice between types Defining a choice of index type on an interface

I now have to create a sequence of elements, usually it can be written as element1 & element2, but since i am converting an XSD schema i want it to be a 1-to-1 match, so that new TypeScript developers won't be confused with what is going on.

Currently i have this type

type Object_Type<T> = { [P in keyof T]: T[P] };
type Sequence<A, B = {}, C = {}, D = {}, E = {}, F = {}, G = {}, H = {}, I = {}, J = {}, K = {}, L = {}, M = {}, N = {}> =
    Object_Type<A>
    & Object_Type<B>
    & Object_Type<C>
    & Object_Type<D>
    & Object_Type<E>
    & Object_Type<F>
    & Object_Type<G>
    & Object_Type<H>
    & Object_Type<I>
    & Object_Type<J>
    & Object_Type<K>
    & Object_Type<L>
    & Object_Type<M>
    & Object_Type<N>;

And can be used like this

const sequence: Sequence<{name: string}, {age: number}> = {
    name: "John",
    age: 999
};

However, it is quite extreme to manually have to define every single generic parameter, and also giving them a default value, so i was wondering if it was possible to define like so

type Sequence<...T> = Object_Type<...T>;

jcalz · Accepted Answer · 2019-02-24T18:47:52.663

2

There are no explicit variadic kinds in TypeScript, so the exact formulation like Sequence<...T> doesn't work. But you could use a tuple type instead as in Sequence<[{name: string}, {age: number}]>. Given a tuple type you could map it with Object_Type, convert the tuple to a union by looking up its number property, and then convert the union to an intersection.

type Object_Type<T> = { [P in keyof T]: T[P] };
type UnionToIntersection<U> =
  (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
type Sequence<T extends any[]> = 
  UnionToIntersection<{ [K in keyof T]: Object_Type<T[K]> }[number]>;

const sequence: Sequence<[{ name: string }, { age: number }]> = {
  name: "John",
  age: 999
};

That works, although there might be some edge cases that differ (e.g., if your individual A, B, etc types are themselves unions). These could likely be hammered out, but... I guess I don't understand the use case here. Object_Type is mostly a no-op, so what are you doing with it? What do you gain by the expression Sequence<A,B,C> (or Sequence<[A,B,C]> in my version) that you don't get by A & B & C? Maybe if you elaborate, there'd be an easier or better solution for what you're trying to do.

edited Feb 24 '19 at 18:47

answered Feb 24 '19 at 18:42

jcalz

264,269
27
359
360

The use case is mostly for developers who aren't used to TypeScript, then when they look at the XSD schema and the index.d.ts generated, then they see the similarities. `Object_Type` was so i didn't have to write `{ [P in keyof T]: T[P] }` over and over again. I changed Sequence to `type Sequence = UnionToIntersection<{ [K in keyof T]: T[K] }[number]>;`. Also the lookup type [number] is that like writing T[0], T[1], T[N], so it checks through every T in the array? Is it possible to do `number-1`, For the Xor use case which you helped me with earlier. – Pavlo Feb 24 '19 at 19:03
1

`{[P in keyof T]: T[P]}` is pretty much equivalent to `T`, especially for types like `{name: string}`. Why are you not just using `T`? – jcalz Feb 24 '19 at 19:10
1

`T[number]` is just looking up the value at the [`number` index](https://www.typescriptlang.org/docs/handbook/interfaces.html#indexable-types), which all arrays (even tuples) have. It is conceptually the same as saying `T[0] | T[1] | T[2] | ... ` for all number literals, but it is not implemented that way. The `number` type is a type for all numbers, so I'm not sure what you mean by `number-1`. – jcalz Feb 24 '19 at 19:14
I see that `boolean` is not allowed tuple parameter when writing `T[number]`, that was my worry. For the second comment, It was the `Xor>` problem, where it would be written as `Xor` where `T[number+1]` would be the result of evaluating `T[number+1]`, so `Xor<[A,B,C]> = Xor >` – Pavlo Feb 24 '19 at 19:35
I'm really not following you, unfortunately. I don't understand "`boolean` is not allowed tuple parameter when writing `T[number]`". Can you provide concrete examples of what you mean? – jcalz Feb 24 '19 at 19:46
`T[number+1]` is not valid code (neither `+` nor `-` are type operators) but *possibly* what you want to do is programmatically turn a tuple type like `[A, B, C, D]` into `Xor>>`, which would be a recursive definition (which would probably run afoul of some limitations), but in the specific case of `Xor` you can write a version which acts on unions and so you can just do `MultiXor<[A, B, C, D][number]>`. So again I'm kind of stumped about what you mean without concrete code examples... and probably in a different question (or an edit to this one) and not in comments. – jcalz Feb 24 '19 at 19:47
`type Sequence = UnionToIntersection;` `const sequence: Sequence<[{name: string}, boolean]>` is not allowed because it can't be both an object and a boolean. The link in the top of the question, is where you helped me making a MultiXor. This question was kind of a followup question to Defining a choice of index type on an interface – Pavlo Feb 24 '19 at 20:09

Is it possible to create a type with a generic rest type?

1 Answers1