Ok, that makes sense. I was mislead by this example: Managing functor dependencies - #11 by n4323 which seemed to show that inside the functor, the full argument module is available without constraint.

So my current understanding is: in

```
module F (X:S) = struct
module M = X
end
```

the module type of `F(X).M`

is `S`

but no type equalities link `M`

to `X`

. If I want them I have to use an `with`

constraint, or use `X`

inside `F`

unchanged.

My remaining problem actually refers to functor application inside another functor. I’ll try a shortened version:

```
module F1 (X:S) = struct ... end
module F2 (X:S) = struct module F1_ = F1 (X) ... end
module X_ = struct ... end
module F1_ = F1 (X_)
module F2_ = F2 (X_)
```

Now I want `F2_.F1_`

to be compatible with `F1_`

. Somehow the compiler thinks otherwise. What can I do?

(The functors live in different compilation units, so they have signatures explicitly written in .mli files.)