Lisp的语法元素在前几集中已经基本讨论完毕,相比C#或Java数百页的Specification,它可能简单的让你有些惊讶,不过,伟大的东西总是简单的,不是吗?现在让我们来回顾一下上一集中提到的内容,首先提几个问题:
/ t: R/ H& |( m6 q
3 e; |' A; [# Y. \既然cond在概念上相当于过程式语言中的if语句,那么与if相对的else分支在cond表达式中应该如何描述?
6 k8 j; c+ ]. C在(我们已经学过的)Lisp中如何表达“重复”这个语义?或者你能写一个foreach循环函数?5 {! ?* m0 E& a9 R, N" J$ @% t
(注:不要问输入输出函数或算术逻辑运算在哪儿之类的问题,它们都是微不足道的事……)- K! A+ a" v$ i" Z( q0 Y" L
) ~& G) L4 O0 U7 |# ~" D) f- S( j这一集中,我们将描述几个常用的函数,并给出它们的简单实现
6 @% Z: A4 {" {. f0 Q- u) Q; g6 H. |" d1 I* Z
首先解答在第一集中提出的问题:如何取一个表中的第二个、第三个或第n个元素?
6 K2 c, S' N7 N( q, @6 @) S# j( f8 M8 O. u1 b
可能有些读者已经想到了,取第二个元素可以采用如下形式:" B$ k' j; V3 j+ I3 R
4 |- B# \' o* c- s! y- h* g9 z8 H(car (cdr x))4 k" c Z4 x( n) Y
3 q5 _, e" p/ ?3 b- c4 I同理,取第三个元素是这样的:2 y/ u) e* S9 R( i8 {+ l
* w, a: H8 k- o$ l' e(car (cdr (cdr x)))" k% j: o; f9 M
: I4 H. i# j7 U% }4 M
事实上,这种组合在Lisp中经常要用到,为了方便,Lisp提供了一个通用模式——cxr,其中x为a或d的序列,来简记car和cdr的组合,例如:$ o/ p, F; _; B& J
/ i" c) \- ~' u0 }> (cadr '((a b) (c d) e))
$ @0 i& }! l$ `8 @, a" h9 L(c d)8 s& f6 h- N% i9 ?- F: W9 A# g
> (caddr '((a b) (c d) e))
; c: c8 A& M; o, l2 i0 m- K& ^6 _e9 R* I2 `8 L3 r- q2 c
> (cdar '((a b) (c d) e))9 V/ \) G5 r: x
(b)
# Z% K. _1 d* }7 x0 V5 k
- ]: v/ l8 a" v* L另外,使用(list e1 e2 ... en)来表示1 a8 u) v# k/ d1 R" E. L
(cons e1 (cons e2 (... (cons en '())...)))
, U- y/ l; b) O& G9 [& e; \# f! R% C2 j1 g( [) Z2 Z# k" S
> (cons 'a (cons 'b (cons 'c '())))
/ @( q+ A5 o0 W j8 n- M. Z* Q(a b c)
' L$ e. h' q# \6 ?2 y9 R> (list 'a 'b 'c)
/ ~$ @9 c; v2 [7 H7 s& V(a b c)9 R( Z$ u6 [, J
6 \4 e- S& B Z" v5 K0 L- U现在我们定义一些新的常用函数,我建议你先自己想一想,不要急着看我给出的实现。
' P% [7 J) J4 D* W0 G. ~/ F$ w8 ?6 j9 H2 _% q b- H" H- w
(注:某些函数在Common Lisp中已经存在,所以如果你想试验一下,给它们换个名字)+ p, t! ~9 F4 a7 o$ f7 A+ t
( r4 Y! m `- O% u; Y9 I(null x),测试x是否为空表。例如:5 U/ {6 T- O+ V+ x
> (null 'a)
9 i" }# C9 q9 ~% U' q4 T()2 d4 f3 ]+ x) w
> (null '())+ C1 d# z w3 K) o
t 6 g9 E( H# Z4 E6 G0 |% ?
(and x y),逻辑与,当且仅当x和y都不是空表时返回't,否则返回空表。/ P7 P' g0 |+ B. u
> (and 'a 'b)4 ?5 U0 f. {; U& p. y: F
t
1 x1 B/ T* Q: M7 c1 C9 _& Z! w. w> (and (atom 'a) (eq 'b 'c))
: T7 q7 H: P. I/ J% |" ]() % {! U) T; _4 T7 B- i
(not x),逻辑非,当x是空表时返回't,否则返回空表。(有人问我or在哪儿?)例如:
/ O% ^, h B* @9 x8 W$ x> (not 'a)$ N; q p$ t! ]+ y1 s
()
8 [; c4 h/ k( F8 M4 t3 N9 d> (not (eq 'a 'b)) t+ t5 W; @0 r1 Y$ z
t
! \3 S8 P8 D8 I) R! b- w/ V- Q(append x y),连接两个表x和y,注意它与cons和list之间的不同之处。例如:9 x6 Y) i% s' N
> (append '(a b) '(c d))
4 h8 h9 c) { F# j* z8 Q( _(a b c d), q: Y, G' Y" t0 p
> (append '() '(x y))
& {: h# A/ V" j) E(x y) : e* n' \ w% f. y: m8 `5 w, q
(pair x y),这里x和y是两个长度相同的表,pair生成一个表,其中每个元素是x和y中相应位置上的元素组成的一个元素对,这个函数的返回值类似于其它语言中的map或dictionary的概念。例如:( Z9 k% l$ U% _4 r, x; f+ }. Y
> (pair '(a b c) '(x y z))$ _. j0 S$ q, m/ t& O/ w
((a x) (b y) (c z)) # z. B- o2 ^, }( ?1 |8 p8 o* o' ~
(assoc x y),其中x是一个原子,y是一个形如pair所返回的表,assoc在y中查找第一个左元素为x的元素对并返回。例如:
9 w3 _+ M+ b# s/ u! F5 x> (assoc 'a '((a x) (b y)))5 V- V7 ~0 m: J& |& ], m% p% Z
x
% i; L9 A" I, _4 f! W: D+ X> (assoc 'a '((a (foo bar)) (b y) (c z)))
% x8 h7 u$ U" t0 _(foo bar)
7 d4 q, x8 f/ A$ q/ R7 \3 s) `& W(subst x y z),在表z中将任意层次上出现的原子y都替换为表达式x。例如:& h$ _7 v, k. ~& {8 R
> (subst '(x y) 'b '(a b (a b c) d))
# d6 [6 Q& }, b* G& P( l3 x(a (x y) (a (x y) c) d)
6 ^; W# _% D2 L下面我们给出这些常用函数的简单实现:
4 S5 ^8 j0 h* l7 D1 q' ]7 E, F5 _$ ~6 @9 s5 f" ]5 ^: r
(defun null (x) T/ q* y, i* g b3 z9 v- q& w
(eq x '())) 6 ?2 u8 Q- ]/ T' ?2 t6 b
(defun and (x y)% n. N' [1 u/ C8 d- Y$ X
(cond (x (cond (y 't) ('t '())))+ n+ i6 a, U3 t5 A& ~! @
('t '())))
" i( Q+ J6 E: D. M& |(defun not (x)
; I; v2 C, a9 @. ?! h8 y (cond (x '())
7 b( X6 i/ `7 e/ z/ t# W A ('t 't))) : z. n/ U: N+ {. Z/ ]# o
(defun append (x y)7 T! ~% y$ X! \) C; `' b: X
(cond ((null x) y)& L; I/ c( M/ Y c$ R& v# D2 N
('t (cons (car x) (append (cdr x) y))))) . l2 F/ C$ z y$ O
(defun pair (x y)
5 r/ D; h2 a2 p6 K" H @! a: E (cond ((and (null x) (null y)) '())8 s _& a& K' F- i4 l' R% {
((and (not (atom x)) (not (atom y)))
& F- D: q& T, M. I1 g (cons (list (car x) (car y))
9 [( D6 a$ H2 y" b9 w) F (pair (cdr) (cdr y))))))
9 V$ _7 H1 y. f: v; P. Y1 `( W' a6 Z' J(defun assoc (x y)! u# a- J7 j" Z
(cond ((eq (caar y) x) (cadar y))6 I" t8 d( u u& ?% M" t2 V
('t (assoc x (cdr y)))))
3 F# N. K$ h, W9 w: T% ]% r1 s(defun subst (x y z)" A7 K# x2 D/ p) A" l ^
(cond ((atom z), i) r" o0 w [! S4 [
(cond ((eq z y) x)( \! H& X0 D! c* z: p
('t z)))- R4 J; D% @, {0 T
('t (cons (subst x y (car z))8 Z! l! @3 s @! h0 M: @9 Q, E
(subst x y (cdr z))))))
3 B$ |* R" Y3 N如果看到这里你还没有晕菜,说明你的神经的确很坚强。注意在这些例子中是如何表达“重复”这个概念的,在Lisp中,最常用的重复其实并不是真正意义上的重复,而是递归,这也是绝大多数函数式语言的一个共同特征——函数的嵌套和递归,构成了整个程序逻辑。2 D5 K8 a' M9 p N& s
9 O6 v( e, D$ ?; u0 K这一部分内容可以让你真正感受到Lisp的特色,与编写过程式语言的程序相比,编写Lisp程序需要一种完全不同的思维方式,也许这正是Lisp语言几十年来长盛不衰的真正原因吧。
+ V7 Y+ `0 `+ r) p* t7 W) U' _7 j& }/ H1 ^ P; n2 l
理解了这一部分,下一集中我们将领教一下Lisp的威力,我们将用Lisp编写一个Lisp解释器。如果你以前没有见过这个程序,我保证它一定会让你吃惊。 |