Before:
datatype Maybe<T> { None, Just(x:T) }

After:
interface Maybe<T> extends ADT{
  match<U>(fs:MaybeFuns<T,U>) : U
  match_<U>(fs:MaybeFuns_<T,U>) : U
}
interface MaybeFuns<T,U> extends MatchFuns<U> {
  None: () => U
  Just: (x:T) => U
}
interface MaybeFuns_<T,U> extends MatchFuns_<U> {
  None?: () => U
  Just?: (x:T) => U
}
class None<T> extends Tuple0 implements Maybe<T> {
  match<U>(fs: MaybeFuns<T,U>) : U {
    return fs.None()
  }
  match_<U>(fs: MaybeFuns_<T,U>) : U {
    return fs.None ? fs.None() : fs._()
  }
}
class Just<T> extends Tuple1<T> implements Maybe<T> {
  constructor(x:T) {
    super(x)
  }
  match<U>(fs: MaybeFuns<T,U>) : U {
    return fs.Just(this[0])
  }
  match_<U>(fs: MaybeFuns_<T,U>) : U {
    return fs.Just ? fs.Just(this[0]) : fs._()
  }
}



Before:
datatype Tree<T> {Empty, Leaf(x:T), Nd(l:Tree<T>,r:Tree<T>)}

After:
interface Tree<T> extends ADT {
  match<U>(fs: TreeFuns<T,U>) : U
  match_<U>(fs: TreeFuns_<T,U>) : U
}
interface TreeFuns<T,U> extends MatchFuns<U> {
  Empty: () => U
  Leaf: (x:T) => U
  Nd: (l:Tree<T>, r:Tree<T>) => U
}
interface TreeFuns_<T,U> extends MatchFuns_<U> {
  Empty?: () => U
  Leaf?: (x:T) => U
  Nd?: (l:Tree<T>, r:Tree<T>) => U
}
class Empty<T> extends Tuple0 implements Tree<T> {
  match<U>(fs: TreeFuns<T,U>) : U {
    return fs.Empty()
  }
  match_<U>(fs: TreeFuns_<T,U>) : U {
    return (fs.Empty) ? fs.Empty() : fs._()
  }
}
class Leaf<T> extends Tuple1<T> implements Tree<T> {
  constructor(x:T) {
    super(x);
  }
  match<U>(fs: TreeFuns<T,U>) : U {
    return fs.Leaf(this[0])
  }
  match_<U>(fs: TreeFuns_<T,U>) : U {
    return (fs.Leaf) ? fs.Leaf(this[0]) : fs._()
  }
}
class Nd<T> extends Tuple2<Tree<T>,Tree<T>> implements Tree<T> {
  constructor(l:Tree<T>, r:Tree<T>) {
    super(l, r)
  }
  match<U>(fs: TreeFuns<T,U>) : U {
    return fs.Nd(this[0], this[1])
  }
  match_<U>(fs: TreeFuns_<T,U>) : U {
    return (fs.Nd) ? fs.Nd(this[0], this[1]) : fs._()
  }
}