MEER VOORGEDEFINIEERDE FUNCTIES

Hoewel de meeste van de volgende procedures met behulp van de eerder beschreven procedures gedefinieerd kunnen worden. Is het beter de voorgedefinieerde versie te gebruiken omdat die meer efficiënt is.

Operaties op lijsten

Bij de definitie van CONS beperkten we ons eerder tot de situatie met een lijst als tweede argument. Ook wanneer het tweede argument van CONS geen lijst is, geeft Lisp een bruikbaar resultaat; een pair. Een pair heeft een CAR en een CDR, en wordt voorgesteld als een lijst met CAR en CDR gescheiden door een dot.

> (define x (cons 'a 'b))
(A . B)
> (car x)
A
> (cdr x)
B
> (cadr x) ; = (car (cdr x)) = (car 'B)
ERROR: cadr: Wrong type in arg1 b

Zoals gezegd zijn lijsten intern eigenlijk gerepresenteerd als paren. Een lijst is ofwel leeg, ofwel een paar met als CDR een lijst. Bijvoorbeeld, een lijst met twee elementen is een paar waarvan de CAR het eerste element van de lijst is, en de CDR een paar met als CAR het tweede element van de lijst, en als CDR de lege lijst.

(a b) = (a . (b . ()))

Nuttige voorgedefinieerde functies om lijsten te manipuleren zijn de volgende:

• (LIST-REF lijst geheel-getal). Neemt als eerste argument een lijst en als tweede argument een index. Retourneert het n-de element van de lijst (waar n de positieve index is). Opgelet, in SCHEME beginnen we te tellen vanaf 0. Dit betekent dat (list-ref '(3 2 1) 0) het eerste element oplevert (in dit geval 3). (list-ref lijst 0) is dus equivalent met (car lijst).
• (LIST-TAIL lijst integer). Neemt als eerste argument een lijst, en als tweede argument een index. De functie retourneert het resultaat van index keer de CDR van de lijst.
• (LENGTH lijst). Retourneert de lengte van zijn argument, dat een lijst moet zijn.
• (REVERSE lijst). Retourneert zijn argument (een lijst) in omgekeerde volgorde.
• (SET-CAR! lijst expressie). Heeft als eerste argument een lijst, en als tweede argument een symbolische expressie die de nieuwe CAR wordt van de lijst.
• (SET-CDR! lijst expressie). Heeft als eerste argument een lijst, en als tweede argument een symbolische expressie die de nieuwe CDR wordt van de eerste lijst.

> (list-ref '(1 2 3) 0)
1
> (list-ref '(1 2 3) -1)
ERROR: list-ref: Wrong type in arg2 -1
> (list-ref '(1 2 3) 3)
ERROR: list-ref: Argument out of range 3

> (list-tail '(aap noot mies) 0)
(AAP NOOT MIES)
> (list-tail '(aap noot mies) 1)
(NOOT MIES)
> (list-tail '(aap noot mies) 3)
()
> (list-tail '(aap noot mies) 4)           ; = (cdr '())
ERROR: list-tail: Wrong type in arg1 ()

> (define l1 '(l1))
(L1)
> (length l1)
1
> (length (append l1 l1))
2
> (list-tail l1 (length l1))
()
> (reverse '(de laatsten zullen de eersten zijn))
(ZIJN EERSTEN DE ZULLEN LAATSTEN DE)
> (reverse '(a   m a n   a   p l a n   a   c a n a l   p a n a m a))
(A M A N A P L A N A C A N A L P A N A M A)
> (define x '(m o o i e z e d e n i))
(M O O I E Z E D E N I)
> (append x (cdr (reverse x)))
(M O O I E Z E D E N I N E D E Z E I O O M)
> (define *life* '(yesterday today tomorrow))
(YESTERDAY TODAY TOMORROW)
> (car (cdr *life*))
> (define lis-a '(1 2 3))
(1 2 3)
> (set-car! lis-a 34)
(34 2 3)
> (set-cdr! lis-a '(55))
(34 55)
> (set-cdr! lis-a '())
(34)
TODAY

Operaties op getallen

Voorgedefinieerde operaties zijn: <, >, EXPT (machtsverheffing), EXP (exponent), SQRT (vierkantswortel), ABS (absolute waarde), GCD (grootste gemene deler van reeks getallen), LCM (kleinste gemene veelvoud), en LOG (natuurlijke logaritme). Daarnaast zijn er de gebruikelijke trigonometrische functies SIN, COS, TAN, ASIN, ACOS, en ATAN.

De procedures FLOOR, CEILING, TRUNCATE en ROUND, telkens met een reëel getal als argument, retourneren gehele getallen; respectievelijk de grootste integer niet groter dan het argument, de kleinste integer niet kleiner dan het argument, het getal zonder decimale gedeelte, en de afgerond dichtste integer.

> (expt 2 6)
64
> (sqrt 24)
4.898979485566356
> (abs -12)
12
> (gcd 144 36 48)
12
> (lcm 12 44 36)
396
> (log 64)
4.1588830833597
> (truncate 3.6)
3
> (round 3.6)
4
> (ceiling 3.6)
4
> (floor 3.6)
3

Operaties op strings

Strings worden vooral gebruikt voor tekstmanipulatie. Er zijn primitieve procedures voor de creatie en manipulatie van strings.

• (MAKE-STRING integer [character]). Alloceert geheugen voor een nieuwe string. Het eerste argument van de functie geeft het aantal elementen aan, het optionele tweede argument is een character dat als initiële waarde wordt gebruikt. Voor string creatie kan ook (STRING character*) worden gebruikt, met als argumenten de characters die in de string moeten staan.
• (STRING-LENGTH string). Heeft een string als argument en geeft het aantal characters in de string.
• (STRING-REF string integer). Heeft als eerste argument een string, en als tweede argument een index. Geeft het character dat correspondeert met de door de index genoemde positie in de string. LISP begint te tellen vanaf 0!
• (SUBSTRING string integer1 integer2) neemt drie argumenten: een string, een startindex en een stopindex, en retourneert de substring die tussen start en stop ligt.
• (STRING-APPEND string*). APPEND voor strings.
• (STRING-SET! string integer character). Heeft als eerste argument een string, als tweede argument een index verwijzend naar een positie in de string, en als derde argument een character dat het character op de genoemde positie in de string vervangt.

> (make-string 10 #\a)
"aaaaaaaaaa"

> (make-string 2)
"  "
> (string #\a #\b #\space #\c)
"ab c

> (string-length "appelflap")
9
> (string-ref "a b c" 1)
#\space

> (substring "aardappel" 4 (string-length "aardappel"))
"appel"

> (string-append "aard" "+" "appel")
"aard+appel"

> (string-set! "appel" 0 #\A)
"Appel"

Operaties op characters

• (CHAR-UPCASE character). Retourneert uppercase versie van het character dat als argument wordt meegegeven.
• (CHAR-DOWNCASE character). Retourneert downcase versie van het character dat als argument wordt meegegeven.

> (char-upcase #\a)
#\A
> (char-downcase #\Z)
#\z
(char-downcase #\space)
#\space

Operaties op vectoren

• (MAKE-VECTOR integer expressie).
• (VECTOR expressie*).
• (VECTOR-LENGTH vector).
• (VECTOR-REF vector integer).
• (VECTOR-SET! vector integer expressie).

> (make-vector 10 'aap)
#(aap aap aap aap aap aap aap aap aap aap)

> (make-vector 2)
#(# #)

> (vector 'aap 'noot '(mies en andere))
#(aap noot (mies en andere))

> (vector-length #(1 2 3 4 5))
5

> (vector-ref #(aap noot (mies en andere)) 2)
(mies en andere)