Let Over Lambda 笔记
Introduction
程序的关键在于合适的抽象，这样才不会有一堆重复的代码，增加更多复杂度
宏很强大，宏很灵活，宏无所不能，BLABLABLA……
正如学C一定要理解指针啥时候用，学LISP一定要理解宏啥时候用
风格是给不知道啥时该用语言的啥特性的人准备的（中枪一片）
看此书之前，最好熟读 On Lisp
宏又被描述为元编程meta-program
先理解一下On Lisp的几个宏，例如mkstr、symb、group、flatten等等
Closures
lisp的闭包一般就是先 let 分配变量，然后返回一个lambda匿名函数，所以叫let over lambda。
在lisp中，变量没有类型，只有值才有类型。
关于lexical scope（词法作用域）和 dynamic scope（动态作用域），注意，现代编程语言基本都是用的lexical scope，因为dynamic scope的函数结果与调用环境紧耦合，同名变量可能引发错误，可参考：CSE 341 – Lexical and Dynamic Scoping
闭包大多建立在 lexical scope之上
lisp可通过defvar定义dynamic scope的special variables，经常会在变量名前后加 * 号，例如 special-var
lexical variables 是在编译阶段分配的symbol
通过declare指定优化条件，指导编译器生成变量，例如 (declare (optimize (speed 3) (safety 0)))
lambda 是个symbol，自身是个宏（注意看实现代码），作用是：生成一个宏，展开时会call指定的function
生成的lambda没法直接像函数一样在form调用，得用funcall或apply调
defun里面定义的lambda，如果不在let包围的lexical scope内（null lexical），就会在编译期的时候生成，后续都是直接调用，不用重复生成；如果是let + lambda组合(non-null lexical)，则是在运行期动态生成，每调一次生成一次
假设一个函数生成闭包，如果该函数被compile，则闭包也会连着被compile；但如果闭包在 non-null lexical 环境下生成，它就没法被compile
其实闭包也可看做是包含一些状态变量（与perl中的state变量含义基本相同）的函数
对象object常用于指代某些数据、程序的集合。闭包类似于只有funcall一个method的对象；对象类似于可以用不同方式funcall的闭包，例如计数器的闭包，可以生成增、减两个lambda（这边的口水话真不少）
初始化一个闭包的方式，所谓的 lambda over let over lambda
(lambda ()
(let ((cnt 0))
(lambda () (incf cnt))))其实就相当于一个匿名类class
如果是用defun定义，则相当于显式指定外层lambda的名字，只是写的时候省掉了lambda的关键字
(defun cnt-class()
(let ((cnt 0))
(lambda () (incf cnt))))给了一个block-scanner的闭包例子，检查几个连续的字符串是否能够匹配预先给定的字符串
(defvar scanner
(block-scanner "jihad")) ; 指定待匹配的字符串为jihad
# (funcall scanner "the ji") ; 匹配了 ji
NIL
* (funcall scanner "had tomorrow.") ;继续匹配了 had
T 又给了个闭包之间共享变量的例子，就是在defun外再套一次let，所谓的 Let Over Lambda Over Let Over Lambda
有了闭包可以没有类class，blablabla。。。
Macro Basics
举例 sleep-units， 有小时、分钟、秒、毫秒、微秒等时间单位
而在lisp中，是用一个symbol来标记一个指定的单位，检查symbol是否相同的速度是很快di
函数调用(sleep-units% '.5 'h)
宏调用(sleep-units .5 h)
sleep-units的调用在编译期就确定了参数取值，因此速度会比sleep-units%快；但同时，sleep-units也就没法在运行期动态确定unit类型
; 错误，宏调用期望的是一个symbol，而这边传入的是一个以if开头的列表
(sleep-units 1 (if super-slow-mode 'd 'h)) 一个nlet宏的例子(name let)
(defmacro nlet (n letargs &rest body)
`(labels ((,n ,(mapcar #'car letargs)
,@body))
(,n ,@(mapcar #'cadr letargs))))
* (macroexpand
'(nlet fact ((n n))
(if (zerop n)
1
(* n (fact (- n 1))))))
(LABELS ((FACT (N)
(IF (ZEROP N)
1
(* N (FACT (- N 1))))))
(FACT N))
T函数会对它的所有参数求值，然后把这些求值结果绑定到调用的环境中，再执行之前生成的lambda机器码
宏不对直接对参数求职，而是把它们嵌入一些lisp代码块中，令其执行某些特定的操作
如果碰到尾递归调用已定义的name let， scheme会默认优化，不会增加栈空间；common lisp可能会栈溢出。
关于 free variable 的介绍，blablabla。。。
讨论 nif 的宏展开，变量命名冲突的问题，用gensym解决
lisp-1 与 lisp-2，主要差别有一点，是否为函数提供分离的名字空间。参考 Lisp-1与Lisp-2比较
defmacro/g! 的宏实现，自动找出g!开头的变量，加上gensym声明，省得打那么多字
(defmacro defmacro/g! (name args &rest body)
(let ((syms (remove-duplicates
(remove-if-not #'g!-symbol-p
(flatten body)))))
`(defmacro ,name ,args
(let ,(mapcar
(lambda (s)
`(,s (gensym ,(subseq
(symbol-name s)
2))))
syms)
,@body))))
* (macroexpand-1
'(defmacro/g! nif (expr pos zero neg)
`(let ((,g!result ,expr))
(cond ((plusp ,g!result) ,pos)
((zerop ,g!result) ,zero)
(t ,neg)))))
(DEFMACRO NIF (EXPR POS ZERO NEG)
(LET ((G!RESULT (GENSYM "RESULT")))
`(LET ((,G!RESULT ,EXPR))
(COND ((PLUSP ,G!RESULT) ,POS)
((ZEROP ,G!RESULT) ,ZERO)
(T ,NEG)))))
T 双层的defmacro/g!那个junk-outer没搞懂
Paradigms Of Artificial Intelligence Programming: Case Studies in COMMON LISP 的 Once-only: A Lesson in Macrology 的宏实现值得仔细学习
once-only 是对传入宏的表达式只求值一次，将值绑定到新变量，在后续代码中使用该变量的值，避免side-effect
一个重点的宏实现demacro!，同时支持只求值一次（once-only），自动加gensym
(defmacro defmacro! (name args &rest body)
(let* ((os (remove-if-not #'o!-symbol-p args)) ;抽出o!开头的变量名
(gs (mapcar #'o!-symbol-to-g!-symbol os))) ;将o!x 转换为 g!x
`(defmacro/g! ,name ,args
`(let ,(mapcar #'list (list ,@gs) (list ,@os)) ;(let (g!x o!x) (g!y o!y))赋值，此时o!x只求值一次
,(progn ,@body)))))
(defmacro! square (o!x)
`(* ,g!x ,g!x))
* (macroexpand
'(square (incf x)))
(LET ((#:X1633 (INCF X)))
(* #:X1633 #:X1633))
Tdynamic variable的取值决定于该表达式什么时候执行，而非它在何处被定义或被编译；lexical varible与之相反。
注意下面这个虽然是let over lambda，但它不是lexical闭包，因为它被解析求值一次后，下回调用直接返回绑定的temp-special值了
* (let ((temp-special 'whatever))
(lambda () temp-special))
#<FUNCTION :LAMBDA NIL TEMP-SPECIAL>扯了一通common lisp的 Duality of Syntax 有多好，唉，口水话太多，有空再领略其中深意吧
喷了一把 special-var 的code style
Read Macros
#. 开头的form在读入的时候被求值，而不是等到整个外层form被求值的时候
* '(football-game
(game-started-at
#.(get-internal-real-time))
(coin-flip
#.(if (zerop (random 2)) 'heads 'tails)))
(FOOTBALL-GAME
(GAME-STARTED-AT 309)
(COIN-FLIP TAILS))Backquote ` 不是lisp必须的，但是宏重度使用此符号，虽然一堆人抱怨这个很晕
` 负责停止evaluate一个form，而 , 可以暂停此效果临时evaluate（称为 unquote)
; 1) regular unquote
* (let ((s 'hello))
`(,s world))
(HELLO WORLD)
; 2) splicing unquote
* (let ((s '(b c d)))
`(a . ,s)) ; 只能在列表尾部接一下
(A B C D)
* (let ((s '(b c d)))
`(a ,@s e)) ; 可以在列表中间展开插入，重新分配空间
(A B C D E)
; 3) destructive splicing unquote
* (defvar to-splice '(B C D))
TO-SPLICE
* `(A ,.to-splice E) ; to-splice 尾部接上了E
(A B C D E)
* to-splice
(B C D E)危险的用法
(defun dangerous-use-of-bq ()
`(a ,.'(b c d) e)) 第一次调 dangerous-use-of-bq 会得到 (A B C D E)，同时 ‘(b c d) 变成了 ‘(b c d e)；第二次就会导致死循环，因为 ‘(b c d e) 尾部的e又要指向自身了
一种解决方案是
(defun safer-use-of-bq ()
`(a ,.(mapcar #'identity '(b c d)) e))defun |#"-reader|比较简单，就是读stream，直到碰上 “# 就停止
(set-dispatch-macro-character #\# #\" #'|#"-reader|)
参考 set-dispatch-macro-character
defun |#>-reader|山寨perl的 « 多行字符串，代码可以看看
CL-PPCRE 是lisp的正则库，跟perl的pcre有些不同：
- CL-PPCRE很快，因为它是用lisp实现di，运行时编译。。。c编译器编译的程序没法去折腾c编译器本身，所以用C写的pcre引擎优化的没lisp彻底，blablabla
- CL-PPCRE不限制匹配字符串，可以自定义一些格式匹配，即所谓的DSL （我咋觉得perl的Parse::RecDescent也能搞这些呢，唔，可能没lisp的S表达式灵活）
- CL-PPCRE语法自由度更大
搞了一个 segment-reader 的函数，跟perl的字符串/g匹配差不多
正则匹配和替换的宏
#+cl-ppcre
(defmacro! match-mode-ppcre-lambda-form (o!args)
``(lambda (,',g!str)
(cl-ppcre:scan
,(car ,g!args)
,',g!str)))
#+cl-ppcre
(defmacro! subst-mode-ppcre-lambda-form (o!args)
``(lambda (,',g!str)
(cl-ppcre:regex-replace-all
,(car ,g!args)
,',g!str
,(cadr ,g!args))))注意，上面的宏都以两个反引号``开始，生成的是一个列表list，而不是待evaluate的expression
后面接着defun |#~-reader|山寨perl的 =~m//, =~s//，用到了上面两个宏
搞好之后就能这么替换字符串了：
(funcall #~s/abc/def/ "Testing abc testing abc")
打印循环结构的例子（注意最后的nil不能省，不然卡住死循环）
* (let ((*print-circle* t))
(print '#1=(hello . #1#))
nil)
#1=(HELLO . #1#)
NILlisp的read macro示例是v587的，lisp-reader 、lisp-printer
一个安全措施是置 read-eval 为 nil，禁止从不可信的源读入数据做为代码执行
另一个安全措施是禁止 #. 宏
还有一个是destructuring-bind指定参数绑定
剩下的是lisp error检查更…的blablabla… common lisp 检查
Programs That Program
lisp不是函数式语言，人家想咋改就咋改，可以比命令式还命令式，也可以比函数式还函数式，blablabla。。。
defmacro! defunits%，有两层反引号`
`与 , 结合，调整代码在运行期的执行先后顺序
defun defunits-chaining% 递归调用
defmacro! defunits%% 单位转换
defmacro! defunits 加上一些安全检查
defun tree-leaves%%和 defmacro tree-leaves，两者对比，tree-leaves的用法比较简洁。（与perl的 匿名函数sub {} 加 默认变量 $_ 组合有点类似，lisp版的写法更简短一点）
注意 tree-leaves里的x，没声明直接往上写，嵌入了一个implicit lexical variable bound，所谓violate lexical transparency
高级一点的macrolet
Macrolet is a COMMON LISP special form that introduces new macros into its enclosed lexical scope.
macrolet-defined macros will be expanded by the lisp system when it code-walks your expressions.
支持在不同的lexical contexts下进行不同的macro expand => defmacro没法这么牛x
code-walking是lisp系统在对一个表达式进行编译或求值之前要做的一些检查
对于macrolet指定的表达式在编译或求值时，lisp系统会先code-walk一下，并做宏展开
nlet-tail 裸实现尾递归，macrolet + tagbody + go 省栈空间，这个看着比较晕
两个命名比较：second 表示想要的东西是啥(What)，cadr 表示怎么拿到想要的(How)
又一堆口水，lisp的car、cdr函数组合成cadr这种风格挺好,blablabla……
写个宏cxr%，无限组合car/cdr（这个宏木啥特别的）
cxr宏比较有意思，基于cxr%优化了2点：
- n可以传变量进去
- 搞成尾递归节省栈空间，省的n比较大（例如n>10）时，原来的版本展开的inline代码搞太长，不划算
def-english-list-accessors 批量命名多个宏，这个不错
with-all-cxrs 根据指定的’cxr字符串动态生成lambda
dlambda 支持通过key指定运行闭包中的某个函数（类似一个类支持多个方法，尼玛看到这，绝对知道类的好处了）
> (setf (symbol-function 'count-test)
(let ((count 0))
(dlambda
(:inc () (incf count))
(:dec () (decf count)))))
#<FUNCTION :LAMBDA (&REST #:ARGS8148)
(CASE (CAR #:ARGS8148)
((:INC) (APPLY (LAMBDA NIL (INCF COUNT)) (CDR #:ARGS8148)))
((:DEC) (APPLY (LAMBDA NIL (DECF COUNT)) (CDR #:ARGS8148))))
> (count-test :inc)
1
(defmacro! dlambda (&rest ds)
`(lambda (&rest ,g!args)
(case (car ,g!args)
,@(mapcar
(lambda (d)
`(,(if (eq t (car d)) t (list (car d)))
(apply (lambda ,@(cdr d))
,(if (eq t (car d)) g!args `(cdr ,g!args)))))
ds)
)))Anaphoric Macros
An anaphoric macro is one that deliberately captures a variable from forms supplied to the macro.
On Lisp中的 alambda 是一个anaphoric宏，capture的变量是其中的self
(defmacro alambda (parms &body body)
`(labels ((self ,parms ,@body))
#'self))
> (alambda (n)
(if (> n 0)
(cons n (self (- n 1)))))
#<FUNCTION SELF (N) (BLOCK SELF (IF (> N 0) (CONS N (SELF (- N 1)))))>defun |#`-reader|的用法举例，注意可能隐含了a1、a2、a3等参数定义
alet% 宏调整了let body里某些语句的执行顺序，注意看this前后
alet 与alet% 大体相同，就是加了个指针功能，每次碰到’invert就返回不一样的lambda，注意宏里面用到了alambda的self，alet的this
(alet ((acc 0))
(alambda (n)
(if (eq n 'invert)
(setq this
(lambda (n)
(if (eq n 'invert)
(setq this #'self)
(decf acc n))))
(incf acc n))))也就是通过alet + alambda 在运行期间动态改变实际执行的代码片断
用labels实现了going-up/going-down的版本，清楚多了
再用alet-fsm，引入了一个state用于切换labels定义的多个lambda
(alet ((acc 0))
(alet-fsm
(going-up (n)
(if (eq n 'invert)
(state going-down)
(incf acc n)))
(going-down (n)
(if (eq n 'invert)
(state going-up)
(decf acc n))))) alet-fsm是个anaphor injection的例子，虽然引入了this，可是光看lexical context的外层代码是没有出现di（押一个桔子，多碰到几次这种，bug就要出来了）
作者说free variable injection写法类似于c指针写法，有N种风格建议（茴字有4种写法，哈哈）
free variable injection常用于两个宏之间通信，复杂度较高，blablabla。。。
ichain-before / ichain-after 注意多个before时，后面的先执行，具体看代码
ichain-intercept% / ichain-intercept 作用类似于参数检查，引入的block为intercept、g!intercept
Hotpatching Closures 运行期动态改变调用的闭包
以 alet-hotpatch%、alet-hotpatch为例，区别在于后者用了dlambda
为了避免alet-hotpatch中this被unwant captured，又优化了一版let-hotpatch，换成上文中的g!this，即所谓的几个宏组合使用成一个整体，与外界隔开。（方法满工巧，就是组合调用的背景略复杂）
上文中demacro!是在sub-lexical scope中绑定变量
指向sub-lexical scope变量的symbol只有在宏展开之前传到lisp的raw lists才会生效（绕不绕呀）
demacro!预处理了g!开头的参数，the G-bang symbols are sub-lexically bound。
举例 junk / junk2 对比，junk中g!var会被替换成#:VAR1663，而junk2调用返回生成g!var字符串的宏，生成的g!var是在sub-lexical scope中，不会再转换成gensyms（这边区别明显）
因此，如果一些symbol reference出现在不同场合，可能展开的结果就不同，例如junk3
另一个例子是with-all-cxrs，宏参数往里传就不要（所以写法有学问）
sublet是搞sub-lexical binding的指令，在看sublet之前得研究let-binding-transform先，不过这个transform比较简单
sublet还用到了tree-leaves。可以看到它的宏展开不保留原来的符号a，而是生成了一个新的标记，连'a都自动转过去了。
sublet*把 body 先做了一次 macroexpand-1，这样body里的宏引用的变量名就可以预先展开了。这个称为supre sub-lexical scope。
sublet*解决了上面的 injector-for-a 问题。不过只能展开一层，嵌套还是不行。原因是“nested macros in the expression are not expanded by macroexpand-1”
sublet*这类宏，可以调整宏展开时，可见的变量，form展开的方式。对宏编程的宏。（确实工巧）
另一本书 Lisp in Small Pieces
pandoriclet 宏，支持根据key进行 变量取值、赋值、执行指定代码，注意这边也用到了this。有些还没定义也可以先写上要用。
What we have done is created an inter-closure protocol, or message passing system, for communicating between closures.
扯了一通generalised variable
Defsetf 宏 implicitly binds gensyms around provided forms
with-pandoric uses symbol-macrolet to install these generalised variables as seemingly new lexical variables with the same names as the closed-over variables. 这些变量由 pandoriclet定义，但lexical contexts分离
跟 Hotpatching Closures 的差别在于，这回的pandoric更精巧，Hotpatching 整个共享lexical binding
Macros are not for inlining, compilers are for inlining
plambda 宏
plambda creates another anaphor—self. While the anaphor this refers to the actual closure that is to be invoked, self refers to the indirection environment that calls this closure.
plambda 和 with-pandoric 可以重写lexical scope。
eval对form求值时，是在一个null lexical环境下的，所以下面这个会出错：
* (let ((x 1))
(eval
'(+ x 1)))
Error: The variable X is unbound.eval 比较慢，而且经常出错，还有限制。所以，想用eval的时候，先想想能不能用宏。
pandoric-eval 先用plambda把变量搞成闭包，传到eval，变成dynamic环境变量生效
* (let ((x 1))
(pandoric-eval (x)
'(+ 1 x)))
2这几段比较晕
More Efficiency Topics
lisp 就是比较快，blablabla…
看 Edi Weitz 的 CL-PPCRE，blablabla…
一堆举例，point就是人家也可以很快的，注意得这么用，blablabla…
Lisp Moving Forth Moving Lisp
又一种语言：Forth
这章我没看
附录
除了lisp，作者推荐学一下C、Perl、Forth、smalltalk、haskell。
为毛要perl呢，作者给出的原因：if lisp is the result of taking syntax away, perl is the result of taking syntax all the way.
哈哈！
CMUCL / SBCL 等等
