Re: [Caml-list] Quizz

[Leo White <lpw25@cam.ac.uk>]

Hi,

In OCaml 4.01 and earlier, first-class modules were typed
nominatively. In other words, their type was based on the name of the
module type used, not its structure. For example:

            OCaml version 4.01.0

    # module type T = sig type t end;;
    module type T = sig type t end

    # module type S = sig type t end;;
    module type S = sig type t end

    # let f (x : (module T)) : (module S) = x;;
    Characters 38-39:
      let f (x : (module T)) : (module S) = x;;
                                            ^
    Error: This expression has type (module T)
           but an expression was expected of type (module S)

This obviously requires that the module type has a name:

    # type t = (module sig type t end);;
    Characters 17-20:
      type t = (module sig type t end);;
                       ^^^
    Error: Syntax error

In version 4.02, the type-checking of first-class modules was changed to
be structural instead of nominative:

            OCaml version 4.02.1

    # module type T = sig type t end;;
    module type T = sig type t end

    # module type S = sig type t end;;
    module type S = sig type t end

    # let f (x : (module T)) : (module S) = x;;
    val f : (module T) -> (module S) = <fun>

This means that it would now be possible to support first-class modules
for types which have no name, but such support has not yet been
added. (There are some awkward issues around the syntax in relation to
with constraints, but they are probably solvable.)

So, in summary, you can't do that, but it is now at least theoretically
something you could do.

Regards,

Leo

Thomas Braibant <thomas.braibant@gmail.com> writes:

> Hi list,
>
> Here is a quizz that can easily be solved using OCaml (version
> 4.02.1), but it would be less fun than trying to infer which functions
> are accepted.
>
> ```
> module type S = sig val test : 'a list end
>
> type t = (module S)
>
> let a (x : t) =
>   let module M = (val x) in
>   List.length M.test
>
> let b (module M : S) =
>   List.length M.test
>
> let c ((module M) : t) =
>   List.length M.test
>
> let d (module M : t) =
>   List.length M.test
>
> let e (x : (module S)) =
>   let module M = (val x) in
>   List.length M.test
>
> let f ((module M) : (module S)) =
>   List.length M.test
>
> let g : (module S) -> int = fun (module M) ->
>   List.length M.test
>
> let h ((module M) : (module sig val test : 'a list end)) =
>   List.length M.test
>
> ```
> (I am sure I have missed interesting variations, though.)
>
> I have read through
>
> http://caml.inria.fr/pub/docs/manual-ocaml/types.html,
> http://caml.inria.fr/pub/docs/manual-ocaml/modtypes.html
> http://caml.inria.fr/pub/docs/manual-ocaml/extn.html#sec230
>
> but what I do not get is how to make a variation of `h` work. That is,
> I would like to inline the module signature. Is that possible?
>
> Best,
> Thomas