type-challengesの学習記録

Yaona

これ

Yaona

中級までの問題を解く！

Yaona

Hello World（お試し）

Yaona

回答

type HelloWorld = string // expected to be a string

Yaona

Pick（初級）

Yaona

回答

type MyPick<T, K extends keyof T> = {
  [k in K]: T[k];
}

Yaona

Readonly（初級）

Yaona

回答

type MyReadonly<T> = {
  readonly [t in keyof T]: T[t];
}

Yaona

Tuple to Object（初級）

Yaona

回答1

type TupleToObject<T extends readonly (number | string | symbol)[]> = {
  [t in T[number]]: t;
};

Yaona

回答2

type TupleToObject<T extends readonly (keyof any)[]> = {
  [t in T[number]]: t;
};

Yaona

回答3

type TupleToObject<T extends readonly PropertyKey[]> = {
  [t in T[number]]: t;
};

Yaona

First of Array（初級）

Yaona

回答

type First<T extends any[]> = T extends [] ? never : T[0];

Yaona

extendsは使われる場所によって意味合いが変わる。

Yaona

Length of Tuple（初級）

Yaona

回答

type Length<T extends readonly any[]> = T['length'];

Yaona

Exclude（初級）

Yaona

回答

type MyExclude<T, U> = T extends U ? never : T;

Yaona

Awaited（初級）

Yaona

回答
これでは不正解

type MyAwaited<T> = T extends Promise<infer U> ? U : never;

Yaona

回答

type MyAwaited<T> = T extends PromiseLike<infer U> ? U extends PromiseLike<any> ? MyAwaited<U> : U : never;

Yaona

Promiseだけなら以下でもOK

type MyAwaited<T> = T extends Promise<infer U> ? U extends Promise<any> ? MyAwaited<U> : U : never;

Yaona

If（初級）

Yaona

回答

type If<C extends Boolean, T, F> = C extends true ? T : F;

Yaona

Concat（初級）

Yaona

回答

type Concat<T extends readonly any[], U extends readonly any[]> = [...T, ...U];

Yaona

Includes（初級）

Yaona

これだと不完全

type Includes<T extends readonly any[], U> = U extends T[number] ? true : false;

Yaona

回答
完全一致は一癖ある。

type MyEqual<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
type Includes<T extends readonly any[], U> = T extends [infer X, ...infer Y] 
  ? MyEqual<U, X> extends true
    ? true
    : Includes<Y, U>
  : false;

Yaona

Push（初級）

Yaona

回答

type Push<T extends any[], U> = [...T, U];

Yaona

Unshift（初級）

Yaona

回答

type Unshift<T extends any[], U> = [U, ...T];

Yaona

Parameters（初級）

Yaona

回答

type MyParameters<T extends (...args: any[]) => any> = T extends (...args: infer X) => any ? X : never;

なぜタプル型が返るか？
ChatGPT先生による解説：
関数の引数型は、関数のシグネチャを記述する際に、すべての引数の型をタプル型としてまとめて表現します

Yaona

Get Return Type（中級）

Yaona

回答

type MyReturnType<T> = T extends ((...args: any) => infer X) ? X : never;

Yaona

Omit（中級）

Yaona

回答
readonlyが付かない。

type MyOmit<T, K extends keyof T> = {
  [t in Exclude<keyof T, K>]: T[t];
}

Yaona

回答

type MyOmit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;

Yaona

展開すると以下

type MyOmit<T, K extends keyof T> = {
  [P in keyof T as P extends K ? never : P]: T[P];
};

Yaona

Readonly 2（中級）

Yaona

回答
なんか違う。。。

type MyReadonly2<T, K = keyof T> = {
  [t in keyof T as t extends K ? never : t]: T[t]; 
} & {
  readonly [t in keyof T as t extends K ? t : never]: T[t]; 
};

Yaona

回答
Kの指定方法の違い。

type MyReadonly2<T, K extends keyof T = keyof T> = {
  [t in keyof T as t extends K ? never : t]: T[t]; 
} & {
  readonly [t in keyof T as t extends K ? t : never]: T[t]; 
};

Yaona

Deep Readonly（中級）

Yaona

回答

type DeepReadonly<T> = {
  readonly [t in keyof T]: T[t] extends Object ? T[t] extends Function ? T[t] : DeepReadonly<T[t]> : T[t];
};

Yaona

Tuple to Union

Yaona

回答
特にひねりなし。

type TupleToUnion<T extends any[]> = T[number];

Yaona

Chainable Options

Yaona

回答
チェインを繋げるために自分自身を返す必要がある。

type Chainable<T = {}> = {
  option<K extends string, V extends any>(key: K extends keyof T ? never : K, value: V):
    Chainable<{
      [t in keyof T as t extends K ? never : t]: T[t]
    } & {
      [k in K]: V
    }>
  get(): T
}

Yaona

Last of Array

Yaona

回答
JSと使い勝手が違うかも。

type Last<T extends any[]> = T extends [...args: any, arg: infer X] ? X : never;

Yaona

Pop（中級）

Yaona

回答
先ほどの類題。

type Pop<T extends any[]> = T extends [...args: infer X, arg: any] ? X : [];

Yaona

Promise.all（中級）

Yaona

回答途中

declare function PromiseAll<A extends any[]>(values: A): A extends [arg: infer X, ...args: infer Y];

Yaona

回答
これだと不完全。

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

Yaona

回答

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

Yaona

Type Lookup（中級）

Yaona

回答

type LookUp<U extends Cat | Dog, T extends "cat" | "dog"> = U extends {type: T} ? U : never;

Yaona

Trim Left（中級）

Yaona

回答

type TrimLeft<S extends string> = S extends `${' ' | '\n' | '\t'}${infer T}` ? TrimLeft<T> : S;

Yaona

Trim（中級）

Yaona

回答

type Trim<S extends string> = S extends `${' ' | '\n' | '\t'}${infer T}`
  ? Trim<T>
  : S extends `${infer T}${' ' | '\n' | '\t'}` ? Trim<T> : S;

Yaona

Capitalize（中級）

Yaona

回答

type MyCapitalize<S extends string> = S extends `${infer X}${infer Y}` ? `${Uppercase<X>}${Y}` : '';

Yaona

Replace（中級）

Yaona

回答

type Replace<S extends string, From extends string, To extends string> = 
  From extends ''
  ? S
  : S extends `${From}${infer Y}`
    ? `${To}${Y}`
    : S extends `${infer X}${From}${infer Y}`
      ? `${X}${To}${Y}`
      : S extends `${infer X}${From}`
        ? `${X}${To}`
        : S;

Yaona

回答
無駄な処理を省くと以下になる。

type Replace<S extends string, From extends string, To extends string> = 
  From extends ''
  ? S
  : S extends `${infer X}${From}${infer Y}`
    ? `${X}${To}${Y}`
    : S;

Yaona

ReplaceAll（中級）

Yaona

回答

type ReplaceAll<S extends string, From extends string, To extends string> = 
  From extends ''
  ? S
  : S extends `${infer X}${From}${infer Y}`
    ? `${X}${To}${ReplaceAll<`${Y}`, From, To>}`
    : S;

Yaona

Append Argument（中級）

Yaona

回答

type AppendArgument<Fn extends Function, A extends any> = 
  Fn extends (...args: infer X) => infer Y 
    ? (...args: [...X, A]) => Y
    : never;

Yaona

Permutation（中級）

Yaona

回答

type Permutation<T, O = T> = 
  [T] extends [never]
    ? []
    : T extends T
      ? [T, ...Permutation<Exclude<O, T>>]
      : never;

Yaona

ChatGPT先生の解説
T = 'A' | 'B' | 'C'
ではない。

Yaona

Length of String（中級）

Yaona

回答

type LengthOfString<S extends string, L = []> = 
  L extends any[] 
    ? S extends `${S[0]}${infer Y}`
      ? LengthOfString<Y, [...L, S[0]]> 
      : L['length'] 
    : never;

Yaona

Flatten（中級）

Yaona

回答

type Flatten<S extends any[], T = []> = 
  T extends any[]
    ? S extends [S[0], ...args: infer X] 
      ? S[0] extends any[]
        ? Flatten<[...S[0], ...X], T>
        : Flatten<X, [...T, S[0]]>
      : T
    : never;

Yaona

回答

type Flatten<S extends any[], T extends any[] = []> = 
  S extends [S[0], ...args: infer X] 
    ? S[0] extends any[]
      ? Flatten<[...S[0], ...X], T>
      : Flatten<X, [...T, S[0]]>
    : T;

Yaona

Append to object（中級）

Yaona

回答

type AppendToObject<T extends Object, U extends string, V extends any> = {
  [X in keyof T | U]: X extends keyof T ? T[X] : V;
};

Yaona

Absolute（中級）

Yaona

回答
BigIntでも対応できるのは面白い！

type Absolute<T extends number | string | bigint> = `${T}` extends `-${infer X}` ? X : `${T}`;

Yaona

String to Union（中級）

Yaona

回答
特にひねりなし

type StringToUnion<T extends string> = T extends `${infer X}${infer Y}` ? X | StringToUnion<Y> : never;

Yaona

Merge（中級）

Yaona

回答

type Merge<F extends Object, S extends Object> = {
  [X in keyof (F & S)]: X extends keyof S ? S[X] : X extends keyof F ? F[X] : never;
};

Yaona

KebabCase（中級）

Yaona

回答

type KebabCase<S extends string> = 
  S extends `${infer X}${infer Y}`
    ? Y extends Uncapitalize<Y>
      ? `${Uncapitalize<X>}${KebabCase<Y>}`
      : `${Uncapitalize<X>}-${KebabCase<Y>}`
    : S;

Yaona

別解

type KebabCase<S extends string> = 
  S extends `${infer X}${infer Y}`
    ? Y extends Uncapitalize<Y>
      ? `${Lowercase<X>}${KebabCase<Y>}`
      : `${Lowercase<X>}-${KebabCase<Y>}`
    : S;

Yaona

Diff（中級）

Yaona

回答

type Diff<O extends Object, O1 extends Object> = {
  [o in keyof (O & O1) as o extends keyof O 
      ? o extends keyof O1
        ? never
        : o
      : o extends keyof O1
        ? o
        : never
  ]: o extends keyof O ? O[o] : o extends keyof O1 ? O1[o] : never;
}

Yaona

AnyOf（中級）

Yaona

回答

type AnyOf<T extends readonly any[]> = 
  T extends []
    ? false
    : T extends [infer X, ...args: infer Y]
      ? X extends (false | null | undefined | 0 | '' | [] | {[key: string]: never})
        ? AnyOf<Y>
        : true
      : false;

Yaona

IsNever （中級）

Yaona

回答

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

Yaona

参考
そもそもの原因は、「neverは空のunionであるがdistributiveに解決しようとして、結果適用されない」ということでした。 conditional typeをdistributiveに適用しない方法が公式でも紹介されており、 [] で囲めばOKとのことなので上記のコードで解決できました。
https://www.m3tech.blog/entry/2023/03/10/142235

Yaona

IsUnion（中級）

Yaona

回答

type IsUnion<T, S = T> =
  [T] extends [never]
    ? false
    : T extends S
      ? [S] extends [T]
        ? false
        : true
      : false;

Yaona

参考
T extends U ? X : Yと[T] extends [U] ? X : Yの間に違いが生じる

↓

Union Distributionが起きている

↓

TはUnionである
https://zenn.dev/t_keshi/articles/tips-typescript-2#union-distribution

Yaona

ReplaceKeys（中級）

Yaona

回答

type ReplaceKeys<U, T, Y> = {
  [u in keyof U]: 
    u extends T
      ? u extends keyof Y
        ? Y[u]
        : never
      : U[u];
};

Yaona

Remove Index Signature（中級）

Yaona

回答

type RemoveIndexSignature<T> = {
  [t in keyof T as string extends t ? never : number extends t ? never : symbol extends t ? never : t]: T[t];
}

Yaona

Percentage Parser（中級）

Yaona

回答
愚直に実装

type PercentageParser<A extends string> = 
  A extends `${infer X}${infer Y}`
    ? X extends "+" | "-"
      ? A extends `${X}${infer Y}${"%"}`
        ? [X, Y, "%"]
        : [X, Y, ""]
      : A extends `${infer Y}${"%"}`
          ? ["", Y, "%"]
          : ["", A, ""]
    : ["", "", ""];

Yaona

Drop Char（中級）

Yaona

回答

type DropChar<S extends string, C extends string, T extends string = ""> = 
  S extends `${infer X}${infer Y}`
    ? X extends C
      ? DropChar<Y, C, T>
      : DropChar<Y, C, `${T}${X}`>
    : T;

Yaona

MinusOne（中級）

Yaona

回答
配列の限界？で1000までしか不可。

type MinusOne<T extends number, C extends any[] = [1]> = 
  T extends C["length"]
    ? C extends [infer X, ...args: infer Y]
      ? [...Y]["length"]
      : C["length"]
    : MinusOne<T, [1, ...C,]>;

Yaona

途中

type MinusOne<T extends number, C extends any[] = []> = 
  `${T}` extends `${infer X extends number}${infer Y extends number}`
    ? MinusOne<Y, [...C, X]>
    : C extends [...args: infer X extends number[], arg: infer Y extends number]
      ? Y extends 0
        ? MyMinusOne<Y>
        : `${Flat<X>}${MyMinusOne<Y>}` extends infer Z extends number
          ? Z
          : never
      : never;

1001以上の対応は難しいのでパス。

回答

type PickByType<T extends Object, U> = {
  [t in keyof T as T[t] extends U ? t : never]: T[t];
}

Yaona

StartsWith（中級）

Yaona

回答

type StartsWith<T extends string, U extends string> = 
  T extends U
    ? true
    : T extends `${infer X extends string}${U}${infer Y extends string}`
      ? true
      : false;

Yaona

EndsWith（中級）

Yaona

回答
StartsWithと同じもので可能

type EndsWith<T extends string, U extends string> = 
  T extends U
    ? true
    : T extends `${infer X extends string}${U}${infer Y extends string}`
      ? true
      : false;

Yaona

PartialByKeys（中級）

Yaona

回答
&のままではだめなので、マージする必要がある。

type PartialByKeys<T extends Object, K extends keyof T = keyof T> = {
  [t in keyof T as t extends K ? never : t]: T[t];
} & {
  [k in K]?: T[k];
} extends infer X ? {[x in keyof X]: X[x]} : never;

Yaona

別解

type PartialByKeys<T extends Object, K extends keyof T = keyof T> = {
  [t in keyof Omit<T, K>]: T[t];
} & {
  [k in K]?: T[k];
} extends infer X ? {[x in keyof X]: X[x]} : never;

Yaona

RequiredByKeys（中級）

Yaona

回答

type RequiredByKeys<T extends Object, K extends keyof T = keyof T> = {
  [t in keyof Omit<T, K>]: T[t];
} & {
  [k in K]-?: T[k];
} extends infer X ? {[x in keyof X]: X[x]} : never;

Yaona

Mutable（中級）

Yaona

回答

type Mutable<T extends object> = {
  -readonly [t in keyof T]: T[t];
};

Yaona

OmitByType（中級）

Yaona

回答

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

Yaona

ObjectEntries（中級）

Yaona

回答

type ObjectEntries<T extends object> = 
  Required<T> extends infer X extends T
    ? {[t in keyof X]: [t, [X[t]] extends [never] ? undefined : X[t]]}[keyof T]
    : never;

Yaona

Shift（中級）

Yaona

回答

type Shift<T extends any[]> = T extends [arg: infer X, ...args: infer Y] ? [...Y] : [];

Yaona

Tuple to Nested Object（中級）

Yaona

回答

type TupleToNestedObject<T extends any[], U> = 
  T extends [arg: infer X extends string, ...args: infer Y extends any[]]
    ? {
      [x in `${X}`]: Y extends [] ? U : TupleToNestedObject<Y, U>;
    }
    : U;

Yaona

Reverse（中級）

Yaona

回答

type Reverse<T extends any[]> = T extends [...args: infer Y, arg: infer X] ? [X, ...Reverse<Y>] : [];

Yaona

Flip Arguments（中級）

Yaona

回答
先ほどのReverseを活用。

type Reverse<T extends any[]> = T extends [...args: infer Y, arg: infer X] ? [X, ...Reverse<Y>] : [];
type FlipArguments<T extends (...args: any) => any> = T extends (...args: infer X extends any[]) => infer Y ? (...args: Reverse<X>) => Y : never;

Yaona

FlattenDepth（中級）

Yaona

回答途中

type FlattenOne<S extends any[]> = 
  S extends [S[0], ...args: infer X] 
    ? S[0] extends any[]
      ? [...S[0], ...X]
      : [S[0], ...FlattenOne<[...X]>]
    : S;

type MinusOne<T extends string> =
  T extends `${infer X extends number}${infer Y extends string}`
    ? Y extends ""
      ? ["9", "0", "1", "2", "3", "4", "5", "6", "7", "8"][X]
      : Y extends "0"
        ? `${MinusOne<`${X}`>}${MinusOne<Y>}`
        : `${X}${MinusOne<Y>}`
    : never;

type FlattenDepth<T extends any[], U extends number = 1> = 
  U extends 1
  ? FlattenOne<T>
  : T extends FlattenOne<T>
      ? T
      : MinusOne<`${U}`> extends `${infer X extends number}`
        ? FlattenDepth<FlattenOne<T>, X>
        : never;

Yaona

回答
だいぶ無理やり減算処理を実現。
※合っているかは不明（とりあえず今回の問題はクリアした）
※110->9になるため、MinusOneは間違っている

type FlattenOne<S extends any[]> = 
  S extends [S[0], ...args: infer X] 
    ? S[0] extends any[]
      ? [...S[0], ...FlattenOne<[...X]>]
      : [S[0], ...FlattenOne<[...X]>]
    : S;

type MinusOne<T extends string> =
  T extends `${infer X extends number}${infer Y extends string}`
    ? Y extends ""
      ? ["9", "0", "1", "2", "3", "4", "5", "6", "7", "8"][X]
      : Y extends "0"
        ? `${MinusOne<`${X}`>}${MinusOne<Y>}` extends `0${infer A}`
          ? `${A}`
          : `${MinusOne<`${X}`>}9`
        : `${X}${MinusOne<Y>}` extends `${X}9${infer Z}`
          ? `${Y}` extends `9${infer A}`
            ? `${X}9${Z}`
            : `${MinusOne<`${X}`>}9${Z}` extends `0${infer A}`
              ? `${A}`
              : `${MinusOne<`${X}`>}9${Z}`
          : `${X}${MinusOne<Y>}`
    : never;

type FlattenDepth<T extends any[], U extends number = 1> = 
  U extends 1
  ? FlattenOne<T>
  : T extends FlattenOne<T>
      ? T
      : MinusOne<`${U}`> extends `${infer X extends number}`
        ? FlattenDepth<FlattenOne<T>, X>
        : never;

Yaona

BEM style string（中級）

Yaona

回答

type BEM<B extends string, E extends string[], M extends string[]> = 
  E extends [infer X extends string, ...infer Y extends string[]]
    ? BEM<`${B}__${X}`, [...Y], M>
    : M extends [infer X extends string, ...infer Y extends string[]]
      ? Exclude<`${B}--${X}` | BEM<B, E, [...Y]>, B>
      : B;

Yaona

InorderTraversal（中級）

Yaona

回答
左の要素は左に、右の要素は右に配置。

type InorderTraversal<T extends TreeNode | null> = 
  T extends TreeNode
    ? T["left"] extends TreeNode
      ? [...InorderTraversal<T["left"]>, T["val"]]
      : T["right"] extends TreeNode
        ? [T["val"], ...InorderTraversal<T["right"]>]
        : [T["val"]]
    : []

Yaona

Flip（中級）

Yaona

回答

type Flip<T extends object> = {
  [t in keyof T as T[t] extends (string | number | boolean) ? `${T[t]}` : never]: t;
};

Yaona

Fibonacci Sequence（中級）

Yaona

回答

type Fibonacci<T extends number, A extends any[] = [1], B extends any[] = [1], C extends any[] = [1, 1, 1]> = 
  T extends 1 | 2
    ? 1
    : C["length"] extends T
      ? [...A, ...B]["length"]
      : Fibonacci<T, B, [...A, ...B], [...C, 1]>;

Yaona

文字の組み合わせ（中級）

Yaona

回答

type AllCombinations<S extends string, T extends string = ""> = 
  S extends `${infer X}${infer Y}`
    ? `${X}${AllCombinations<`${Y}${T}`>}` | `${AllCombinations<`${Y}`, `${T}${X}`>}`
    : '';

Yaona

Greater Than（中級）

Yaona

回答
Union型を作成し、上の桁から比較。
不一致または桁数が異なる時に最終判定。

type Split<T extends (string | number)> = 
  `${T}` extends `${infer X extends number}${infer Y extends string}`
    ? [X, ...Split<Y>]
    : [];

type GetUnion<T extends number, U extends any[] = []> = 
  T extends U["length"]
    ? [U["length"], ...U][number]
    : GetUnion<T, [...U, U["length"]]>;

type GreaterThanAll<T extends number[], U extends number[]> =
  GetUnion<T["length"]> extends GetUnion<U["length"]>
    ? GetUnion<U["length"]> extends GetUnion<T["length"]>
      ? T extends [infer X extends number, ...infer Y extends number[]]
        ? U extends [infer A extends number, ...infer B extends number[]]
          ? GetUnion<X> extends GetUnion<A>
            ? GetUnion<A> extends GetUnion<X>
              ? GreaterThanAll<Y, B>
              : false
            : true
          : true
        : false
      : false
    : true;
    
type GreaterThan<T extends number, U extends number> = GreaterThanAll<Split<T>, Split<U>>

Yaona

Zip（中級）

Yaona

回答

type Zip<T extends any[], U extends any[]> =
  T extends [infer X, ...infer Y]
    ? U extends [infer A, ...infer B]
      ? [[X, A], ...Zip<Y, B>]
      : []
    : [];

Yaona

IsTuple（中級）

Yaona

回答

type IsTuple<T> =
  [T] extends [never]
    ? false
    : T extends any[] | readonly any[]
      ? any[] extends T
        ? false
        : true
      : false;

Yaona

Chunk（中級）

Yaona

回答

type Chunk<T extends any[], U extends number, R extends any[] = []> =
  T extends [infer X, ...infer Y]
    ? R["length"] extends U
      ? [[...R], ...Chunk<Y, U, [X]>]
      : [...Chunk<Y, U, [...R, X]>]
    : [[...R]] extends [[]]
      ? []
      : [[...R]];

Yaona

Fill（中級）

Yaona

回答
Lの値で分岐。

type Fill<
  T extends unknown[],
  N,
  Start extends number = 0,
  End extends number = T['length'],
  L extends number[] = [],
> =
  T[L["length"]] extends undefined
    ? []
    : L["length"] extends Start
        ? L["length"] extends End
          ? [T[L["length"]], ...Fill<T, N, Start, End, [1, ...L]>]
          : [N, ...Fill<T, N, Start, End, [2, ...L]>]
        : L extends [infer X extends number, ...infer Y]
          ? X extends 2
            ? L["length"] extends End
              ? [T[L["length"]], ...Fill<T, N, Start, End, [1, ...L]>]
              : [N, ...Fill<T, N, Start, End, [2, ...L]>]
            : [T[L["length"]], ...Fill<T, N, Start, End, [1, ...L]>]
          : [T[L["length"]], ...Fill<T, N, Start, End, [1, ...L]>];

Yaona

Trim Right（中級）

Yaona

回答
Trimの類題。

type TrimRight<S extends string> = S extends `${infer T}${" " | "\n" | "\t"}` ? TrimRight<T> : S;

Yaona

Without（中級）

Yaona

回答

type Without<T extends number[], U extends number | number[]> =
  T extends [infer X, ...infer Y extends number[]]
    ? U extends number[]
      ? X extends U[number]
        ? [...Without<Y, U>]
        : [X, ...Without<Y, U>]
      : X extends U
        ? [...Without<Y, U>]
        : [X, ...Without<Y, U>]
    : [];

Yaona

Trunc（中級）

Yaona

回答

type Trunc<T extends string | number> = 
  `${T}` extends `${infer X}.${infer Y}`
    ? X extends "-" | ""
      ? `${X}0`
      : X
    : `${T}`;

Yaona

IndexOf（中級）

Yaona

回答
anyの判定はkeyof

type IndexOf<T extends any[], U extends any, L extends number[] = []> =
  T extends [infer X, ...infer Y]
    ? X extends U
      ? U extends X
        ? keyof X extends keyof U
          ? keyof U extends keyof X
            ? L["length"]
            : IndexOf<Y, U, [...L, 1]>
          : IndexOf<Y, U, [...L, 1]>
        : IndexOf<Y, U, [...L, 1]>
      : IndexOf<Y, U, [...L, 1]>
    : -1;

Yaona

Join（中級）

Yaona

回答

type Join<T extends string[], U extends (string | number) = ","> =
  T extends [infer X extends string, ...infer Y extends string[]]
    ? `${X}${U}${Join<Y, U>}` extends `${infer A}`
      ? A extends `${infer B}${U}`
        ? B
        : A
      : never
    : "";

Yaona

LastIndexOf （中級）

Yaona

回答
だいぶ力技パターン。

type IndexOf<T extends any[], U extends any, L extends number[] = []> =
  T extends [infer X, ...infer Y]
    ? X extends U
      ? U extends X
        ? keyof X extends keyof U
          ? keyof U extends keyof X
            ? L["length"]
            : IndexOf<Y, U, [...L, 1]>
          : IndexOf<Y, U, [...L, 1]>
        : IndexOf<Y, U, [...L, 1]>
      : IndexOf<Y, U, [...L, 1]>
    : -1;

type Reverse<T extends any[]> = T extends [...args: infer Y, arg: infer X] ? [X, ...Reverse<Y>] : [];

type Pop<T extends any[], U extends number, L extends number[] = []> =
  U extends L["length"]
    ? T
    : T extends [...infer X, infer Y]
      ? Pop<X, U, [1, ...L]>
      : [];

type LastIndexOf<T extends any[], U extends any> =
  IndexOf<Reverse<T>, U> extends infer X extends number
    ? X extends -1
      ? -1
      : Pop<Pop<T, X>, 1>["length"]
    : never;

Yaona

Unique（中級）

Yaona

回答
IndexOfにnever判定を追加して実施。

type IndexOf<T extends any[], U extends any, L extends number[] = []> =
  T extends [infer X, ...infer Y]
    ? [X] extends [U]
      ? [U] extends [X]
        ? keyof X extends keyof U
          ? keyof U extends keyof X
            ? L["length"]
            : IndexOf<Y, U, [...L, 1]>
          : IndexOf<Y, U, [...L, 1]>
        : IndexOf<Y, U, [...L, 1]>
      : IndexOf<Y, U, [...L, 1]>
    : -1;

type Unique<T extends any[], L extends any[] = []> = 
  T["length"] extends 0
    ? L
    : T extends [T[0], ...infer X]
      ? IndexOf<L, T[0]> extends -1
        ? [...Unique<X, [...L, T[0]]>]
        : [...Unique<X, L>]
      : [...Unique<[], [...L, T[0]]>];

Yaona

MapTypes（中級）

Yaona

回答

type MapTypes<T extends object, R extends { mapFrom: any, mapTo: any }> = {
  [t in keyof T]: T[t] extends R["mapFrom"]
    ? R extends { mapFrom: T[t]}
      ? R["mapTo"]
      : never
    : T[t];
};

Yaona

Construct Tuple（中級）

Yaona

回答

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

Yaona

Number Range（中級）

Yaona

回答

type NumberRange<L extends number, H extends number, T extends number[] = [], U extends number[] = []> = 
  U["length"] extends 0
    ? T["length"] extends L
      ? NumberRange<L, H, [1, ...T], [...U, L]>
      : NumberRange<L, H, [1, ...T], U>
    : T["length"] extends H
      ? [...U, T["length"]][number]
      : NumberRange<L, H, [1, ...T], [...U, T["length"]]>;

Yaona

Combination（中級）

Yaona

回答
他の人の回答を参考にしたが、難しい。

type Combination<T extends string[], U extends string = T[number], K extends string = U> =
  K extends U
    ? K | `${K} ${Combination<T, Exclude<U, K>>}`
    : never;

Yaona

Subsequence （中級）