mscolnick

const SectionedListWrapper = styled.div<{ clickable?: boolean; bordered?: boolean }>`
  display: flex;
  flex-direction: column;
  ${padding.b('$8')}

  ${cond.if(
    'clickable',
    css`
      > *:not(:first-child):hover {
        cursor: pointer;

mscolnick

type Plus1<A extends any[]> = [true, ...A];
type Add<A extends any[], B extends any[]> = [...A, ...B];
type Minus1<A extends any[]> = A extends readonly [any?, ...infer U] ? U : [...A];
type Minus2<A extends any[]> = Minus1<Minus1<A>>;

// verify
type D = Plus1<A>; // [true, true, true, true]
type E = Minus1<A>; // [true, true]
type F = Minus2<A>; // [true]

mscolnick

function fibonacci(num) {
  if (num <= 1) {
    return 1;
  }

  return fibonacci(num - 1) + fibonacci(num - 2);
}

mscolnick

interface Person {
  name: string;
  age: number;
  location: string;
}

type P1 = Person["name"]; // string
type P2 = string[][0]; // string
type P3 = string[]["length"]; // number
type P4 = [string]["length"]; // 1

mscolnick

type TypeName<T> =
    T extends string ? "string" :
    T extends number ? "number" :
    T extends boolean ? "boolean" :
    T extends undefined ? "undefined" :
    T extends Function ? "function" :
    "object";

type T0 = TypeName<string>;  // "string"
type T1 = TypeName<"a">;  // "string"

mscolnick

type Unpacked<T> =
    T extends (infer U)[] ? U :
    T extends (...args: any[]) => infer U ? U :
    T extends Promise<infer U> ? U :
    T;

type T0 = Unpacked<string>;  // string
type T1 = Unpacked<string[]>;  // string
type T2 = Unpacked<() => string>;  // string
type T3 = Unpacked<Promise<string>>;  // string

mscolnick

// Variadic tuple elements

type Foo<T extends unknown[]> = [string, ...T, number];

type T1 = Foo<[boolean]>;  // [string, boolean, number]
type T2 = Foo<[number, number]>;  // [string, number, number, number]
type T3 = Foo<[]>;  // [string, number]

// Strongly typed tuple concatenation

mscolnick

// Awaiting promises

type Awaited<T> =
    T extends null | undefined ? T :
    T extends PromiseLike<infer U> ? Awaited<U> :
    T;

type P1 = Awaited<Promise<string>>;  // string
type P2 = Awaited<Promise<Promise<string>>>;  // string
type P3 = Awaited<Promise<string | Promise<Promise<number> | undefined>>;  // string | number | undefined

mscolnick

// number -> array

type ArrayOfSize<N extends number> = N extends N ? (number extends N ? boolean[] : _ArrayOfSize<N, []>) : never;
type _ArrayOfSize<N extends number, R extends unknown[]> = R['length'] extends N ? R : _ArrayOfSize<N, [true, ...R]>;

// verify
type A = ArrayOfSize<3>; // [true, true, true]
type B = ArrayOfSize<1>; // [true]
type C = ArrayOfSize<0>; // []

mscolnick

type Plus1<A extends any[]> = [true, ...A];
type Add<A extends any[], B extends any[]> = [...A, ...B];
type Minus1<A extends any[]> = A extends readonly [any?, ...infer U] ? U : [...A];
type Minus2<A extends any[]> = Minus1<Minus1<A>>;

// verify
type D = Plus1<A>; // [true, true, true, true]
type E = Minus1<A>; // [true, true]
type F = Minus2<A>; // [true]