ClassAsADTDefinition

cadt.ts

/**
data List a = Nil | Cons a (List a)

class Monoid a where
  mempty :: a
  mappend :: a -> a -> a

instance Monoid (List a) where
  mempty = Nil
  mappend Nil ys = ys
  mappend xs Nil = xs
  mappend (Cons x xs) ys = Cons x $ mappend xs ys
**/

abstract class Monoid<A> { // Type Class Monoid
  public abstract getMempty(): A; // Required operations
  public abstract mappend(x: A, y: A): A;

  public static getMempty<A extends Monoid<A>>(instance: A): Monoid<A> { // Generalized operations
    return instance.getMempty();
  }

  public static mappend<A>(instance: Monoid<A>, x: A, y: A): A;
  public static mappend<A extends Monoid<A>>(instance: A, y: A): Monoid<A>;
  public static mappend<A, B extends Monoid<B>>(instance: Monoid<A> | B, y: A | B, z?: A): A | Monoid<B> {
    if (typeof z === 'undefined') return (instance as B).mappend(instance as B, y as B);
    else return (instance as Monoid<A>).mappend(y as A, z);
  }
}

abstract class List<A> extends Monoid<List<A>> {
  public getMempty<A>(): Nil<A> {
    return new Nil;
  }

  public mappend(xs: List<A>, ys: List<A>): List<A> {
    if (xs instanceof Cons) return new Cons(xs.value, Monoid.mappend(xs.next, ys));
    return ys;
  }
}

class Nil<A> extends List<A> {}

class Cons<A> extends List<A> {
  public constructor(public readonly value: A, public readonly next: List<A>) {
    super();
  }
}

const Add: Monoid<number> = {
  getMempty(): number {
    return 0;
  },
  mappend(x: number, y: number): number {
    return x + y;
  }
};