From: Pierre Weis <weis@pauillac.inria.fr>
Message-Id: <199509140949.LAA12642@pauillac.inria.fr>
Subject: Re: Suggestions
To: raffalli@cs.chalmers.se (Christophe Raffalli)
Date: Thu, 14 Sep 1995 11:49:55 +0200 (MET DST)
In-Reply-To: <199509131651.SAA24277@waldorf.cs.chalmers.se> from "Christophe Raffalli" at Sep 13, 95 06:51:38 pm
Continuing the ``where match'' saga ...
> the problem is that "when" is not a binder !
> The "where match" is in fact strictly more general than the when:
> pat when exp ->
> is equivalent to
> pat where match exp with true ->
> but the when is weaker because it does not bind any variable.
You're right. In my mind even your ``where'' construct is not general
enough. What you want is the so-called ``continue'' feature of Caml
V3.1: a way to ask the pattern matcher to get out from an already
selected clause (wherever you can be within its expression part).
The continue construct works as this: in a pattern matching like
| pat -> expr
| pat' -> expr'
| ...
a ``continue'' statement within expr will exit from the computation of
expr, and the pattern matching will go on with the next clause
appropriate for pat (presumably pat' -> expr').
Using continue, you can freely mix computation of expr and exits to the rest of
the pattern matching, as in:
| pat ->
begin try
let x = ... in
if x > 2 then continue else assoc x l
with Not_found -> continue end
Furthermore ``continue'' subsumes the ``where match'' you proposed:
| pat where match expr with pati -> ei
is equivalent to
| pat -> (match expr with pati -> ei | _ -> continue)
(In fact the implemented ``continue'' statement is a bit more complex:
pattern matchings with continue are named so that you may exit to
another pattern matching from within a more nested one.)
In Caml Light, you may simulate a kind of continue statement, using
exception handling and functionality. This is a bit less efficient and
less readable than a built-in mechanism, but it is acceptable since it
is not so common to need ``continue''...
(
Here is the encoding trick:
Suppose you have a clause pat -> expr that needs a continue statement,
inside a given pattern matching:
| ...
| pat -> expr
| pati -> ei
Then define a Continue exception and an auxiliary function for the
rest of the pattern:
exception Continue;;
let rest = function
| pati -> ei
Use ``raise Continue'' when you need a continue statement and rewrite
your code as:
| ...
| pat as p ->
begin try expr
with Continue -> rest p end
| x -> rest x
)
Pierre Weis
----------------------------------------------------------------------------
WWW Home Page: http://pauillac.inria.fr/~weis
Projet Cristal
INRIA, BP 105, F-78153 Le Chesnay Cedex (France)
E-mail: Pierre.Weis@inria.fr
Telephone: +33 1 39 63 55 98
Fax: +33 1 39 63 53 30
----------------------------------------------------------------------------