A summary of some of the places where I spent time on TypeScript

type Type = {
  key: "value"
}
interface Interface {
  key: "value"
}

type seems to be no different, both are true = Type extends Interface ? Type extends Interface ? true : false : false

type pit point = {
  [key: string]: pit point} | string

type test<T> = T extends pitfall? true : false
type This is true = Test <Type>
type This is false = Test <Interface>

//That's about it. I'm too lazy to actually test the following code 🙃

//fns is a function index table, TFns is the const type of the index table. Function overloading failed <T extends keyof TFns>(fn:T, params: Parameters<fns[T]>){
    fns[fn](...params) //In the implementation, the union type will not be narrowed, so an error will be reported //The error should be something like "cannot pass the parameters of method 1 to method 2"}
//But when used externally, it doesn't matter if the semantics of the type are met

// Required types: [...number[], "middle-element", ...boolean[]] 
//The above is invalid, it just indicates what the following type code is used for (to implement the type constraints indicated above)

type Elem = number | boolean | "middle-element";

type Last<T extends any[]> = T extends [infer _]
  ? never
  : T extends [...infer _, infer Tl]
  ? Tl
  : never

type HandleEmpty<T extends any[], Data> = T['length'] extends 0 ? never : Data

type Validation<Params extends any[], Cache extends Elem[] = []> =
  Params extends []
  ? Cache['length'] extends 0
  ? never
  : Cache
  : Params extends [infer Fst, ...infer Rest]
  ? Cache extends []
  ? Fst extends number
  ? HandleEmpty<Rest, Validation<Rest, [...Cache, Fst]>>
  : never
  : Fst extends number
  ? Last<Cache> extends number
  ? HandleEmpty<Rest, Validation<Rest, [...Cache, Fst]>>
  : never
  : Fst extends "middle-element"
  ? Last<Cache> extends number
  ? HandleEmpty<Rest, Validation<Rest, [...Cache, Fst]>>
  : never
  : "middle-element" extends Cache[number]
  ? Fst extends boolean
  ? Validation<Rest, [...Cache, Fst]>
  : never
  : never
  : never

type IsNever<T> = [T] extends [never] ? true : false;

function check<
  Params extends Elem[],
  IsValid extends Validation<Params>
>(...arr: IsNever<IsValid> extends true ? [never] : [...Params]) {
  return arr
}

const normal = check(1, 'middle-element', false)
const error = check(false, "middle-element", 2)

//{ "new-a":any; "new-b":any }
type remap = {
    [K in "a" | "b" as `new-${K}`]: any
}

//"a1"|"b2"
type split successfully <_Keys = keyof { a: 1, b: 2 }> = _Keys extends infer K ?
    `${Extract<K, string>}${{ a: 1, b: 2 }[Extract<K, _Keys>]}`
    : never

// Note: (as of ts4.4.4) Directly `keyof Obj extends infer K` cannot split the union type, the reason is unknown (too lazy to check 😁).
//The result is "a1"|"a2"|"b1"|"b2"
type split failed = keyof { a: 1, b: 2 } extends infer K ?
    `${Extract<K, string>}${{ a: 1, b: 2 }[Extract<K, "a" | "b">]}`
    : never

type Converter<T> = T extends string ? "str" ​​: null
//It goes in as [string,number,string], and comes out as ["str",null,"str"]
type recursion<
        Input source extends any[],
        The internal type cache extends any[] = []
    > = input source extends [any, ...infer remaining elements] ?
        Recursion <remaining elements, [...internal type cache, converter <input source [0]>]>
        : Input Source