Re: [Caml-list] Manipulating Modules Modularly

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

> Moving quantifiers around is awkward in the module system, but is also
> not safe in general. We can clearly illustrate this by reencoding your
> example without modules:
>
> First we define `m` as a record type and create one for lists:
>
>     # type 'a m = { u : 'a; p : 'a -> 'a -> 'a };;
>     type 'a m = { u : 'a; p : 'a -> 'a -> 'a; }
>
>     # let list = { u = []; p = (@) };;
>     val list : 'a list m = {u = []; p = <fun>}
>
> Then we define the `me` as another record type and create a simple
> function for creating them from monoids:
>
>     # type 'a me = { ps : 'a list -> 'a };;
>     type 'a me = { ps : 'a list -> 'a; }
>
>     # let me (m : 'a m) = { ps = List.fold_left m.p m.u };;
>     val me : 'a m -> 'a me = <fun>
>
> Now we can apply the `me` function to the `list` monoid:
>
>     # let mel = me list;;
>     val mel : '_a list me = {ps = <fun>}
>
> But what we get is only weakly polymophic because of the value
> restriction.

It is worth noting we can eta-expand to avoid the value restriction:

    # type 'a me = 'a list -> 'a;;
    type 'a me = 'a list -> 'a

    # let me (m : 'a m) : 'a me = List.fold_left m.p m.u;;
    val me : 'a m -> 'a me = <fun>

    # let mel : 'a list me = fun l -> me list l;;
    val mel : 'a list me = <fun>

Which is just equivalent to the solution you already described:

>> With local modules it is reasonably easy to implement LE without modifying ME, by re-exporting every function as a
>> function which instantiates LEF (though I guess [u] would only work because list is covariant). But I would rather the
>> module LE to extend automatically as I extend the signature of ME.

However, since we are using the core language instead of the module
language, we get type inference and can avoid repeating ourselves so
much. Perhaps this is an acceptable solution for your use cases.

Regards,

Leo