From mboxrd@z Thu Jan  1 00:00:00 1970
Received: (from weis@localhost) by pauillac.inria.fr (8.6.10/8.6.6) id VAA17790 for caml-redistribution; Mon, 13 Nov 1995 21:00:15 +0100
Received: (from weis@localhost) by pauillac.inria.fr (8.6.10/8.6.6) id UAA17777; Mon, 13 Nov 1995 20:59:55 +0100
From: Pierre Weis <weis@pauillac.inria.fr>
Message-Id: <199511131959.UAA17777@pauillac.inria.fr>
Subject: Re: test with several issues
To: quercia@u-bourgogne.fr
Date: Mon, 13 Nov 1995 20:59:55 +0100 (MET)
Cc: caml-list@pauillac.inria.fr
In-Reply-To: <9511111308.AA94394@satie.u-bourgogne.fr> from "quercia@u-bourgogne.fr" at Nov 11, 95 02:08:02 pm
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Sender: weis


> *match* together with *when* enables to code nicely a test with several issues :
> match 0 with
>   _ when {condition-1} -> {action-1}
> | _ when {condition-2} -> {action-2}
> ...
> | _                    -> {default action}

I introduced the when construct in Caml V3.0 a long time ago (1990),
following exactly the same reasoning:

<<
1) Simple when:

Gards in patterns imply that you may write:

match true with
   _ when cond1 -> e1
|  _ when cond2 -> e2
|  ...
| _ -> e3

which is equivalent to

 if cond1 then e1 else
 if cond2 then e2 else
 ...
 else e3

In fact writing conditional with -> | is much more readable and
interaction between sequences and branches of consitional diseapear.
Thus we may introduce a when construct:

Syntax:
 when expr1 -> e1
    | expr2 -> e2
   ...
    | exprn -> en

Analogy with ``match true with ...'' suggests to admit
 | _ -> en
a equivalent to
 | true -> en

2) Extended when:

We may also extend this construct to multiple conditions:

Syntax:

 when expr1 { &| expr11 -> e11
              &| expr12 -> e12
              ...
              &| expr1n -> e1n}

 |    expr2 { &| expr21 -> e21
              ... }
 ...
 
 |    exprn { ... }

Se'mantixs:

 when expr1 &| expr11 -> e11
            &| expr12 -> e12
    | expr2 -> e2
    | _ -> en

is equivalent to:
 if expr1 then
    (if expr11 then e11
     else if expr12 then e12
     else if expr2 then e2 else en) else
 if expr2 then e2 else en

Now the compiler has something to do, since there is so code sharing
that you cannot write directly in Caml (except with functions).

Note:
1) When you use the when construct once, you use it all the time since it
is really clearer.

[...]
>>

Nothing to add to this old message, there is no problem to add it to
Caml Light, we simply have to decide to do it...

> ------------------------------ texte Francais --------------------------------
J'ai introduit la conditionnelle ily a tre`s longtemps en Caml V3.0 en
suivant le me^me raisonnement que le vo^tre. Je cite mes arguments de
l'e'poque (1990):
<<
1) When simple:

Les gardes ds le filtrage induisent la possibilite' d'e'crire des if
en cascades avec le ``truc'' suivant:

match true with
   _ when cond1 -> e1
|  _ when cond2 -> e2
|  ...
| _ -> e3

Evidemment equivalent a`:

 if cond1 then e1 else
 if cond2 then e2 else
 ...
 else e3

Il se trouve cependant que la construction syntaxique -> | est bien
plus lisible et bien plus tole'rante en ce qui concerne les se'quences
(qui apparraissent souvent ds les conditionnelles).

D'ou` l'ide'e d'abbreger un peu la construction ci-dessus avec une
construction ``when'':

Syntaxe:
 when expr1 -> e1
    | expr2 -> e2
   ...
    | exprn -> en

L'analogie avec ``match true with ...'' sugge`re en plus d'admettre
 | _ -> en
 comme e'quivalent a`
 | true -> en

2) Le when e'tendu:

On peut aussi e'tendre la construction when avec des conditions
multiples :

Syntaxe:

 when expr1 { &| expr11 -> e11
              &| expr12 -> e12
              ...
              &| expr1n -> e1n}

 |    expr2 { &| expr21 -> e21
              ... }
 ...
 
 |    exprn { ... }

Se'mantique:

 when expr1 &| expr11 -> e11
            &| expr12 -> e12
    | expr2 -> e2
    | _ -> en

Est e'quivalent a`:
 if expr1 then
    (if expr11 then e11
     else if expr12 then e12
     else if expr2 then e2 else en) else
 if expr2 then e2 else en

Chacun aura remarque' que le travail du compilateur est devenu non
nul, puisqu'il y a maintenant du partage de code non exprimable en
CAML sans recopie de source (ce qui cre'e une perte de lisibilite' et
des bugs potentiel lors de la maintenance du programme).

Remarques:

1) Apre`s avoir employe' le ``when'', il n'y a pas de doute que c'est plus
clair: c'est a` mon avis la construction de base, le if e'tant une
macro pour un when simplifie' (de la me^me facon que le ``let destructurant''
est un cas particulier de pattern matching)

[...]

>>

Y'a qu'a` le faire !

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