TypeScript Practice 12/12

A generic class (capstone)

Generic functions carry their T for one call. A generic class carries it for a lifetime: new Stack<string>() is a stack of strings forever - every push, pop, and peek on that instance speaks strings, and pushing a number is a compile error. One implementation, a fully-typed container for any element type. This is exactly how the built-ins you already use work: Array<T>, Map<K, V>, Set<T>.

The container to build is a stack - last in, first out, like a stack of plates:

class Stack<T> {
  private items: T[] = [];
  push(item: T): void { ... }     // add to the top
  pop(): T | undefined { ... }    // remove and return the top
  peek(): T | undefined { ... }   // look at the top without removing
  size(): number { ... }          // how many items
}

Two details worth noticing: the T is declared once, on the class, and every method shares it; and pop/peek return T | undefined, because an empty stack has nothing to give - encoding "might be empty" in the type instead of hoping callers remember.

Your task: implement all four methods. Arrays make it short: push and pop on the private array are most of the work, and the top of the stack is the array's last element.

You'll practice:

Declaring a class-level type parameter shared by all methods
Returning T | undefined for operations that can come up empty

class Stack<T> {
  private items: T[] = [];

  push(item: T): void {
    // add item to the top
  }

  pop(): T | undefined {
    // remove and return the top item
  }

  peek(): T | undefined {
    // return the top item WITHOUT removing it
  }

  size(): number {
    return 0;
  }
}

const history = new Stack<string>();
history.push("/home");
history.push("/guides");
history.push("/practice");

const numbers = new Stack<number>();
numbers.push(1);
numbers.push(2);