Typescript Generics Patterns And Constraints Practice Exam
Question 1 of 50
[T] extends [U] ? A : B
type Concat<A extends any[], B extends any[]> = [...A, ...B];
{ [K in keyof T as T[K] extends Function ? K : never]: T[K] }
function List<T>({items, render}: {items:T[]; render:(x:T)=>JSX.Element}): JSX.Element
Extract<string|number, string> // string
type FunctionsOf<T> = { [K in keyof T as T[K] extends Function ? K : never]: T[K] }
type Box<T> = { value: T };
React.MouseEvent<HTMLButtonElement>
{ [K in keyof T]-?: T[K] }
function id<T>(x: T): T { return x; }
type Pretty<T> = { [K in keyof T]: T[K] } & {}
{ [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K] }
keyof Record<'a'|'b', number> // 'a' | 'b'
function assert(x: unknown, msg?: string): asserts x { if (!x) throw new Error(msg) }
type NoNull<T> = { [K in keyof T]: NonNullable<T[K]> };
React.ChangeEvent<HTMLInputElement>
type Color = keyof typeof Color
Partial<T>
type Dict<V> = { [k: string]: V }
function fn<T extends string = string>(x: T): T { return x; }
type Elem<T> = T extends (infer U)[] ? U : never;
const _exhaustive: never = shape;
type Awaited<T> = T extends Promise<infer U> ? Awaited<U> : T;
T extends Array<infer U> ? U : never
arr.filter((x): x is NonNull => x != null)
type DeepPartial<T> = { [K in keyof T]?: DeepPartial<T[K]> };
function Timestamped<TBase extends new (...args:any[]) => {}>(B: TBase) { return class extends B { ts = Date.now(); } }
Awaited<Promise<Promise<string>>> // string
type State<T = unknown> = { value: T }
function isEmpty<T>(a: T[]): a is [] { return a.length === 0; }
K extends string
type Unwrap<T> = T extends Promise<infer U> ? U : T;
Awaited<T>
const colors = { red: '#f00', blue: '#00f' } as const; type ColorName = keyof typeof colors;
function fn<T extends any[]>(...args: T): T
satisfies
function head<T>(arr: T[]): T | undefined { return arr[0]; }
Record<'a'|'b', number> // {a:number; b:number}
identity<number>(42)
type Partial<T> = { [K in keyof T]?: T[K] }
type R = ReturnType<typeof fn>;
type Flat<T> = T extends (infer U)[] ? U : T;
<T, K extends keyof T>
K extends `__${infer R}` ? R : never
type Kind<T extends { kind: string }> = T['kind']
K extends keyof T
class Holder<T> { value!: T }
type T = typeof myObj
function get<T extends 'a'|'b'>(t: T): T extends 'a' ? number : string
type ExcludeNumberProps<T> = { [K in keyof T as T[K] extends number ? never : K]: T[K] }
declare module 'lib' { interface Existing { newProp: T } }
type DeepPartial<T> = { [K in keyof T]?: DeepPartial<T[K]> }
C extends new (...args: any[]) => any
declare const tag: unique symbol; type UserId = string & { [tag]: 'UserId' };
type Action = { kind: 'login'; ... } | { kind: 'logout' }
NoInfer<T>
function identity<T>(x: T): T { return x; }
function f<T extends string>(x: T): T
function fn<const T>(x: T): T
keyof { [k: string]: number } // string | number
type Concat<A extends any[], B extends any[]> = [...A, ...B]
function isString(x: unknown): x is string { return typeof x === 'string' }
type Sync<F> = F extends (...a:infer A) => Promise<infer R> ? (...a:A) => R : F
Omit<User, 'password'>
type NonEmpty<T extends any[]> = T['length'] extends 0 ? never : T
Promise<{ id: string }>
class Box<T> { constructor(public value: T) {} }
type Merge<A, B> = Omit<A, keyof B> & B
declare global { interface Window { myApp: any } }
class A { id<T>(x: T): T { return x; } }
function fn<T extends string>(x: T): T
type ToAsync<F> = F extends (...a:infer A) => infer R ? (...a:A)=>Promise<R> : never;
React.ReactNode
T extends { id?: string }
export type
verbatimModuleSyntax
type Shape = { kind:'circle'; r:number } | { kind:'square'; s:number };
interface Comparable<T extends Comparable<T>> { compareTo(other: T): number }
function assertString(x: unknown): asserts x is string { ... }
const config = { ... } satisfies Schema
function pair<A, B>(a: A, b: B): [A, B] { return [a, b]; }
function assertNever(x: never): never { throw new Error('unexpected'); }
Record<'a'|'b','number'>
{ a: number; b: number }
F extends (...args: any[]) => any
type Paths<T> = { [K in keyof T & (string|number)]: T[K] extends object ? `${K}` | `${K}.${Paths<T[K]>}` : `${K}` }[keyof T & (string|number)]
type Curry<F> = F extends (a: infer A, ...r: infer R) => infer Z ? (a: A) => R extends [] ? Z : Curry<(...r: R) => Z> : never
const a: any[] = [1,'x']
interface UserId { readonly __brand: unique symbol }; type UserId_t = string & UserId;
Pick<User, 'id' | 'email'>
fn<T>(a: T, b: NoInfer<T>)
function handle<T extends { kind: string }>(x: T): void
F extends (...a:any[])=>Promise<any>
function isString(x: unknown): x is string { return typeof x === 'string'; }
tsc --declaration
"declaration": true
type Greeting = `hello ${string}`
type P = Parameters<typeof fn>;
type Len<T extends any[]> = T['length']
function get<T, K extends keyof T>(obj: T, key: K): T[K] { return obj[key]; }
const x = { a: 1 } satisfies Record<string,number>;
T extends any ? F<T> : never
function keys<T extends object>(o: T): (keyof T)[] { return Object.keys(o) as any; }
type Reverse<T extends any[], R extends any[] = []> = T extends [infer H, ...infer Rest] ? Reverse<Rest, [H, ...R]> : R
function set<T, K extends keyof T>(obj: T, key: K, value: T[K]): void
Object.entries(o) as [keyof T, T[keyof T]][]
Question navigator