From mboxrd@z Thu Jan  1 00:00:00 1970
Received: by margaux.inria.fr, Wed, 27 Jan 93 11:46:33 +0100
Message-Id: <9370.732388385@margaux.inria.fr>
Subject: filtrage curryfie
To: caml-redistribution@margaux
Date: Wed, 27 Jan 1993 11:46:32 +0100 (MET)
X-Mailer: ELM [version 2.4 PL13]
Content-Type: text/plain

Quote ou majuscule ?

Le proble`me des matchs curryfie's est re'el. Il n'est pas indique'
dans la doc pour cette raison: officiellement, il n'existe pas de match
curryfie's en Caml V2-6.1 et Caml V3.1. En Caml Light, ils existent.
C'est un des points mineurs qui diffe'rencient Caml V3.1 et Caml
Light.

La se'mantique de ce filtrage fanto^me en Caml V3.1 et V2-6.1 est la
suivante:
fun p1 p2 -> est e'quivalent a` fun p1 -> fun p2 ->
donc fun p1 p2 ->
       | p3 p4 ->
est e'quivalent a`:
     fun p1 -> (fun p2 -> )
       | p3 -> (fun p4 -> )
On en de'duit que
fun
   x [] -> 
 | x (h::t) ->
est e'quivalent a`:
fun
   x -> (fun [] -> )
 | x -> (fun (h::t) ->)
Ce qui explique les messages du syste`me: le deuxie`me cas du filtrage
est inutile, et les filtrage (fun [] ->) et (fun (h::t) ->) sont
partiels. Remarquez qu'il aurait suffit d'e'changer les arguments pour
que tout se passe bien:
fun
   [] x -> 
 | (h::t) x ->
aurait le comportement souhaite'.

Cette se'mantique est e'videmment e'trange. C'est pourquoi celle de
Caml Light est radicalement diffe'rente. En Caml Light
 fun p1 p2 ->
   | p3 p4 ->
est e'quivalent a`
 function x -> function y -> match (x,y) with
                               (p1, p2) ->
                             | (p3, p4) ->
Cette se'mantique a une proprie'te' inte'ressante: elle est
compre'hensible. En revanche, l'application partielle ne de'clenche pas
le filtrage, au contraire de la se'mantique pre'ce'dente qui ope`re
imme'diatement le filtrage des arguments disponibles. Ce point peut
e^tre conside're' comme mineur en face des difficulte's de
compre'hension du me'canisme.


En tout e'tat de cause, "fun" et "function" ne sont pas e'quivalents.
"function" introduit une fonction a` un seul argument. "fun" introduit
des fonctions a` un ou plusieurs arguments. Or il se trouve que les
filtres ou` interviennent des constructeurs applique's sont
indiffe'rentiables syntaxiquement des arguments multiples:
"foo bar" peut signifier l'application du constructeur foo a` la
variable bar, ou la succession des deux varibles "foo" et "bar".
Si l'on e'crit "function foo bar ->", c'est la premie`re
interpre'tation qui est retenue (avec "function" un seul argument, ce
ne peut donc qu'e^tre l'application du constructeur "foo" a` "bar");
au contraire, si l'on e'crit "fun foo bar ->" c'est la seconde
interpre'tation qui est choisie: fonction a` deux variables "foo" et
"bar".

Dans les cas usuels, la traduction est la suivante:
fun x y -> s'e'crit function x -> function y ->
et function x y -> se traduit par fun (x y) ->

Tout ca n'arriverait pas si l'on savait repe'rer syntaxiquement les
constructeurs! C'est un vieux de'bat en Caml ... on a propose' de
faire commencer obligatoirement les constructeurs par des majuscules
et les variables par des minuscules, ou bien de pre'ce'der les
constructeurs par un quote ('). L'ide'al serait de pouvoir changer de fonte!

Pierre Weis
----------------------------------------------------------------------------
Formel Project
INRIA, BP 105, F-78153 Le Chesnay Cedex (France)
E-mail: Pierre.Weis@inria.fr
Telephone: +33 1 39 63 55 98
----------------------------------------------------------------------------