// type T0 = string
type T0 = ReturnType<() => string>;
 
// type T1 = number
type T1 = ReturnType<(s: string) => number>;
 
// type T2 = unknown
type T2 = ReturnType<<T>() => T>;

type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

// 잘 작동한다.
type Element<T>=T extends (infer U)[] ? U : T;
// Cannot find name 'U'
type Element<T>=T extends (infer U)[] ? T : U;

// 배열 요소 타입 얻기
type Elem<T>=T extends (infer U)[] ? U : T;
 
type A=Elem<string[]>; // string
 
// 함수 파라미터 타입 얻기
type Param<T>=T extends (...args: infer P) => any ? P : never;
 
type B=Param<(a: string, b: number) => void>; // [string, number]

// 매개변수 타입과 리턴 타입을 추론해서 튜플에 담아 리턴해 준다.
type ParamAndReturn<T>=T extends (...args: infer P) => infer R ? [P, R] : never;

// a의 타입과 b의 타입이 합쳐져서 리턴된다. 
type InferUnion<T> = T extends { a: infer U; b: infer U } ? U : never;
// a의 타입과 b의 타입의 intersection이 리턴된다. 매개변수는 반공변성을 가지고 있기 때문이다
type InferIntersection<T> = T extends { a: (x: infer U) => void; b: (y: infer U) => void } ? U : never;

type GetArgumentType<T> = T extends (...args: infer U) => any ? U : never;
 
type GetFirstArgumentType<T> = T extends (arg: infer U, ...args:any) => any ? U : never;

function introduce(person:{
    name:string;
    age:number;
    hobbies:[string, string];
}){
    return `${person.name}은 ${person.age}살이고 ${person.hobbies.join(" 와 ")}가 취미입니다.`
}

const me={
    name:"김타입",
    age:26,
    hobbies:["JS", "TS"],
}
// me.hobbies의 타입이 string[]으로 추론되어 타입 에러 발생
introduce(me);

type GetFirstArgumentType<T> = T extends (arg: infer U, ...args:any) => any ? U : never;
 
const me:GetFirstArgumentType<typeof introduce>={
    name:"김타입",
    age:26,
    hobbies:["JS", "TS"],
}
 
introduce(me);

type InferProps<T> = T extends React.ComponentType<infer P> ? P : never;
 
// LibComponent의 props 타입을 추론
type MyProps = InferProps<typeof LibComponent>;

// @types/react/index.d.ts
type ComponentProps<T extends keyof JSX.IntrinsicElements | JSXElementConstructor<any>> =
    T extends JSXElementConstructor<infer P>
        ? P
        : T extends keyof JSX.IntrinsicElements
            ? JSX.IntrinsicElements[T]
            : {};

// 배열 T를 flat한 배열의 타입을 나타낸다
type Flatten<T extends readonly unknown[]> = T extends unknown[] ? _Flatten<T>[] : readonly _Flatten<T>[];
// T 타입을 flat 하기 위한 보조 타입. T가 배열이 아니라면 T를 리턴하고 배열이면 배열의 요소를 리턴한다.
// 즉 배열의 요소들을 모두 평탄화해 유니언한 타입을 리턴한다.
type _Flatten<T> = T extends readonly (infer U)[] ? _Flatten<U> : T;
 
// T를 평탄화한 배열의 타입 Flatten<T> 타입을 리턴한다
function flatRecurisve<T extends readonly unknown[]>(xs: T): Flatten<T> {
  const result: unknown[] = [];
 
  function flattenArray(arr: readonly unknown[]) {
    for (const item of arr) {
      if (Array.isArray(item)) {
        flattenArray(item);
      } else {
        result.push(item);
      }
    }
  }
 
  flattenArray(xs);
 
  return result as Flatten<T>;
}
 
const t1 = flatRecurisve(['apple', ['orange', 100], [[4, [true]]]] as const);

type PromiseReturnType<T> = T extends Promise<infer Return> ? Return : T
 
type t = PromiseReturnType<Promise<string>> // string 

let promise = Promise.resolve([1, 2, 3]); // Promise<number[]>
 
type A=Awaited<typeof promise>; // number[]

// lib.es5.d.ts
/**
 * Recursively unwraps the "awaited type" of a type. Non-promise "thenables" should resolve to `never`. This emulates the behavior of `await`.
 */
type Awaited<T> =
    // `--strictNullChecks` mode가 아닐 때 T가 null이나 undefined라면 T를 리턴한다
    T extends null | undefined ? T :
    // T가 호출 가능한 then 메서드를 가진 thenable이라면 await이 unwrap한다. 아니라면 T를 리턴한다.
        T extends object & { then(onfulfilled: infer F, ...args: infer _): any } ?
        // F는 then 메서드의 첫번째 인자 타입이다. 만약 이게 callable이라면 재귀적으로 unwrap한다. 이는 thenable 내부 값의 awaited type도 unwrap하는 역할을 한다.
            F extends ((value: infer V, ...args: infer _) => any) ?
                Awaited<V> : // recursively unwrap the value
                // 만약 then 메서드의 첫 번째 매개변수 F가 호출 가능한 함수가 아니라면
                // thenable이 제대로 처리되지 않은 것이므로 never 리턴
                never : 
        T; // T is non-object or non-thenable

// 제공된 객체 T에서 문자열 경로 K의 값을 가져올 때 사용하는 타입
type PathValue<T, K extends string> =
    // K가 점으로 구분된 문자열이라면 점 앞쪽 문자열을 Root, 점 뒤쪽 문자열을 Rest로 할당한다.
    K extends `${infer Root}.${infer Rest}` ?
        // Root가 T의 key 중 하나라면 재귀적으로 타입을 추론한다. 만약 Root가 T의 key 중 하나가 아니라면 never를 리턴하여 재귀 탈출
        Root extends keyof T ? PathValue<T[Root], Rest> : never
    // K가 더 이상 점으로 구분되지 않는 경우이다. 이때는 top level key라는 것이므로 T의 key 중 하나인지 확인하고 그 값을 가져오기를 시도한다
    : (K extends keyof T ? T[K] : undefined)
 
// 이 타입은 경로 K가 유효한지 확인한다. 유효한 경로라면 K를 반환, 그렇지 않다면 never를 반환
type ValidatedPath<T, K extends string> = PathValue<T, K> extends never ? never : K;
 
/**
 * Access an object via dot-notation string
 */
// 객체 entity와 점으로 분할된 경로 path를 받아서 해당 경로의 값을 리턴한다.
// PathValue의 정의상 만약 T에 K경로 값이 존재하지 않는다면 리턴타입이 never가 되어 오류가 발생한다
function get<T extends object, K extends string>(entity: T, path: ValidatedPath<T, K>): PathValue<T, K> {
  // path를 점으로 분할하여 entity 내의 해당 경로에 접근하여 값을 반환
    return path.split(".").reduce((acc: any, k) => acc[k], entity);
}

type InferUnion<T>=T extends {[key:string]:infer U}?U:never;
 
// 1 | 2 | 3 | 'a' | 'b'
type R=InferUnion<{a:1|2, b:2|3, c:1|'a'|'b'}>

type InferIntersection<T>=T extends {[key:string]:(p:infer U)=>void}?U:never;
 
type Foo={
    a(p:1|2|3):void,
    b(p:2|3|4):void
}
// 2|3
type R2=InferIntersection<Foo>

type UnionToIntersection<U>=
(U extends any?(param:U)=>void:never) extends (param:infer I)=>void? I : never;