common-lisp
funzioni

Osservazioni

Parametri richiesti

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

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

Parametri opzionali

I parametri facoltativi possono essere specificati dopo i parametri richiesti, utilizzando la parola chiave &OPTIONAL . Potrebbero esserci più parametri facoltativi dopo di esso.

(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

Alore predefinito

Un valore predefinito può essere fornito per i parametri opzionali specificando il parametro con una lista; il secondo valore è il valore predefinito. Il modulo del valore predefinito verrà valutato solo se è stato fornito l'argomento, quindi può essere utilizzato per effetti collaterali, come la segnalazione di un errore.

(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

Controlla se è stato fornito un argomento opzionale

Un terzo membro può essere aggiunto all'elenco dopo il valore predefinito; un nome di variabile che è vero se l'argomento è stato dato, o NIL se non è stato dato (e il default è usato).

(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

Funzione senza parametri

Le funzioni con nome globale sono definite con 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

Il corpo della funzione può contenere un numero qualsiasi di moduli. I valori dell'ultimo modulo verranno restituiti dalla funzione.

Riposo Parametro

Un singolo parametro di riposo può essere fornito con la parola chiave &REST dopo gli argomenti richiesti. Se un tale parametro esiste, la funzione può richiedere un numero di argomenti, che saranno raggruppati in una lista nel parametro rest. Si noti che la variabile CALL-ARGUMENTS-LIMIT determina il numero massimo di argomenti che possono essere utilizzati in una chiamata di funzione, quindi il numero di argomenti è limitato a un valore specifico di implementazione di almeno 50 o più argomenti.

(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

Resto e parametri delle parole chiave insieme

Il parametro resto potrebbe essere prima dei parametri della parola chiave. In tal caso, conterrà l'elenco di proprietà fornito dall'utente. I valori delle parole chiave saranno comunque associati al parametro della parola chiave corrispondente.

(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

Keyword &ALLOW-OTHER-KEYS possono essere aggiunti alla fine della lambda-list per consentire all'utente di fornire argomenti di parole chiave non definiti come parametri. Andranno nella rest-list.

(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

Variabili ausiliarie

La parola chiave &AUX può essere utilizzata per definire le variabili locali per la funzione. Non sono parametri; l'utente non può fornirli.

&AUX variabili &AUX sono usate raramente. È sempre possibile utilizzare LET , o un altro modo di definire le variabili locali nel corpo della funzione.

&AUX variabili &AUX hanno il vantaggio che le variabili locali dell'intero corpo della funzione si spostano verso l'alto e rendono superfluo un livello di rientro (ad esempio introdotto da un LET).

(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

Un tipico utilizzo potrebbe essere la risoluzione dei parametri "designatore". Ancora, non è necessario farlo in questo modo; usare let è altrettanto idiomatico.

(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, uscita da un blocco o da una funzione

Le funzioni stabiliscono sempre un blocco attorno al corpo. Questo blocco ha lo stesso nome del nome della funzione. Ciò significa che è possibile utilizzare RETURN-FROM con questo nome di blocco per tornare dalla funzione e restituire i valori.

Dovresti evitare di tornare presto quando possibile.

(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"

Parametri delle parole chiave

I parametri della parola chiave possono essere definiti con la parola &KEY . Sono sempre opzionali (vedere l'esempio Parametri facoltativi per i dettagli della definizione). Potrebbero esserci più parametri di parole chiave.

(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