Typescript Optional<T> type (Rust-esque)

index.ts

type Option<T> = Some<T> | None<T>;

interface Optional<T> {
  unwrap(): T;
  unwrapOr(or: T): T;
  isSome(): boolean;
  isNone(): boolean;
}

class Some<T> implements Optional<T> {

  constructor(private value: T) {}

  unwrap(): T {
    return this.value
  }

  unwrapOr(or: T): T {
    return this.unwrap();
  }

  isSome(): boolean {
    return true
  }
  
  isNone(): boolean {
    return false
  }
}

class None<T> implements Optional<T> {
  unwrap(): never {
    throw new ReferenceError('Attempt to call `unwrap()` on `None` value.')
  }

  unwrapOr(or: T): T {
    return or
  }

  isSome(): boolean {
    return false;
  }

  isNone(): boolean {
    return true;
  }
}

function expectsOptional(value: Option<string>) {
  if (value.isSome()) {
    console.log(`Some: ${value.unwrap()}`)
  } else {
    console.log(`None`)
  }
}

expectsOptional(new Some("Hello!"))
expectsOptional(new None)