partial match in let

partial match in let

[Christophe Raffalli]

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


Wish: I had like a way to avoid the partial match warning in code like

let [x;y] = f (x) in foo

Because if foo is long writing

match f(x) with [x;y] -> foo | _ -> assert false

is really ennoying, especially if you have a long sequence of let.

I find usefull the partial match warning for match and function but not 
for let (if you write a let, I think you are aware that your matching 
will be partial for any data type with more than one constructor, you do 
not need a warning)

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

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 252 bytes --]

Re: [Caml-list] partial match in let

[Dan Grossman]

let g x = match f(x) with [x1;y1] -> (x,y) | assert false
let (x,y) = g x in foo

Christophe Raffalli wrote:
> 
> Wish: I had like a way to avoid the partial match warning in code like
> 
> let [x;y] = f (x) in foo
> 
> Because if foo is long writing
> 
> match f(x) with [x;y] -> foo | _ -> assert false
> 
> is really ennoying, especially if you have a long sequence of let.
> 
> I find usefull the partial match warning for match and function but not 
> for let (if you write a let, I think you are aware that your matching 
> will be partial for any data type with more than one constructor, you do 
> not need a warning)
> 

Re: [Caml-list] partial match in let

[Dan Grossman]

Oops, a bit too hasty on the send (flaky mail reader):

let (x,y) = (match f(x) with [x1;y1] -> (x,y) | _ -> assert false) in foo

Dan Grossman wrote:

> 
> let g x = match f(x) with [x1;y1] -> (x,y) | assert false
> let (x,y) = g x in foo
> 
> Christophe Raffalli wrote:
> 
>>
>> Wish: I had like a way to avoid the partial match warning in code like
>>
>> let [x;y] = f (x) in foo
>>
>> Because if foo is long writing
>>
>> match f(x) with [x;y] -> foo | _ -> assert false
>>
>> is really ennoying, especially if you have a long sequence of let.
>>
>> I find usefull the partial match warning for match and function but 
>> not for let (if you write a let, I think you are aware that your 
>> matching will be partial for any data type with more than one 
>> constructor, you do not need a warning)
>>
> 
> _______________________________________________
> 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

Re: [Caml-list] partial match in let

[Dan Grossman]

let (x,y) = (match f(x) with [x1;y1] -> (x,y) | _ -> assert false) in foo

Christophe Raffalli wrote:

> 
> Wish: I had like a way to avoid the partial match warning in code like
> 
> let [x;y] = f (x) in foo
> 
> Because if foo is long writing
> 
> match f(x) with [x;y] -> foo | _ -> assert false
> 
> is really ennoying, especially if you have a long sequence of let.
> 
> I find usefull the partial match warning for match and function but not 
> for let (if you write a let, I think you are aware that your matching 
> will be partial for any data type with more than one constructor, you do 
> not need a warning)
> 

Re: [Caml-list] partial match in let

[Robert W.]

Christophe Raffalli schrieb:

>
> Wish: I had like a way to avoid the partial match warning in code like
>
> let [x;y] = f (x) in foo
>
> Because if foo is long writing
>
> match f(x) with [x;y] -> foo | _ -> assert false
>

Wouldn't this be semantically equivalent to the constant function 
returning foo?
What I mean, instead of explicitly adding the wild card pattern, you can 
can substitute another one without. This would lead to an exhaustive 
pattern matching as well.

> is really ennoying, especially if you have a long sequence of let.
>
> I find usefull the partial match warning for match and function but 
> not for let (if you write a let, I think you are aware that your 
> matching will be partial for any data type with more than one 
> constructor, you do not need a warning)
>

I'm sure, there are formal problems with partial matching leading to 
serious serious headaches, but I'll need some time to think about.

-- 

	Robert...

Re: [Caml-list] partial match in let

[Luc Maranget]

> 
> Wish: I had like a way to avoid the partial match warning in code like
> 
> let [x;y] = f (x) in foo
> 
> Because if foo is long writing
> 
> match f(x) with [x;y] -> foo | _ -> assert false
> 
> is really ennoying, especially if you have a long sequence of let.
> 
> I find usefull the partial match warning for match and function but not 
> for let (if you write a let, I think you are aware that your matching 
> will be partial for any data type with more than one constructor, you do 
> not need a warning)
> 
> -- 
> Christophe Raffalli


I think the warning clearly is useful even in this situation of
a pattern in let.

In fact it can even be argued that 'let pat = exp in exp' should be legal
only when 'pat' provable cannot fail.
And the is camlp4 'revised syntax' approach, as far as I remember.


I also remark that your sentence
'I think you are aware that your matching 
will be partial for any data type with more than one constructor, you do 
not need a warning'
Does not apply to novices or in case of type alteration.


Besides a simple solution using a function has been given.


Cheers, 

-- 
Luc Maranget