Is this a bug?

Is this a bug?

[Thomas Fischbacher]

If we look at the following piece of code:

===>
type dof_region_spec = (string * bool * (int option array)) array;;
type opt_field_restriction = dof_region_spec option;;

let make_field ?(name="Field") ?restriction ?constant_value mwe =
   let restriction:opt_field_restriction = restriction in
	failwith "FOO";;
<===

...then make_field types as:

===>
val make_field :
   ?name:string -> ?restriction:<hidden> -> ?constant_value:'a -> 'b -> 'c
<===

The <hidden> actually should not show up here. What is going on?

-- 
best regards,
Thomas Fischbacher
tf@functionality.de

Re: [Caml-list] Is this a bug?

[Eric Cooper]

It certainly seems to be a bug.  Here's a smaller example:
    type intopt = int option
    let foo ?flag () = let (_ : intopt) = flag in ()
prints as
    val foo : ?flag:<hidden> -> unit -> unit = <fun>

It still seems to be typed correctly:

# foo ~flag:17 ();;
- : unit = ()
# foo ~flag:"x" ();;
This expression has type string but is here used with type int
# let bar ?(flag=0) () = ();;
val bar : ?flag:int -> unit -> unit = <fun>
# [foo; bar];;
- : (?flag:<hidden> -> unit -> unit) list = [<fun>; <fun>]

The bug is also present when you run "ocamlc -i ..."

-- 
Eric Cooper             e c c @ c m u . e d u

Re: [Caml-list] Is this a bug?

[Jacques Garrigue]

From: Thomas Fischbacher <tf@functionality.de>
> If we look at the following piece of code:
> 
> ===>
> type dof_region_spec = (string * bool * (int option array)) array;;
> type opt_field_restriction = dof_region_spec option;;
> 
> let make_field ?(name="Field") ?restriction ?constant_value mwe =
>    let restriction:opt_field_restriction = restriction in
> 	failwith "FOO";;
> <===
> 
> ...then make_field types as:
> 
> ===>
> val make_field :
>    ?name:string -> ?restriction:<hidden> -> ?constant_value:'a -> 'b -> 'c
> <===
> 
> The <hidden> actually should not show up here. What is going on?

You could call it a printer "bug", but it's probably not worth fixing.
The problem is that opt_field_restriction hides the "option" type
constructor. To recover it one would have to expand it, but the
printer is not supposed to do type expansion (it must show the types
as they are).

So I would be tempted to say that a reasonable fix would be to replace
<hidden> by <option hidden>, to make things clearer?

Note that this is purely a printer problem. The type-checker itself
shall work correctly.

Jacques Garrigue

Re: [Caml-list] Is this a bug?

[Thomas Fischbacher]

Jacques Garrigue wrote:

> You could call it a printer "bug", but it's probably not worth fixing.

It is highly annoying if one tries to autogenerate .mli files with
ocamlc -i.

-- 
best regards,
Thomas Fischbacher
tf@functionality.de

Re: [Caml-list] Is this a bug?

[Jacques GARRIGUE]

From: Thomas Fischbacher <tf@functionality.de>
> Jacques Garrigue wrote:
> 
> > You could call it a printer "bug", but it's probably not worth fixing.
> 
> It is highly annoying if one tries to autogenerate .mli files with
> ocamlc -i.

OK, I've fixed it for simple cases.
It should be considerably harder to see this <hidden>.

Jacques Garrigue

Re: [Caml-list] is this a bug ?

[Jonathan Roewen]

> You found an semantic problem in the gramar ^^
> or-patterns do not play well with "when"
>
> I think it's a bug in the semantics...

I don't believe so. It depends on the type. In fact, it works very
well with sum types (I did a very small inference engine which used or
patterns with when to great effect).

The problem is the two match clauses are not different. They look
different for the fact that the variables are bound in a different
order -- which is why the warning occurs. For matching, variable
naming has no semantic impact, hence the confusion.

Jonathan

Re: [Caml-list] is this a bug ?

[Alain Frisch]

Christophe Raffalli wrote:
> 
> hello,
> 
> --------------------------------
> let f b l = match l with
>   [] | [_] -> 1
> | [a;_] | [_;a] when a = b-> 2
> | _ -> 3
> 
> let _ =
>   print_int (f 1 [1;2]);
>   print_int (f 1 [2;1]);
>   print_newline ()
> --------------------------------
> 
> Do you think this code should have a useless pattern warning and print
> "23" instead of "22" ?

Well, both happens, right?  I don't see any problem.

The pattern [_;a] is useless because [a;_] matches the same values and
the first match (left-to-right) policy is specificed
(http://caml.inria.fr/pub/docs/manual-ocaml/manual014.html).

The guard is checked after the binding, and there is no backtracking.
This explains why the function returns 3 when b=1 l=[2;1].

-- Alain

Re: [Caml-list] is this a bug ?

[Arne Ehrlich]

Am Dienstag, 9. Mai 2006 15:09 schrieb Christophe Raffalli:
> hello,
>
> --------------------------------
> let f b l = match l with
>    [] | [_] -> 1
>
> | [a;_] | [_;a] when a = b-> 2
> | _ -> 3
>
> let _ =
>    print_int (f 1 [1;2]);
>    print_int (f 1 [2;1]);
>    print_newline ()
> --------------------------------
>
> Do you think this code should have a useless pattern warning and print "23"
> instead of "22" ?
You found an semantic problem in the gramar ^^
or-patterns do not play well with "when"

I think it's a bug in the semantics... 

Re: [Caml-list] is this a bug ?

[Samuel Mimram]

Christophe Raffalli wrote:
> Samuel Mimram a écrit :
>> Christophe Raffalli wrote:
>>
>>> --------------------------------
>>> let f b l = match l with
>>>  [] | [_] -> 1
>>> | [a;_] | [_;a] when a = b-> 2
>>> | _ -> 3
>>>
>>> let _ =
>>>  print_int (f 1 [1;2]);
>>>  print_int (f 1 [2;1]);
>>>  print_newline ()
>>> --------------------------------
>>>
>>> Do you think this code should have a useless pattern warning and print
>>> "23" instead of "22" ?
>>>
>>> If someone tell me this is a bug then I fill a bug report ...
>>
>> I guess that the priorities says that you should "read" the third line as
>>
>> | [a;_] | ( [_;a] when a = b ) -> 2
> 
> but the you should be allowed to write
> 
>  | ([a;_] when a = b) | ( [_;a] when a = b ) -> 2
> 
> but this results in a syntax error ...

Yes, in fact I answered too quickly. The answers would have been 22 in
both cases. Moreover,

let f x = match x with
  | z | y when y = 0 -> 0
  | _ -> 1
;;

results in "Variable y must occur on both sides of this | pattern"...

Samuel.

Re: [Caml-list] is this a bug ?

[Luc Maranget]

> 
> hello,
> 
> --------------------------------
> let f b l = match l with
>   [] | [_] -> 1
> | [a;_] | [_;a] when a = b-> 2
            ^^^^
> | _ -> 3
Warning U: this pattern is unused.

> 
> let _ =
>   print_int (f 1 [1;2]);
>   print_int (f 1 [2;1]);
>   print_newline ()
> --------------------------------
23


> 
> Do you think this code should have a useless pattern warning and print "23" 
> instead of "22" ?
> 
> If someone tell me this is a bug then I fill a bug report ...
> 


You may object the semantics, but it is consitent w.r.t. both
documentation (deterministic left-to-right matching of or-patterns,
semantics of when as match first, then test)
and supplied warning (which you omit).

So I am tempted to say not a bug.

However, there is indeed a difficulty, if we expand or-pat as:

let f b l = match l with
| [] -> 1
| [_] -> 1
| [a;_] when a = b -> 2
| [_;a] when a = b -> 2
| _ -> 3

Then, we have the other behavior (no warning, 22).

Oups, another oddity of 'when...'

--Luc

Re: [Caml-list] is this a bug ?

[Yoann Padioleau]

Samuel Mimram <samuel.mimram@ens-lyon.org> writes:

> Hi,
>
> Christophe Raffalli wrote:
>> --------------------------------
>> let f b l = match l with
>>   [] | [_] -> 1
>> | [a;_] | [_;a] when a = b-> 2
>> | _ -> 3
>> 
>> let _ =
>>   print_int (f 1 [1;2]);
>>   print_int (f 1 [2;1]);
>>   print_newline ()
>> --------------------------------
>> 
>> Do you think this code should have a useless pattern warning and print
>> "23" instead of "22" ?
>> 
>> If someone tell me this is a bug then I fill a bug report ...
>
> I guess that the priorities says that you should "read" the third line as
>
> | [a;_] | ( [_;a] when a = b ) -> 2

I am not sure because because  | ([a;_] | [_;a]) when a = b    -> 2
issues the same warning.


I think | [a;_] | [_;a] when a = b-> 2    is  parsed  as 

| ( [a;_] | [_;a])  when a = b -> 2

but that the semantic is first to look at the pattern, 
and if one is found, then look at the condition, which is too late.

'when' does not "distribute" over Or-patterns :( 



let f b l = match l with
   [] | [_] -> 1
| [a;_] when a = b-> 2
| [_;a] when a = b-> 2
| _ -> 3

works.

>
> This would justify the warning and explain the behaviour...
>
> Cheers,
>
> Samuel.
>
> _______________________________________________
> Caml-list mailing list. Subscription management:
> http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
> Archives: http://caml.inria.fr
> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> Bug reports: http://caml.inria.fr/bin/caml-bugs
>
>

-- 
pad

Re: [Caml-list] is this a bug ?

[Christophe Raffalli]

Samuel Mimram a écrit :
> Hi,
> 
> Christophe Raffalli wrote:
> 
>>--------------------------------
>>let f b l = match l with
>>  [] | [_] -> 1
>>| [a;_] | [_;a] when a = b-> 2
>>| _ -> 3
>>
>>let _ =
>>  print_int (f 1 [1;2]);
>>  print_int (f 1 [2;1]);
>>  print_newline ()
>>--------------------------------
>>
>>Do you think this code should have a useless pattern warning and print
>>"23" instead of "22" ?
>>
>>If someone tell me this is a bug then I fill a bug report ...
> 
> 
> I guess that the priorities says that you should "read" the third line as
> 
> | [a;_] | ( [_;a] when a = b ) -> 2
> 

but the you should be allowed to write

  | ([a;_] when a = b) | ( [_;a] when a = b ) -> 2

but this results in a syntax error ...

> This would justify the warning and explain the behaviour...
> 
> Cheers,
> 
> Samuel.

-- 
Christophe Raffalli
Université de Savoie
Batiment Le Chablais, bureau 21
73376 Le Bourget-du-Lac Cedex

tél: (33) 4 79 75 81 03
fax: (33) 4 79 75 87 42
mail: Christophe.Raffalli@univ-savoie.fr
www: http://www.lama.univ-savoie.fr/~RAFFALLI
---------------------------------------------
IMPORTANT: this mail is signed using PGP/MIME
At least Enigmail/Mozilla, mutt or evolution
can check this signature. The public key is
stored on www.keyserver.net
---------------------------------------------

Re: [Caml-list] is this a bug ?

[Christophe Raffalli]

2006/5/9, Christophe Raffalli <christophe.raffalli@univ-savoie.fr>:
>
> hello,
>
> --------------------------------
> let f b l = match l with
>    [] | [_] -> 1
> | [a;_] | [_;a] when a = b-> 2
> | _ -> 3
>
> let _ =
>    print_int (f 1 [1;2]);
>    print_int (f 1 [2;1]);
>    print_newline ()
> --------------------------------
>
> Do you think this code should have a useless pattern warning ?

Yes. When you wrote a pattern as :  '| [a;_] | [_;a] when a = b' it
first match the pattern '| [a;_] | [_;a]' then try the condition. So
it will match [a;_] and never [_;a]. You have to wrote it as :
| [a;c] when a = b or c = b -> 2


> and print "23" instead of "22" ?

It is the same problem there. Only the first patttern to match is matched.

Re: [Caml-list] is this a bug ?

[Samuel Mimram]

Hi,

Christophe Raffalli wrote:
> --------------------------------
> let f b l = match l with
>   [] | [_] -> 1
> | [a;_] | [_;a] when a = b-> 2
> | _ -> 3
> 
> let _ =
>   print_int (f 1 [1;2]);
>   print_int (f 1 [2;1]);
>   print_newline ()
> --------------------------------
> 
> Do you think this code should have a useless pattern warning and print
> "23" instead of "22" ?
> 
> If someone tell me this is a bug then I fill a bug report ...

I guess that the priorities says that you should "read" the third line as

| [a;_] | ( [_;a] when a = b ) -> 2

This would justify the warning and explain the behaviour...

Cheers,

Samuel.

Re: [Caml-list] is this a bug ?

[Remi Vanicat]

2006/5/9, Christophe Raffalli <christophe.raffalli@univ-savoie.fr>:
>
> hello,
>
> --------------------------------
> let f b l = match l with
>    [] | [_] -> 1
> | [a;_] | [_;a] when a = b-> 2
> | _ -> 3
>
> let _ =
>    print_int (f 1 [1;2]);
>    print_int (f 1 [2;1]);
>    print_newline ()
> --------------------------------
>
> Do you think this code should have a useless pattern warning ?

Yes. When you wrote a pattern as :  '| [a;_] | [_;a] when a = b' it
first match the pattern '| [a;_] | [_;a]' then try the condition. So
it will match [a;_] and never [_;a]. You have to wrote it as :
| [a;c] when a = b or c = b -> 2


> and print "23" instead of "22" ?

It is the same problem there. Only the first patttern to match is matched.

Re: [Caml-list] Is this a bug?

[Xavier Leroy]

> There is a bug here

Perhaps, but there's no way to tell from the limited context that you give.

As I already explained you in the past, if you expect us to
investigate, please package a test program that reproduces the
unexpected behavior, and submit a bug report to caml-bugs@inria.fr.
(This list doesn't really care.)

- Xavier Leroy
-------------------
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

[Caml-list] Is this a bug?

[John Max Skaller]

There is a bug here: is it in:

 Objective Caml version 3.04+11 (2002-05-16)

or is it in my code:
 
in one module:

    | `TYP_none -> print_endline ("NONE DETECTED");
       0,"Unknown"
 
in another module:

       | `DCL_val t ->
          print_endline ("val " ^ id^ "[old] : " ^ string_of_typecode t);
          let t' = match t with | `TYP_none -> `TYP_var n | _ -> t in
          print_endline ("val " ^ id^"[new] : " ^ string_of_typecode t');

output (2 test cases):

val printv[old] : Unknown
NONE DETECTED
val printv[new] : Unknown
NONE DETECTED
val x[old] : Unknown
NONE DETECTED
val x[new] : Unknown


The code also fails if I replace the match t with |`TYP_none with
and if/then/else construction.

It looks like the constructor `TYP_none isn't equal to itself :-)

-- 
John Max Skaller, mailto:skaller@ozemail.com.au
snail:10/1 Toxteth Rd, Glebe, NSW 2037, Australia.
voice:61-2-9660-0850




-------------------
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