🚀 go-pugleaf

Before I can ask my question I need to give some background. The following code fails to compile with 3.12.1:

  module type S = sig type t val x : t  end
  module M = struct type t = string let x = "Hi" end

  let f m p =
    let module X = (val m : S) in
    p X.x
  
  let () =
    f (module M : S) print_endline

The error claims that X.t would escape its scope.  However, it is possible to make it work by adding type annotations, as follows.

  module type S = sig type t val x : t  end
  module M = struct type t = string let x = "Hi" end

  let f (type a) m p =
    let module X = (val m : S with type t = a) in
    p X.x
  
  let () =
    f (module M : S with type t = string) print_endline

If type t is in a submodule, then the type annotations above become syntactically incorrect.  That is, the following doesn't parse.

  module type T = sig type t end
  module type S = sig module V : T val x : V.t  end
  module M = struct
    module V = struct type t = string end
    let x = "Hi"
  end

  let f (type a) m p =
    let module X = (val m : S with type V.t = a) in
    p X.x
  
  let () =
    f (module M : S with type V.t = string) print_endline

Without type annotations it again complains about escaping scope, because the type inference goes wrong.  Is it possible to give it the correct type for f? I would prefer not to change the modules, as those are in a library in the real code.

The type of f should be something like 
  (module S with type V.t = 'a) -> ('a -> 'b) -> 'b