; global variable, constant declaration/initialization
(defvar x 10)
(defconstant pi 3.14)
; simple data types and syntax:
; real numbers, e.g. 5.123
; integers, e.g. 1024
; rationals, e.g. 14/3
; strings, e.g. "foo"
; characters, e.g. #\c
; booleans, e.g. t and nil
; prefix style function calls and operations, e.g.
; (+ (* x y) (- (/ a b) c))
; equivalent of C++ (x*y) + ((a/b) - c)
;
; common math functions:
; +, -, *, /, tan sin cos sqrt mod ceiling floor expt
; e.g. (expt 2 3) is 2 to the power of 3
; typechecking functions return t (true) if the parameter
; has the specified type, nil (false) otherwise
; (stringp x) (integerp x) (realp x) (numberp x) (listp x)
; (characterp x) (symbolp x) (functionp x) etc
; function to read and return next item of user input
; (can be number, string, character, list, etc)
(read)
; format can display text, variable, newline (~%), returns nil
(format t "Value in x is ~A~%" x)
; if/else statement to return larger of x and y
; (skips error checking for numbers in this example)
(if (> x y) x y)
; cond statements take a list of pairs, each has
; a condition to check and value to return if true
; t used as final pair's condition since it is always true
(cond
((stringp z) (format t "length of string ~A is ~A~%" z (length z)))
((listp z) (format t "length of list ~A is ~A~%" z (length z)))
((numberp z) (format t "given number, value is ~A~%" z))
(t (format t "given unexpected value: ~A~%" z)))
; numeric comparison functions: < <= > >= = /=
; string comparisons: string= string> etc
; boolean operators: and or not
; sequence functions (work on lists)
(length L) ; returns length of list L
(member e L) ; true if e is element of L, false otherwise
(count e L) ; counts how often e is in L
(position e L) ; finds first position of e in L
; list syntax '(1 2 3 4) where elements can be any type
; empty list denoted nil or '()
(list x y z) ; create/return list with elements x, y, z
(dolist (e L) (format t "Next element: ~A~%" e)) ; do something with each element of L
(null L) ; true iff L is empty list
|
; more list functions
(car L) ; returns first element of L
(cdr L) ; returns list of all the elements in L except the first
(cons e L) ; return a list with element e followed by elements of L
(reverse L) ; returned reversed copy of L
(append L1 L2) ; return list with elements of L1 then elements of L2
; examples of higher order functions/calls
(sort '(10 4 1.2 9.5 8) '<=) ; final argument is the comparison function to be used
(funcall 'cons "foo" '(1 2 3)) ; like running (cons "foo" '(1 2 3))
(apply 'cons '("foo" '(1 2 3))) ; also like running (cons "foo" '(1 2 3))
(eval '(cons "foo" '(1 2 3))) ; and also like running (cons "foo" '(1 2 3))
(maplist 'length '(10 20 30)) ; returns '(3 2 1)
(mapcar 'sqrt '(16 4 9)) ; returns '(4 2 3)
(reduce '/ '(120 3 5 2)) ; => 120/3 = 40, then 40/5 = 8, then 8/2 => 4, returns 4
(map 'list '* '(10 20 30) '(5 2 3)) ; => applies * pairwise, giving '(50 40 90)
; example of tail-recursive factorial with an accumulator
(defun factorial (N &optional (sofar 1))
(cond
((not (integerp N)) nil)
((< N 1) 0)
((= N 1) sofar)
(t (factorial (- N 1) (* N sofar)))))
; sample let-over-(labels-over-)lambda for a stored integer
; with sample local functions
(defun buildStoredInt (&optional (orig 0))
(let ( ; local variables
(stored 0) ; just a valid stored integer, defaults to 0
)
(labels
( ; local functions
(setNew (v) (if (integerp v) (setf stored v))) ; sets stored if v a valid int
(incr () (setf stored (+ stored 1))) ; increments stored value
(decr () (setf stored (- stored 1))) ; decrements stored value
(disp () (format t "~A~%" stored)) ; displays stored value
)
(setNew orig) ; try to initialize stored from orig
; build and return dispatcher as lambda function
(lambda (cmd &optional (val 0))
(cond
; run whichever local function corresponds to the caller's command
((equalp cmd 'increment) (incr))
((equalp cmd 'decrement) (decr))
((equalp cmd 'display) (disp))
((equalp cmd 'set) (setnew val))
(t (format t "Error: invalid command ~A~%" cmd)))))))
; calls to buildStoredInt
(defvar x (buildStoredInt)) ; build dispatcher using orig's default value of 0 for stored
(defvar y (buildStoredInt 15)) ; build dispatcher using value 15 for stored
(defvar z (buildStoredInt "foo")) ; build dispatcher, setting "foo" fails, stored still 0
; uses of resulting dispatchers (calls to the lambdas to update content)
(funcall x 'increment) ; increments x's stored value (to 1)
(funcall y 'display) ; displays y's stored value (15)
(funcall x 'decrement) ; decrements x's stored value (back down to 0)a
(funcall z 'set 5) ; set z's stored value (to 5)
|