Re: [Caml-list] Equality between abstract type definitions

[Ivan Gotovchits <ivg@ieee.org>]

Roberto Di Cosmo <roberto@dicosmo.org> writes:

>
> I am curious to know why you consider this a pitfall: if it is
> not what people expect, it is probably because nobody explained
> their meaning to them properly, and I am quite interested in
> understanding how to explain this better.
>

I think that people expect that an expression:

```
  let a : int = b 
```

is a declaration that value `a` has type int (Just like C'ish 
`int a = b;`). But, indeed, it should be understood as a type
constraint. Thus the following, will be readily accepted by the
type checker (because we «constrain» a to be anything):

```
  let a : 'a = 12
```

The root of misunderstanding, I think, lies in that the same syntax is
used for type annotations and value specifications. Consider the
following example:

```
   module T : sig
    val sum: 'a -> 'a -> 'a
   end = struct
    let sum: 'a -> 'a -> 'a = 
        fun x y -> x + y
   end
```

It looks like that the value sum has the same type in the module
specification and in the module implementation. So if compiler accepts
definition, it should accept that it conforms to the specification. 

Indeed, it's rather intuitional - this types do look the same!

So, I think, that it should be clarified by someone, who knows OCaml and
English much better than me, what is the difference between this two
cases. And it would be great if it will be described in the manual,
too. 




-- 
         (__) 
         (oo) 
   /------\/ 
  / |    ||   
 *  /\---/\ 
    ~~   ~~   
...."Have you mooed today?"...