[Caml-list] confusing type error when using function with optional arguments

[Caml-list] confusing type error when using function with optional arguments

[Milan Stanojević]

I was playing with %revapply primitive and ran into the following
compiler behavior that I don't understand.

external (|!) : 'a -> ('a -> 'b) -> 'b = "%revapply"

let foo1 ?x ?y () = ()    (* val foo1 : ?x:'a -> ?y:'b -> unit -> unit
*)
let foo2 ?x ?y z = z     (* val foo2 : ?x:'a -> ?y:'b -> 'c -> 'c  *)

let x = () |! foo1   (* compiles just fine *)

let y = () |! foo2   (* fails with
                             Error: This expression has type ?x:'a ->
?y:'b -> 'c -> 'c
                             but an expression was expected of type
unit -> 'd   *)

I don't understand why foo1 is fine and foo2 isn't. I would have
thought that I can use foo2 wherever I can foo1 since it has a
strictly more general type.
Am I missing something obvious here?

%revapply is not important here I just wanted to include context. I
get the same behavior in 3.12.1 and 4.00.1

Re: [Caml-list] confusing type error when using function with optional arguments

[Török Edwin]

On 11/16/2012 04:50 PM, Milan Stanojević wrote:
> I was playing with %revapply primitive and ran into the following
> compiler behavior that I don't understand.
> 
> external (|!) : 'a -> ('a -> 'b) -> 'b = "%revapply"
> 
> let foo1 ?x ?y () = ()    (* val foo1 : ?x:'a -> ?y:'b -> unit -> unit
> *)
> let foo2 ?x ?y z = z     (* val foo2 : ?x:'a -> ?y:'b -> 'c -> 'c  *)
> 
> let x = () |! foo1   (* compiles just fine *)
> 
> let y = () |! foo2   (* fails with
>                              Error: This expression has type ?x:'a ->
> ?y:'b -> 'c -> 'c
>                              but an expression was expected of type
> unit -> 'd   *)
> 
> I don't understand why foo1 is fine and foo2 isn't. I would have
> thought that I can use foo2 wherever I can foo1 since it has a
> strictly more general type.
> Am I missing something obvious here?

Its probably due to the optional labels, this works:
let y = () |! foo2 ?x:None ?y:None

--Edwin

Re: [Caml-list] confusing type error when using function with optional arguments

[Milan Stanojević]

>> I don't understand why foo1 is fine and foo2 isn't. I would have
>> thought that I can use foo2 wherever I can foo1 since it has a
>> strictly more general type.
>> Am I missing something obvious here?
>
> Its probably due to the optional labels, this works:
> let y = () |! foo2 ?x:None ?y:None

The question is why foo1 doesn't need this and foo2 does.

Re: [Caml-list] confusing type error when using function with optional arguments

[Didier Cassirame]

[-- Attachment #1: Type: text/plain, Size: 1003 bytes --]

And this works too :

let _ = () |! (fun z -> z);;

while this:

let _ = () |! (fun ?x z -> z);;

doesn't.

It appears that when the mandatory parameter is typed, the inference kernel
doesn't fail, as seen with the unit type. Here's another working example:

let _ = 1 |! (fun ?x (z : int) -> z);;

didier


2012/11/16 Milan Stanojević <milanst@gmail.com>

> >> I don't understand why foo1 is fine and foo2 isn't. I would have
> >> thought that I can use foo2 wherever I can foo1 since it has a
> >> strictly more general type.
> >> Am I missing something obvious here?
> >
> > Its probably due to the optional labels, this works:
> > let y = () |! foo2 ?x:None ?y:None
>
> The question is why foo1 doesn't need this and foo2 does.
>
> --
> Caml-list mailing list.  Subscription management and archives:
> https://sympa.inria.fr/sympa/arc/caml-list
> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> Bug reports: http://caml.inria.fr/bin/caml-bugs
>

[-- Attachment #2: Type: text/html, Size: 1802 bytes --]