HI yall,

No idea how to find out more about this, but i have seen in places:

`module X: X with type t := int`

A normal equal also works but it looks like := exposes more?

Where can I find out about that?

Thanks

A

[edit]

Ahh. looks like it fully replaces the type in the module, and consumes the inner type declaration.

```
// // externally type t = int
module Int: X with type t := int = {
type t = int
let x: t = 1
let increment: t => t = x => x + 1
}
```

===

```
module Int = {
let x: int = 1
let increment: int => int = x + 1
}
```

?

Im wondering how that works when the inner type is consumed?

It seems to me like inner types are the crux of module types.

If these types are consumed by := these then become effectively â€śTerminalâ€ť modules that cannot participate in successive functors?

I have also been using the inner type t to join multiple Functor arguments.