﻿ [Lisp] Common LISP Hints 中譯(頁 1) - 網路時代 - 程式語言 - Math Pro 數學補給站

## Math Pro 數學補給站's Archiver

### [Lisp] Common LISP Hints 中譯

Common LISP Hints
Geoffrey J. Gordon
<[email=ggordon@cs.cmu.edu]ggordon@cs.cmu.edu[/email]>
Friday, February 5, 1993

Modified by
Bruno Haible
<[email=haible@ma2s2.mathematik.uni-karlsruhe.de]haible@ma2s2.mathematik.uni-karlsruhe.de[/email]>

Wei-Yueh Chen (陳瑋岳)

[quote]Note: This tutorial introduction to Common Lisp was written for the
CMU environment, so some of the details of running lisp toward the end
may differ from site to site.[/quote]

[quote]
Further Information
The best LISP textbook I know of is
Guy L. Steele Jr. _Common LISP: the Language_. Digital Press. 1984.
The first edition is easier to read; the second describes a more recent
standard. (The differences between the two standards shouldn't affect
casual programmers.)

A book by Dave Touretsky has also been recommended to me, although I
[/quote]

[quote]
[b]Symbols[/b]

A symbol is just a string of characters. There are restrictions on what
you can include in a symbol and what the first character can be, but as
long as you stick to letters, digits, and hyphens, you'll be safe.
(Except that if you use only digits and possibly an initial hyphen,
LISP will think you typed an integer rather than a symbol.) Some
examples of symbols:
a
b
c1
foo
bar
baaz-quux-garply
[/quote]

[b]Symbols(字符)[/b]

symbol 就是一串字元，不過這串字元裡面可以使用的字元跟起始的第一個字元是稍有限制的，

（如果你只有使用使用數字的，並且至多在拿減號當啟始字元，那將會被 Lisp 視為是數字，而不是 symbol 。）

a
b
c1
foo
bar
baaz-quux-garply

[quote]Some things you can do with symbols follow. (Things after a ">" prompt
are what you type to the LISP interpreter, while other things are what
the LISP interpreter prints back to you. The ";" is LISP's comment
character: everything from a ";" to the end of line is ignored.)
> (setq a 5)            ;store a number as the value of a symbol
5
> a                     ;take the value of a symbol
5
> (let ((a 6)) a)       ;bind the value of a symbol temporarily to 6
6
> a                     ;the value returns to 5 once the let is finished
5
> (+ a 6)               ;use the value of a symbol as an argument to a function
11
> b                     ;try to take the value of a symbol which has no value
Error: Attempt to take the value of the unbound symbol B
[/quote]

（在 > 提示符號後面的就是你的輸入給 Lisp 直譯器的內容，
而其他的就是 Lisp 直譯器所送回來輸出的結果。而 ";" 分號
則是 Lisp 的註解符號，在分號之後到該行結束的資料都會
被直譯器所忽略。）

> (setq a 5)            ; 把數值 5 存入 a 這個 symbol 裡面。
5
> a                     ; 取得 a 這個 symbol 所存的值。
5
> (let ((a 6)) a)       ; 暫時性地把 a 這個 symbol 的值給設定成 6
6
> a                     ; 當脫離 let 區塊之後， a 的值又變回到 5
5
> (+ a 6)               ; 把 a 這個 symbol 的值當作是加法函數的參數
11
> b                     ; 嘗試著取得並沒有值的 b 這個 symbol 的值看會發生蝦咪事情？
Error: Attempt to take the value of the unbound symbol B

[quote]There are two special symbols, t and nil. The value of t is defined
always to be t, and the value of nil is defined always to be nil. LISP
uses t and nil to represent true and false. An example of this use is
in the if statement, described more fully later:

> (if t 5 6)
5
> (if nil 5 6)
6
> (if 4 5 6)
5

The last example is odd but correct: nil means false, and anything else
means true. (Unless we have a reason to do otherwise, we use t to mean
true, just for the sake of clarity.)
[/quote]

t 這個 symbol 所定義的值就是 t ，而 nil 這個 symbol 所定義

> (if t 5 6)
5
> (if nil 5 6)
6
> (if 4 5 6)
5

（除非你有理由要這樣寫程式，不然通常我們還是習慣用
t 來表示〝真〞，這樣讀程式的時候也比較清楚。）

[quote]
Symbols like t and nil are called self-evaluating symbols, because
they evaluate to themselves. There is a whole class of self-evaluating
symbols called keywords; any symbol whose name starts with a colon is a
keyword. (See below for some uses for keywords.) Some examples:

> :this-is-a-keyword
:THIS-IS-A-KEYWORD
> :so-is-this
:SO-IS-THIS
> :me-too
:ME-TOO
[/quote]

（皆下來看如何使用 keyword ）一些 keyword 例子如下：

> :this-is-a-keyword
:THIS-IS-A-KEYWORD
> :so-is-this
:SO-IS-THIS
> :me-too
:ME-TOO

[quote][b]Numbers(數字)[/b]
An integer is a string of digits optionally preceded by + or -. A real
number looks like an integer, except that it has a decimal point and
optionally can be written in scientific notation. A rational looks like
two integers with a / between them. LISP supports complex numbers,
which are written #c(r i) (where r is the real part and i is the
imaginary part). A number is any of the above. Here are some numbers:
5
17
-34
+6
3.1415
1.722e-15
#c(1.722e-15 0.75)[/quote]

[b]Numbers[/b]

i 表示複數的虛部。上列的任何一種都稱做是 Number (數字)型別。

5
17
-34
+6
3.1415
1.722e-15
#c(1.722e-15 0.75)

[quote]The standard arithmetic functions are all available: +, -, *, /, floor,
ceiling, mod, sin, cos, tan, sqrt, exp, expt, and so forth. All of them
accept any kind of number as an argument. +, -, *, and / return a
number according to type contagion: an integer plus a rational is a
rational, a rational plus a real is a real, and a real plus a complex
is a complex. Here are some examples:
> (+ 3 3/4)             ;type contagion
15/4
> (exp 1)               ;e
2.7182817
> (exp 3)               ;e*e*e
20.085537
> (expt 3 4.2)          ;exponent with a base other than e
100.90418
> (+ 5 6 7 (* 8 9 10))  ;the fns +-*/ all accept multiple arguments
There is no limit to the absolute value of an integer except the memory
size of your computer. Be warned that computations with bignums (as
large integers are called) can be slow. (So can computations with
rationals, especially compared to the corresponding computations with
small integers or floats.)[/quote]

ceiling, mod, sin, cos, tan, sqrt, exp, expt 都有內建，而且這些

> (+ 3 3/4)             ;傳回值型別範圍自動加廣
15/4
> (exp 1)               ;自然對數的基底 e
2.7182817
> (exp 3)               ;e*e*e
20.085537
> (expt 3 4.2)          ;指數函數，以 3 為底數，次方數是 4.2
100.90418
> (+ 5 6 7 (* 8 9 10))  ;內建的 +,-,*,/ 四個算數函數都可以接受多個參數值的呼叫

[quote][b]Conses
[/b]A cons is just a two-field record. The fields are called "car" and
"cdr", for historical reasons. (On the first machine where LISP was
implemented, there were two instructions CAR and CDR which stood for
"contents of address register" and "contents of decrement register".
Conses were implemented using these two registers.)
Conses are easy to use:
> (cons 4 5)            ;Allocate a cons. Set the car to 4 and the cdr to 5.
(4 . 5)
> (cons (cons 4 5) 6)
((4 . 5) . 6)
> (car (cons 4 5))
4
> (cdr (cons 4 5))
5[/quote]

[b]Conses(點對)[/b]

"[b]C[/b]ontents of [b]D[/b]ecrement [b]R[/b]egister"。而 cons 就是透過這兩個暫存器而實作的。）
Cons 很容易使用：
> (cons 4 5)            ; 設置一個 cons ，其中 car 設為數字 4 ，而 cdr 設為數字 5 。
(4 . 5)
> (cons (cons 4 5) 6)  ; 設置一個 cons ，其中 car 設為一個點對(4 . 5)，而 cdr 設為數字 5 。
((4 . 5) . 6)
> (car (cons 4 5))    ; 取出 (4 . 5) 的 car 設定值。
4
> (cdr (cons 4 5))    ; 取出 (4 . 5) 的 cdr 設定值。
5

[quote][b]Lists[/b]
You can build many structures out of conses. Perhaps the simplest is a
linked list: the car of each cons points to one of the elements of the
list, and the cdr points either to another cons or to nil. You can
create such a linked list with the list fuction:
> (list 4 5 6)
(4 5 6)
Notice that LISP prints linked lists a special way: it omits some of
the periods and parentheses. The rule is: if the cdr of a cons is nil,
LISP doesn't bother to print the period or the nil; and if the cdr of
cons A is cons B, then LISP doesn't bother to print the period for cons
A or the parentheses for cons B. So:
> (cons 4 nil)
(4)
> (cons 4 (cons 5 6))
(4 5 . 6)
> (cons 4 (cons 5 (cons 6 nil)))
(4 5 6)
The last example is exactly equivalent to the call (list 4 5 6). Note
that nil now means the list with no elements: the cdr of (a b), a list
with 2 elements, is (b), a list with 1 element; and the cdr of (b), a
list with 1 element, is nil, which therefore must be a list with no
elements.
The car and cdr of nil are defined to be nil.
If you store your list in a variable, you can make it act like a stack:
> (setq a nil)
NIL
> (push 4 a)
(4)
> (push 5 a)
(5 4)
> (pop a)
5
> a
(4)
> (pop a)
4
> (pop a)
NIL
> a
NIL[/quote]

[b]Lists(串列)[/b]

> (list 4 5 6)
(4 5 6)

Cons B 的話，那在 Cons B 前面的連結點以及 Cons B 本身的小括弧都

> (cons 4 nil)
(4)
> (cons 4 (cons 5 6))
(4 5 . 6)
> (cons 4 (cons 5 (cons 6 nil)))
(4 5 6)

NIL 的另一個表示意義，其時就是沒有包含任何元素的 list。比如說，

> (setq a nil)
NIL
> (push 4 a)
(4)
> (push 5 a)
(5 4)
> (pop a)
5
> a
(4)
> (pop a)
4
> (pop a)
NIL
> a
NIL

[quote][b]Functions[/b]
You saw one example of a function above. Here are some more:
> (+ 3 4 5 6)                   ;this function takes any number of arguments
18
> (+ (+ 3 4) (+ (+ 4 5) 6))     ;isn't prefix notation fun?
22
> (defun foo (x y) (+ x y 5))   ;defining a function
FOO
> (foo 5 0)                     ;calling a function
10
> (defun fact (x)               ;a recursive function
(if (> x 0)
(* x (fact (- x 1)))
1))
FACT
> (fact 5)
120
> (defun a (x) (if (= x 0) t (b (- x))))        ;mutually recursive functions
A
> (defun b (x) (if (> x 0) (a (- x 1)) (a (+ x 1))))
B
> (a 5)
T
> (defun bar (x)                ;a function with multiple statements in
(setq x (* x 3))            ;its body -- it will return the value
(setq x (/ x 2))            ;returned by its final statement
(+ x 4))
BAR
> (bar 6)
13[/quote]

[b]Functions(函數、函式)[/b]

> (+ 3 4 5 6)                   ; 加法函數可以接受任意多的輸入參數
18
> (+ (+ 3 4) (+ (+ 4 5) 6))     ; 或是你也可以像這樣慢慢加，哈~
22

> (defun foo (x y) (+ x y 5))   ; 定義一個叫做 foo 的函數
FOO
> (foo 5 0)                     ; 呼叫函數，傳入的參數個別是 5 跟 0
10

> (defun fact (x)               ; 以遞迴呼叫的方式定義函數 fact
(if (> x 0)
(* x (fact (- x 1)))
1))
FACT
> (fact 5)
120

> (defun a (x) (if (= x 0) t (b (- x))))        ; 以兩個函數相互呼叫的遞迴方式來定義函數
A
> (defun b (x) (if (> x 0) (a (- x 1)) (a (+ x 1))))
B
> (a 5)
T
> (defun bar (x)                ; 一個函數的定義裡面如果有很多敘述句的話
(setq x (* x 3))            ; 那整個函數的傳回值，
(setq x (/ x 2))            ; 將會是最後的一個敘述句
(+ x 4))
BAR
> (bar 6)
13
[quote]
When we defined foo, we gave it two arguments, x and y. Now when we
call foo, we are required to provide exactly two arguments: the first
will become the value of x for the duration of the call to foo, and the
second will become the value of y for the duration of the call. In
LISP, most variables are lexically scoped; that is, if foo calls bar
and bar tries to reference x, bar will not get foo's value for x.
The process of assigning a symbol a value for the duration of some
lexical scope is called binding.
You can specify optional arguments for your functions. Any argument
after the symbol &optional is optional:
> (defun bar (x &optional y) (if y x 0))
BAR
> (defun baaz (&optional (x 3) (z 10)) (+ x z))
BAAZ
> (bar 5)
0
> (bar 5 t)
5
> (baaz 5)
15
> (baaz 5 6)
11
> (baaz)
13[/quote]

> (defun bar (x &optional y) (if y x 0))
BAR
> (defun baaz (&optional (x 3) (z 10)) (+ x z))
BAAZ
> (bar 5)
0
> (bar 5 t)
5
> (baaz 5)
15
> (baaz 5 6)
11
> (baaz)
13

[quote]
It is legal to call the function bar with either one or two arguments.
If it is called with one argument, x will be bound to the value of that
argument and y will be bound to nil; if it is called with two
arguments, x and y will be bound to the values of the first and second
argument, respectively.
The function baaz has two optional arguments. It specifies a default
value for each of them: if the caller specifies only one argument, z
will be bound to 10 instead of to nil, and if the caller specifies no
arguments, x will be bound to 3 and z to 10.
You can make your function accept any number of arguments by ending its
argument list with an &rest parameter. LISP will collect all arguments
not otherwise accounted for into a list and bind the &rest parameter to
that list. So:
> (defun foo (x &rest y) y)
FOO
> (foo 3)
NIL
> (foo 4 5 6)
(5 6)

Finally, you can give your function another kind of optional argument
called a keyword argument. The caller can give these arguments in any
order, because they're labelled with keywords.
> (defun foo (&key x y) (cons x y))
FOO
> (foo :x 5 :y 3)
(5 . 3)
> (foo :y 3 :x 5)
(5 . 3)
> (foo :y 3)
(NIL . 3)
> (foo)
(NIL)
An &key parameter can have a default value too:
> (defun foo (&key (x 5)) x)
FOO
> (foo :x 7)
7
> (foo)
5

[/quote]

bar 函數，那 x 跟 y 就分別被設定成第一及第二個傳入參數。

baaz 函數時，沒有給任何傳入值，則 x 跟 z 的值就會是預設值 3 跟 10 。

> (defun foo (x &rest y) y)
FOO
> (foo 3)
NIL
> (foo 4 5 6)
(5 6)

> (defun foo (&key x y) (cons x y))
FOO
> (foo :x 5 :y 3)
(5 . 3)
> (foo :y 3 :x 5)
(5 . 3)
> (foo :y 3)
(NIL . 3)
> (foo)
(NIL)

> (defun foo (&key (x 5)) x)
FOO
> (foo :x 7)
7
> (foo)
5 [quote][b]Printing[/b]
Some functions can cause output. The simplest one is print, which
prints its argument and then returns it.
> (print 3)
3
3

The first 3 above was printed, the second was returned.
If you want more complicated output, you will need to use format.
Here's an example:
> (format t "An atom: ~S~%and a list: ~S~%and an integer: ~D~%"
nil (list 5) 6)
An atom: NIL
and a list: (5)
and an integer: 6

The first argument to format is either t, nil, or a stream. T specifies
output to the terminal. Nil means not to print anything but to return a
string containing the output instead. Streams are general places for
output to go: they can specify a file, or the terminal, or another
program. This handout will not describe streams in any further detail.
The second argument is a formatting template, which is a string
optionally containing formatting directives.

All remaining arguments may be referred to by the formatting
directives. LISP will replace the directives with some appropriate
characters based on the arguments to which they refer and then print
the resulting string.

Format always returns nil unless its first argument is nil, in which
case it prints nothing and returns a string.

There are three different directives in the above example: ~S, ~D, and
~%. The first one accepts any LISP object and is replaced by a printed
representation of that object (the same representation which is
produced by print). The second one accepts only integers. The third one
doesn't refer to an argument; it is always replaced by a carriage
return.

Another useful directive is ~~, which is replaced by a single ~.
Refer to a LISP manual for (many, many) additional formatting
directives.[/quote]

[b]Printing(顯示)[/b]

> (print 3)
3
3

> (format t "An atom: ~S~%and a list: ~S~%and an integer: ~D~%"
nil (list 5) 6)
An atom: NIL
and a list: (5)
and an integer: 6

Format 函數的傳回值預設會是 NIL ，除非在呼叫 Format 函數的第一個參數是 NIL ，

Lisp 物件，並且會用該物件的可以顯示的方式來取代掉 ~S (當中可以顯示的方式跟直接

[quote][b]Forms and the Top-Level Loop[/b]
The things which you type to the LISP interpreter are called forms; the
LISP interpreter repeatedly reads a form, evaluates it, and prints the
result. This procedure is called the read-eval-print loop.
Some forms will cause errors. After an error, LISP will put you into
the debugger so you can try to figure out what caused the error. LISP
debuggers are all different; but most will respond to the command
"help" or ":help" by giving some form of help.
In general, a form is either an atom (for example, a symbol, an
integer, or a string) or a list. If the form is an atom, LISP evaluates
it immediately. Symbols evaluate to their value; integers and strings
evaluate to themselves. If the form is a list, LISP treats its first
element as the name of a function; it evaluates the remaining elements
recursively, and then calls the function with the values of the
remaining elements as arguments.
For example, if LISP sees the form (+ 3 4), it treats + as the name of
a function. It then evaluates 3 to get 3 and 4 to get 4; finally it
calls + with 3 and 4 as the arguments. The + function returns 7, which
LISP prints.
The top-level loop provides some other conveniences; one particularly
convenient convenience is the ability to talk about the results of
previously typed forms. LISP always saves its most recent three
results; it stores them as the values of the symbols *, **, and ***.
For example:
> 3
3
> 4
4
> 5
5
> ***
3
> ***
4
> ***
5
> **
4
> *
4[/quote]

[b]Forms(表單) 跟 the Top-Level Loop(最高層評估值迴圈)[/b]

Lisp 直譯器會一直讀取你給它的表單，然後進行運算/評估，並且把傳回值

〝讀取[color=gray](資料)[/color]─評估[color=gray](傳回值)[/color]─顯示[color=gray](傳回值)[/color]〞的迴圈。

> 3  ; 要評估的表單是 3 ，所以傳回值是 3
3
> 4  ; 要評估的表單是 4 ，所以傳回值是
4
> 5  ; 要評估的表單是 5 ，所以傳回值是 5
5
> ***   ; 要評估的表單是，在這之前推三步的那個表單，所以評估 3 之後，傳回值是 3
3
> ***   ; 要評估的表單是，在這之前推三步的那個表單，所以評估 4 之後，傳回值是 4
4
> ***     ; 要評估的表單是，在這之前推三步的那個表單，所以評估 5 之後，傳回值是 5
5
> **   ; 要評估的表單是，在這之前推兩步的那個表單，所以評估 4 之後，傳回值是 4
4
> *   ; 要評估的表單是，在這之前推一步的那個表單，所以評估 4 之後，傳回值是 4
4

[quote][b]Special forms[/b]
There are a number of special forms which look like function calls but
aren't. These include control constructs such as if statements and do
loops; assignments like setq, setf, push, and pop; definitions such as
defun and defstruct; and binding constructs such as let. (Not all of
these special forms have been mentioned yet. See below.)
One useful special form is the quote form: quote prevents its argument
from being evaluated. For example:
> (setq a 3)
3
> a
3
> (quote a)
A
> 'a                    ;'a is an abbreviation for (quote a)
A
Another similar special form is the function form: function causes its
argument to be interpreted as a function rather than being evaluated.
For example:
> (setq + 3)
3
> +
3
> '+
+
> (function +)
#<Function + @ #x-fbef9de>
> #'+                   ;#'+ is an abbreviation for (function +)
#<Function + @ #x-fbef9de>
The function special form is useful when you want to pass a function as
an argument to another function. See below for some examples of
functions which take functions as arguments.[/quote]

[b]Special forms (特殊表單)[/b]

> (setq a 3)
3
> a
3
> (quote a)
A
> 'a                    ; 'a 是 (quote a) 的縮寫
A

> (setq + 3)
3
> +
3
> '+
+
> (function +)
#<Function + @ #x-fbef9de>
> #'+                   ;#'+ 是 (function +) 的縮寫
#<Function + @ #x-fbef9de>

function 這個特殊表單常常被拿來用在，當你要把函數當作是參數來傳遞的時候。

[quote][b]Binding[/b]
Binding is lexically scoped assignment. It happens to the variables in
a function's parameter list whenever the function is called: the formal
parameters are bound to the actual parameters for the duration of the
function call. You can bind variables anywhere in a program with the
let special form, which looks like this:
(let ((var1 val1)
(var2 val2)
...)
body)
Let binds var1 to val1, var2 to val2, and so forth; then it executes
the statements in its body. The body of a let follows exactly the same
rules that a function body does. Some examples:
> (let ((a 3)) (+ a 1))
4
> (let ((a 2)
(b 3)
(c 0))
(setq c (+ a b))
c)
5
> (setq c 4)
4
> (let ((c 5)) c)
5
> c
4
Instead of (let ((a nil) (b nil)) ...), you can write (let (a b) ...).
The val1, val2, etc. inside a let cannot reference the variables var1,
var2, etc. that the let is binding. For example,
> (let ((x 1)
(y (+ x 1)))
y)
Error: Attempt to take the value of the unbound symbol X
If the symbol x already has a global value, stranger happenings will
result:
> (setq x 7)
7
> (let ((x 1)
(y (+ x 1)))
y)
8
The let* special form is just like let except that it allows values to
reference variables defined earlier in the let*. For example,
> (setq x 7)
7
> (let* ((x 1)
(y (+ x 1)))
y)
2
The form
(let* ((x a)
(y b))
...)
is equivalent to
(let ((x a))
(let ((y b))
...))
[/quote]

[b]Binding(綁定)[/b]

(let ((var1 val1)
(var2 val2)
...)
body)

Let 把 var1 綁定成 val1 ，把 var2 綁定成 val2 ，如此類推，然後它會執行
body 這一區塊的程式敘述。 上面 Let 特殊表單裡面的 body 程式區塊敘述執行

(譯註：這像是函數呼叫，只是把參數列改成 let 特殊表單而已，而 body 執行完

> (let ((a 3)) (+ a 1)) ; 在 let 表單裡面，綁定 a 為 3，然後執行 a+1 ，傳回值就是 4 。
4

> (let ((a 2)
(b 3)
(c 0))
(setq c (+ a b))
c)
5

> (setq c 4)
4

> (let ((c 5)) c)
5

> c
4

Let 特殊表單裡面的綁定值 val1, val2 ... 等的值不能參照 var1, var2 ... 等，因為綁定正在

> (let ((x 1)
(y (+ x 1)))
y)
Error: Attempt to take the value of the unbound symbol X

> (setq x 7)
7

> (let ((x 1)
(y (+ x 1)))
y)
8

> (setq x 7)
7

> (let* ((x 1)
(y (+ x 1)))
y)
2

(let* ((x a)
(y b))
...)

(let ((x a))
(let ((y b))
...))

[quote][b]Dynamic Scoping[/b]
The let and let* forms provide lexical scoping, which is what you
expect if you're used to programming in C or Pascal. Dynamic scoping is
what you get in BASIC: if you assign a value to a dynamically scoped
variable, every mention of that variable returns that value until you
assign another value to the same variable.
In LISP, dynamically scoped variables are called special variables. You
can declare a special variable with the defvar special form. Here are
some examples of lexically and dynamically scoped variables.
In this example, the function check-regular references a regular (ie,
lexically scoped) variable. Since check-regular is lexically outside of
the let which binds regular, check-regular returns the variable's
global value.
> (setq regular 5)
5
> (defun check-regular () regular)
CHECK-REGULAR
> (check-regular)
5
> (let ((regular 6)) (check-regular))
5
In this example, the function check-special references a special (ie,
dynamically scoped) variable. Since the call to check-special is
temporally inside of the let which binds special, check-special returns
the variable's local value.
> (defvar *special* 5)
*SPECIAL*
> (defun check-special () *special*)
CHECK-SPECIAL
> (check-special)
5
> (let ((*special* 6)) (check-special))
6
By convention, the name of a special variable begins and ends with a *.
Special variables are chiefly used as global variables, since
programmers usually expect lexical scoping for local variables and
dynamic scoping for global variables.
scoping, see _Common LISP: the Language_.[/quote]

[b]Dynamic Scoping[/b]
let 跟 let* 這樣的特殊表單提供了 lexical scoping ，那就像你在寫 C 或是 Pascal 程式

scoped 變數的例子。

lexically scoped 的變數)。因為 check-regular 函數的定義是在 let 區塊之外，所以 let

check-regular 的傳回值是 regular 變數的全域可視範圍的值。

> (setq regular 5)
5

> (defun check-regular () regular)
CHECK-REGULAR

> (check-regular)
5

> (let ((regular 6)) (check-regular))
5

dynamically scoped 的變數)。因為在 let 區塊裡面有一段暫時呼叫了 check-special 這個

let 區塊綁定影響的區域變數值。

> (defvar *special* 5)
*SPECIAL*

> (defun check-special () *special*)
CHECK-SPECIAL

> (check-special)
5

> (let ((*special* 6)) (check-special))
6

[url=http://www.cs.cmu.edu/Groups/AI/html/cltl/cltl2.html]_Common LISP: the Language_[/url] 這本書。

[quote][b]Arrays
[/b]The function make-array makes an array. The aref function accesses its
elements. All elements of an array are initially set to nil. For
example:
> (make-array '(3 3))
#2a((NIL NIL NIL) (NIL NIL NIL) (NIL NIL NIL))
> (aref * 1 1)
NIL
> (make-array 4)        ;1D arrays don't need the extra parens
#(NIL NIL NIL NIL)
Array indices always start at 0.
See below for how to set the elements of an array.

[b]Strings[/b]
A string is a sequence of characters between double quotes. LISP
represents a string as a variable-length array of characters. You can
write a string which contains a double quote by preceding the quote
with a backslash; a double backslash stands for a single backslash. For
example:
"abcd" has 4 characters
"\"" has 1 character
"\\" has 1 character
Here are some functions for dealing with strings:
> (concatenate 'string "abcd" "efg")
"abcdefg"
> (char "abc" 1)
#\b                     ;LISP writes characters preceded by #\
> (aref "abc" 1)
#\b                     ;remember, strings are really arrays
The concatenate function can actually work with any type of sequence:
> (concatenate 'string '(#\a #\b) '(#\c))
"abc"
> (concatenate 'list "abc" "de")
(#\a #\b #\c #\d #\e)
> (concatenate 'vector '#(3 3 3) '#(3 3 3))
#(3 3 3 3 3 3)

[b]Structures[/b]
LISP structures are analogous to C structs or Pascal records. Here is
an example:
> (defstruct foo
bar
baaz
quux)
FOO
This example defines a data type called foo which is a structure
containing 3 fields. It also defines 4 functions which operate on this
data type: make-foo, foo-bar, foo-baaz, and foo-quux. The first one
makes a new object of type foo; the others access the fields of an
object of type foo. Here is how to use these functions:
> (make-foo)
#s(FOO :BAR NIL :BAAZ NIL :QUUX NIL)
> (make-foo :baaz 3)
#s(FOO :BAR NIL :BAAZ 3 :QUUX NIL)
> (foo-bar *)
NIL
> (foo-baaz **)
3
The make-foo function can take a keyword argument for each of the
fields a structure of type foo can have. The field access functions
each take one argument, a structure of type foo, and return the
appropriate field.
See below for how to set the fields of a structure.[/quote]

[b]Arrays(陣列)[/b]

> (make-array '(3 3))
#2a((NIL NIL NIL) (NIL NIL NIL) (NIL NIL NIL))

> (aref * 1 1)
NIL

> (make-array 4)        ; 一維陣列的維度不需要額外的小括弧
#(NIL NIL NIL NIL)

[b]Strings(字串)[/b]

"abcd" 包含有 4 個字元
"\"" 包含有 1 個字元
"\\" 包含有 1 個字元

> (concatenate 'string "abcd" "efg")  ; 連接字串用 concatenate 函數
"abcdefg"

> (char "abc" 1)
#\b                     ; Lisp 會在字元前面加上 #\ 用來表示字元。

> (aref "abc" 1)
#\b                     ; 請記住，字串其實就是字元陣列而已。

> (concatenate 'string '(#\a #\b) '(#\c))
"abc"

> (concatenate 'list "abc" "de")
(#\a #\b #\c #\d #\e)

> (concatenate 'vector '#(3 3 3) '#(3 3 3))
#(3 3 3 3 3 3)

[b]Structures(結構)[/b]
Lisp 的結構就類似 C 語言的 struct 跟 Pascal 語言的 record 。下面是一個範例：

> (defstruct foo
bar
baaz
quux)
FOO

make-foo, foo-bar, foo-baaz, 跟 foo-quux 。第一個函數 make-foo 可以用來產生 foo 資料

> (make-foo)
#s(FOO :BAR NIL :BAAZ NIL :QUUX NIL)

> (make-foo :baaz 3)
#s(FOO :BAR NIL :BAAZ 3 :QUUX NIL)

> (foo-bar *)
NIL

> (foo-baaz **)
3

keyword 參數。而存取資料欄位的取用函數則可以接受一個 foo 物件當作是輸入參數，並且

[quote][b]Setf[/b]
Certain forms in LISP naturally define a memory location. For example,
if the value of x is a structure of type foo, then (foo-bar x) defines
the bar field of the value of x. Or, if the value of y is a one-
dimensional array, (aref y 2) defines the third element of y.
The setf special form uses its first argument to define a place in
memory, evaluates its second argument, and stores the resulting value
in the resulting memory location. For example,
> (setq a (make-array 3))
#(NIL NIL NIL)
> (aref a 1)
NIL
> (setf (aref a 1) 3)
3
> a
#(NIL 3 NIL)
> (aref a 1)
3
> (defstruct foo bar)
FOO
> (setq a (make-foo))
#s(FOO :BAR NIL)
> (foo-bar a)
NIL
> (setf (foo-bar a) 3)
3
> a
#s(FOO :BAR 3)
> (foo-bar a)
3
Setf is the only way to set the fields of a structure or the elements
of an array.
Here are some more examples of setf and related functions.
> (setf a (make-array 1))       ;setf on a variable is equivalent to setq
#(NIL)
> (push 5 (aref a 1))           ;push can act like setf
(5)
> (pop (aref a 1))              ;so can pop
5
> (setf (aref a 1) 5)
5
> (incf (aref a 1))             ;incf reads from a place, increments,
6                               ;and writes back
> (aref a 1)
6[/quote]

[b]Setf[/b]

foo 資料型別的結構的話，那 (foo-bar x) 表示的就是 x 裡面的 bar 資料欄位。

> (setq a (make-array 3))
#(NIL NIL NIL)

> (aref a 1)
NIL

> (setf (aref a 1) 3)
3

> a
#(NIL 3 NIL)

> (aref a 1)
3

> (defstruct foo bar)
FOO

> (setq a (make-foo))
#s(FOO :BAR NIL)

> (foo-bar a)
NIL

> (setf (foo-bar a) 3)
3

> a
#s(FOO :BAR 3)

> (foo-bar a)
3

Setf 是唯一可以用來設定結構裡資料欄位的值，以及設定陣列裡元素之值的方法。

> (setf a (make-array 1))       ; setf 作用在單一個變數上面的效果跟 setq 一樣。
#(NIL)

> (push 5 (aref a 1))           ; push 也可以拿來當作是 setf 使用(不過參數順序不太一樣喔！)
(5)

> (pop (aref a 1))              ; 既然 push 可以存值，那 pop 當然就可以取值。
5

> (setf (aref a 1) 5)
5

> (incf (aref a 1))             ; incf 的功用是從記憶體位置讀取出值，然後累加
6                               ; 最後在把累加完之後的值，存回到相同的記憶體位置。

> (aref a 1)
6

[quote][b]Booleans and Conditionals[/b]
LISP uses the self-evaluating symbol nil to mean false. Anything other
than nil means true. Unless we have a reason not to, we usually use the
self-evaluating symbol t to stand for true.
LISP provides a standard set of logical functions, for example and, or,
and not. The and and or connectives are short-circuiting: and will not
evaluate any arguments to the right of the first one which evaluates to
nil, while or will not evaluate any arguments to the right of the first
one which evaluates to t.
LISP also provides several special forms for conditional execution. The
simplest of these is if. The first argument of if determines whether
the second or third argument will be executed:
> (if t 5 6)
5
> (if nil 5 6)
6
> (if 4 5 6)
5
If you need to put more than one statement in the then or else clause
of an if statement, you can use the progn special form. Progn executes
each statement in its body, then returns the value of the final one.
> (setq a 7)
7
> (setq b 0)
0
> (setq c 5)
5
> (if (> a 5)
(progn
(setq a (+ b 7))
(setq b (+ c 8)))
(setq b 4))
13
An if statement which lacks either a then or an else clause can be
written using the when or unless special form:
> (when t 3)
3
> (when nil 3)
NIL
> (unless t 3)
NIL
> (unless nil 3)
3
When and unless, unlike if, allow any number of statements in their
bodies. (Eg, (when x a b c) is equivalent to (if x (progn a b c)).)
> (when t
(setq a 5)
(+ a 6))
11

More complicated conditionals can be defined using the cond special
form, which is equivalent to an if ... else if ... fi construction.
A cond consists of the symbol cond followed by a number of cond
clauses, each of which is a list. The first element of a cond clause is
the condition; the remaining elements (if any) are the action. The cond
form finds the first clause whose condition evaluates to true (ie,
doesn't evaluate to nil); it then executes the corresponding action and
returns the resulting value. None of the remaining conditions are
evaluated; nor are any actions except the one corresponding to the
selected condition. For example:
> (setq a 3)
3
> (cond
((evenp a) a)        ;if a is even return a
((> a 7) (/ a 2))    ;else if a is bigger than 7 return a/2
((< a 5) (- a 1))    ;else if a is smaller than 5 return a-1
(t 17))              ;else return 17
2
If the action in the selected cond clause is missing, cond returns what
the condition evaluated to:
> (cond ((+ 3 4)))
7
Here's a clever little recursive function which uses cond. You might be
interested in trying to prove that it terminates for all integers x at
least 1. (If you succeed, please publish the result.)
> (defun hotpo (x steps)        ;hotpo stands for Half Or Triple Plus One
(cond
((= x 1) steps)
((oddp x) (hotpo (+ 1 (* x 3)) (+ 1 steps)))
(t (hotpo (/ x 2) (+ 1 steps)))))
A
> (hotpo 7 0)
16
The LISP case statement is like a C switch statement:
> (setq x 'b)
B
> (case x
(a 5)
((d e) 7)
((b f) 3)
(otherwise 9))
3
The otherwise clause at the end means that if x is not a, b, d, e, or
f, the case statement will return 9.
[/quote]

[b]Booleans(布林值) and Conditionals(控制判斷條件)[/b]
Lisp 使用其值為本身的 NIL 表示〝偽〞。任何其他不是 NIL 的值都表示真。

Lisp 提供了一系列的標準的邏輯函數，比如像是 and, or 以及 not 函數。
and 以及 or 函數是屬於 short-circuit ，也就是說，如果 and 函數的有任何

Lisp 也提供了幾個特殊表單用來做控制判斷執行的條件。最簡單的就是 if 敘述
，在 if 敘述的第一個參數將會決定，接下來執行的會是第二個或是第三個參數。
> (if t 5 6)
5
> (if nil 5 6)
6
> (if 4 5 6)
5

> (setq a 7)
7
> (setq b 0)
0
> (setq c 5)
5
> (if (> a 5)
(progn
(setq a (+ b 7))
(setq b (+ c 8)))
(setq b 4))
13
if 敘述如果缺乏 then(第二個參數) 或是 else(第三個參數) 的部份，其實也可以

> (when t 3)
3
> (when nil 3)
NIL
> (unless t 3)
NIL
> (unless nil 3)
3
when 跟 unless 特殊表單並不像 if 只可以放一個敘述，他們可以放任一個數的

> (when t
(setq a 5)
(+ a 6))
11

if ... else if ... fi 控制判斷條件一樣。

cond 特殊表單包含有開頭的 cond 字符，後面接的一連串的判斷子句，每一個

> (setq a 3)
3
> (cond
((evenp a) a)        ;如果(if) a 是偶數，則傳回值為 a
((> a 7) (/ a 2))    ;不然，如果(else if) a 比 7 大，則傳回值為 a/2
((< a 5) (- a 1))    ;不然，如果(else if) a 比 5 小，則傳回值為 a-1
(t 17))              ;不然(else)，傳回值為 17
2

> (cond ((+ 3 4)))
7

(譯註：這是數學界有名的 3x+1 猜想，至 2006 年目前依然無人成功証出。)

> (defun hotpo (x steps)        ; hotpo 會把偶數減半，把奇數乘三後加一
(cond
((= x 1) steps)
((oddp x) (hotpo (+ 1 (* x 3)) (+ 1 steps)))
(t (hotpo (/ x 2) (+ 1 steps)))))
A
> (hotpo 7 0)                   ; 從 7 經 hotpo 運算到 1 共要經過 16 步。
16

Lisp 也有一個 case 敘述句，就類似 C 語言的 switch 敘述句一樣。如下範例：

> (setq x 'b)
B
> (case x
(a 5)     ; 如果 x 是 a ，那傳回值就是 5
((d e) 7)    ; 如果 x 是 d 或 e ，那傳回值就是 7
((b f) 3)    ; 如果 x 是 b 或 f ，那傳回值就是 3
(otherwise 9))   ; 此外，那傳回值就是 9
3

[quote]
[b]Iteration[/b]
The simplest iteration construct in LISP is loop: a loop construct
repeatedly executes its body until it hits a return special form. For
example,
> (setq a 4)
4
> (loop
(setq a (+ a 1))
(when (> a 7) (return a)))
8
> (loop
(setq a (- a 1))
(when (< a 3) (return)))
NIL
The next simplest is dolist: dolist binds a variable to the elements of
a list in order and stops when it hits the end of the list.
> (dolist (x '(a b c)) (print x))
A
B
C
NIL
Dolist always returns nil. Note that the value of x in the above
example was never nil: the NIL below the C was the value that dolist
returned, printed by the read-eval-print loop.
The most complicated iteration primitive is called do. A do statement
looks like this:

> (do ((x 1 (+ x 1))
(y 1 (* y 2)))
((> x 5) y)
(print y)
(print 'working))

1
WORKING
2
WORKING
4
WORKING
8
WORKING
16
WORKING
32

The first part of a do specifies what variables to bind, what their
initial values are, and how to update them. The second part specifies a
termination condition and a return value. The last part is the body. A
do form binds its variables to their initial values like a let, then
checks the termination condition. As long as the condition is false, it
executes the body repeatedly; when the condition becomes true, it
returns the value of the return-value form.

The do* form is to do as let* is to let.
[/quote]

Iteration(重複結構)

> (setq a 4)
4

> (loop
(setq a (+ a 1))
(when (> a 7) (return a)))
8

> (loop
(setq a (- a 1))
(when (< a 3) (return)))
NIL

> (dolist (x '(a b c)) (print x))
A
B
C
NIL

Dolist 的傳回值必定是 NIL 。請注意看上面範例裡面 x 綁訂的值卻從未是 NIL ，

> (do ((x 1 (+ x 1))
(y 1 (* y 2)))
((> x 5) y)
(print y)
(print 'working))
1
WORKING
2
WORKING
4
WORKING
8
WORKING
16
WORKING
32

do 表單會先如同 let 特殊表單依樣綁定變數初始值，然後檢查迴圈終止條件是否成立，

let* 而已。

[b]Non-local Exits[/b]
The return special form mentioned in the section on iteration is an
example of a nonlocal return. Another example is the return-from form,
which returns a value from the surrounding function:
> (defun foo (x)
(return-from foo 3)
x)
FOO
> (foo 17)
3
Actually, the return-from form can return from any named block -- it's
just that functions are the only blocks which are named by default. You
can create a named block with the block special form:
> (block foo
(return-from foo 7)
3)
7
The return special form can return from any block named nil. Loops are
by default labelled nil, but you can make your own nil-labelled blocks:
> (block nil
(return 7)
3)
7
Another form which causes a nonlocal exit is the error form:
> (error "This is an error")
Error: This is an error
The error form applies format to its arguments, then places you in the
debugger.

[quote][b]Funcall, Apply, and Mapcar
[/b]Earlier I promised to give some functions which take functions as
arguments. Here they are:
> (funcall #'+ 3 4)
7
> (apply #'+ 3 4 '(3 4))
14
> (mapcar #'not '(t nil t nil t nil))
(NIL T NIL T NIL T)
Funcall calls its first argument on its remaining arguments.
Apply is just like funcall, except that its final argument should be a
list; the elements of that list are treated as if they were additional
arguments to a funcall.
The first argument to mapcar must be a function of one argument; mapcar
applies this function to each element of a list and collects the
results in another list.
Funcall and apply are chiefly useful when their first argument is a
variable. For instance, a search engine could take a heuristic function
as a parameter and use funcall or apply to call that function on a
state description. The sorting functions described later use funcall
to call their comparison functions.
Mapcar, along with nameless functions (see below), can replace many
loops.

[b]Lambda
[/b]If you just want to create a temporary function and don't want to
bother giving it a name, lambda is what you need.
> #'(lambda (x) (+ x 3))
(LAMBDA (X) (+ X 3))
> (funcall * 5)
8
The combination of lambda and mapcar can replace many loops. For
example, the following two forms are equivalent:
> (do ((x '(1 2 3 4 5) (cdr x))
(y nil))
((null x) (reverse y))
(push (+ (car x) 2) y))
(3 4 5 6 7)
> (mapcar #'(lambda (x) (+ x 2)) '(1 2 3 4 5))
(3 4 5 6 7)

[b]Sorting[/b]
LISP provides two primitives for sorting: sort and stable-sort.
> (sort '(2 1 5 4 6) #'<)
(1 2 4 5 6)
> (sort '(2 1 5 4 6) #'>)
(6 5 4 2 1)
The first argument to sort is a list; the second is a comparison
function. The sort function does not guarantee stability: if there are
two elements a and b such that (and (not (< a b)) (not (< b a))), sort
may arrange them in either order. The stable-sort function is exactly
like sort, except that it guarantees that two equivalent elements
appear in the sorted list in the same order that they appeared in the
original list.
Be careful: sort is allowed to destroy its argument, so if the original
sequence is important to you, make a copy with the copy-list or copy-seq
function.

[b]Equality[/b]
LISP has many different ideas of equality. Numerical equality is
denoted by =. Two symbols are eq if and only if they are identical. Two
copies of the same list are not eq, but they are equal.
> (eq 'a 'a)
T
> (eq 'a 'b)
NIL
> (= 3 4)
NIL
> (eq '(a b c) '(a b c))
NIL
> (equal '(a b c) '(a b c))
T
> (eql 'a 'a)
T
> (eql 3 3)
T
The eql predicate is equivalent to eq for symbols and to = for numbers
or the same type:
> (eql 2.0 2)
NIL
> (= 2.0 2)
T
> (eq 12345678901234567890 12345678901234567890)
NIL
> (= 12345678901234567890 12345678901234567890)
T
> (eql 12345678901234567890 12345678901234567890)
T
The equal predicate is equivalent to eql for symbols and numbers. It is
true for two conses if and only if their cars are equal and their cdrs
are equal. It is true for two structures if and only if the structures
are the same type and their corresponding fields are equal.[/quote]

[b]Funcall, Apply, and Mapcar (函數當作參數)[/b]

> (funcall #'+ 3 4)
7

> (apply #'+ 3 4 '(3 4))
14

> (mapcar #'not '(t nil t nil t nil))
(NIL T NIL T NIL T)

funcall 會呼叫以第一個參數為名的函數，並把 funcall 的其他參數當作是要呼叫的

apply 就像是 funcall 一樣的功用，除了 apply 的最後一個參數必須要是串列；這

mapcar 的第一個參數必須是可以作用於單一傳入值的函數名稱， mapcar 會把該函數

funcall 跟 apply 就是因為他們的第一個參數可以是變數，所以特別有用。舉例應用如，

mapcar 跟未具名函數(後面會介紹)一起使用，可以取代掉很多迴圈的使用。

[b]Lambda (未具名函數)[/b]

> #'(lambda (x) (+ x 3))
(LAMBDA (X) (+ X 3))

> (funcall * 5)      ; 譯註： * 表示前一個輸入表單，在此就是 #'(lambda (x) (+ x 3))
8

> (do ((x '(1 2 3 4 5) (cdr x))
(y nil))
((null x) (reverse y))
(push (+ (car x) 2) y))
(3 4 5 6 7)

> (mapcar #'(lambda (x) (+ x 2)) '(1 2 3 4 5))
(3 4 5 6 7)

[b]Sorting(排序)[/b]

Lisp 提供了兩個主要的排序函數： sort 跟 stable-sort 。

> (sort '(2 1 5 4 6) #'<)
(1 2 4 5 6)

> (sort '(2 1 5 4 6) #'>)
(6 5 4 2 1)

sort 的第一個參數是一個串列，而第二個參數則是一個比較大小用的比較函數的名稱。
sort 函數並不保證排序的穩定性，也就是說，如果有兩個元素 a 與 b 滿足
(and (not (< a b)) (not (< b a))) (譯註：也就是 a 與 b 套用在排序函數時相等)，
sort 或許有可能在排序之後，會對調 a 與 b 的順序。而 stable-sort 跟 sort 使用方式

[b]Equality(相等)[/b]

Lisp 對於"相等"的意義有很多種類型。 數值上的相等是用 = 來判別。兩個字符則是用 eq 來

> (eq 'a 'a)
T

> (eq 'a 'b)
NIL

> (= 3 4)
NIL

> (eq '(a b c) '(a b c))
NIL

> (equal '(a b c) '(a b c))
T

> (eql 'a 'a)
T

> (eql 3 3)
T

eql 判斷式等價於 "判斷是否是相同型別" 加上 "如果同是字符，判斷是否 eq " 再加上
"如果同是數值，判斷是否 = "的合體。

> (eql 2.0 2)
NIL

> (= 2.0 2)
T

> (eq 12345678901234567890 12345678901234567890)
NIL

> (= 12345678901234567890 12345678901234567890)
T

> (eql 12345678901234567890 12345678901234567890)
T

[quote][b]Some Useful List Functions[/b]
These functions all manipulate lists.
> (append '(1 2 3) '(4 5 6))    ;concatenate lists
(1 2 3 4 5 6)
> (reverse '(1 2 3))            ;reverse the elements of a list
(3 2 1)
> (member 'a '(b d a c))        ;set membership -- returns the first tail
(A C)                           ;whose car is the desired element
> (find 'a '(b d a c))          ;another way to do set membership
A
> (find '(a b) '((a d) (a d e) (a b d e) ()) :test #'subsetp)
(A B D E)                       ;find is more flexible though
> (subsetp '(a b) '(a d e))     ;set containment
NIL
> (intersection '(a b c) '(b))  ;set intersection
(B)
> (union '(a) '(b))             ;set union
(A B)
> (set-difference '(a b) '(a))  ;set difference
(B)
Subsetp, intersection, union, and set-difference all assume that each
argument contains no duplicate elements -- (subsetp '(a a) '(a b b)) is
allowed to fail, for example.
Find, subsetp, intersection, union, and set-difference can all take a
:test keyword argument; by default, they all use eql.[/quote]

[b]一些好用的串列處理函數[/b]

> (append '(1 2 3) '(4 5 6))    ; 連結許多串列
(1 2 3 4 5 6)

> (reverse '(1 2 3))            ; 逆轉一個串列裡面的元素
(3 2 1)

> (member 'a '(b d a c))        ; 集合元素的"屬於"判斷 -- 它會傳回第一個找到的元素
(A C)                           ; 至後方所有元素所形成的串列，也就是找第一個 car 是該元素的串列
; 譯註：空串列NIL 即為偽，其他任何非空串列皆表示真。

> (find 'a '(b d a c))          ; 另一個檢查元素是否屬於該集合的方法就是用 find 。
A

> (find '(a b) '((a d) (a d e) (a b d e) ()) :test #'subsetp)
(A B D E)                       ; find 是很有彈型的，可以傳入要用來判斷的函數。
; 上面例子就是改用 subsectp (檢查是否為子集合) 來找尋滿足條件的集合。

> (subsetp '(a b) '(a d e))     ; 檢查是否為子集合
NIL

> (intersection '(a b c) '(b))  ; 求集合的交集
(B)

> (union '(a) '(b))             ; 求集合的聯集
(A B)

> (set-difference '(a b) '(a))  ; 求差集合
(B)

Subsetp, intersection, union, 和 set-difference 都有一個基本假設就是傳入值的參數串列內

Find, subsetp, intersection, union, 和 set-difference 都可以加上 :test 這一個 keyword 參數，

＝.＝ 慢慢來～不要急～ :P

[b]Getting Started with Emacs[/b]
You can use Emacs to edit LISP code: most Emacses are set up to enter
LISP mode automatically when they find a file which ends in .lisp, but
if yours isn't, you can type M-x lisp-mode.
You can run LISP under Emacs, too: make sure that there is a command in
your path called "lisp" which runs your favorite LISP. For example, you
could type
ln -s /usr/local/bin/clisp ~/bin/lisp
Then in Emacs type M-x run-lisp. You can send LISP code to the LISP you
just started, and do all sorts of other cool things; for more
information, type C-h m from any buffer which is in LISP mode.
Actually, you don't even need to make a link. Emacs has a variable
called inferior-lisp-program; so if you add the line
(setq inferior-lisp-program "/usr/local/bin/clisp")
to your .emacs file, Emacs will know where to find CLISP when
you type M-x run-lisp.