Fonction à `` arguments variables ''

Le langage Scheme permet de définir facilement des fonctions avec un nombre d'arguments variable.

Cela peut être utile dans les cas suivants :

• Simplification des appels à une fonction lorsque certains arguments sont rarement nécessaires ;
• Modification de la signature d'une fonction sans compromettre le code existant ;
• Le nombre d'arguments ne peut être connu à l'avance.

Nous avons déjà rencontré de telles fonctions. C'est le cas des opérateurs arithmétiques comme +. On a par exemple :

Osm> (+)
  => 0

Osm> (+ 1)
  => 1

Osm> (+ 1 2 3 4)
  => 10

D'autres fonctions, comme display et newline, read-char acceptent aussi un argument facultatif qui est le port d'entrée / sortie.

Une fonction ayant un nombre d'arguments variable est créée avec la forme lambda de la manière suivante :

(lambda (a1 a2 . av) corps)

où a1 et a2 sont des paramètres réguliers et av représente un paramètre qui contiendra la liste des arguments supplémentaires.

Bien sûr, il est possible de définir la fonction avec 0, 1 ou plusieurs paramètres réguliers et les noms des paramètres sont libres.

Nous pouvons aussi utiliser la forme compacte de define où :

(define f (lambda (a1 a2 . av) corps))

représente la même fonction que :

(define (f a1 a2 . av) corps)

Ecrivons une fonction ayant un nombre d'arguments variable. Il s'agit d'une fonction qui calcule la moyenne des arguments avec au moins un argument :

Osm> (define (moyenne premier . autres)
      (let ((somme premier))
         (for-each (lambda (n)
                    (set! somme (+ somme n)))
                   autres)
        (/ somme (+ 1 (length autres)))))
  => #unspecified

Osm> (moyenne 13)
  => 13

Osm> (moyenne 13 14 15)
  => 14

Pour affiner la détection des erreurs, il serait possible d'ajouter un test dans l'itération qui vérifierait avec number? que n est bien un nombre.

Pour les fonctions dont tous les arguments sont optionnels, on utilisera la forme contractée suivante :

(lambda (. av) corps)

qui peut aussi s'écrire :

(lambda av corps)

On pourrait ainsi définir une fonction qui affiche la valeur de ses arguments et retourne leur nombre avec :

(define (compte . arguments)
  (let loop ([arguments arguments]
             [n         0])
    (if (null? arguments)
      n
      (begin
       (display (car arguments))
       (newline)
       (loop (cdr arguments) (+ 1 n))))))