Re: [Caml-list] What am I reinventing here?

[Gabriel Scherer <gabriel.scherer@gmail.com>]

Yes it is, but you have to use judicious "with .." annotations to make
the type non-abstract.

Silly example that captures the problem I think you're thinking of:

  module type S = sig
    type t
    val v : t
  end

  type foo = A | B

  module M = struct
    type t = foo
    let v = A
  end

  let () = match M.v with A -> () | B -> ()
  (* works *)

  module M2 = (M : S)
  let () = match M2.v with A -> () | B -> ()
  (* Error: This pattern matches values of type foo
     but a pattern was expected which matches values of type M2.t *)

  module M3 = (M : S with type t = foo)
  let () = match M3.v with A -> () | B -> ()
  (* works *)


In your case, you should write (module Make(O : Ops) : S with type foo
= ... and bar = ...).

On Tue, Feb 14, 2012 at 11:24 AM, Andre Nathan <andre@digirati.com.br> wrote:
> On Tue, 2012-02-14 at 11:09 +0100, Gabriel Scherer wrote:
>> Here is an attempt at a functor translation. Note that's it's mostly a
>> glorified way to do exactly the same thing. Passing a module or a
>> record of operation is not very different; yet a module can carry
>> types so you don't have to parametrize your operations explicitly.
>
> Thank you Gabriel.
>
>> module Make (O : OPS) = struct
>>   let foo = O.bar_of_foo
>>   let bar = O.foo_of_bar
>> end
>
> Would it be correct to say that it isn't possible to specify a signature
> S for the output module like
>
> module Make (O : OPS) : S = struct
>  ...
> end
>
> that would still make pattern-matching outside of the module possible?
>
> Thanks,
> Andre
>