on-lisp要点（一）

chapter-2

1.symbol-value & symbol-function

lisp中可以通过symbol-value, symbol-function从对应的symbol获取变量值和函数值。

(defun double (x) (* x 2))(defvar double 0)(setq double 2)(symbol-value 'double)(symbol-function 'double)

2、将函数，谓词作为参数

与其把功能写死,不如传进去一个函数参数。

mapcar remove-if sort

3.闭包

(defun make-adder (n)  #(lambda (x) (+ x n))

4.局部函数

(defun count-instances (obj lsts)  (labels ((instances-in (lst)     (if (consp lst) (+ (if (eq (car lst) obj) 1 0)    (instances-in (cdr lst))) 0)))    (mapcar #'instances-in lsts)))

5.eql&equal

eql比较两个对象是否是同一个对象，equal表示两个对象的内容是否相同。

chapter-3

1、副作用&函数式编程

函数式编程意味着利用返回值而不是副作用来写程序。副作用包括破坏性修改对象(例如通过replaca)以

及变量赋值(例如通过setq)。如果副作用很少并且局部化，程序就会容易阅读，测试和调试。（感觉就是吐槽命令式编程C&C++)

2、返回多值(values,multiple-value-bind)

(defun powers (x)  (values x (sqrt x) (expt x 2)

3.简码之美（lisp宏）

 如果说简洁是智慧的灵魂，那么它和效率也同是优秀软件的本质特征。编写和维护一个程序的开销与其长
度成正比。同等条件下，程序越短越好.

chapter-5

1记住过去.

通用的将函数设计为记忆的代码：

(defun memoize (fn)  (let ((cache (make-hash-table :test #'equal)))    #'(lambda (&rest args)    (multiple-value-bind (val win) (gethash args cache)      (if win          val          (setf (gethash args cache)            (apply fn args)))))))

2 复合函数

(defun compose (&rest fns)  (if fns      (let ((fn1 (car (last fns)))    (fns (butlast fns)))#'(lambda (&rest args)    (reduce #'funcall fns    :from-end t    :initial-value (apply fn1 args))))      #'identity))

3、条件，逻辑变形

if else的变形，and,or的变形实现

(defun fif (if then &optional else)  #'(lambda (x)      (if (funcall if x)  (funcall then x)  (if else (funcall else x)))))(defun fint (fn &rest fns)  (if (null fns)      fn      (let ((chain (apply #'fint fns)))#'(lambda (x)    (and (funcall fn x) (funcall chain x))))))(defun fun (fn &rest fns)  (if (null fns)      fn      (let ((chain (apply #'fun fns)))#'(lambda (x)    (or (funcall fn x) (funcall chain x))))))

4.在cdr上递归

(defun lrec (rec &optional base)  (labels ((self (lst)     (if (null lst) (if (functionp base)     (funcall base)     base) (funcall rec (car lst)  #'(lambda ()      (self (cdr lst)))))))    #'self)); copy-list(lrec #'(lambda (x f) (cons x (funcall f)))); remove-duplicates(lrec #'(lambda (x f) (adjoin x (funcall f)))); find-if,(defun find-if-1 (pred)  (lrec #'(lambda (x f) (if (funcall pred x) x (funcall f)))));for some function fn(defun some-1 (pred)  (lrec #'(lambda (x f) (or (funcall pred x) (funcall f)))))

5. 在子树上递归

(defun ttrav (rec &optional (base #'identity))  (labels ((self (tree)     (if (atom tree) (if (functionp base)     (funcall base tree)     base) (funcall rec (self (car tree))  (if (cdr tree)      (self (cdr tree)))))))    #'self)); our-copy-tree(ttrav #'cons); count-leaves(ttrav #'(lambda (l r) (+ l (or r 1))) 1); flatten(ttrav #'nconc #'mklist)(defun trec (rec &optional (base #'identiy))  (labels      ((self (tree) (if (atom tree)     (if (functionp base) (funcall base tree) base)     (funcall rec tree      #'(lambda ()  (self (car tree)))      #'(lambda ()  (if (cdr tree)      (self (cdr tree))))))))    #'self))(trec #'(lambda (o l r) (or (funcall l) (funcall r)))      #'(lambda (tree) (and (oddp tree) tree)))