common-lisp
Funciones

Observaciones

Parámetros requeridos

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

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

Parámetros opcionales

Los parámetros opcionales se pueden especificar después de los parámetros requeridos, utilizando la palabra clave &OPTIONAL . Puede haber múltiples parámetros opcionales después de ello.

(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

Alor por defecto

Se puede dar un valor predeterminado para los parámetros opcionales especificando el parámetro con una lista; El segundo valor es el predeterminado. La forma del valor predeterminado solo se evaluará si se proporcionó el argumento, por lo que se puede usar para efectos secundarios, como señalar un error.

(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

Compruebe si el argumento opcional fue dado

Se puede agregar un tercer miembro a la lista después del valor predeterminado; un nombre de variable que es verdadero si se proporcionó el argumento, o NIL si no se dio (y se usa el valor predeterminado).

(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

Función sin parámetros

Las funciones nombradas globales se definen 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

El cuerpo de la función puede contener cualquier número de formas. Los valores del último formulario serán devueltos desde la función.

Parámetro de descanso

Se puede dar un único parámetro de descanso con la palabra clave &REST después de los argumentos requeridos. Si tal parámetro existe, la función puede tomar varios argumentos, que se agruparán en una lista en el parámetro resto. Tenga en cuenta que la variable CALL-ARGUMENTS-LIMIT determina el número máximo de argumentos que se pueden usar en una llamada de función, por lo tanto, el número de argumentos se limita a un valor específico de implementación de un mínimo de 50 o más argumentos.

(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 y parámetros de palabras clave juntos

El parámetro resto puede estar antes de los parámetros de palabras clave. En ese caso contendrá la lista de propiedades dada por el usuario. Los valores de palabra clave seguirán vinculados al parámetro de palabra clave correspondiente.

(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

Las palabras clave &ALLOW-OTHER-KEYS se pueden agregar al final de la lista lambda para permitir al usuario dar argumentos de palabras clave no definidos como parámetros. Ellos irán en la lista de descanso.

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

La palabra clave &AUX se puede usar para definir variables locales para la función. No son parámetros; El usuario no puede suministrarlos.

&AUX variables &AUX son raramente usadas. Siempre puede utilizar LET lugar, o alguna otra forma de definir variables locales en el cuerpo de la función.

&AUX variables &AUX tienen las ventajas de que las variables locales de todo el cuerpo de la función se mueven a la parte superior y hacen que un nivel de sangría (por ejemplo, introducido por un LET) sea innecesario.

(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 uso típico puede ser resolver los parámetros de "designador". De nuevo, no necesitas hacerlo de esta manera; Usar let es igual de idiomático.

(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, salir de un bloque o una función

Las funciones siempre establecen un bloque alrededor del cuerpo. Este bloque tiene el mismo nombre que el nombre de la función. Esto significa que puede usar RETURN-FROM con este nombre de bloque para regresar de la función y devolver los valores.

Debe evitar regresar temprano siempre que sea posible.

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

Parámetros de palabras clave

Los parámetros de palabras clave se pueden definir con la palabra clave &KEY . Siempre son opcionales (consulte el ejemplo de Parámetros opcionales para obtener detalles de la definición). Puede haber múltiples parámetros de palabras clave.

(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