Hi,

I have encountered a behavior of the type checking of recursive modules
which is hard for me to understand.
Especially so, since the code used to compile with Ocaml 3.10.0 but does not
with 3.10.2. And, an almost similar piece of code compiles correctly.

I tried to extract the smallest piece of code that exhibits the problem, but
it's still quite long. Sorry.

Here is the code that does not type with 3.10.2:
=======================================

module type BSig =
sig
  type t
  val f: t -> unit
end

module type ASig = functor(B: BSig) ->
sig
  type t
  val g: B.t -> unit
end

module Make(C: BSig) =
struct
  type t = int
  let g _ = ()
end

module MakeA = (Make: ASig)

module rec A:
sig
  type t
  val g: B.t -> unit
end
= MakeA(B)

and B:
sig
  type t = int * A.t
  val f: t -> unit
end
=
struct
  type t = int * A.t

  let f x = A.g x   (* does not type *)
(*
  let f (a, b) = A.g (a, b)   (* types correctly *)
*)
end

=========================

Note that if function f is replaced by the commented version, then the type
checker succeeds. Even though, this code modification is only giving the
additional information that the argument of f is a pair.

It would be nice for both versions of the code to compile, because the
current behavior of the type checker seems to me not easily predictable.

Thank you in advance for your help,