type Foo = {[key: string]: anyfoo(): void}type A = RemoveIndexSignature<Foo> 
// expected { foo(): void }

type RemoveIndexSignature<T> = {
  [K in keyof T as/* filters out all 'string' keys */
    string extends K
      ? never/* filters out all 'number' keys */
      : number extends K
        ? never/* filers out all 'symbol' keys */
        : symbol extends K
          ? never 
          : K /* all that's left are literal type keys */
   ]: T[K]
}

type PercentageParser<A extends string> = 
A extends `${infer O extends '+' | '-'}${infer N}%` 
    ? [O, N, '%']
    : A extends `${infer O extends '+' | '-'}${infer N}`
        ? [O, N, '']
        : A extends `${infer N}%`
            ? [N, '%']
            : A extends `${infer N}`
                ? ['', N, '']
                : never 

type Butterfly = DropChar<' b u t t e r f l y ! ', ' '> // 'butterfly!'

type DropChar<S, C extends string> = 
    S extends `${infer F}${C}${infer R}` 
        ? DropChar<`${F}${R}`, C> 
        : S 

type OnlyBoolean = PickByType<{
  name: string
  count: number
  isReadonly: boolean
  isEnable: boolean
}, boolean> // { isReadonly: boolean; isEnable: boolean; }

type PickByType<T, U> = {
  // 筛选符合要求的key，再映射
  [K in keyof T as T[K] extends U ? K : never] : T[K]
}

[K in keyof T as T[K] extends U ? K : never]

{ [K in Keys] : Type } // 旧写法，只能遍历
{ [K in Keys as NewKey] : Type } // 新写法，可以重命名或排除

interface Todo {
  readonly title: string
  readonly description: string
  readonly completed: boolean
}

// { title: string; description: string; completed: boolean; }
type MutableTodo = Mutable<Todo> 

type Mutable<T> = {
  - readonly [key in  keyof T]:T[key]
}

type OmitBoolean = OmitByType<
    {name: stringcount: numberisReadonly: booleanisEnable: boolean}, 
boolean> // { name: string; count: number }

type OmitByType<T, U> = {
  [key in keyof T as T[key] extends U ? never : key] : T[key]
}

interface Model {
  name: string;
  age: number;
  locations: string[] | null;
}
type modelEntries = ObjectEntries<Model> 
// ['name', string] | ['age', number] | ['locations', string[] | null];

type ObjectEntries<T> = {
  [K in keyof T]-?: [K, T[K]]
}[keyof T]

type a = Reverse<['a', 'b']> 
// ['b', 'a']

type b = Reverse<['a', 'b', 'c']> 
// ['c', 'b', 'a']

// 将第一个放到最后
type Reverse<T extends any[]> = 
    T extends [infer F, ...infer Rest] ? [...Reverse<Rest>, F] : T;

// 反之，将最后一个放到前面来  
type Reverse<T extends any[]> = 
    T extends [...infer rest, infer last] ? [last, ...Reverse<rest>] : T

type FlipArguments<T extends (...args: any[]) => any> = 
    T extends (...args: infer P) => infer U 
        ? (...args: Reverse<P>) => U
        : never;

// 这里做了换行，是为了看的清楚，最好是写在一行里
type BEM<B extends string, E extends string[],M extends string[]> = 
  `
    ${B}
    ${E extends [] ? '' : `__${E[number]}`}
    ${M extends [] ? '' : `--${M[number]}`}
  `

// 这样写，会有几个测试过不了，需要优化
type Flip<T> = {
  [key in keyof T as T[key]] : key
}

// 优化后
type Flip<T extends Record<string, string | number | boolean>> = {
  [key in keyof T as `${T[key]}`] : key
}

type exp = Zip<[1, 2], [true, false]> // expected to be [[1, true], [2, false]]

type Zip<T extends any[], U extends any[]> = 
    [T, U] extends [[infer L, ...infer restL], [infer R, ...infer restR]] 
        ? [[L, R], ...Zip<restL, restR>] 
        : []

type case1 = IsTuple<[number]> // true
type case2 = IsTuple<readonly [number]> // true
type case3 = IsTuple<number[]> // false

type IsTuple<T> = [T] extends [never] 
  ? false 
  : T extends readonly any[]
    ? number extends T['length'] ? false : true
    : false

type Trimmed = TrimRight<'   Hello World    '> 
// expected to be '   Hello World'

// 注意最后有一个空格
type TrimRight<S extends string> = S extends `${infer Rest}${' '}` 
  ? TrimRight<Rest>
  : S

type TrimRight<S extends string> = 
  S extends `${infer Rest}${ ' ' | '\t' | '\n' }` 
    ? TrimRight<Rest>
    : S

type Res = Without<[1, 2], 1>; // expected to be [2]
type Res1 = Without<[1, 2, 4, 1, 5], [1, 2]>; // expected to be [4, 5]
type Res2 = Without<[2, 3, 2, 3, 2, 3, 2, 3], [2, 3]>; // expected to be []

type ToUnion<T> = T extends any[] ? T[number] : T
type Without<T, U> = 
  T extends [infer R, ...infer F]
    ? R extends ToUnion<U>
      ? Without<F, U>
      : [R, ...Without<F, U>]
    : T
    

type Join<T extends string[], U extends string | number> = 
  T extends [infer L extends string, ...infer R extends string[]]
    ? R['length'] extends 0
      ?  L
      : `${L}${U}${Join<R, U>}`
    : ''

type Res = Unique<[1, 1, 2, 2, 3, 3]>; // expected to be [1, 2, 3]
type Res1 = Unique<[1, 2, 3, 4, 4, 5, 6, 7]>; // expected to be [1, 2, 3, 4, 5, 6, 7]
type Res2 = Unique<[1, "a", 2, "b", 2, "a"]>; // expected to be [1, "a", 2, "b"]
type Res3 = Unique<[string, number, 1, "a", 1, string, 2, "b", 2, number]>; // expected to be [string, number, 1, "a", 2, "b"]
type Res4 = Unique<[unknown, unknown, any, any, never, never]>; // expected to be [unknown, any, never]

type result = ConstructTuple<2> // expect to be [unknown, unknown]

type ConstructTuple<L extends number, U extends unknown[] = []> = 
  U['length'] extends L
    ? U
    : ConstructTuple<L, [...U, unknown]>

type NumberRange<
  L, 
  H, 
  Count extends any[] = [], 
  Res extends any[] = [] , 
  Flag extends boolean = Count['length'] extends L ? true : false
> = 
  Flag extends true
    ? Count['length'] extends H
      ? [...Res, Count['length']][number]
      : NumberRange<L, H, [...Count, ''], [...Res,  Count['length']], Flag>
    : NumberRange<L, H, [...Count, '']>

type CheckRepeatedChars<T extends string> = T extends `${infer F}${infer E}` 
  ? E extends `${string}${F}${string}`
    ? true
    : CheckRepeatedChars<E>
  : false

ParseUrlParams<':id'> // id
ParseUrlParams<'posts/:id'> // id
ParseUrlParams<'posts/:id/:user'> // id | user

type ParseUrlParams<T> = 
  T extends `${string}:${infer R}` 
    ? R extends `${infer F}/${string}` 
      ? F | ParseUrlParams<R> 
      : R
    : never

type simple1 = GetMiddleElement<[1, 2, 3, 4, 5]>, // expected to be [3]
  type simple2 = GetMiddleElement<[1, 2, 3, 4, 5, 6]> // expected to be [3, 4]

type GetMiddleElement<T extends any[]> = 
  T extends [infer F, ...infer M, infer B ] 
    ? M extends [] 
      ? [F, B] 
      : GetMiddleElement<M> 
    : T

type Fn1 = (arg: Dog) => Dog

// 返回值 Corgi <: Dog，所以协变成立
let fn: Fn1 = (arg: Dog): Corgi => ({ name: 'corgi', waggingTail() {}, canWagging: false })

type Fn1 = (arg: Dog) => void
type Fn3 = (arg: Corgi) => void

let fn: Fn1 = fn3 // ❌ 不安全！

type Fn1 = (arg: Dog) => void
type Fn2 = (arg: Animal) => void

let fn: Fn1 = fn2 // ✅ 安全！

interface Example {
  method(arg: Dog): void       // 双向协变（宽松）
  arrow: (arg: Dog) => void    // 严格逆变（--strict下）
}