common-lisp
funktioner

Anmärkningar

Obligatoriska parametrar

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

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

Valfria parametrar

Valfria parametrar kan anges efter önskade parametrar, med hjälp av &OPTIONAL nyckelord. Det kan finnas flera valfria parametrar efter det.

(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

Standardalue

Ett standardvärde kan anges för valfria parametrar genom att ange parametern med en lista; det andra värdet är standard. Standardvärdesformuläret kommer endast att utvärderas om argumentet gavs, så det kan användas för biverkningar, såsom signalering av ett fel.

(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

Kontrollera om valfritt argument gavs

En tredje medlem kan läggas till i listan efter standardvärdet; ett variabelnamn som är sant om argumentet gavs, eller NIL om det inte anges (och standarden används).

(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

Funktion utan parametrar

Global namngivna funktioner definieras med 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

Funktionsorganet kan innehålla valfritt antal former. Värdena från den sista formen kommer att returneras från funktionen.

Restparameter

En enda viloparameter kan ges med nyckelordet &REST efter de nödvändiga argumenten. Om en sådan parameter finns kan funktionen ta ett antal argument som kommer att grupperas i en lista i viloparametern. Observera att variabeln CALL-ARGUMENTS-LIMIT bestämmer det maximala antalet argument som kan användas i ett funktionssamtal, varför antalet argument begränsas till ett implementeringsspecifikt värde på minst 50 eller fler argument.

(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

Vila och sökordsparametrar tillsammans

Restparametern kan vara före sökordsparametrar. I så fall kommer den att innehålla egenskapslistan som ges av användaren. Sökordsvärdena kommer fortfarande att vara bundna till motsvarande sökordsparameter.

(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

Nyckelord &ALLOW-OTHER-KEYS kan läggas till i slutet av lambda-listan så att användaren kan ge sökordargument som inte definieras som parametrar. De kommer att gå i restlistan.

(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

Hjälpvariabler

Nyckelordet &AUX kan användas för att definiera lokala variabler för funktionen. De är inte parametrar; användaren kan inte leverera dem.

&AUX variabler används sällan. Du kan alltid använda LET istället, eller på något annat sätt att definiera lokala variabler i funktionskroppen.

&AUX variabler har fördelarna med att lokala variabler för hela funktionskroppen rör sig till toppen och det gör en indragningsnivå (till exempel introducerad av en LET) onödig.

(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

En typisk användning kan vara att lösa "designator" -parametrar. Återigen behöver du inte göra det på detta sätt; att använda let är lika idiomatiskt.

(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, avsluta från ett block eller en funktion

Funktioner skapar alltid ett block runt kroppen. Detta block har samma namn som funktionsnamnet. Detta betyder att du kan använda RETURN-FROM med detta blocknamn för att återgå från funktionen och returnera värden.

Du bör undvika att återvända tidigt när det är möjligt.

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

Nyckelordsparametrar

Sökordsparametrar kan definieras med &KEY nyckelordet. De är alltid valfria (se Exempel på valfria parametrar för detaljer om definitionen). Det kan finnas flera sökordsparametrar.

(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