BASIC CONCEPTS
Atom
3 types of Atom
- Symbols: (case insensitive) John, abc, 23-Jordan
- Numbers: 123, 0, #C(3 4) ;complex number = 3+4i
#C(3/4 4) ;complex number = 0.75+4i != 3/4+4i - Constants(self-evaluating): NIL, T
Symbolic-Expression(s-expression)
- An atom is an s-expression
- If s1, s2, ..., sn are s-expression, so is the list(s1, s2, ..., sn)
List
A nonatomic s-expression
A collection of atom or list enclosed by parentheses ()
NIL and T
NIL
A special list called the null list
Also an atom
non-NIL is true
T
All the data types are subtypes of T
EVALUATION
Form
A form is an s-expression that is intended to be evaluated
e.g. (+ 2 4)
Evaluation
Evaluate the second through the last arguments(recursion)
Control the Flow of Evaluation
Quote
Return the arguments without evaluation
/> 'a
A
/> (quote a)
A
EVAL
tell the interpreter to evaluate the expression
/> (eval '(* 2 3))
6
Binding Variables Explicity
Set binds a value to the global environment
Setq is a variant of SET which dose not evaluate the first argument
/> (set 'index (+ 1 4))
5
/> (set 'index (+ 1 index))
6
/> (setq index (+ 2 index)) ;no ' is needed for SETQ
8
setf is a macro that examines an access from and produces a call to the corresponding update function
It uses its first argument to obtain a memory location and places the calue of the second argument in that location
/> (setf index (+ 2 6))
8
/> (setq a '(1 2 3)) ;create a list of '(1 2 3)
(1 2 3)
/> (setf (car a) 4) ;car is a function that returns the head of the list
4
/> a
(4 2 3)
setq and setf
source: https://blog.csdn.net/csfreebird/article/details/8761634
(Oct 18 2018)
setq: 避免使用set时用'来阻止表达式求值
setf: 用于设置list或array
/> (setq L '(a b (c d) e f g))
(a b (c d) e f g)
/> L
(a b (c d) e f g)
/> (setf (L 1) 'B)
B
/> L
(a B (c d) e f g)
/> (L 1)
B
LIST MANIPULATION
Cons cell: A two-field record
/> (cons 3 nil)
(3)
/> (cons 3 (cons 4 'x))
(3 4 . x) ;dotted-pair notation, improper list
/> (cons 3 (cons 4 (cons 'x nil)))
(3 4 x)
C[AD][AD]*R and NTHCDR
/> (car NIL)
NIL ;behave as an atom
/> (cdr NIL)
NIL ;behave as a list
/> (cadr '(a b c)) ;(car (cdr '(a b c)))
B
/>(cdar '((1 . 2) 3))
2
/> (nthcdr 0 '(1 2 3 4 5))
(1 2 3 4 5)
/> (nthcdr 3 '(1 2 3 4 5)) ;(cdr cdr( cdr '(1 2 3 4 5)))
(4 5)
Lists: implemented on top of cons pairs
LIST
/> (list 3 4 'x)
(3 4 X)
/> '(3 4 x)
/> (list 3 (+ 2 2) x)
(3 4 X)
/> (setq L (list 1 2 3 4))
(1 2 3 4)
/> (car L)
1
/> (cdr L)
(2 3 4)
PUSH and POP
/> (setq a nil)
NIL
/> (push 3 a)
(3)
/> (push 5 a)
(5 3) ;the leftmost is the top of the stack
/> (pop a)
5
/> a
(3)
/> (pop a)
3
/> (pop a)
NIL
/> a
NIL
NTH, APPEND, DELETE
/> (nth 5 '(a b c d e f))
F
APPEND concatenates lists into one list. It created a new list and does NOT modify the argument lists
/> (append '(a b) 'c)
(A B . C)
/> (delete 'b '(a b c))
(A C)
/> (delete 'd '(a b c)) ;no error message
(A B C)
/> (delete 'a '(a a a b a))
(B)
Type Predicates
TYPOP object data_type: is the type of object data_type
SUBTYPEP subtype data_type: is the subtype a subtype of data_type
- ATOM: atom
SYMBOLP: symbol
CONSP: cons
LISTP: list
/> (symbolp 10)
NIL
/> (atom 10)
T
/> (typep 10 'atom)
T ;same as the last result
Equality Predicates
- (= x y): Numbers only and ignore type
- (EQ x y): Are the two objects implementationally identical?
Same memory location - (EQL x y): Are the two objects conceptually identical?
- (EQUAL x y): isomorphic?
/> (setq q1 '(abc 123))
(ABC 123)
/> (setq q2 '(abc 123))
(ABC 123)
/> (eq q1 q2)
NIL
/> (eql q1 q2)
NIL
/> (eql (car q1) (car q2))
T
/> (equal q1 q2)
T
Conditional Constructs
AND NOT OR
IF test then [else]
/> (setq p 10)
10
/> (set1 d 3)
3
/> (if (eql (mod p d) 0)
(list '* p d)
(list '+ (list '* d (floor (/ p d))) (mod p d)))
(+ (* 3 3) 1)
COND {(test {form})}
/> (setq person 'Sam)
SAM
/> (cond
((eql person 'Peter) 'Boss)
((eql person 'Sam) 'Staff1001)
((eql person 'Paco) 'Staff1002)
(t 'Intruder!))
STAFF1001
Indefinite Iteration
LOOP {forms}
/> (setq x 3)
/> (loop
(print x)
(setq x (- x 1))
(if (zerop x) (return "GO!")))
3
2
1
"GO!"
DO
(DO({ (variable [initial-value [step-form]]) })
(end-test {result})
{declaration}
{tag | statement})
/> (setq x 3)
/> (do ((a x (- a 1)))
((zerop a) "GO!")
(print a))
Let
LET ({var | (car value)}) {declaration} {from}
/> (let ((x 3))
(loop (print x))
(setq x (- x 1))
(if (zerop x) (return "GO!")))
3
2
1
"GO!"
YOUR CONTROL CONSTRUCTS
Named Function
DEFUN name lambda-list {declaration | doc-string} {form}
/> (defun decompose (p d)
(if (eql (mod p d) 0)
(list '* p d)
(list '+ (list '* d (floor (/ p d))) (mod p d))))
DECOMPOSE
/> (decompose 10 4)
(+ (* 4 2) 2)
Lambda Expression
LAMBDA lambda-list . body
/> ((lambda (p d)
(if (eql (mod p d) 0)
(list '* p d)
(list '+ (list '* d (floor (/ p d))) (mod p d)))) 10 4)
(+ (* 4 2) 2)