Openly recursive module shenanigans

not_quite_open_recursion.ml

module Greeter = struct
  type t = unit

  let create () = ()
  let addressee _t = "World"
  let greet _t = "Hello, " ^ addressee _t
end

module Name_greeter = struct
  type t = { name : string }
  include (Greeter : module type of Greeter with type t := Greeter.t)
  let create ~name = { name }
  let addressee t = t.name
end

let g = Name_greeter.create ~name:"Bob"
let () = print_endline (Name_greeter.greet g)

open_recursion.py

class Greeter:
    def greet(self):
        return 'Hello, ' + self.addressee()

    def addressee(self):
        return 'World'

g = Greeter()
print(g.greet())

class NameGreeter(Greeter):
    def __init__(self, name):
        self.name = name

    def addressee(self):
        return self.name

g = NameGreeter('Bob')
print(g.greet())

open_recursion_classes.ml

class greeter = object (self)
  method greet = "Hello, " ^ self#addressee
  method addressee = "World"
end

class name_greeter name = object (self)
  inherit greeter as super
  method! addressee = name
end

let g = new name_greeter "Bob"
let () = print_endline g#greet

openly_recursive_modules.ml

module type Greeter = sig
  type t
  type ctor

  val create : ctor -> t
  val addressee : t -> string
  val greet : t -> string
end

module Greeter (Self : Greeter) :
  Greeter with type t = Self.t and type ctor = Self.ctor = struct
  type t = Self.t
  type ctor = Self.ctor

  let create = Self.create
  let addressee _t = "World"
  let greet t = "Hello, " ^ Self.addressee t
end

module rec G : (Greeter with type t = unit and type ctor = unit) = Greeter (struct
    include G
    let create () = ()
  end)

let () =
  let g = G.create () in
  print_endline (G.greet g)
;;

type 'super name_greeter =
  { super : 'super
  ; name : string
  }

module Name_greeter (Self : Greeter) :
  Greeter with type t = Self.t and type ctor = Self.ctor = struct
  type t = Self.t
  type ctor = Self.ctor

  module rec Super : (Greeter with type t := t and type ctor := ctor) = Greeter (Self)

  let create = Self.create
  let addressee = Self.addressee
  let greet (t : t) = Super.greet t
end

module rec NG : (Greeter with type t = unit name_greeter and type ctor = unit * string) =
  Name_greeter (struct
    include NG

    let create (super, name) = { super; name }
    let addressee t = t.name
  end)

let g = NG.create ((), "Bob")
let () = print_endline (NG.greet g)