common-lisp
functies

Opmerkingen

Vereiste parameters

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

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

Optionele parameters

Optionele parameters kunnen worden opgegeven na vereiste parameters, met behulp van &OPTIONAL trefwoord. Er kunnen meerdere optionele parameters achter staan.

(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

Standaard alue

Een standaardwaarde kan worden gegeven voor optionele parameters door de parameter op te geven met een lijst; de tweede waarde is de standaardwaarde. Het standaardwaardeformulier wordt alleen geëvalueerd als het argument is opgegeven, dus het kan worden gebruikt voor bijwerkingen, zoals het signaleren van een fout.

(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

Controleer of optioneel argument is gegeven

Een derde lid kan aan de lijst worden toegevoegd na de standaardwaarde; een variabelenaam die waar is als het argument werd gegeven, of NIL als het niet werd gegeven (en de standaard wordt gebruikt).

(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

Functie zonder parameters

Globale benoemde functies worden gedefinieerd met 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

De hoofdtekst kan een willekeurig aantal vormen bevatten. De waarden uit het laatste formulier worden door de functie geretourneerd.

Rest parameter

Een enkele rust-parameter kan worden gegeven met het trefwoord &REST na de vereiste argumenten. Als een dergelijke parameter bestaat, kan de functie een aantal argumenten aannemen, die worden gegroepeerd in een lijst in de rest-parameter. Merk op dat de variabele CALL-ARGUMENTS-LIMIT het maximale aantal argumenten bepaalt dat in een functieaanroep kan worden gebruikt, dus het aantal argumenten is beperkt tot een implementatiespecifieke waarde van minimaal 50 of meer argumenten.

(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

Rust- en trefwoordparameters samen

De rest-parameter kan vóór sleutelwoordparameters zijn. In dat geval zal het de eigenschappenlijst bevatten die door de gebruiker is gegeven. De trefwoordwaarden blijven gebonden aan de bijbehorende trefwoordparameter.

(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

Trefwoord &ALLOW-OTHER-KEYS kunnen worden toegevoegd aan het einde van de lambda-lijst zodat de gebruiker trefwoordargumenten kan geven die niet als parameters zijn gedefinieerd. Ze komen in de restlijst.

(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

Hulpvariabelen

Het &AUX sleutelwoord kan worden gebruikt om lokale variabelen voor de functie te definiëren. Het zijn geen parameters; de gebruiker kan ze niet leveren.

&AUX variabelen worden zelden gebruikt. U kunt in plaats daarvan altijd LET gebruiken of een andere manier om lokale variabelen in de hoofdtekst te definiëren.

&AUX variabelen hebben het voordeel dat lokale variabelen van het hele functielichaam naar boven gaan en het maakt één inspringniveau (bijvoorbeeld geïntroduceerd door een LET) overbodig.

(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

Een typisch gebruik kan het oplossen van "aanwijzingsparameters" zijn. Nogmaals, je hoeft het niet op deze manier te doen; let is net zo idiomatisch.

(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, verlaat een blok of een functie

Functies vormen altijd een blok rond het lichaam. Dit blok heeft dezelfde naam als de functienaam. Dit betekent dat u RETURN-FROM met deze bloknaam kunt gebruiken om vanuit de functie en waarden terug te keren.

U moet vermijden om waar mogelijk vroeg terug te keren.

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

Zoekwoordparameters

Sleutelwoordparameters kunnen worden gedefinieerd met het sleutelwoord &KEY . Ze zijn altijd optioneel (zie het voorbeeld van optionele parameters voor details van de definitie). Er kunnen meerdere zoekwoordparameters zijn.

(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