jfet97

type AllKeys<T> = T extends unknown ? keyof T : never
// type Idx<T, K extends PropertyKey> = T extends any ? T[K & keyof T] : never
type Idx<T, K extends PropertyKey> = T extends unknown ? K extends keyof T ? T[K] : never : never;
type MyMerge<T> = { [K in AllKeys<T>]: Idx<T, K> }

// TODO: result of test case must be `{foo: 1 | 2; bar: 3}`
type TestCase1 = MyMerge<{ foo: 1 } | { foo: 2; bar: 3 }>;

// TODO: result of test case must be `{foo: 1 | 2 | 7; bar: 3 | 8}`
type TestCase2 = MyMerge<

jfet97

type Decision = "yes" | "no" | 1 | 0 | true | false;
type JustStrings = Decision & string;
///              = ("yes" | "no" | 1 | 0 | true | false) & string
///              = | ("yes" & string) | ("no" & string)
///                | (1 & string) | (0 & string)
///                | (true & string)| (false & string))
///              = "yes" | "no" | never | never | never | never
///              = "yes" | "no"

//

jfet97

// is always the extends keyword that makes the difference, enabling the narrow infering
type Narrowable = string | number | boolean | symbol | undefined | null | void;

declare function wrongKeepLiteralTypes(x: Narrowable): Narrowable;
declare function keepLiteralTypes<T extends Narrowable>(x: T): T;

wrongKeepLiteralTypes(1); // Narrowable
keepLiteralTypes(1); // 1

//

jfet97

type Nodes =
  | {
      type: "a";
      age: number;
    }
  | {
      type: "b";
      size: string;
    };

jfet97

type Entries<T> = {
  [P in keyof T]: { key: P; value: T[P] };
}[keyof T];

// -----------------------------------

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

jfet97

type SameLenTuple<N extends number, T extends any[] = []> = number extends N
  ? never
  : T["length"] extends N
  ? T
  : SameLenTuple<N, [0, ...T]>;

type ConcatTuples<T1 extends any[], T2 extends any[]> = [...T1, ...T2];

type TupleToLen<T extends any[]> = T["length"];

jfet97

const FlatMap = (ma, famb) => ({
  ma,
  famb,
  tag: 'FlatMap'
})

const Pure = (a) => ({ a, tag: 'Pure' })

const expression = FlatMap(
  FlatMap(

jfet97

// expression problem:
// evaluating expressions mantaining type safety and returning
// the right value of the right type
// In functional programming all is an expression

object ExpressionProblem {
  trait Expr
  case class B(boolean: Boolean) extends Expr
  case class Or(left: Expr, right: Expr) extends Expr
  case class And(left: Expr, right: Expr) extends Expr

jfet97

// cata alg = alg . fmap(cata alg) . unfix
function cata(alg, FixF) {
    return (i) => alg(FixF.fmap(cata(alg, FixF))(FixF.unfix(i)))
}

// ListF a x = NilF | ConsF a x
// where 'a' is the type of the values inside the list,
// whereas 'x' is the type on which the list will be evaluated (aka the carrier type)
const NilF = () => ({
    _tag: "NilF"

jfet97

function isObject(entity) {
    return typeof entity === "object" && entity !== null;
}

function getAdjacentNodes(obj) {
    return (
        Object.entries(obj)
        .filter(([, v]) => isObject(v))
    )
}