< C'est très intéressant, car le pattern matching n'a qu'une seule
< définition.

Je ne suis pas informaticien de formation, encore moins spécialiste de
la sémantique des langages. Mon approche pour cette raison est
purement pragmatique :

let valeur = function
  | (1,2) -> 0
  | (1, snd) -> snd
  | (fst, snd) -> fst

Filtrage par valeurs : on peut transformer en « if then else »

let valeurs = function (x, y) ->
    if (x = 1) && (y = 2) then 1
    else if (x = 1) then y
    else x
;;

De même le code suivant

let valeur = function
  | [ ] -> 0
  | [1; 3] -> 1
  | _ -> 2

Par contre

let structure = function
  | [ ] -> 0
  | [x; 1] -> x
  | _ -> 2
;;

on ne peut pas transformer en « if then else » seul, il faut
utiliser un let destructurant (pour faire l'unification)

let structure = function liste ->
  if (liste = [ ]) then 0
  else
      let (x :: reste) = liste in
      if (reste = [1]) then x else 2
;;

Pour moi un code comme :

match couple with
| (0, 1) -> 0
| (1, y) -> y
| (x, y) -> x

commence par destructurer couple puis fait un filtrage de valeurs

let (x,y) = couple in
  match (x,y) with
  | (0,1) -> 0
  | (1, _) -> y
  | (_, _) -> x

Une seule liaison des variables x et y puis comparaisons (les
unifications multiples ne se justifient pas)
C'est d'ailleurs ce que fait la définition d'une fonction

let valeurs = function (x,y) -> [...]
let valeurs = function couple -> let (x,y) = couple in [...]

Autrement dit, je décompose le filtrage de motif en deux opérations
élémentaires :
  i) l'unification
  ii) disjonction de cas

Ce qui donne 3 « types » de filtrages
  - disjonction de cas (éventuellement précédée d'une unification)
  - unification (éventuellement suivie d'une disjonction)
  - mélange des deux

Je proscris pour les raisons déjà expliquées le mélange (risques
d'erreur liées aux variables muettes...) et recommande au lieu
l'enchaînement des deux opérations élémentaires

Bien sûr, formellement le code suivant
  match liste with
  | [x; 1] -> x
est équivalent à une disjonction de cas infinie
  ...
  | [0; 1] -> 0
  | [1; 1] -> 1
  | [2; 1] -> 2
  ...
Ce qui en ferait un filtrage de structure serait l'utilisation dans le
second membre d'un motif interne au premier membre, cela dit

let valeur = function
 | [ ] -> 0
 | [ _ ; 1] -> 1
 | _ ->2

ne peut pas se transformer en « if then else » sans unification et
n'utilise pas de motif interne au premier membre ce qui finit
d'achever la séparation des deux notions  : d'un point de vue
théorique elle est parfaitement vaseuse.

De toutes les façons, vous ne pouvez pas demander aux utilisateurs
d'un langage de comprendre parfaitement les fondements théoriques de
celui-ci pour l'utiliser correctement, sous peine de produire un
langage qui - comme Caml actuellement - ne dépassera jamais le cadre
des universitaires. Il faut résoudre un certain nombre de problèmes
pragmatiques liés à l'usage, et les erreurs (nombreuses) liées au
pattern matching en sont un.

        Diego Olivier






-------------------
Bug reports: http://caml.inria.fr/bin/caml-bugs  FAQ: http://caml.inria.fr/FAQ/
To unsubscribe, mail caml-list-request@inria.fr  Archives: http://caml.inria.fr