typescript Either<L, R>

either.ts

export abstract class Either<L, R> {
  left!: L;

  right!: R;
  static Right = <T>(v: T) => new Right(v);
  static Left = <T>(v: T) => new Left(v);

  abstract map<T>(f: (a: R) => T): Either<L, T>;
  abstract flatMap<T>(f: (a: R) => Either<L, T>): Either<L, T>;
  abstract orElse<T>(a: Either<L, T>): Either<L, R>;

  abstract get(): R;
  abstract getOrElse(v: R): R;
}

export class Left<L> extends Either<L, any> {
  constructor(value: L) {
    super();
    this.left = value;
  }

  flatMap<T>(f: (a: any) => Either<L, T>): Either<L, T> {
    return this;
  }

  map<T>(f: (a: any) => T): Either<L, T> {
    return this;
  }

  orElse<T>(a: Either<L, T>): Either<L, any> {
    return a;
  }

  get(): any {
    throw new Error(this.toString());
  }

  getOrElse(v: any) {
    return v;
  }

  override toString() {
    return this.left?.toString() ?? 'something wrong';
  }
}

export class Right<R> extends Either<any, R> {
  constructor(value: R) {
    super();
    this.right = value;
  }

  flatMap<T>(f: (a: R) => Either<any, T>): Either<any, T> {
    return f(this.right);
  }

  map<T>(f: (a: R) => T): Either<any, T> {
    return Either.Right(f(this.right));
  }

  orElse<T>(a: Either<any, T>): Either<any, R> {
    return this;
  }

  get() {
    return this.right;
  }

  getOrElse(v: R) {
    return this.right;
  }
}