Structures de contrôle

Dans un langage, les structures de contrôle permettent de contrôler la manière avec laquelle le programme va s'exécuter ou la manière d'organiser le programme et les différentes déclarations.

Scheme est un langage suffisamment puissant pour permettre d'ajouter des structures de contrôle à l'aide des macros : il est par exemple possible de définir la forme while qui n'existe pas en standard. Pour l'instant, la définition des macros sort de notre cadre.

La forme begin

Cette forme est beaucoup utilisée avec le if : en effet, la clause alors et la clause sinon du if n'acceptent qu'une seule expression Scheme. Si on souhaite écrire plusieurs expressions dans l'une ou l'autre des deux clauses, il faut utiliser begin :

Osm> (if condition
       (begin
         alors-1
         ...
         alors-n)
       (begin
         sinon-1
         ...
         sinon-m))

Variables locales et la forme let

Nous avons vu que pour nommer une variable, nous écrivons :

Osm> (define symbole valeur)

Ainsi, symbole est ``rattaché'' à valeur. Pour définir des fonctions, nous utilisons l'écriture :

Osm> (define (symbole param-1 param-n)
        expression-1
        ...
        expression-m)

Pour déclarer des variables dans le corps de la fonction, nous pouvons utiliser define :

Osm> (define (f a b)
        (define c (+ a b))
        (/ c 2))
  => #unspecified

Lorsque nous exécutons cette fonction, la variable c est déclarée et initialisée à a+b. Cette variable est ensuite utilisée pour retourner c/2.

Dans cette écriture, la variable c est définie dans toutes les expressions du corps de la fonction qui suivent la déclaration.

Il existe une manière plus commode pour déclarer un ensemble de variables locales, c'est la forme let :

Osm> (define (f a b)
        (let ((c (+ a b)))
          (/ c 2)))
  => #unspecified

Let possède la structure suivante :

(let ((variable-1 valeur-1)
      (variable-2 valeur-2)
       ...
      (variable-n valeur-n))
  expression-1
  ...
  expression-m)

Les valeurs ne peuvent pas faire références aux variables dans la forme let. Le lecteur pourra consulter la définition des formes spéciales let* et letrec qui permettent de contourner cette limitation.

La forme cond

Pour effectuer des choix multiples, Scheme définit la forme cond qui s'écrit :

(cond (condition-1 expressions …)
      ...
      (condition-1 expressions …))

L'évaluation commence par la première clause jusqu'à la dernière. A la première condition évaluée comme vrai, les expressions sont évaluées et le résultat est le résultat de l'évaluation de la dernière expression. Si une condition est le mot clef else, elle est considérée comme vraie.

Ecrivons :

Osm> (define (nom-type objet)
        (cond ((char? objet)
               (display "caractère")
               (newline))
              ((integer? objet)
               (display "entier")
               (newline))
              ((number? objet)
               (display "nombre")
               (newline))
              ((string? objet)
               (display "chaîne")
               (newline))
              ((or (pair?   objet)
                   (vector? objet))
               (display "composé")
               (newline))
              (else
               (display "autre type")
               (newline))))
  => #unspecified

Osm> (nom-type 123.456)
  => "nombre"

Osm> (nom-type '())
  => "autre type"

Le lecteur pourra consulter la définition de la forme spéciale case qui permet aussi d'effectuer des choix multiples avec des constantes.