Garde (informatique)

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher
Page d'aide sur l'homonymie Pour les articles homonymes, voir Garde.

En informatique, une garde est une expression de type booléen qui a pour valeur vrai si l'exécution du programme doit continuer dans la branche en question.
Le terme est utilisé notamment dans les langages informatiques Haskell et Clean.
Dans Mathematica, les gardes sont appelés contraintes. Les gardes sont un concept fondamental des commandes gardées, un langage de méthode formelles.
Les gardes peuvent être utilisées pour augmenter le filtrage par motif avec la possibilité de sauter un motif même si la structure passe le filtre. Les expressions booléennes dans une instruction conditionnelle répondent aussi à la définition de garde mais elles sont appelées conditions.

Dans l'exemple suivant en langage Haskell, les gardes apparaissent entre chaque paire de "|" et "=" :

f x
  | x > 0     = 1
  | otherwise = 0

C'est similaire à la notation mathématique suivante :


f(x) = \left\{ \begin{matrix} 
               1   & \mbox{si } x>0 \\ 
               0   & \mbox{sinon} 
               \end{matrix} 
       \right.

Dans la notation Haskell les gardes sont dans les clauses « si » et « sinon ».

S'il y a des gardes parallèles, comme dans l'exemple ci-dessous, elles sont tentées dans l'ordre de la première à la dernière. La première branche qui passe la garde est choisie. Les gardes d'une liste de cas sont typiquement parallèles. Mais, dans une compréhension de liste en Haskell, les gardes sont en série. Si l'une d'elle échoue, la liste d'éléments n'est pas produite. Cela équivaut à combiner les différentes gardes avec un et logique, sauf qu'il peut y avoir d'autres clauses de compréhension de liste parmi les gardes.

Évolution[modifier | modifier le code]

Une simple expression conditionnelle, déjà présente dès 1963 en CPL, comporte une garde dans la première sous-expression, et une autre sous-expression à utiliser dans le cas où la première ne l'est pas. Quelques façons communes d'écrire ceci :

(x>0) → 1/x; 0
x>0 ? 1/x : 0

Si la seconde sous-expression peut être une expression conditionnelle encore plus simple, nous pouvons donner plusieurs alternatives supplémentaires à essayer avant la chute (fall-through) :

(x>0) → 1/x; (x<0) → -1/x; 0

Déjà en 1966, ISWIM supporte une forme d'expression sans un cas obligatoire de chute, séparant ainsi la garde du concept de choix de forme soit cela/soit ceci. Dans le cas de ISWIM, si aucune des alternatives ne peut être utilisée, la valeur devient alors undefined, qui signifie de ne jamais calculer une valeur.

SASL (1976) est un des premiers langages informatiques à utiliser le terme de garde. Dans ce langage, les fonctions peuvent avoir plusieurs définitions et celle qui est appliquée est choisie selon les gardes qui suivent chaque définition :

fac n = 1,             n = 0
      = n * fac (n-1), n > 0


Motif de garde[modifier | modifier le code]

En plus d'une garde attachée à un motif, une garde par motif peut désigner l'utilisation de filtrage par motif dans le contexte d'une garde. En effet, la reconnaissance par un motif signifie le succès de la garde. Cette signification a été introduite par une proposition pour Haskell de Simon Peyton Jones titrée (en) a new view of guards en avril 1997 et été implantée. Cette fonctionnalité permet d'utiliser des motifs dans les gardes d'un motif.

Un exemple d'Haskell ainsi étendu :

clunky env var1 var2
  | Just val1 ← lookup env var1

, Just val2 ← lookup env var2

  = val1 + val2

…other equations for clunky…

On le lit ainsi : "Clunky pour un environnement et deux variables, si le lookups(?) des variables de l'environnement produit des valeurs, est la somme des valeurs.…" Comme dans une compréhension de liste, les gardes sont en série, et si l'une d'elle échoue la branche n'est pas suivie.


Références[modifier | modifier le code]