Proposal: Typing an operator that takes an array (tuple) as an argument

[yukiyokotani]

Currently, operators that take an array (strictly speaking, a tuple in TypeScript) as an argument are typed separately according to the length of the array.
For example, the case of combineLatest is as follows.

// case the length of the array is 1
export declare function combineLatest<
  O1 extends ObservableInput<any>
>(sources: [O1]): Observable<[ObservedValueOf<O1>]>;

// case the length of the array is 2
export declare function combineLatest<
  O1 extends ObservableInput<any>,
  O2 extends ObservableInput<any>
>(sources: [O1, O2]): Observable<[ObservedValueOf<O1>, ObservedValueOf<O2>]>;

// case the length of the array is 3
...
// case the length of the array is 4
...
// case the length of the array is 5
...
// case the length of the array is 6
...

However, they can be aggregated into a single type definition using Valiadic Tuple Types, as follows.

export declare function combineLatest<
  T extends ReadonlyArray<ObservableInput<unknown>>
>(
  souces: [...T]
): Observable<
  [
    ...{
      [K in keyof T]: ObservedValueOf<T[K]>;
    }
  ]
>;

This not only completes a single type definition, but also allows for tuple arguments of arbitrary length.

While there are some advantages in terms of type, I think the scope for modification is large.
How do you all feel about this proposal?

Thanks in advance.

[yukiyokotani]

Sorry, I was referring to an older version. I'm taking it down.