Lisp 3

Hieronder volgt een lijstje van de op het tweede en derde college behandelde functie's in Lisp
length
Heeft argument een lijst, en levert de lengte van de lijst op: (length '(a b c)) -> 3
reverse
Heeft een lijst als argument, die in omgekeerde volgorde wordt opgeleverd. (reverse '(a b c)) -> (c b a)
last
last levert een lijst met een element: het laatste element van de lijst die als argument werd meegegeven. (last '(a b c)) -> (c)
assoc
assoc zoekt uit een z.g. associatielijst naar een door een key geidentificeerd element. Voorbeeld: (assoc 'weight '((height 1.65) (weight 55))) -> (weight 55)
eq
eq test of twee elementen identiek zijn: (eq 'a 'a) -> T ; (eq '(a b) '(a b)) -> nil
null
Null test of een element gelijk is aan nil: (eq x nil) = (null x)

Functiedefinities in Lisp

In lisp worden functie's gedefinieerd met behulp van de defun functie. Het algemene schema voor defun is als volgt: 
(defun [functienaam]
       ([parameters])
       [body])
Voorbeeld van een functiedefinitie: second, dat het tweede element van een lijst oplevert: 
(defun second            ; functienaam
       (l)               ; parameter
       (first (rest l))) ; body

Conditieconstructies in Lisp

Voor een als...dan... constructie zijn een aantal mogelijkheden binnen Lisp. De meest algemene is de COND functie, met IF en WHEN als afgeleiden: 
(cond ( [test-1] [body-1] )
      ( [test-2] [body-2] )
        ................
      ( [test-n] [body-n] ))
Bij de cond functie worden [test-1] t/m [test-n] een voor een geevalueerd, tot er een is die iets ongelijk nil oplevert. Zodra deze gevonden wordt de bijbehorende [body-i] geevalueerd en als resultaat opgeleverd. De resteren [test-i] worden niet meer geevalueerd. 
(if [test] [then-part] [else-part])
   =
(cond ( [test] [then-part])
      ( T [else-part]))

(when [test] [then-part])
   =
(if [test] [then-part] nil)

Definitie van reverse

Conditieconstructies en functiedefinities kunnen gecombineerd worden tot recursieve functies, bijvoorbeeld in de definitie van reverse: 
(defun reverse (l)
  (if (null l)
      nil
    (append (reverse (rest l))
	    (list (first l)))))

Definitie van assoc

Nog een voorbeeld van een recursieve functie, nu met cond: 
(defun assoc (key a-list)
  (cond
   ((null a-list) nil)
   ((eq key (first (first a-list))) (first a-list))
   (t (assoc key (rest a-list)))))

De LET-constructie

Met behulp van LET kunnen tijdelijke variabele-bindingen gemaakt worden, een soort locale variabelen, dus. 
(let ( ( [var-1] [initial-1] )
       ( [var-2] [initial-2] )
        ....................
       ( [var-n] [initial-n] ))
  [body]
)
De let-constructie levert de evaluatie van [body] op, met daarin de variabelen [var-1] t/m [var-n] gekoppeld aan [initial-1] t/m [initial-n]. Binnen de body kunnen variabelen een andere waarde krijgen, b.v. door een setf.

Inhoud Lisp