见: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))
    T

dynamic 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#)
    NIL

lisp的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 等等



blog comments powered by Disqus

Published

13 December 2013

Tags