kennetpostigo

type binarySearchTree('a) =
  | Empty
  | Node(node('a))
and node('a) = {
  value: 'a,
  left: binarySearchTree('a),
  right: binarySearchTree('a),
};

let empty = Empty;

kennetpostigo

/*Single line function named square*/
let square = x => x * x;

/* Multiline function named logNSquare */
let logNSquare = x => {
  let squared = x * x;
  Js.log(squared);
  squared;
};

kennetpostigo

let rec insert = (tree, compare, v) =>
  switch (tree) {
  | Empty => Node({value: v, left: Empty, right: Empty})
  | Node({value, left, right}) =>
    if (compare(v, value) == (-1)) {
      Node({value, left: insert(left, compare, v), right});
    } else if (compare(v, value) == 1) {
      Node({value, left, right: insert(right, compare, v)});
    } else {
      tree;

kennetpostigo

let compare = (f, s) =>
  if (f < s) {
    (-1);
  } else if (f > s) {
    1;
  } else {
    0;
  };

kennetpostigo

let rec remove = (tree, compare, v) =>
  switch (tree) {
  | Empty => Empty
  | Node({value, left: Empty, right: Empty}) =>
    compare(v, value) == 0 ? Empty : tree
  | Node({value, left: Node(_) as left, right: Empty as right}) =>
    compare(v, value) == 0 ?
      left : Node({value, left: remove(left, compare, v), right})
  | Node({value, left: Empty as left, right: Node(_) as right}) =>
    compare(v, value) == 0 ?

kennetpostigo

let rec min = node =>
  switch (node) {
  | Empty => Empty
  | Node({value, left, right}) =>
    if (left == Empty) {
      node;
    } else {
      min(left);
    }
  };

kennetpostigo

type t('a) = string;

kennetpostigo

module type Animal = {
  /* Define abstract types t, dog, and cat */
  type t('a);
  type dog;
  type cat;
  
  /* helpers to create a type dog or cat */
  let makeDog: string => t(dog);
  let makeCat: string => t(cat);
  let mate: (t('a), t('a)) => string;

kennetpostigo

module Animal: Animal = {
  type t('a) = string;
  type dog;
  type cat;
  
  let makeDog = d => d;
  let makeCat = c => c;
  let mate = (x, y) => {j|🌈 $x and $y mated! 🌈|j};
};

kennetpostigo

module type Animal = {
  /* ... */
  let mate: (t('a), t('a)) => string;
  let interMate: (t('a), t('b)) => string;
};