I've been playing around with using recursive modules to implement mixins
and don't understand why the type checker fails to accept code below.
Assume I have the following functor:

  module Mix(M : type t val f : t -> t) = struct
    let f_twice x = M.f (M.f x)
  end

If I then write:

  module type S = sig
    type t
    val f : t -> t
    val f_twice : t -> t
  end
  module rec M : S = struct
    type t = int
    let f t = t + 1
    include Mix(M)
  end

then the type checker complains
  Signature mismatch:
  Modules do not match:
    sig type t = int val f : int -> int val f_twice : M.t -> M.t end
  is not included in
    S
  Values do not match:
    val f_twice : M.t -> M.t
  is not included in
    val f_twice : t -> t

I don't quite understand why the type system doesn't know that t and M.t
are the same.  However, if I inline the signature and directly reference
M.t there, it works:

  module rec M : sig
    type t
    val f : t -> t
    val f_twice : M.t -> M.t  (* Note M. prefix *)
  end = struct
    type t = int
    let f t = t + 1
    include Mix(M)
  end

Is this a bug in the type checker or is there a reason that it does not
unify 't' and 'M.t'?


Cheers,
-Mike

P.S. This is with 3.10.0.