Re: [Caml-list] Multi-matches & "when", also binding values in "when" clauses

[Pierre Weis <Pierre.Weis@inria.fr>]

> 
> Some questions on pattern matching....
> 
> 1. - Multi-matches & "when"
> 
> I've just discovered that one can write
> 
> match x with
>   | C _   | D _ -> ...
>   | E | F -> ...
> 
> to catch multiple patterns by single cases.  However, if you guard the
> patterns with "when" clauses, you must guard all the patterns att once
> 
> match x with
>   | C _   | D _ when !foo = 3 -> ...
>   | E | F -> ...
> 
> Here the "when" clause covers matches against both C and D.  Is there
> any good reason for this?  It seems reasonable to be able to write
> 
> match x with
>   | C _  when !foo = 4 | D _ when !foo = 3 -> ...
>   | E | F -> ...
> 
> Are there any plans for this?

No for more than one reason:
 - a trivial one: syntax ambiguity
 - more reasonable ones: when clauses introduce arbitrary
computations into pattern matching; thus limiting the number of guard
occurrences in the pattern of a clause seems to be good practice;
moreover the order of evaluation of multiple guards into a given
patterns will add further complexity in the semantics (and a lot of
indeterminism).

> 2. - Multiple binding in patterns
> 
> It would sometimes be nice to bind variables twice in different
> patterns, as in 
> 
> match x with
>   | C y | D y -> ...
>   | E | F -> ...
> 
> Are there any plans for this?

It's already available (again).

> 3. Binding values in "when" clauses
> 
> It would be very nice to be able to bind things in the "when" clauses
> and have them visible on the r.h.s.
> 
> match x with
>   | C y  in 
>       let z = y + 4 in 
>       when !foo = z -> f z
>   | D _ -> ...

As of the bindings inside guards, there are no problems: you can write

match x with
| C y when let z = y + 4 in !foo = z -> ...
| D _ -> ...

However the binding for z is lost when the corresponding expression is
selected.

(In your specific program, this indeed does not matter since z is equal
to !foo when calling f :) So that

| C y when let z = y + 4 in !foo = z -> f !foo

would just work perfectly!)

For a more general treatment of this kind of bindings inside guards,
I'm not sure it is worth the extra implementation efforts. (In many
case one can bind the variables outside the pattern matching, and in
case this is not possible, you can assign the local values to some
external references).

Pierre Weis

INRIA, Projet Cristal, Pierre.Weis@inria.fr, http://pauillac.inria.fr/~weis/



-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr