Land of LISP

第五章 创建文本游戏引擎 这一章的游戏是一个文本游戏，创建了一个简单的虚拟世界，有不同的地点(node)，不同的地点之间有路径相连 (edges)， 还有一些物体分布在不同的地点上。 数据使用有向图来表示，用列表存储。 在本章里使用 symbol来代替文本，这是很老派的Lisp程序做法，可以让注意力集中在算法原型上。而且操作symbol的列表，也是macro操作的基础。 描述地点的关联列表：(association list)

(defparameter *nodes* '((living-room (you are in the living-room.
				      a wizard is snoring loudly on the couch.))
			(garden (you are in a beautiful garden.
				 there is a well in front of you.))
			(attic (you are in the attic.
				there is a giant welding torch in the corner.))))

查找地点使用 assoc 函数，获得关联表中 key 对应的值：

? (assoc 'garden *nodes*)
(GARDEN (YOU ARE IN A BEAUTIFUL GARDEN. THERE IS A WELL IN FRONT OF YOU.))

(defun describe-location (location nodes)
  (cadr (assoc location nodes)))

这里将 *nodes* 作为参数传递给 describe-location 函数，而不是直接在此函数中操作全局变量，这是函数式编程风格。 描述不同地点之间的路径：

(defparameter *edges* '((living-room (garden west door)
			 (attic upstairs ladder))
			(garden (living-room east door))
			(attic (living-room downstairs ladder))))

(defun describe-path (edge)
  `(there is a ,(caddr edge) going ,(cadr edge) from here.))

? (describe-path '(garden west door))
(THERE IS A DOOR GOING WEST FROM HERE.)

describe-path 中使用的反引号，是quasiquoting (准引用) ， 它与引用的区别是可以用逗号插入code 。 在 macro的定义中会广泛应用。 # mapcar 与 apply 要描述多个路径，需要对一个路径列表分别调用 describe-path ，然后 append 在一起。

(defun describe-paths (location edges)
  (apply #'append (mapcar #'describe-path (cdr (assoc location edges)))))

? (describe-paths 'living-room *edges*)
(THERE IS A DOOR GOING WEST FROM HERE. THERE IS A LADDER GOING UPSTAIRS FROM HERE.)

#' 符号等价于 function 函数， 即 #'append == (function append) 因为 Common Lisp 具有两个 namespace： 变量与函数，在两个空间中可以分别具有相同名字的两个不同值。如下： 在let的局部block中， car 表示一个变量值为1 ， 而 #'car 则表示内置函数。

? (let ((car 1))
    (mapcar #'car `((,car 2) (,car 3))))
(1 1)

Scheme只具有一个namespace，因此叫做 Lisp-1 , Common Lisp 称为 Lisp-2 。 apply 函数的目的是把参数列表传给一个函数，相当于去除了最外层的括号。 下面处理散落在各处的物体，用物体的列表 *objects* 和物体地点对应关联表 *object-locations*

(defparameter *objects* '(whiskey bucket frog chain))

(defparameter *object-locations* '((whiskey living-room)
				   (bucket living-room)
				   (chain garden)
				   (frog garden)))

(defun objects-at (loc objs obj-locs)
  (labels ((at-loc-p (obj)
	     (eq (cadr (assoc obj obj-locs)) loc)))
    (remove-if-not #'at-loc-p objs)))

objects-at 函数中用 labels 定义了局部函数 at-loc-p ，它是高阶函数 remove-if-not 的第一个参数， 这比直接用 lambda 定义匿名函数要清晰一些。 -p 后缀的函数名是返回t 或 nil 的断言类型函数的习惯用法。 remove-if-not 相当于Haskell 里面的 filter 。

(defun describe-objects (loc objs obj-loc)
  (labels ((describe-obj (obj)
	     `(you see a ,obj on the floor.)))
    (apply #'append (mapcar #'describe-obj (objects-at loc objs obj-loc)))))

? (describe-objects 'living-room *objects* *object-locations*)
(YOU SEE A WHISKEY ON THE FLOOR. YOU SEE A BUCKET ON THE FLOOR.)

描述看到的物体的函数， 它的结构与 describe-paths 几乎一样。 look 函数，描述当前的环境，将前面几个函数组合起来。注意，这个函数不是函数式风格，因为它引用了一个全局变量，它的行为将依赖于全局变量 *location* 的值，因为它的值可能改变，因此每次调用返回结果可能不同，这违反了引用透明性。这一点是函数式编程避免bug的重要特性。 不过Common Lisp没那么学究了。要不然还要搞些monad啥的来～

(defparameter *location* 'living-room)

(defun look ()
  (append (describe-location *location* *nodes*)
	  (describe-paths *location* *edges*)
	  (describe-objects *location* *objects* *object-locations*)))

在地图中walk ：

(defun walk (direction)
  (let ((next (find direction
		    (cdr (assoc *location* *edges*))
		    :key #'second)))
    (if next
	(progn (setf *location* (car next))
	       (look))
	'(you cannot go that way.))))

:key 是find 函数的 keyword 参数， 我用 second 替换了原文的 cadr ，看到那些 caddad....r 就头疼。 代码很简单：找到当前位置上关联的路径，查找方向匹配的那一条，如果找到就修改当前位置，否则提示错误。 捡起物品：

(defun pickup (object)
  (cond ((member object
		 (objects-at *location* *objects* *object-locations*))
	 (push (list object 'body) *object-locations*)
	 `(you are now carrying the ,object))
	(t '(you cannot get that.))))


(defun inventory ()
  (cons 'items- (objects-at 'body *objects* *object-locations*)))

＊＊＊ pickup 函数中用到了 push/assoc 组合，这里将物体的新的位置 push 到 *object-locations* 里，但是并没有去除掉之前的值，而 assoc 在查找时总是返回遇到的第一个结果，因此产生的效果相当于修改了物体对应的位置值！！ 这个有一个好处是可以记录下各个值的历史，不过如果操作过多，存储空间必然膨胀较大。 ＊＊＊ 执行结果：

? (look)
(YOU ARE IN A BEAUTIFUL GARDEN. THERE IS A WELL IN FRONT OF YOU. THERE IS A DOOR GOING EAST FROM HERE. YOU SEE A FROG ON THE FLOOR. YOU SEE A CHAIN ON THE FLOOR.)
? (pickup 'chain)
(YOU ARE NOW CARRYING THE CHAIN)
? (look)
(YOU ARE IN A BEAUTIFUL GARDEN. THERE IS A WELL IN FRONT OF YOU. THERE IS A DOOR GOING EAST FROM HERE. YOU SEE A FROG ON THE FLOOR.)

既然Lisp那么强，为啥没人用Lisp？ 其实很多hacker、机构和商业公司在用，而且Lisp的很多特性被很多其他语言借用。Semantic Web语义网的很多工具也是用Lisp开发的，如 RacerPro, AllegroGraph 那为什么Lisp会给人一种已经死去的感觉呢？人们判断一个事物的价值一般通过三种没有科学根据的条件： 1. 看别人学什么 （C++， Java） 2. 哪些容易学 （忽悠、Ruby 等 ， 呵呵，原文如此） 3. 显而易见有价值的 而Lisp哪种条件都不合，因此大部分人的结论就是不要学Lisp。 而一个lisp用户，是不会废口舌跟别人说Lisp有多强大的，浪费时间，或许挫折太多。乐得让Lisp呆在角落里面，自己暗爽。 此书末尾有一个漫画，可以一窥Lisp的威力。

Lisp feature: 1. function result is returned automaticall by called function.( retur... is not necessary in lisp)

Clisp内置函数列表：ash （num offest） 把ash向左移动offset位。offset为正数时向左，为负数时向右移动。 (1- variable) 把变量的值-1 (1+ variable) return variable + 1 ; (/ var1 var2) (oddp var) var 是否是奇数 (progn list1 list2 ...) 在只准一个语句的地方嵌套如多个语句，每个code语句都会被执行但只返回最后一个被执行语句的结果。 (and ...) 逻辑于 (or ... ) 逻辑或 （上面的and 和 or在执行中都是短路法 shortcut Boolean evaluation） (member find list) 在list中查找find，如果有返回由find，即find以后所有成员组成的list，若没有返回NIL。 (eq va1 va2) 用于比较两个符号 (eql ) 除了符号外还可比较数字和字符 (equal ) 可以比较一切类型。 (equalp ) 于equal相同但是还可用于比较不是严格相同的类型的值如 (equalp "Bob" "bob") (equalp 1.0 1) (= num1 num2) 用于比较数字可转换的值为相同（= 1.0 1）T (sting-equal str1 str2）不区分大小写 (char-equal char1 char2) 不区分大小写 backquto[`] 反引号在Lisp中和单引号的功能相似，也是声明为 date mode，不同的是在【`】后的list中可以用逗号（comma）将，后紧接着的list从date mode切换到code mode。（filp 和flop 分别用作` 和，） #' 操作符时function 操作符的缩写（shorthand）形式。 而之所以好在一个功能符号前加上#‘时因为怕解释器在有多个相同名字时不知到到底是哪个对象要执行。如

(let ((car "hello"))
  (mapcar #'car '((one hello) (two hello))))

#'将指明car不是第一局的变量car而是函数car。 (append ...) 把几个list(data)联合（combine）成一个list。 (apply func list)接收一个函数和一个list，他会吧list中的每一个元素分别开即每一个元素为一个单独对象，然后把这些单独对象传递给func中。 (find item list) 在list中找寻item，若存在返回item，若没有返回nil 我们也可以给find函数传递一个keyword参数。（在Common Lisp 中许多的函数都有一种内建的功能，就是可以在参数列表的最后给他们传递一个特别的参数）如：

(find 'x '((x 1) (y 2) (z 3)) :key #'car)
return:(x 1)

后面的:key参数像一个谓词函数，他先执行返回的结果再被find函数要来查找 item，最后返回找到item的原始item。 (push item list-variable's-list) 把item加（push）到list里。（加到一个变量列表的开头） (print data) 打印data到终端的单独一行。并且会在sting的最后留一个字符的空间。（即一个空格） (prin1 data) 只是打印data到终端不会为每一个string打印到独立的一行。 (princ data) 按人类可以理解的方式打印出data。如：

(princ '"foo") => foo
(princ '#\b)   => b

(eval var) 执行var里的data。 Lisp conception 1.form:对lisp中code列表的称呼。即一个list中的所有元素都将被视作code，compiler将会执行所有的元素。 如（expt 2 4) 2.quoting:对lisp中data列表的称呼。即一个list中的所有元素都会别看做data，compiler不会执行他们。 要把一个list作为data list 即在list的最前面加上一个单引号。顾名思义叫做quoting。 如‘（expt 2 4） 3.cons cells:指LIsp中的所有括号包围着的符号，数字，字符串。他的功能就是把所有的Lisp元素结合在一起，形成一个有机整体。逻辑上指的是数据结构中list的每一个节点。 对于cons 和 cells 维基百科上有更详细的解释。http://en.wikipedia.org/wiki/Cons 4homoiconic:A programming language that uses the same data structures to store data and program code is called homoiconic.维基百科上的解释http://en.wikipedia.org/wiki/Quasiquote Lisp defining a global variable (defparmeter *variable* init-value) defining a local varibale (let (variable declarations) ..body... ) e.g (let ((a 1) (b 4)) (+ a b) ) declaring a global variable (defvar *variable* init-value) defining a global function (defun function-name (arguments) ...) defining a local function (flet ((function-name (arguments) ....function body........)) ....block body..........) e.g (flet ((fun (n) (+ n 10))) (fun 7) ) to make function names available in other defined function(can be called itself) (labels ((a (n) (+ a 5)) (b (n) (+ (a n) 6)) ) 声明：大家如果发现上文有不对的地方，还请大家原谅。毕竟本人学识浅薄。英文又不行。欢迎大家批评指正哈。

第三章 探索Lisp代码的语法 要弄懂为什么Lisp的语法那么怪异，需要从语法和语义说起。Lisp的语法非常简单，这是它区别于其他语言很重要的特点。 相比较来说，C＋＋的语法要远比Lisp复杂多了。 《The Root of Lisp》一文中总结的，基本Lisp只有7个语法结构。 要写一个C++的编译器，是极端困难的，而写一个Lisp的编译器或解释器就要简单很多。那是，Lisp的代码本身就是准备好的语法树了。这也难怪会有成百上千的各类Lisp实现了。 例如： http://en.wikibooks.org/wiki/Write_Yourself_a_Scheme_in_48_Hours Write scheme in 48 hours (Haskell写scheme解释器). Lisp将代码组织成嵌套的列表。 Lisp代码本身就是语法树这一点，也是Lisp强大的地方，通过Macro宏，可以在任何时候来修改这个语法树，也就是可以写出“能写程序的程序”。Lisp强大的根源就在于它那一堆括号的写法。 列表中可以放入各类数据， 如 symbol， numbers， strings Numbers , 可以计算大数, 也可以用有理数表示，对于科学计算比较方便

? (expt 2 100)
1267650600228229401496703205376
? (/ 36 24)
3/2

＝＝＝＝＝ Common Lisp中的 code mode 和 data mode 默认是code mode ， 即读取一个列表即form，第一个元素是命令或函数。 在列表前加 quote 单引号，即转为 data mode。 ＝＝＝＝ List List 是 Lisp中关键的特性，Lisp的名称即来自 List Process 。List 是组织代码以及数据的方式。 (expt 2 3) ，一个代码列表，由一个符号 expt ， 两个数字 2 3 组成。 List中元素用 cons cells 组合。

cons cell

用 cons 表示 list ：

'(42 69 613)

基本的 List 函数： cons car cdr cons 将两个元素创建为一个 cons cell， car 和 cdr 分别取 cons cell 的两个元素。 nil 与 '() 等价。 将一个元素添加到一个列表开头，使用 cons 来组合。

? (cons 'pork (cons 'beef (cons 'chicken ())))
(PORK BEEF CHICKEN)
? (list 'pork 'beef 'chicken)
(PORK BEEF CHICKEN)