Common Lisp 符号中文文档

(+ 1 1)                                 ; => 2
(+ 1 2 3)                               ; => 6

(- 2 1)                                 ; => 1
;;; 等同 10 - 8 - 1
(- 10 8 1)                            ; => 1
;;; 如果只有一个数字，就取它的负数
(- 2)                                   ; => -2

(* 3 2 5)                               ; => 30

(/ 3)                                   ; => 1/3
;;; 无法整除时返回有理数
(/ 3 2)                                 ; => 3/2
(/ 10 5)                                ; => 2

(1+ 1.0)                                ; => 2.0
(1+ 10)                                 ; => 11

(1- 10)                                 ; => 9

(and 1 2 3)                             ; => 3
(and 1 2 nil)                           ; => NIL

(atom "123")                   ; => T
(atom '1)                      ; => T
(atom "1")                     ; => T
(atom #\1)                     ; => T
(atom 1)                       ; => T
(atom nil)                     ; => T
;;; 非空列表不是原子
(atom '(1 2 3))                ; => NIL

(defvar x (make-array 10 :initial-element 1))
(arrayp x)                              ; => T

;;; 访问一维数组中下标0和下标1的元素

(aref #(A B C) 0)                       ; => A
(aref #(A B C) 1)                       ; => B

;;; 访问二维数组
(defvar a-rank-array (make-array '(2 2))) ; 创建一个二维数组
(aref a-rank-array 0 1)                   ; => 0
(setf (aref a-rank-array 0 1) 1)          ; => 1
a-rank-array                              ; => #2A((0 1) (0 0))

;;; 由于 aref 是直接指向数组元素的内存地址，所以借助它可修改数组元素：
(defvar a-array #(1 2 3))
(setf (aref a-array 2) 'A)
a-array                                 ; => #(1 2 A)

(assoc 'a '((a 1) (b 2)))                             ; => (A 1)
;;; 指定 :test 参数
(assoc "a" '(("a" 1) ("b" 2)) :test #'equal) ; => ("a" 1)

(character #\a)                         ; => #\a
;;; 字符串只能包含一个字符，包含多个字符会出错
(character "a")                         ; => #\a
(character 'a)                          ; => #\A
(character 100) ; 错误，不能是数字

(character 97)                          ; => #\a
(character 0)                           ; => #\Null

(char-code #\a)                         ; => 97
(char-code #\A)                         ; => 65

;;; 如果 obj 的类型和 output-type 一样的，就原样返回：
(coerce 1 'integer)                     ; => 1
(coerce "1" 'string)                    ; => "1"

;;; 把 obj 转换成序列：
(coerce "hello world" 'simple-vector) ; => #(#\h #\e #\l #\l #\o #\  #\w #\o #\r #\l #\d)
(coerce "hello world" 'list) ; => (#\h #\e #\l #\l #\o #\  #\w #\o #\r #\l #\d)
(coerce "hello world" 'array)           ; => "hello world"

;;; 字符列表转成字符串：
(coerce '(#\h #\e #\l #\l #\o) 'string) ; => "hello"

;;; 转换成字符：
(coerce 'a 'character)                  ; => #\A
(coerce 'hello 'character)              ; 错误，obj 必须是单字符
(coerce :a 'character)                  ; => #\A

;;; 数字类型转换：
;; 转换成复数类型
(coerce 1.23 'complex)         ; => #C(1.23 0.0)'
;; 转换成浮点数类型
(coerce 1 'float)              ; => 1.0

;;; 根据符号名转换成已绑定的函数。注意必须是函数，不能用在宏上：
(coerce '+ 'function)                        ; => #<FUNCTION +>
;;; 调用返回的函数类型
(funcall (coerce '+ 'function) 1 1)     ; => 2
(coerce "+" 'function)                  ; 错误，名字不能是字符串

;;; 左边指针指向存储了“1”的内存地址，右边指针指向存储了“2”的内存地址
(cons 1 2)                     ; => (1 . 2)
(cons 1 nil)                   ; => (1)
(cons 1 (cons 2 nil))          ; => (1 2)

(defvar a-value 10)
;;; 默认减1
(decf a-value)                          ; => 9
;;; 对象的值减2
(decf a-value (+ 1 1))                  ; => 7

(defmethod add ((a number) (b number))
  (+ a b))

(defmethod add ((a list) (b list))
  (append a b))

(add 1 1)                               ; => 2
(add '(1 2) '(3 4))                     ; => (1 2 3 4)

(defconstant +a-constant+ 10)
(defconstant +a-constant+ 10 "定义一个常量")
+a-constant+                            ; => 10

;;; 查看 funcall 函数的信息
(describe 'funcall)
;; =>
;; COMMON-LISP:FUNCALL
;;   [symbol]

;; FUNCALL names a compiled function:
;;   Lambda-list: (FUNCTION &REST ARGUMENTS)
;;   Declared type: (FUNCTION ((OR FUNCTION SYMBOL) &REST T) *)
;;   Documentation:
;;     Call FUNCTION with the given ARGUMENTS.
;;   Known attributes: call, unwind, any
;;   Source file: SYS:SRC;CODE;EVAL.LISP

(i) ; 定义变量 i
(i 0) ; 定义变量 i，并初始为 0
(i 0 (+1 i)) ; 定义变量i并初始为 0，每次循环都会调用 +1 进行自加操作

((> i 100)) ; 结束条件为 i 大于 100
((> i 100) i) ; 指定 do 循环的返回值 i

(do ((i 0 (1+ i))
     ;; 变量n作为累加器
     (n 0 (+ n i)) )
    ((> i 100) n)
  (print i))

(dolist (i '(1 2 3 4 5))
  (print i))

(dotimes (i 100 i)
  (print i))

(defvar hello "hello world")
(defvar a hello)
(defvar b hello)
(eq a b)                       ; => T
(defvar c a)
(eq a c)                       ; => T
(eq b c)                       ; => T
c                              ; => "hello world"
(defvar d "hi")
(eq d c)                       ; => NIL
(defvar a-list '(a b a))
(eq (car a-list) (caddr a-list)) ; => T

(defvar a 1)
(defvar b a)
;;; 指向相同对象
(eqlf a b)                     ; => T
;;; 相同类型、相同值的数字
(eql 1 1)                      ; => T
;;; 类型不同，所以返回 nil
(eql 1 1.0)                    ; => NIL
;;; 相同的字符
(eql #\a #\a)                  ; => T
(defvar a-list '(1 2 3))
;;; 值相同，但并不是一个对象，所以返回 nil
(eql a-list '(1 2 3))          ; => NIL

;;; 符号判断和 eq 的规则一样
(equal 'a 'a)                  ; => T
;;; 数字判断和 eql 规则一样
(equal 100 100)                ; => T
;;; 字符判断和 eql 规则一样
(equal #\a #\a)                ; => T

;;; 判断 cons
;; 元素相同也为 t
(equal '(1 2 3) '(1 2 3))      ; => T
;; 元素顺序必须一致才返回 t
(equal '(1 2 3) '(3 2 1))      ; => NIL

;;; 判断 array
;;; 只有字符串和 bit-vector 才能判断是否相等
(equal "test" "test")          ; => T
;;; 字符串比较时不会忽略大小写
(equal "Test" "test")          ; => NIL
(equal #*1001 #*1001) ; => T
;;; 其他 array 无法比较
(equal #(1 2 3) #(1 2 3))      ; => NIL

;;; 判断 pathname 是否相等
(equal #p"/tmp/test" #p"/tmp/test") ; => T

;;; 字符串比较会忽略大小写
(equalp "Test" "test")         ; => T
;;; 比较 array 是否相等
(equalp #(1 2 3) #(1 2 3))     ; => T
;;; 字符比较
(equalp #\a #\a)               ; => T
;;; 数字比较
(equalp 1 1)                   ; => T
;;; 整数和浮点数比较
(equalp 1 1.0)                 ; => T
;;; cons 比较
(equalp '(1 2 3) '(1 2 3))     ; => T

;;; 比较结构体
(make-my-info :name "lu4nx" :blog "shellcodes.org") ; => #S(MY-INFO :NAME "lu4nx" :BLOG "shellcodes.org")
(defvar a (make-my-info :name "lu4nx" :blog "shellcodes.org"))
(defvar b (make-my-info :name "lu4nx" :blog "shellcodes.org"))
(equalp a b)                   ; => T
;;; 元素不相等返回 nil
(equalp a (make-my-info :name "luanx" :blog "shellcodes.org")) ; => NIL

;;; 比较 hash 表
(defvar x (make-hash-table))
(defvar y (make-hash-table))
;;; 两个 hash 表都是空元素，所以相等
(equalp x y)                     ; => T
;;; 给其中一个 hash 表设置键值后再比较
(setf (gethash :name x) "lu4nx") ; => "lu4nx"
(equalp x y)                     ; => NIL

(ensure-directories-exist "/tmp/test-function/")
;; => "/tmp/test-function/"
;; T

;;;; 如果路径不以“/”结尾，目录 a 是不会被创建的
(ensure-directories-exist "/tmp/test-function/a")
;; => "/tmp/test-function/a"
;; NIL

(fboundp '+)                            ; => T
(fboundp 'a)                            ; => NIL

(defvar hello "hello")
;; 字符串要大写
(find-symbol "HELLO") ; => HELLO
;; 从 CL 包里查找 funcall
(find-symbol "FUNCALL" :cl) ; => FUNCALL
;; 直接调用返回的函数符号
(funcall (find-symbol "+" :cl) 1 1) ; => 2

(format t "say:")
(read)

(format t "say:")
(force-output)
(read)

(incf n)                                ; 等同于 (setf n (1+ n))
(incf n 10)                             ; 等同于 (setf n (+ n 10))

(defvar a 1)
(incf a)                                ; => 2
a                                       ; => 2
(incf a 10)                             ; => 12
(incf a (+ 1 1))                        ; => 14
a                                       ; => 14

(input-stream-p *standard-input*) ; => T
(input-stream-p *standard-output*) ; => NIL

(list 1 2 3)                            ; => (1 2 3)
(list 1 2 3 'a 'b 'c)                   ; => (1 2 3 A B C)

(listp '(1 2 3))                        ; => T
(listp 123)                             ; => NIL

;; for CLISP
(long-site-name) ; => "Linux mypc 4.3.5-300.fc23.x86_64 #1 SMP Mon Feb 1 03:18:41 UTC 2016 x86_64 x86_64 x86_64 GNU/Linux"
;; for Allegro CL
(long-site-name)                        ; => "MYPC"
;; for LispWorks
(long-site-name)                        ; => "unknown"
;; for SBCL
(long-site-name)                        ; => NIL

(machine-type)                          ; => "X86-64"

(machine-version)      ; => "Intel(R) Core(TM) i7-3520M CPU @ 2.90GHz"

(machine-instance)                      ; => "mypc"

(macroexpand '(dotimes (i 10) (print i)))
;; 展开后：
;; (BLOCK NIL
;;   (LET ((I 0))
;;     (DECLARE (TYPE UNSIGNED-BYTE I))
;;     (TAGBODY
;;       (GO #:G682)
;;      #:G681
;;       (TAGBODY (PRINT I))
;;       (PSETQ I (1+ I))
;;      #:G682
;;       (UNLESS (>= I 10) (GO #:G681))
;;       (RETURN-FROM NIL (PROGN NIL)))))
;; T

(macroexpand-1 '(dotimes (i 10) (print i)))
;; 展开后：
;; (DO ((I 0 (1+ I))) ((>= I 10) NIL) (DECLARE (TYPE UNSIGNED-BYTE I)) (PRINT I))
;; T

(make-string 10 :initial-element #\a)   ; => "aaaaaaaaaa"

;; for CLISP，返回主机名
(short-site-name)                       ; => "lx"

;; for Allegro CL
(short-site-name)           ; => "LU4NX-PC"

;; for LispWorks
(short-site-name)                       ; => "Unknown"

;; for SBCL
(short-site-name)                       ; => NIL

;;; 只会剔除第一次匹配到的
(string-left-trim "Hi" "Hi,girl. Hi,boy.") ; => ",girl. Hi,boy."

(string-right-trim "boy." "Hi,girl. Hi,boy.") ; => "Hi,girl. Hi,"

(string-trim "hello" "hello, world")    ; => ", world"
(string-trim "world" "hello, world")    ; => "hello, "

(software-type)                         ; => "Linux"

(software-version)                      ; => "4.3.5-300.fc23.x86_64"

(defvar a 1)
(defvar b 2)
(defvar c 3)
(shiftf a b c 4)                        ; => 1
a                              ; => 2
b                              ; => 3
c                              ; => 4
;;;; 第二个例子：修改列表
(defvar x '(a b c))
(defvar y 'd)
(defvar z 0)
(shiftf z (nth 1 x) y)                  ; => 0
z                                       ; => B
x                                       ; => (A D Z)
y                                       ; => D

(substitute #\a #\b "abcd")    ; => "aacd"
(substitute 10 1 #(1 2 3 4 5)) ; => #(10 2 3 4 5)

(minusp 1)                              ; => NIL
(minusp 0)                              ; => NIL
(minusp -1)                             ; => T

(mismatch "http://www.shellcodes.org" "http://") ; => 7

(multiple-value-prog1
    (1+ 1)
  (print "a")
  (print "b"))

;; 输出：
;; "a"
;; "b"
;; 2

(null nil)                              ; => T
;;; 空列表等同于 nil
(null '())                              ; => T
(null 1)                                ; => NIL

(numberp 123)                           ; => T
(numberp 123.0)                         ; => T
(numberp 0.1)                           ; => T
(numberp "1")                           ; => NIL
(numberp 1/2)                           ; => T

(notany #'evenp '(1 2 3 4))             ; => NIL
(notany #'evenp '(1 3 5 7))             ; => T

(notany #'equal '(1 3 5 7) '(1 3 5 7))          ; => NIL
;;; 全部不相等
(notany #'equal '(1 3 5 7) '(2 4 6 8))  ; => T

(nth-value 1 (values 'value1 "value2")) ; => "value2"
(nth-value 0 (values 'value1 "value2")) ; => VALUE1

;;; 等同于 (cdr (cdr '(1 2 3)))
(nthcdr 2 '(1 2 3))                     ; => (3)

(output-stream-p *standard-input*)      ; => NIL
(output-stream-p *standard-output*)     ; => T

(pairlis '(a b c) '(1 2 3))             ; => ((C . 3) (B . 2) (A . 1))
;;; 指定最后一个 alist 参数
(pairlis '(a b c) '(1 2 3) '((x 1) (y 2) (z 3))) ; => ((C . 3) (B . 2) (A . 1) (X 1) (Y 2) (Z 3))

(plusp 1)                      ; => T
(plusp 0)                      ; => NIL
(plusp -1)                     ; => NIL

(progn (print 1) (print 2) 3)
;; 输出：
;; 1
;; 2
;; 3

(defvar x '(1 2 3))
(defvar y '(4 5 6))
(psetf (car x) 'one (car y) 'four) ; => NIL
x                                  ; => (ONE 2 3)
y                                  ; => (FOUR 5 6)
(psetf x 1 y 2)                    ; => NIL
x                                  ; => 1
y                                  ; => 2

(parse-integer "123")                   ; => 123
                                        ;    3
;;; radix 指定进制，这里转换二进制
(parse-integer "1101" :radix 2)         ; => 13
                                        ;    4

(rename-file #p"/tmp/old" "new")

(defvar a 1)
(defvar b 2)
(defvar c 3)
a                                       ; => 1
b                              ; => 2
c                              ; => 3
(rotatef a b c)                ; => NIL
a                              ; => 2
b                              ; => 3
;;; 因为是轮旋交换变量，c 是最后个变量，所以应该取第一个变量的值
c                              ; => 1

(defvar var1 1)
(defvar var2 2)
(rotatef var1 var2)
var1                                    ; => 2
var2                                    ; => 1

(defvar a-list '(a 1 b 2 c 3))
(rotatef (nth 0 a-list) (nth 1 a-list)) ; => NIL
a-list                                  ; => (1 A B 2 C 3)

(set 'a 1)                              ; => 1
a                                       ; => 1

(string-capitalize "hello world")       ; => "Hello World"

(svref #(1 2 3 4 5 6) 3)                ; => 4

(defvar hi "hi")
(symbol-value 'hi)                      ; => "hi"

(time (sleep 10))
;; Evaluation took:
;;   10.0000 seconds of real time
;;   0.012742 seconds of total run time (0.009542 user, 0.003200 system)
;;   0.13% CPU
;;   28,934,402,420 processor cycles
;;   68,336 bytes consed

(truncate pi)
;; 输出：
;; 3
;; 0.14159265358979312d0
(truncate pi 3)
;; 输出：
;; 1
;; 0.14159265358979312d0

(defun fab (n)
  (cond ((equal 0 n) 0)
        ((equal 1 n) 1)
        (t (+ (fab (- n 1))
              (fab (- n 2))))))

(trace fab)

(fab 5)
;; 输出：
;;   0: (FAB 5)
;;     1: (FAB 4)
;;       2: (FAB 3)
;;         3: (FAB 2)
;;           4: (FAB 1)
;;           4: FAB returned 1
;;           4: (FAB 0)
;;           4: FAB returned 0
;;         3: FAB returned 1
;;         3: (FAB 1)
;;         3: FAB returned 1
;;       2: FAB returned 2
;;       2: (FAB 2)
;;         3: (FAB 1)
;;         3: FAB returned 1
;;         3: (FAB 0)
;;         3: FAB returned 0
;;       2: FAB returned 1
;;     1: FAB returned 3
;;     1: (FAB 3)
;;       2: (FAB 2)
;;         3: (FAB 1)
;;         3: FAB returned 1
;;         3: (FAB 0)
;;         3: FAB returned 0
;;       2: FAB returned 1
;;       2: (FAB 1)
;;       2: FAB returned 1
;;     1: FAB returned 2
;;   0: FAB returned 5
;; 5

(trace)                                 ; => (FAB)

(type-of 1) ; => BIT
(type-of 12345) ; => (INTEGER 0 4611686018427387903)
(type-of "abc") ; => (SIMPLE-ARRAY CHARACTER (3))
(type-of #\a) ; => nSTANDARD-CHAR
(type-of '(1 2 3)) ; => CONS

(defvar a 1)
a                              ; => 2
(unintern 'a)                  ; => T
a                              ; The variable A is unbound.

(defun hello ()
  (unwind-protect
       (error "hello")
    ;; 一定在最后会被执行
    (print "exit")))

(macroexpand '(with-open-file (f "/etc/passwd")))
;; 展开如下：
(LET ((F (OPEN "/etc/passwd")) (#:G930 T))
  (UNWIND-PROTECT (MULTIPLE-VALUE-PROG1 (PROGN) (SETQ #:G930 NIL))
    (WHEN F (CLOSE F :ABORT #:G930))))
T

(values 'value1 'value2)
;; 输出：
;; VALUE1
;; VALUE2

(vector 1 2 3)                          ; => #(1 2 3)
(vector 1 2 3 'a 'b 'c)                 ; => #(1 2 3 A B C)

;;; #(...) 语法和 vector 函数等同：
#(1 2 3)                                ; => #(1 2 3)

(let ((a '(1 2 3 4 5))
      ;; *print-length* 设置打印 list 时显示的元素数量
      (*print-length* 3))
  (print a) ; => (1 2 3 ...)
  (with-standard-io-syntax
    ;; 输出：(1 2 3 4 5)，在 with-standard-io-syntax 代码块中，*print-length* 将恢复成默认值
    (print a)))

(write-to-string '(1 2 3))     ; => "(1 2 3)"
;; 可以作为数字和字符串的转换
(write-to-string 123)          ; => "123"
(write-to-string (make-hash-table)) ; => "#<HASH-TABLE :TEST EQL :COUNT 0 {10035DC8B3}>"
(write-to-string #'and) ; => "#<CLOSURE (:MACRO AND) {1000BDFB8B}>"
(write-to-string #(1 2 3))     ; => "#(1 2 3)"

(zerop 0)                               ; => T
(zerop 1)                               ; => NIL