On Lisp (豆瓣)

副标题: Advanced Techniques for Common LISP
作者: Paul Graham
出版社: Prentice Hall
出版年: 09 September, 1993
页数: 432
定价: $52.00
装帧: paperback
ISBN: 9780130305527

9.6

(43人评价)

79.1%

18.6%

2.3%

0.0%

想读在读读过

评价:

内容简介 · · · · · ·

　　On Lisp is a comprehensive study of advanced Lisp techniques, with bottom-up programming as the unifying theme. It gives the first complete description of macros and macro applications. The book also covers important subjects related to bottom-up programming, including functional programming, rapid prototyping, interactive development, and embedded languages. The final chapter ... (展开全部) 　　

豆瓣成员常用的标签(共49个) · · · · · ·

lisp(152) programming(43) 编程(31) FP(28) 计算机(22) paulgraham(17) 计算机科学(16) Functional(13)

喜欢读"On Lisp"的人也喜欢 · · · · · ·

: ANSI Common LISP

: Practical Common Lisp

: Paradigms of Artificial Intelligence ...

: Land of Lisp

: Hackers and Painters: Big Ideas fr...

: Structure and Interpretation of Com...

: 计算机程序的构造和解释

: Coders at Work

: ML程序设计教程

: 具体数学

读书笔记 · · · · · · (共7篇)
我来写笔记

按有用程度 按页码先后 最新笔记

第69页

撒旦先生 (-_-||)

(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))))))) (lrec #'(lambda (x f) (1+ (funcall f))) 0) (lrec #'(lambda (x f) (... (更多)

(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)))))))
(lrec #'(lambda (x f) (1+ (funcall f))) 0)
(lrec #'(lambda (x f) (and (oddp x) (funcall f))) t)
看不懂，自己推导一下
大概样子:
(defun lrec1 (op lst base join)
(if (null lst)
base
(funcall join (funcall op (car lst))
(lrec1 op (cdr lst) base join))))
可以把 lst 抽出来:
(defun lrec2 (op base join)
(labels ((self (lst)
(if (null lst)
base
(funcall join (funcall op (car lst)) (funcall (lrec2 op base join) (cdr lst))))))
#'self))
------->
(defun lrec2 (op base join)
(labels ((self (lst)
(if (null lst)
base
(funcall join (funcall op (car lst)) (funcall self (cdr lst))))))
#'self))
op和join是宏的话，就不行了，所以把op和join放到一个函数里在传入:
函数的样子是这样的 (lambda (x) (join (op x) (self (cdr lst))))
(self (cdr lst))由调用者传给它
最后就是这样子的 (lambda (x f) (join (op x) (funcall f)))
(defun lrec4 (rec base)
(labels ((self (lst)
(if (null lst)
base
(funcall rec (car lst)
#'(lambda ()
(self rec (cdr lst))))))) (收起)

2011-11-26 11:18:51 回应

收藏
推荐
第4页

jesse

最前边的第iv页竟然是个孤零零的 λ。 (更多)

最前边的第iv页竟然是个孤零零的 λ。 (收起)

2011-10-24 19:51:58 回应

收藏
推荐
第17页

drunkedcat

在 cl 中, 采用的是 lexically scope, 所以在函数定义的时候, 函数的名字除了绑定这个函数,还绑定了函数中定义的 free varibale, 这样一堆东西放在一起,叫做 closure. 闭包. free 的反义词是 bound. free 的变量, 它的值是不一定的. bound 的变量的值, 是确定的. closures are functions with local state. (更多)

在 cl 中, 采用的是 lexically scope, 所以在函数定义的时候, 函数的名字除了绑定这个函数,还绑定了函数中定义的 free varibale, 这样一堆东西放在一起,叫做 closure. 闭包.
free 的反义词是 bound.
free 的变量, 它的值是不一定的. bound 的变量的值, 是确定的.
closures are functions with local state. (收起)

2011-05-31 22:31:51 回应

收藏
推荐

第4页

jesse

最前边的第iv页竟然是个孤零零的 λ。 (更多)

最前边的第iv页竟然是个孤零零的 λ。 (收起)

2011-10-24 19:51:58 回应

收藏
推荐
第11页

drunkedcat

lambda 表达式,就是函数的 literally 表示. 有没有什么快捷的方法来"证明"两个函数是等价的呢?比如 (lambda (x) (+ x x)) 和 (lambda (x) (* 2 x)) ? (更多)

lambda 表达式,就是函数的 literally 表示.
有没有什么快捷的方法来"证明"两个函数是等价的呢?比如 (lambda (x) (+ x x)) 和 (lambda (x) (* 2 x)) ? (收起)

2011-05-31 22:04:10 回应

收藏
推荐
第12页

drunkedcat

在 common lisp 中, 函数和变量使用不同的名空间,所以,可以有名字相同的函数和变量,不会混淆. (更多)

在 common lisp 中, 函数和变量使用不同的名空间,所以,可以有名字相同的函数和变量,不会混淆. (收起)

2011-05-31 22:07:55 回应

收藏
推荐

第69页

撒旦先生 (-_-||)

(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))))))) (lrec #'(lambda (x f) (1+ (funcall f))) 0) (lrec #'(lambda (x f) (... (更多)

(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)))))))
(lrec #'(lambda (x f) (1+ (funcall f))) 0)
(lrec #'(lambda (x f) (and (oddp x) (funcall f))) t)
看不懂，自己推导一下
大概样子:
(defun lrec1 (op lst base join)
(if (null lst)
base
(funcall join (funcall op (car lst))
(lrec1 op (cdr lst) base join))))
可以把 lst 抽出来:
(defun lrec2 (op base join)
(labels ((self (lst)
(if (null lst)
base
(funcall join (funcall op (car lst)) (funcall (lrec2 op base join) (cdr lst))))))
#'self))
------->
(defun lrec2 (op base join)
(labels ((self (lst)
(if (null lst)
base
(funcall join (funcall op (car lst)) (funcall self (cdr lst))))))
#'self))
op和join是宏的话，就不行了，所以把op和join放到一个函数里在传入:
函数的样子是这样的 (lambda (x) (join (op x) (self (cdr lst))))
(self (cdr lst))由调用者传给它
最后就是这样子的 (lambda (x f) (join (op x) (funcall f)))
(defun lrec4 (rec base)
(labels ((self (lst)
(if (null lst)
base
(funcall rec (car lst)
#'(lambda ()
(self rec (cdr lst))))))) (收起)

2011-11-26 11:18:51 回应

收藏
推荐
第4页

jesse

最前边的第iv页竟然是个孤零零的 λ。 (更多)

最前边的第iv页竟然是个孤零零的 λ。 (收起)

2011-10-24 19:51:58 回应

收藏
推荐
第17页

drunkedcat

在 cl 中, 采用的是 lexically scope, 所以在函数定义的时候, 函数的名字除了绑定这个函数,还绑定了函数中定义的 free varibale, 这样一堆东西放在一起,叫做 closure. 闭包. free 的反义词是 bound. free 的变量, 它的值是不一定的. bound 的变量的值, 是确定的. closures are functions with local state. (更多)

在 cl 中, 采用的是 lexically scope, 所以在函数定义的时候, 函数的名字除了绑定这个函数,还绑定了函数中定义的 free varibale, 这样一堆东西放在一起,叫做 closure. 闭包.
free 的反义词是 bound.
free 的变量, 它的值是不一定的. bound 的变量的值, 是确定的.
closures are functions with local state. (收起)

2011-05-31 22:31:51 回应

收藏
推荐