Signature matching question?

Signature matching question?

[Manuel Fahndrich]

I've run into the following problem with signature matching.

Consider the following module type and module definitions:

module type FOO =
  sig

    type bar

    module A :
  	sig

	  val fresh : unit -> bar

  	end

  end

module Foo : FOO =
  struct

    module A =
      struct
	type t = {foo: int}

	let fresh () = {foo=1}

      end

    type bar = A.t

  end

ocamlc -i test.ml
File "test.ml", line 19, characters 2-133:
Signature mismatch:
Modules do not match:
  sig
    module A : sig type t = { foo: int } val fresh : unit -> t end
    type bar = A.t
  end
is not included in
  FOO
Modules do not match:
  sig type t = { foo: int } val fresh : unit -> t end
is not included in
  sig val fresh : unit -> bar end
Values do not match:
  val fresh : unit -> t
is not included in
  val fresh : unit -> bar


Is this intended behavior, or a bug? I would assume that within a module,
delcarations are treated as an unordered set.
Thus, the compiler should first find all type equivalences before matching
individual types.

-Manuel

Re: Signature matching question?

[Xavier Leroy]

> I've run into the following problem with signature matching.
>
> module type FOO =
>   sig
>     type bar
>     module A : sig val fresh : unit -> bar end
>   end
> 
> module Foo : FOO =
>   struct
>     module A =
>       struct type t = {foo: int} let fresh () = {foo=1} end
>     type bar = A.t
>   end
>
> [... Signature mismatch ...]

> Is this intended behavior, or a bug? I would assume that within a module,
> delcarations are treated as an unordered set.

It is a bug.  The intent is, as you say, to perform signature matching
independently of the order of module components.  The typing rules
currently implemented get it right when there are only type and value
components, something is wrong with nested modules as in your example.

Indeed, your example type-checks when rewritten as follows:

> module Foo1 =
>   struct
>     module A =
>       struct type t = {foo: int} let fresh () = {foo=1} end
>     type bar = A.t
>   end
> module Foo : FOO = Foo1

The naming of the structure allows the type-checker to get its type
names right.

It's not obvious how to change the signature matching rules, though,
so I don't promise a quick fix.

- Xavier Leroy