86/ &optional之后的参数都是选择性的，缺省为nil:

有的参数可以被忽略，并可以缺省设成特定的值。这样的参数称为选择性参数（optional parameters）。（相比之下，普通的参数有时称为必要参数「required parameters」) 如果符号&optional出现在一个函数的形参列表时。

1 > (defun philosoph (thing &optional property);;;缺省
  (list thing 'is property))
PHILOSOPH
1 > (philosoph 'death)
(DEATH IS NIL)
1 > (defun philosoph (thing &optional (property 'fun));;;参数fun
  (list thing 'is property))
PHILOSOPH
1 > (philosoph 'death)
(DEATH IS FUN)

87/ &key放在一个形参列表，那在&key之后的形参都是选择性的。

此外，当函数被调用时，这些参数会被识别出来，参数的位置在哪不重要，而是用符号标签（译注::）识别出来：

1 > (defun keylist (a &key x y z);;;函数名及形参
    (list a x y z));;按序排列
KEYLIST
1 > (keylist 1 :y 2);;;a为1，：之后为选择值，即y值为2
(1 NIL 2 NIL);;按函数定义好的序列排列数值，无值得默认为nil

1 > (keylist 1 :y 3 :x 2);;;a为1，：之后为选择值，即y值为3，x值为2
(1 2 3 NIL)
1 > (keylist 1 :Z 9 :y 3 :x 2 );;;a为1，：之后为选择值，即y值为3，x值为2，z为9
(1 2 3 9)

88/ single?，当实参是只有一个元素的列表时，返回真。自定义函数

1 > (defun single? (lst)
  (and (consp lst) (null (cdr lst))))
SINGLE?
1 > (single? '(a))
T
1 > (single? '(a b))
NIL

89/ append1和cons很像，但在列表后面新增一个元素，而不是在前面:

1 > (defun append1 (lst obj)
  (append lst (list obj)))
APPEND1
1 > (append1 '(a b c) 'd);;在列表后面新增一个元素，末位实参不为列表
(A B C D)
1 > (cons 'd '(a b c) );;在列表前面新增一个元素，末位实参必须为列表
(D A B C)

其他

1 > (append1 '(a b c) '(d 7));;末位若为列表，则整体作为一个实参并入新列表
(A B C (D 7))
1 > (cons '(a b c) 'd );末位若为一个元素，则与前列表构成一个数组
((A B C) . D)

90/ map-int，接受一个函数与整数n，并返回将函数应用至整数0到n-1的结果的列表。

1 > (defun map-int (fn n)
  (let ((acc nil))
    (dotimes (i n)
      (push (funcall fn i) acc))
    (nreverse acc)))
MAP-INT
1 > (map-int #'identity 10);;接受一个函数与一个整数，结果返回整数以下从0到n-1的列表
(0 1 2 3 4 5 6 7 8 9)
1 > (map-int #'identity 6)
(0 1 2 3 4 5)

1 > (map-int #'(lambda (x) (random 100))
           10)
(51 45 90 49 72 40 26 38 72 23);;产生10个随机数

91/ RANDOM产生随机数，从0～n-1中

1 > (random 100)
77;;;随机数
1 > (random 100)
72;;随机数
1 > (random 100)
17;;随机数

92/ filter接受一个函数与一个列表，将函数应用至列表元素上时，返回所有非nil元素

4 > (defun filter (fn lst)
  (let ((acc nil))
    (dolist (x lst)
      (let ((val (funcall fn x)))
        (if val (push val acc))))
    (nreverse acc)))
FILTER
4 > (filter #'(lambda (x)
              (and (evenp x) (+ x 10)));;;函数，作用是偶数，+10，并存储
          '(1 2 3 4 5 6 7));;;从此列表中选出偶数
(12 14 16)

93/ most，根据某个评分函数（scoring function），返回列表中最高分的元素。它返回两个值，获胜的元素以及它的分数:

4 > (defun most (fn lst)
  (if (null lst)
      (values nil nil)
      (let* ((wins (car lst))
             (max (funcall fn wins)))
        (dolist (obj (cdr lst))
          (let ((score (funcall fn obj)))
            (when (> score max)
              (setf wins obj
                    max  score))))
        (values wins max))))
MOST
4 > (most #'length '((a b) (a b c r y 6 7) (a)));;返回最长的列表和其元素个数
(A B C R Y 6 7)
7