common-lisp
Les fonctions

Remarques

Paramètres requis

(defun foobar (x y)
  (format t "X: ~s~@
             Y: ~s~%"
          x y))

(foobar 10 20)
; X: 10
; Y: 20
;=> NIL

Paramètres facultatifs

Les paramètres facultatifs peuvent être spécifiés après les paramètres requis, en utilisant le mot clé &OPTIONAL . Il peut y avoir plusieurs paramètres facultatifs après cela.

(defun foobar (x y &optional z)
  (format t "X (~s) and Y (~s) are required.~@
             Z (~s) is optional.~%"
          x y z))

(foobar 10 20)
; X (10) and Y (20) are required.
; Z (NIL) is optional.
;=> NIL
(foobar 10 20 30)
; X (10) and Y (20) are required.
; Z (30) is optional.
;=> NIL

Alue par défaut

Une valeur par défaut peut être donnée pour les paramètres facultatifs en spécifiant le paramètre avec une liste; la deuxième valeur est la valeur par défaut. La forme de valeur par défaut ne sera évaluée que si l'argument a été donné, de sorte qu'il peut être utilisé pour les effets secondaires, tels que signaler une erreur.

(defun foobar (x y &optional (z "Default"))
  (format t "X (~s) and Y (~s) are required.~@
             Z (~s) is optional.~%"
          x y z))

(foobar 10 20)
; X (10) and Y (20) are required.
; Z ("Default") is optional.
;=> NIL
(foobar 10 20 30)
; X (10) and Y (20) are required.
; Z (30) is optional.
;=> NIL

Vérifiez si un argument optionnel a été donné

Un troisième membre peut être ajouté à la liste après la valeur par défaut; un nom de variable qui est vrai si l'argument a été donné ou NIL s'il n'a pas été donné (et la valeur par défaut est utilisée).

(defun foobar (x y &optional (z "Default" zp))
  (format t "X (~s) and Y (~s) are required.~@
             Z (~s) is optional. It ~:[wasn't~;was~] given.~%"
          x y z zp))

(foobar 10 20)
; X (10) and Y (20) are required.
; Z ("Default") is optional. It wasn't given.
;=> NIL
(foobar 10 20 30)
; X (10) and Y (20) are required.
; Z (30) is optional. It was given.
;=> NIL

Fonction sans paramètres

Les fonctions nommées globales sont définies avec DEFUN .

(defun foobar ()
  "Optional documentation string. Can contain line breaks.

Must be at the beginning of the function body. Some will format the
docstring so that lines are indented to match the first line, although
the built-in DESCRIBE-function will print it badly indented that way.

Ensure no line starts with an opening parenthesis by escaping them
\(like this), otherwise your editor may have problems identifying
toplevel forms."
  (format t "No parameters.~%"))

(foobar)
; No parameters.
;=> NIL

(describe #'foobar) ; The output is implementation dependant.
; #<FUNCTION FOOBAR>
;   [compiled function]
;
; Lambda-list: ()
; Derived type: (FUNCTION NIL (VALUES NULL &OPTIONAL))
; Documentation:
;   Optional documentation string. Can contain line breaks.
;   
;   Must be at the beginning of the function body. Some will format the
;   docstring so that lines are indented to match the first line, although
;   the built-in DESCRIBE-function will print it badly indented that way.
; Source file: /tmp/fileInaZ1P
;=> No values

Le corps de la fonction peut contenir un nombre quelconque de formulaires. Les valeurs du dernier formulaire seront renvoyées par la fonction.

Paramètre de repos

Un seul paramètre de repos peut être donné avec le mot-clé &REST après les arguments requis. Si un tel paramètre existe, la fonction peut prendre plusieurs arguments, qui seront regroupés dans une liste du paramètre rest. Notez que la variable CALL-ARGUMENTS-LIMIT détermine le nombre maximum d'arguments pouvant être utilisés dans un appel de fonction. Le nombre d'arguments est donc limité à une valeur spécifique d'implémentation d'au moins 50 arguments ou plus.

(defun foobar (x y &rest rest)
  (format t "X (~s) and Y (~s) are required.~@
             The function was also given following arguments: ~s~%"
          x y rest))

(foobar 10 20)
; X (10) and Y (20) are required.
; The function was also given following arguments: NIL
;=> NIL
(foobar 10 20 30 40 50 60 70 80)
; X (10) and Y (20) are required.
; The function was also given following arguments: (30 40 50 60 70 80)
;=> NIL

Paramètres de repos et de mots-clés ensemble

Le paramètre rest peut être avant les paramètres mot clé. Dans ce cas, il contiendra la liste de propriétés donnée par l'utilisateur. Les valeurs de mot-clé seront toujours liées au paramètre de mot-clé correspondant.

(defun foobar (x y &rest rest &key (z 10 zp))
  (format t "X (~s) and Y (~s) are required.~@
             Z (~s) is a keyword argument. It ~:[wasn't~;was~] given.~@
             The function was also given following arguments: ~s~%"
          x y z zp rest))

(foobar 10 20)
; X (10) and Y (20) are required.
; Z (10) is a keyword argument. It wasn't given.
; The function was also given following arguments: NIL
;=> NIL
(foobar 10 20 :z 30)
; X (10) and Y (20) are required.
; Z (30) is a keyword argument. It was given.
; The function was also given following arguments: (:Z 30)
;=> NIL

Le mot &ALLOW-OTHER-KEYS clé &ALLOW-OTHER-KEYS peut être ajouté à la fin de la liste lambda pour permettre à l'utilisateur de donner des arguments de mot-clé non définis en tant que paramètres. Ils iront dans la liste de repos.

(defun foobar (x y &rest rest &key (z 10 zp) &allow-other-keys)
  (format t "X (~s) and Y (~s) are required.~@
             Z (~s) is a keyword argument. It ~:[wasn't~;was~] given.~@
             The function was also given following arguments: ~s~%"
          x y z zp rest))

(foobar 10 20 :z 30 :q 40)
; X (10) and Y (20) are required.
; Z (30) is a keyword argument. It was given.
; The function was also given following arguments: (:Z 30 :Q 40)
;=> NIL

Variables Auxiliaires

Le mot clé &AUX peut être utilisé pour définir des variables locales pour la fonction. Ce ne sont pas des paramètres. l'utilisateur ne peut pas les fournir.

&AUX variables &AUX sont rarement utilisées. Vous pouvez toujours utiliser LET ou une autre manière de définir des variables locales dans le corps de la fonction.

&AUX variables &AUX ont l'avantage que les variables locales du corps entier de la fonction sont déplacées vers le haut et qu'un niveau d'indentation (par exemple, introduit par un LET) est inutile.

(defun foobar (x y &aux (z (+ x y)))
  (format t "X (~d) and Y (~d) are required.~@
             Their sum is ~d."
          x y z))

(foobar 10 20)
; X (10) and Y (20) are required.
; Their sum is 30.
;=> NIL

Une utilisation typique peut être la résolution des paramètres "désignateur". Encore une fois, vous n'avez pas besoin de le faire de cette façon; Utiliser let est tout aussi idiomatique.

(defun foo (a b &aux (as (string a)))
  "Combines A and B in a funny way.  A is a string designator, B a string."
  (concatenate 'string as " is funnier than " b))

RETURN-FROM, sortie d'un bloc ou d'une fonction

Les fonctions établissent toujours un bloc autour du corps. Ce bloc porte le même nom que le nom de la fonction. Cela signifie que vous pouvez utiliser RETURN-FROM avec ce nom de bloc pour revenir de la fonction et renvoyer des valeurs.

Vous devriez éviter de revenir tôt si possible.

(defun foobar (x y)
  (when (oddp x)
    (format t "X (~d) is odd. Returning immediately.~%" x)
    (return-from foobar "return value"))
  (format t "X: ~s~@
             Y: ~s~%"
          x y))

(foobar 10 20)
; X: 10
; Y: 20
;=> NIL
(foobar 9 20)
; X (9) is odd. Returning immediately.
;=> "return value"

Paramètres de mot clé

Les paramètres de mot-clé peuvent être définis avec le mot-clé &KEY . Ils sont toujours facultatifs (voir l'exemple des paramètres facultatifs pour plus de détails sur la définition). Il peut y avoir plusieurs paramètres de mot-clé.

(defun foobar (x y &key (z "Default" zp))
  (format t "X (~s) and Y (~s) are required.~@
             Z (~s) is a keyword argument. It ~:[wasn't~;was~] given.~%"
          x y z zp))

(foobar 10 20)
; X (10) and Y (20) are required.
; Z ("Default") is a keyword argument. It wasn't given.
;=> NIL
(foobar 10 20 :z 30)
; X (10) and Y (20) are required.
; Z (30) is a keyword argument. It was given.
;=> NIL