Based on https://blog.softwaremill.com/algebraic-data-types-in-four-languages-858788043d4e

tree0.ts

module Tree0 {

  type Tree<T> = Empty | Node<T>;

  class Empty {
    public toString(): string {
      return "Empty";
    }
  }

  class Node<T> {
    constructor(
      public readonly value: T,
      public readonly left: Tree<T>,
      public readonly right: Tree<T>
    ) {}

    public toString(): string {
      return `Node(${this.value}, ${this.left.toString()}, ${this.right.toString()})`;
    }
  }

  const tree: Tree<number> = new Node(
    42,
    new Node(
      0,
      new Empty(),
      new Empty()
    ),
    new Empty()
  );

  console.log(tree.toString()); // Node(42, Node(0, Empty, Empty), Empty)

}

tree1.ts

module Tree1 {

  type Tree<T> = Empty | Node<T>;

  class Empty {}

  class Node<T> {
    constructor(
      public readonly value: T,
      public readonly left: Tree<T>,
      public readonly right: Tree<T>,
    ) {}
  }

  function stringify(tree: Tree<unknown>): string {
    if (tree instanceof Empty) return "Empty";
    return `Node(${tree.value}, ${stringify(tree.left)}, ${stringify(tree.right)})`;
  }

  const tree: Tree<number> = new Node(
    42,
    new Node(
      0,
      new Empty(),
      new Empty()
    ),
    new Empty()
  );

  console.log(stringify(tree)); // Node(42, Node(0, Empty, Empty), Empty)

}

tree2.ts

module Tree2 {

  type Tree<T> = Empty | Node<T>;

  enum NodeType {
    Empty,
    Node
  }

  interface Empty {
    type: NodeType.Empty;
  }

  interface Node<T> {
    type: NodeType.Node;
    value: T;
    left: Tree<T>;
    right: Tree<T>;
  }

  export function stringify(tree: Tree<unknown>): string {
    switch (tree.type) {
      case NodeType.Empty:
        return "Empty";
      case NodeType.Node:
        return `Node(${tree.value}, ${stringify(tree.left)}, ${stringify(tree.right)})`;
    }
  }

  const tree: Tree<number> = {
    type: NodeType.Node,
    value: 42,
    left: {
      type: NodeType.Node,
      value: 0,
      left: { type: NodeType.Empty },
      right: { type: NodeType.Empty },
    },
    right: { type: NodeType.Empty },
  };

  console.log(stringify(tree)); // Node(42, Node(0, Empty, Empty), Empty)

}

tree2b.ts

// Does not compile!

module Tree2B {

  type Tree<T> = Empty | Node<T>;

  interface Empty {}

  interface Node<T> {
    value: T;
    left: Tree<T>;
    right: Tree<T>;
  }

  export function stringify(tree: Tree<unknown>): string {
    switch (typeof tree) {
      case Empty:
        return "Empty";
      case Node:
        return `Node(${tree.value}, ${stringify(tree.left)}, ${stringify(tree.right)})`;
    }
  }

  const tree: Tree<number> = {
    value: 42,
    left: {
      value: 0,
      left: {},
      right: {},
    },
    right: {},
  };

  console.log(stringify(tree)); // Node(42, Node(0, Empty, Empty), Empty)

}

tree3.ts

module Tree3 {

  type Tree<T> = Empty | Node<T>;

  type Empty = undefined;

  interface Node<T> {
    value: T;
    left: Tree<T>;
    right: Tree<T>;
  }

  function stringify(tree: Tree<unknown>): string {
    if (typeof tree === "undefined") return 'Empty';
    return `Node(${tree.value}, ${stringify(tree.left)}, ${stringify(tree.right)})`;
  }

  const tree: Tree<number> = {
    value: 42,
    left: {
      value: 0,
      left: undefined,
      right: undefined,
    },
    right: undefined
  };

  console.log(stringify(tree)); // Node(42, Node(0, Empty, Empty), Empty)

}

tree3b.ts

// Does not compile!

module Tree3B {

  type Tree<T> = Empty | Node<T>;

  type Empty = undefined;

  interface Node<T> {
    value: T;
    left: Tree<T>;
    right: Tree<T>;
  }

  function stringify(tree: Empty): string {
    return "Empty";
  }

  function stringify(tree: Node<unknown>): string {
    return `Node(${tree.value}, ${stringify(tree.left)}, ${stringify(tree.right)})`;
  }

  const tree: Tree<number> = {
    value: 42,
    left: {
      value: 0,
      left: undefined,
      right: undefined,
    },
    right: undefined,
  };

  console.log(stringify(tree)); // Node(42, Node(0, Empty, Empty), Empty)

}

tree4.ts

module Tree4 {

  type Tree<T> = Empty | {
    value: T;
    left: Tree<T>;
    right: Tree<T>;
  };

  type Empty = undefined;

  function isEmpty(tree: Tree<unknown>): tree is Empty {
    return tree === undefined;
  }

  export function stringify(tree: Tree<unknown>): string {
    if (isEmpty(tree)) {
      return "Empty";
    }
    return `Node(${tree.value}, ${stringify(tree.left)}, ${stringify(tree.right)})`;
  }

  const tree: Tree<number> = {
    value: 42,
    left: {
      value: 0,
      left: undefined,
      right: undefined,
    },
    right: undefined,
  };

  console.log(stringify(tree)); // Node(42, Node(0, Empty, Empty), Empty)

}