Pal-Kristian Engstad <engstad@naughtydog.com> a écrit :

> Hi,
> 
> I don't know if it is in the FAQ, but a more interesting question is why the 
> compiler cannot deduce the correct type without us having to type in 
> parenthesis, at least in cases where there can be no ambiguity.
> 
> I.e.:
> 
> let addone x = x + 1
> let double x = x * x
> 
> let f x = addone double x     (*** Should the compiler not deduce this? ***)
> let g = addone double         (*** Is this why? ***)

In the general case it can't:

# let f g x = x;;
val f : 'a -> 'b -> 'b = <fun>
# let h x = x;;
val h : 'a -> 'a = <fun>
# (f h) 1;;
- : int = 1
# f (h 1);;
- : '_a -> '_a = <fun>

When there is no ambiguity it could but it would be
expensive, dangerous (because the compiler could find a way to type an
expression which is ill typed according to what you meant) and would
make the sources unreadable.
-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners