Defining Functions with DEFUN

1
Defining Functions with DEFUN
Functions are the primary abstraction mechanism
available in Lisp. (Others are structures and
macros). Non-built-in Functions are usually
defined using the special form DEFUN. gt (defun
sqr (x) ( x x)) SQR gt (defun sqr (y) Returns
the square of its arg." ( y y) ) SQR
2
Functions with no arguments
A function can take zero, one, or more
arguments. gt (defun say-hello () "prints a
greeting." (format t "Hello there!")) SAY-HEL
LO gt (say-hello) Hello there! NIL gt
3
Symbol binding, function property
A symbol can have a value and a function binding
at the same time. gt (setq foo 10) 10 gt (defun
foo (n) "Returns n plus two." ( n 2) ) FOO gt
(describe 'foo) FOO is a SYMBOL. Its value is
10 It is INTERNAL in the COMMON-LISP-USER
package. Its function binding is ltInterpreted
Function FOOgt The function takes arguments
() Its property list has these indicator/value
pairs EXCLFUN-DOCUMENTATION "Returns n
plus two." gt
4
COND (an alternative to IF)
gt (defun small-prime-p (n) "Returns T if n is
a small prime." (cond (( n 2) t) ((
n 3) t) (( n 5) t) (( n 7)
t) (t nil) ) ) SMALL-PRIME-P gt
(small-prime-p 9) NIL gt (small-prime-p 3) T
5
Recursive Functions
A function may be defined in terms of itself. gt
(defun factorial (n) "Returns factorial of N."
(if ( n 1) 1 ( n (factorial (- n 1))) )
) FACTORIAL gt (factorial 5) 120 gt (factorial
20) 2432902008176640000
6
Primitive List-Manipulating Functions
gt (setq x '(a b c d)) (A B C D) gt (first x)
FIRST returns 1st elt of list A gt (rest x)
REST returns all but 1st. (B C D) gt x (A B C D)
X has not been changed. gt (cons 'a 'b) (A .
B) CONS combines two things. gt (cons 'a
nil) (A) The result is often a
list. gt (cons 'z x) (Z A B C D)
7
CAR, CDR, and their combinations
gt (setq x '(a b c d)) (A B C D) gt (car x) A
CAR is equivalent to FIRST gt (rest x)
(B C D) CDR is equivalent to REST. gt
(cdr (cdr x)) (C D) gt (cddr x) (C D) gt (caddr
x) C CADDR is equivalent to THIRD
8
Recursive Functions of Lists
gt (defun censor (lst) "Returns LST with no
instances of BAD." (cond ((null lst) nil)
((eq (car lst) 'BAD) (censor (rest
lst)) ) (t (cons (car lst)
(censor (rest lst)) ) ) ) ) CENSOR gt (censor
'(This is a bad bad list)) (THIS IS A LIST)
9
One-Way Recursion Doesnt Do Sublists
gt (censor '(This bad list (has a bad
sublist))) (THIS LIST (HAS A BAD SUBLIST))
10
Two-Way Recursive Functions
gt (defun censor2 (lst) "Returns LST with no
instances of BAD." (cond ((null lst) nil)
((atom lst) lst) ((eq (car lst)
'BAD) (censor2 (rest lst)) )
(t (cons (censor2 (car lst))
(censor2 (rest lst)) ) ) ) ) CENSOR2 gt (censor2
'(This bad list (has a bad sublist))) (THIS LIST
(HAS A SUBLIST))
11
Looping DOTIMES
gt (defun promise (n) "Prints a promise N
times." (let ((the-promise "I will
balance parentheses")) (dotimes (i n)
(format t "d. A." i the-promise) ) )
) PROMISE gt (promise 3) 0. I will balance
parentheses. 1. I will balance parentheses. 2. I
will balance parentheses. NIL gt
12
Looping DOLIST
gt (defun print-on-separate-lines (lst) "Prints
LST with one line per element." (dolist (elt
lst nil) (print elt) ) ) PRINT-ON-SEPARATE-LI
NES gt (print-on-separate-lines '(lunch around
the corner) ) LUNCH AROUND THE CORNER NIL gt
13
Pure Functions
A pure function is one whose returned value
depends only on its arguments (i.e., it possesses
referential transparency), and it does not have
any side effects. (defun plus3 (x)( x 3)) a
pure function (defun plus3-with-y (x) not a
pure function (setq y 3) ( x y) ) (defun
plus3-with-z (x) not pure unless ( x z) )
z is constant
14
Functional Programming
Pure functional programming is programming using
only pure functions. No assignment statements,
no loops.