Type Challenges: 00020-medium-promise-all Solution

declare function PromiseAll<T extends any[]>(values: readonly [...T]): Promise<{
  [P in keyof T]: T[P] extends Promise<infer R> | infer R ? R : never
}>

Solution by DevShinnThant #34567

declare function PromiseAll<T extends any[]>(values: T): Promise<{
  [K in keyof T]: Awaited<T[K]>
}>

Solution by ktim816 #34445

// 如果函数入参为[1, true, 'str']，此时T为[number, boolean, string]，keyof T为['0', '1', '2']
type MyAwaited<T> = T extends Promise<infer R> ? MyAwaited<R> : T
declare function PromiseAll<T extends any[]>(values: readonly [...T]): Promise<{
  [P in keyof T]: MyAwaited<T[P]>
}>

Solution by ouzexi #33991

type MyAwaited<T> = T extends Promise<infer P> ? MyAwaited<P> : T
declare function PromiseAll<T extends Array<unknown>>(value: [...T]): Promise<{
  [P in keyof T]: MyAwaited<T[P]>
}>

Solution by Danny101201 #33836

declare function PromiseAll<T extends any[]>(arr: readonly [...T]): Promise<{ [K in keyof T]:T[K] extends Promise ? P :T[K]}>

Solution by rookiewxy #33672

// your answers
declare function PromiseAll<V extends any[]>(values: [...V]): 
  Promise<{ [K in keyof V]: V[K] extends Promise<infer P> ? P : V[K] extends number ? V[K] : number}>;

Solution by nupthale #33583

declare function PromiseAll<T extends any[]>(values: [...T]) :Promise<{[K in keyof T] : Awaited<T[K]>}>

Solution by raymondanythings #33475

declare function PromiseAll<T extends any[]>(values: readonly [...T]): Promise<{ [K in keyof T]: T[K] extends Promise<infer P> | infer P ? P : never}>

Solution by Tubring25 #33295

// your answers

declare function PromiseAll<T extends unknown[] | []>(value: T): Promise<{
  -readonly [P in keyof T]: Awaited<T[P]>
}>

Solution by KeithChou #33252

// 你的答案
type P1<T extends any[]> = {
  [K in keyof T]: T[K] extends PromiseLike<infer R> ? R : T[K];
};

declare function PromiseAll<T extends any[]>(arr:readonly [...T] ): P1<T>;

Solution by 2531800823 #33244

type Awaited<T> = T extends PromiseLike<infer R> ? Awaited<R> : T

declare function PromiseAll<V extends unknown[]>(values: [...V]): Promise<{
  [P in keyof V]: Awaited<V[P]>
}>

Solution by Taneros #33044

// 解答をここに記入
declare function PromiseAll<T extends readonly any[]>(values: [...T]): Promise<{
  [Key in keyof T]: Awaited<T[Key]>
}>

型引数Tを使用するためにPromiseAllに型引数設定を追加。
返り値はPromise<T>になるように記述。
Tの配列内を1つずつPromiseが解決された後の方に変換する必要があるため、Awaited<T>のようなことがしたい。
- ただしAwaited<T>では配列内の各要素ではなく、配列自体がPromiseであるような扱われ方をしてしまう。
- なので配列内の要素1つずつにAwaitedをするため、[Key in keyof T]: Awaited<T[Key]>とする。

Solution by Yasunori-aloha #32880

// 你的答案
declare function PromiseAll<T extends any[]>(values: [...T]): 
    Promise<{[K in keyof T]: Awaited<T[K]>}>

Solution by geweidong #32764

题目的两个关键：

理解 Tuple 也是一种对象，要用Mapped Type来构建。这点有想到。
要把输入的 T 进行 const 推演。一开始我用 PromiseAll<const T extends unknown[]> 来实现，这样导致 test case 3, 4 也进行 const 推演。其实这样蛮好的，不过不符合 test case。最后采用下面这种 readonly [...T] 的方式。

declare function PromiseAll<T extends unknown[]>(values: readonly [...T]):
  Promise<{ [K in keyof T]: Awaited<T[K]>;

Solution by mistkafka #32644

declare function PromiseAll<const T extends unknown[]>(values: T): 
    Promise<{[K in keyof T]: Awaited<T[K]>}>

Solution by wubrafiq807 #32555

declare function PromiseAll<T extends unknown[]>(values: [...T]): 
  Promise<{[K in keyof T]: Awaited<T[K]> }>

Solution by dev-hobin #32362

// your answers

declare function PromiseAll<T extends any[]>(values: readonly [...T]): Promise<{ [K in keyof T]: Awaited<T[K]> }>

Solution by laqudee #32357

// Solution 1
declare function PromiseAll<T extends unknown[]>(values: readonly [...T]): 
  Promise<{ [K in keyof T]: Awaited<T[K]>}>

// Solution 2
declare function PromiseAll<T extends unknown[]>(values: readonly [...T]): 
  Promise<{ [K in keyof T]: T[K] extends Promise<infer R> | infer R ? R : never }>

Solution by Tap-Kim #32161

declare function PromiseAll<T extends any[]>(values: [...T]): Promise<{
  [Key in keyof T]: Awaited<T[Key]>
}>

We declare T as extension from an array of any type, its important to spread T when typing values, this way it will spread each element type, otherwise it will compress all the values as union[] instead of [type1, type2, ...]. We use our dear Awaited type to extract the expected awaited type of T[Key] even if it is not a promise at all

Solution by joyanedel #32154

// 你的答案

type ReturnType<T extends PromiseLike> = T extends PromiseLike ? R extends PromiseLike ? ReturnType : R : T

declare function PromiseAll<T extends any[]>(values: readonly [...T]): Promise<{ [K in keyof T]: ReturnType<T[K]> }>

Solution by LuciusXy #31973

// your answers
declare function PromiseAll<const T>(values: T): Promise<any>

Solution by TheDAS-designer #31875

declare function PromiseAll<T extends any[]>(values: readonly [...T]): Promise<TPromiseAll<T>>;

type TPromiseAll<T> = {[K in keyof T]: Awaited<T[K]>}

Solution by kai-phan #31623

// your answers
declare function PromiseAll<T extends any[]>(values: readonly [...T]): Promise<{ [key in keyof T]: Awaited<T[key]> }>;

Solution by LcsGa #31577

// your answers

declare function PromiseAll<T extends unknown[]>(
  promises: T
): Promise<{ [K in keyof T]: T[K] extends Promise<infer R> ? R : T[K] }>;

Solution by AhmedRagabKamal #31493

declare function PromiseAll<T extends any[]>(
  values: [...T]
): Promise<{
  [key in keyof T]: Awaited<T[key]>;
}>;

Solution by jinyoung234 #31488

declare function PromiseAll<T extends any[]>(
  values: readonly [...T]
): Promise<{
  [K in keyof T]: T[K] extends Promise<infer R>
    ? R
    : T[K] extends number
    ? T[K]
    : number;
}>;

Solution by vipulpathak113 #31307

type Helper<T extends any[]>  = T extends [infer A, ...infer B] ? A extends Promise<infer C> ? [C, ...Helper<B>] : [A , ...Helper<B>] : [];
type Expand<T> = T extends Promise<infer A> ? A : T;

declare function PromiseAll<V extends any[]>(values: readonly [...V]): Promise< V extends [infer A,...infer B] ? Helper<V> : V extends Array<infer C> ? Expand<C>[] : unknown>

Solution by eward957 #31222

EZ.

// your answers

type AwaitAll<T extends any[]> = T extends [infer First, ... infer Rest] ? [Awaited<First>, ...AwaitAll<Rest>] : [];

type Push<T extends any[], V> = [...T, V];
type NTuple<N extends number = number, T extends any[] = []> = T['length'] extends N ? T : NTuple<N, Push<T, any>>;

type IsFixedArray<T extends any[] | NTuple<number>> = 
  T['length'] extends number 
    ? number extends T['length'] 
      ? false
    : true
  : true;

declare function PromiseAll<T extends any[] | NTuple>(values: T): 
  IsFixedArray<T> extends true
    ? Promise<AwaitAll<T>> 
    : T extends Array<infer R> 
      ? Promise<Array<Awaited<R>>> 
      : [];

Solution by kakasoo #31181

declare function PromiseAll<T extends any[]>(values: readonly [...T]):
  Promise<{ [K in keyof T]: T[K] extends Promise<infer R> ? R : T[K] }>;

Solution by MyeonghoonNam #30900

// your answers
declare function PromiseAll<T extends unknown[]>(
  values: [...T]
): Promise<{ [K in keyof T]: Awaited<T[K]> }>;

Solution by boymax1 #30673