Support default implementations about ad-hoc-poly

[coord-e]

...and mutable recursion

 class<T> Eq {
   eq :: T -> T -> Bool = \x. \y. not (ne x y)
   ne :: T -> T -> Bool = \x. \y. not (eq x y)
 } in
 impl Eq for Int {
   eq = eq_int
 } in
 impl Eq for Float {
   ne = \x. \y. not (eq_float x y)
 } in
 ne 1 2

translation:

type Eq = ΛT. constraint eqD (T -> T -> Bool, T -> T -> Bool) in
overload (∀'a. Eq 'a) in
let eq = eqD#0 in
let ne = eqD#1 in
instance (Eq Int) = (eq_int, \x. \y. not (eq x y)) in
instance (Eq Float) = (\x. \y. not (ne x y), \x. \y. not (eq_float x y)) in
ne 1 2

It seems that lazy evaluation can be applied this case:

let eq = (fun eqD_22 -> Lazy.force (fst (eqD_22))) in
let ne = (fun eqD_22 -> Lazy.force (snd (eqD_22))) in
let rec eqD_37 = (lazy eq_int, lazy (fun x y -> not (eq (eqD_37) x y))) in
let rec eqD_39 = (lazy (fun x y -> not (ne (eqD_39) x y)), lazy (fun x y -> not (eq_float x y))) in
print_bool (ne (eqD_37) (1) (2))