2024-08-26 |欢迎您，第位读者！|

006 好奇先生在Lisp的花园里挖呀挖呀挖

好奇先生Lisp探索工具`explore-lisp`

好奇先生学会了懒惰先生交给他的Package开发和管理流程，quickproject管理package。好奇先生一步一步定义了一个叫做explore-lisp的package，这个包提供了探索Lisp的工具，并且提供了把探索结果输出成markdown文档的方法。

这个工程的地址在explore-lisp。当把这个源代码下载（clone）到本地之后，可以通过quicklisp的quickload函数加载这个包。

在安装之前，记得要把文件克隆到quicklisp的本地目录下，比如~/quicklisp/local-projects。

或者还有一个办法，克隆到任何地方，除了利用修改变量asdf:*central-registry*方式，还可以直接在quicklisp的local-projects目录下建立一个软链接，指向这个包的目录。

1mklink /D ~/quicklisp/local-projects/explore-lisp  /path/to/explore-lisp

然后在REPL中加载这个包：

1(ql:quickload :explore-lisp)

这之后，就可以用这个包的功能了。

1* (el:dir 'el)
2(EXPLORE-LISP:FORMAT-DESCRIPTIONS EXPLORE-LISP:DESCRIBE-SYMBOL EXPLORE-LISP:DIR
3                                  EXPLORE-LISP:EXPORT-ALL-EXTERNAL-SYMBOLS
4                                  EXPLORE-LISP:EXPORT-DESCRIPTIONS)
55

这个包本身的dir功能就能够列出这个包的所有函数和变量。还可以用

 1(el:describe-symbol 'el:dir)
 2"EXPLORE-LISP:DIR
 3  [symbol]
 4
 5DIR names a compiled function:
 6  Lambda-list: (PACKAGE)
 7  Derived type: (FUNCTION (T) (VALUES LIST UNSIGNED-BYTE &OPTIONAL))
 8  Documentation:
 9    List all external symbols in a package, return a list of symbol names and its length
10  Source file: C:/Users/qchen/quicklisp/local-projects/explore-lisp/explore-lisp.lisp
11"

可以看到这个符号的文档有几个基本的部分：

函数的全名（包括包的名字作为前缀）
符号的类型（这里是一个symbol）
下面就是函数的定义，包括参数列表和返回值的类型
文档字符串，这个字符串描述了这个函数的功能
函数的源代码文件

好奇先生运行了(el:export-all-external-symbols 'el :fn "docs.md" :start-level 2)，这个函数的功能是把el包的所有外部符号都导出来，哇啦，一个文件docs.md就生成了，里面包含了这个包的所有外部符号的文档。

挖一下`explore-lisp`

下面的文档主体部分，都是通过好奇先生的探索工具集生成的。真的是太好玩，好奇先生可以玩一整天。

DESCRIBE-SYMBOL
DIR
EXPORT-ALL-EXTERNAL-SYMBOLS
EXPORT-DESCRIPTIONS
FORMAT-DESCRIPTIONS
SEARCH-SYMBOLS

`DESCRIBE-SYMBOL`

这个函数可以把一个符号的文档描述输出成一个字符串。可以看到这个函数的签名，以及参数列表，返回值的类型，文档描述，函数的源代码文件位置。

1EXPLORE-LISP:DESCRIBE-SYMBOL
2  [symbol]
3
4DESCRIBE-SYMBOL names a compiled function:
5  Lambda-list: (NAME)
6  Derived type: (FUNCTION (T) (VALUES SIMPLE-STRING &OPTIONAL))
7  Documentation:
8    Describe a symbol and return the output as a string
9  Source file: C:/Users/qchen/quicklisp/local-projects/explore-lisp/explore-lisp.lisp

`DIR`

这个函数列出一个包的所有外部符号，返回一个符号名字的列表和列表的长度。

1EXPLORE-LISP:DIR
2  [symbol]
3
4DIR names a compiled function:
5  Lambda-list: (PACKAGE)
6  Derived type: (FUNCTION (T) (VALUES LIST UNSIGNED-BYTE &OPTIONAL))
7  Documentation:
8    List all external symbols in a package, return a list of symbol names and its length
9  Source file: C:/Users/qchen/quicklisp/local-projects/explore-lisp/explore-lisp.lisp

`EXPORT-ALL-EXTERNAL-SYMBOLS`

这个函数把一个包的所有外部文件列出在一个文件中，可以通过关键词来设定文件名称和最开始文档在markdown中的标题级别。

这里最有趣的是这个，这个函数的源程序直接被列在这里？为什么？为什么其他的函数没有呢？只是给出了函数对应文件的位置。这就是Lisp最为独特的地方，Lisp的运行环境（REPL）中的符号都是动态的，可以被修改，可以被重新定义，可以被删除。这个函数的源代码就是这样被列在这里的。

这里有一个Lisp的核心概念，一个运行的环境中所有的符号、绑定都可以很容易的存成一个文件，然后在另一个环境中重新加载，这就是Lisp的强大之处。

所以很多资深Lisp程序员都说，Lisp程序是一个不停进化的活的程序，运行时修改功能，增加功能，删除功能，都是很容易的事情。

 1EXPLORE-LISP:EXPORT-ALL-EXTERNAL-SYMBOLS
 2  [symbol]
 3
 4EXPORT-ALL-EXTERNAL-SYMBOLS names a compiled function:
 5  Lambda-list: (PACKAGE &KEY (FN  FN-P) (START-LEVEL 1))
 6  Derived type: (FUNCTION (T &KEY (:FN T) (:START-LEVEL T))
 7                 (VALUES NULL &OPTIONAL))
 8  Documentation:
 9    List all external symbols in a package and their doc strings into a file ~package~.md
10  Source form:
11    (LAMBDA
12        (PACKAGE
13         &KEY (EXPLORE-LISP::FN "" EXPLORE-LISP::FN-P)
14         (EXPLORE-LISP::START-LEVEL 1))
15      "List all external symbols in a package and their doc strings into a file ~package~.md"
16      (BLOCK EXPLORE-LISP:EXPORT-ALL-EXTERNAL-SYMBOLS
17        (LET ((EXPLORE-LISP::SORTED-NAMES
18               (EXPLORE-LISP::SORT-SYMBOLS (EXPLORE-LISP:DIR PACKAGE)))
19              (EXPLORE-LISP::_FN
20               (IF EXPLORE-LISP::FN-P
21                   EXPLORE-LISP::FN
22                   (FORMAT NIL "~a.md" PACKAGE))))
23          (WITH-OPEN-STREAM
24              (EXPLORE-LISP::S
25               (OPEN EXPLORE-LISP::_FN :DIRECTION :OUTPUT :IF-EXISTS
26                     :SUPERSEDE))
27            (FORMAT EXPLORE-LISP::S "~A ~A external symbols~%~%~%"
28                    (EXPLORE-LISP::MARKDOWN-NTH-HEADER
29                     EXPLORE-LISP::START-LEVEL)
30                    PACKAGE)
31            (LET ((EXPLORE-LISP::INDEX 1))
32              (DOLIST (EXPLORE-LISP::NAME EXPLORE-LISP::SORTED-NAMES)
33                (FORMAT EXPLORE-LISP::S "~d. [~A](#~A)~%"
34                        EXPLORE-LISP::INDEX EXPLORE-LISP::NAME
35                        EXPLORE-LISP::NAME)
36                (INCF EXPLORE-LISP::INDEX)))
37            (FORMAT EXPLORE-LISP::S "~%~%")
38            (DOLIST (EXPLORE-LISP::NAME EXPLORE-LISP::SORTED-NAMES)
39              (FORMAT EXPLORE-LISP::S "~A  `~A`~%~%"
40                      (EXPLORE-LISP::MARKDOWN-NTH-HEADER
41                       (+ 1 EXPLORE-LISP::START-LEVEL))
42                      EXPLORE-LISP::NAME)
43              (FORMAT EXPLORE-LISP::S "```lisp~%")
44              (DESCRIBE EXPLORE-LISP::NAME EXPLORE-LISP::S)
45              (FORMAT EXPLORE-LISP::S "```~%"))))))

`EXPORT-DESCRIPTIONS`

将一个名称列表的描述导出到一个文件中，可以通过关键词来设定文件名称和最开始文档在markdown中的标题级别。

1EXPLORE-LISP:EXPORT-DESCRIPTIONS
2  [symbol]
3
4EXPORT-DESCRIPTIONS names a compiled function:
5  Lambda-list: (NAME-LIST FN &OPTIONAL (START-LEVEL 1))
6  Derived type: (FUNCTION (T T &OPTIONAL T) (VALUES NULL &OPTIONAL))
7  Documentation:
8    Save a list of symbol names to a file
9  Source file: C:/Users/qchen/quicklisp/local-projects/explore-lisp/explore-lisp.lisp

`FORMAT-DESCRIPTIONS`

将一个名称列表的描述格式化成markdown文档，可以通过关键词来设定文件名称和最开始文档在markdown中的标题级别。

 1EXPLORE-LISP:FORMAT-DESCRIPTIONS
 2  [symbol]
 3
 4FORMAT-DESCRIPTIONS names a compiled function:
 5  Lambda-list: (NAME-LIST &OPTIONAL (START-LEVEL 1))
 6  Derived type: (FUNCTION (T &OPTIONAL T)
 7                 (VALUES SIMPLE-STRING &OPTIONAL))
 8  Documentation:
 9    Format a list of symbol names as markdown, with optional start level for headers
10  Source file: C:/Users/qchen/quicklisp/local-projects/explore-lisp/explore-lisp.lisp

`SEARCH-SYMBOLS`

这个函数可以搜索一个包中的所有符号，包括符号的名字和文档字符串。文档字符串内的搜索是可选的。所有的搜索和字符串比较都是不区分大小写的。

 1EXPLORE-LISP:SEARCH-SYMBOLS
 2  [symbol]
 3
 4SEARCH-SYMBOLS names a compiled function:
 5  Lambda-list: (NAME PACKAGE &KEY (DOC-STRING NIL))
 6  Derived type: (FUNCTION (T T &KEY (:DOC-STRING T))
 7                 (VALUES LIST &OPTIONAL))
 8  Documentation:
 9    Search for string in symbol names and doc strings in a package
10  Source file: C:/Users/qchen/quicklisp/local-projects/explore-lisp/explore-lisp.lisp

挖一下`string`

好奇先生探索工具非常简单，每个函数功能都很单一。并且，在(ql:quickload 'explore-lisp)之后，如果对功能不满意或者发现运行不符合预期，

可以在源代码所在位置（describe一下任意一个函数就知道）修改，然后重新加载，(require 'explore-lisp)。
直接在VSCode中打开一个任意新文件，(in-package :explore-lisp)，编写函数新定义，然后运行一下，也能达到效果。

这就是Lisp的动态开发理念，与传统的“编译-运行-调试”不同，Lisp把当前REPL中的所有符号都当作一个整体，可以随时修改，随时调试，随时运行。并且，Lisp的函数绑定都是动态的，这就鼓励各种运行时修改的开发模式。

另外，好奇先生觉得最后这个函数实在是太好玩了……他太好奇了。

好奇先生应该睡觉，但是他就是忍不住，又在REPL中敲一个命令：

1(el:search-symbols "string" :common-lisp)

好奇先生还没来得及按下回车，挠痒痒先生的手从很远的地方伸过来，挠了一下好奇先生的咯吱窝，然后还按了一下键盘，好奇先生的命令就被执行了。

啊，Lisp的REPL关于字符串的函数全部跑出来了~~~一共有46个！

 1(BASE-STRING DIRECTORY-NAMESTRING ENOUGH-NAMESTRING FILE-NAMESTRING
 2 FILE-STRING-LENGTH GET-OUTPUT-STREAM-STRING HOST-NAMESTRING MAKE-STRING
 3 MAKE-STRING-INPUT-STREAM MAKE-STRING-OUTPUT-STREAM NAMESTRING
 4 NSTRING-CAPITALIZE NSTRING-DOWNCASE NSTRING-UPCASE PARSE-NAMESTRING
 5 PRIN1-TO-STRING PRINC-TO-STRING READ-FROM-STRING SIMPLE-BASE-STRING
 6 SIMPLE-STRING SIMPLE-STRING-P STRING STRING-CAPITALIZE STRING-DOWNCASE
 7 STRING-EQUAL STRING-GREATERP STRING-LEFT-TRIM STRING-LESSP STRING-NOT-EQUAL
 8 STRING-NOT-GREATERP STRING-NOT-LESSP STRING-RIGHT-TRIM STRING-STREAM
 9 STRING-TRIM STRING-UPCASE STRING/= STRING< STRING<= STRING= STRING> STRING>=
10 STRINGP WITH-INPUT-FROM-STRING WITH-OUTPUT-TO-STRING WRITE-STRING
11 WRITE-TO-STRING)

来，对子一个base-string继续哇呀挖：

 1(el:describe-symbol 'base-string)
 2COMMON-LISP:BASE-STRING
 3  [symbol]
 4
 5BASE-STRING names the built-in-class #<BUILT-IN-CLASS COMMON-LISP:BASE-STRING>:
 6  Class precedence-list: BASE-STRING, STRING, VECTOR, ARRAY, SEQUENCE, T
 7  Direct superclasses: STRING
 8  Direct subclasses: SIMPLE-BASE-STRING
 9  Sealed.
10  No direct slots.
11
12BASE-STRING names a primitive type-specifier:
13  Lambda-list: (&OPTIONAL SIZE)
14

好奇先生的好奇心彻底爆炸，这里居然有很不一样的东西，base-string是一个内置的类，继承自string，并且有一个直接的子类simple-base-string。它的祖先依次是string、vector、array、sequence、t。这又是什么意思？而且这里的sequence是什么？

所有的类都是t这很好理解，因为除了nil，其他所有东西都是t，在面向对象的编程中，is也就是是的关系就是继承关系。那么sequence是什么呢？

好奇先生把这里的Class precedence-list, Direct superclasses, Direct subclasses都挖了出来，然后一路挖下去……

挖到了`sequence`

最后，好奇先生挖出来一个下面这样的继承关系图：

classDiagram
    T <|-- SYMBOL
    T <|-- SEQUENCE
    T <|-- ARRAY
    SIMPLE-ARRAY <|-- SIMPLE-VECTOR
    SEQUENCE <|-- LIST
    SEQUENCE <|-- VECTOR
    ARRAY <|-- VECTOR
    VECTOR <|-- STRING
    VECTOR <|-- SIMPLE-VECTOR
    STRING <|-- BASE-STRING
    STRING <|-- SIMPLE-STRING
    SIMPLE-ARRAY <|-- SIMPLE-STRING
    ARRAY <|-- SIMPLE-ARRAY
    SYMBOL <|-- NULL
    LIST <|-- NULL
    LIST <|-- CONS
    SIMPLE-ARRAY <|-- SIMPLE-BIT-VECTOR
    BASE-STRING <|-- SIMPLE-BASE-STRING
    SIMPLE-STRING <|-- SIMPLE-BASE-STRING

啊哈，好奇先生觉得好玩极了！从这个图里可以看到，sequence是一个很重要的类，它是list和vector的祖先，所有的跟字符串相关的类都是sequence的子类。

那么还能怎么挖呢？当然是看看哪些操作（函数）直接定义在sequence上了。

 1(sort (el:search-symbols "sequence" :common-lisp :doc-string t) #'string-lessp)
 2(* *FEATURES* BASE-STRING BIT-VECTOR CONCATENATE CONS COPY-SEQ COUNT COUNT-IF
 3   COUNT-IF-NOT DELETE DELETE-DUPLICATES DELETE-IF DELETE-IF-NOT ELT EVERY FILL
 4   FIND FIND-IF FIND-IF-NOT LENGTH LIST MAKE-SEQUENCE MAP MAP-INTO MAPHASH
 5   MERGE MISMATCH NOTANY NOTEVERY NREVERSE NSUBSTITUTE NSUBSTITUTE-IF
 6   NSUBSTITUTE-IF-NOT NULL POSITION POSITION-IF POSITION-IF-NOT PROGRAM-ERROR
 7   READ-SEQUENCE REDUCE REMOVE REMOVE-DUPLICATES REMOVE-IF REMOVE-IF-NOT
 8   REPLACE REVERSE SEARCH SEQUENCE SIMPLE-BASE-STRING SIMPLE-BIT-VECTOR
 9   SIMPLE-CONDITION SIMPLE-STRING SIMPLE-VECTOR SOME SORT STABLE-SORT STRING
10   STRING-LEFT-TRIM STRING-RIGHT-TRIM STRING-TRIM SUBSEQ SUBSTITUTE
11   SUBSTITUTE-IF SUBSTITUTE-IF-NOT T THE TYPE-ERROR VECTOR
12   WITH-HASH-TABLE-ITERATOR WRITE-SEQUENCE)

真是完美，好奇先生的好奇心又双叒叕被点燃了。这里有很多操作，比如concatenate、copy-seq、count、count-if、count-if-not、delete、delete-duplicates、delete-if、delete-if-not、elt、every、fill、find、find-if、find-if-not、length、list、make-sequence、map、map-into、maphash、merge、mismatch、notany、notevery、nreverse、nsubstitute、nsubstitute-if、nsubstitute-if-not、null、position、position-if、position-if-not、read-sequence、reduce、remove、remove-duplicates、remove-if、remove-if-not、replace、reverse、search、sequence、sort、stable-sort、string、string-left-trim、string-right-trim、string-trim、subseq、substitute、substitute-if、substitute-if-not、the、type-error、vector、with-hash-table-iterator、write-sequence。

好奇先生是没法睡觉了……

附录A: Sequence相关的函数

挠痒痒先生的手很长很长，不停地伸过来挠好奇先生的咯吱窝，然后又不停地按键盘，好奇先生只好带了无穷无尽的好奇心去睡觉了，只留下了下面这些函数的文档。

`CONCATENATE`

 1COMMON-LISP:CONCATENATE
 2  [symbol]
 3
 4CONCATENATE names a compiled function:
 5  Lambda-list: (RESULT-TYPE &REST SEQUENCES)
 6  Declared type: (FUNCTION
 7                  ((OR CONS SYMBOL SB-KERNEL:CLASSOID CLASS) &REST
 8                   SEQUENCE)
 9                  (VALUES
10                   (OR LIST (SIMPLE-ARRAY * (*))
11                       SB-KERNEL:EXTENDED-SEQUENCE)
12                   &OPTIONAL))
13  Derived type: (FUNCTION (T &REST T)
14                 (VALUES
15                  (OR LIST (SIMPLE-ARRAY * (*))
16                      SB-KERNEL:EXTENDED-SEQUENCE)
17                  &OPTIONAL))
18  Documentation:
19    Return a new sequence of all the argument sequences concatenated together
20      which shares no structure with the original argument sequences of the
21      specified RESULT-TYPE.
22  Source file: SYS:SRC;CODE;SEQ.LISP

`COPY-SEQ`

 1COMMON-LISP:COPY-SEQ
 2  [symbol]
 3
 4COPY-SEQ names a compiled function:
 5  Lambda-list: (SEQUENCE)
 6  Declared type: (FUNCTION (SEQUENCE)
 7                  (VALUES
 8                   (OR LIST (SIMPLE-ARRAY * (*))
 9                       SB-KERNEL:EXTENDED-SEQUENCE)
10                   &OPTIONAL))
11  Derived type: (FUNCTION (T) *)
12  Documentation:
13    Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.
14  Known attributes: flushable, unsafely-flushable
15  Source file: SYS:SRC;CODE;SEQ.LISP

`COUNT`

 1COMMON-LISP:COUNT
 2  [symbol]
 3
 4COUNT names a compiled function:
 5  Lambda-list: (ITEM SEQUENCE &REST ARGS &KEY FROM-END (START 0)
 6                (END NIL) (KEY NIL) (TEST (FUNCTION EQL) TEST-P)
 7                (TEST-NOT NIL TEST-NOT-P))
 8  Dynamic-extent arguments: keyword=(:KEY :TEST :TEST-NOT)
 9  Declared type: (FUNCTION
10                  (T SEQUENCE &REST T &KEY (:TEST (OR FUNCTION SYMBOL))
11                   (:TEST-NOT (OR FUNCTION SYMBOL))
12                   (:START (UNSIGNED-BYTE 45))
13                   (:END (OR NULL (UNSIGNED-BYTE 45))) (:FROM-END T)
14                   (:KEY (OR FUNCTION SYMBOL)))
15                  (VALUES (UNSIGNED-BYTE 45) &OPTIONAL))
16  Derived type: (FUNCTION
17                 (T T &REST T &KEY (:TEST . #1=((OR FUNCTION SYMBOL)))
18                  (:TEST-NOT . #1#)
19                  (:START . #2=(#3=(UNSIGNED-BYTE 45)))
20                  (:END (OR NULL . #2#)) (:FROM-END T) (:KEY . #1#))
21                 (VALUES #3# &OPTIONAL))
22  Documentation:
23    Return the number of elements in SEQUENCE satisfying a test with ITEM,
24       which defaults to EQL.
25  Known attributes: call, foldable, flushable, unsafely-flushable
26  Source file: SYS:SRC;CODE;SEQ.LISP

`COUNT-IF`

 1COMMON-LISP:COUNT-IF
 2  [symbol]
 3
 4COUNT-IF names a compiled function:
 5  Lambda-list: (PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0)
 6                (END NIL) (KEY NIL))
 7  Dynamic-extent arguments: positional=(0), keyword=(:KEY)
 8  Declared type: (FUNCTION
 9                  ((OR FUNCTION SYMBOL) SEQUENCE &REST T &KEY
10                   (:FROM-END T) (:START (UNSIGNED-BYTE 45))
11                   (:END (OR NULL (UNSIGNED-BYTE 45)))
12                   (:KEY (OR FUNCTION SYMBOL)))
13                  (VALUES (UNSIGNED-BYTE 45) &OPTIONAL))
14  Derived type: (FUNCTION
15                 (#1=(OR FUNCTION SYMBOL) T &REST T &KEY (:FROM-END T)
16                  (:START . #2=(#3=(UNSIGNED-BYTE 45)))
17                  (:END (OR NULL . #2#)) (:KEY #1#))
18                 (VALUES #3# &OPTIONAL))
19  Documentation:
20    Return the number of elements in SEQUENCE satisfying PRED(el).
21  Known attributes: call, foldable, flushable, unsafely-flushable
22  Source file: SYS:SRC;CODE;SEQ.LISP

`COUNT-IF-NOT`

 1COMMON-LISP:COUNT-IF-NOT
 2  [symbol]
 3
 4COUNT-IF-NOT names a compiled function:
 5  Lambda-list: (PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0)
 6                (END NIL) (KEY NIL))
 7  Dynamic-extent arguments: positional=(0), keyword=(:KEY)
 8  Declared type: (FUNCTION
 9                  ((OR FUNCTION SYMBOL) SEQUENCE &REST T &KEY
10                   (:FROM-END T) (:START (UNSIGNED-BYTE 45))
11                   (:END (OR NULL (UNSIGNED-BYTE 45)))
12                   (:KEY (OR FUNCTION SYMBOL)))
13                  (VALUES (UNSIGNED-BYTE 45) &OPTIONAL))
14  Derived type: (FUNCTION
15                 (#1=(OR FUNCTION SYMBOL) T &REST T &KEY (:FROM-END T)
16                  (:START . #2=(#3=(UNSIGNED-BYTE 45)))
17                  (:END (OR NULL . #2#)) (:KEY #1#))
18                 (VALUES #3# &OPTIONAL))
19  Documentation:
20    Return the number of elements in SEQUENCE not satisfying TEST(el).
21  Known attributes: call, foldable, flushable, unsafely-flushable
22  Source file: SYS:SRC;CODE;SEQ.LISP

`DELETE`

 1COMMON-LISP:DELETE
 2  [symbol]
 3
 4DELETE names a compiled function:
 5  Lambda-list: (ITEM SEQUENCE &REST ARGS &KEY FROM-END
 6                (TEST (FUNCTION EQL)) (TEST-NOT NIL) (START 0)
 7                (END NIL) (COUNT NIL) (KEY NIL))
 8  Dynamic-extent arguments: keyword=(:TEST :TEST-NOT :KEY)
 9  Declared type: (FUNCTION
10                  (T SEQUENCE &REST T &KEY (:FROM-END T)
11                   (:TEST (OR FUNCTION SYMBOL))
12                   (:TEST-NOT (OR FUNCTION SYMBOL))
13                   (:START (UNSIGNED-BYTE 45))
14                   (:END (OR NULL (UNSIGNED-BYTE 45)))
15                   (:COUNT (OR NULL INTEGER))
16                   (:KEY (OR FUNCTION SYMBOL)))
17                  (VALUES SEQUENCE &OPTIONAL))
18  Derived type: (FUNCTION
19                 (T T &REST T &KEY (:FROM-END T)
20                  (:TEST . #1=((OR FUNCTION SYMBOL))) (:TEST-NOT . #1#)
21                  (:START . #2=((UNSIGNED-BYTE 45)))
22                  (:END (OR NULL . #2#)) (:COUNT (OR NULL INTEGER))
23                  (:KEY . #1#))
24                 (VALUES T &OPTIONAL))
25  Documentation:
26    Return a sequence formed by destructively removing the specified ITEM from
27      the given SEQUENCE.
28  Known attributes: call, important-result
29  Source file: SYS:SRC;CODE;SEQ.LISP

`DELETE-DUPLICATES`

 1COMMON-LISP:DELETE-DUPLICATES
 2  [symbol]
 3
 4DELETE-DUPLICATES names a compiled function:
 5  Lambda-list: (SEQUENCE &REST ARGS &KEY (TEST (FUNCTION EQL))
 6                (TEST-NOT NIL) (START 0) (END NIL) FROM-END (KEY NIL))
 7  Dynamic-extent arguments: keyword=(:TEST :TEST-NOT :KEY)
 8  Declared type: (FUNCTION
 9                  (SEQUENCE &REST T &KEY (:TEST (OR FUNCTION SYMBOL))
10                   (:TEST-NOT (OR FUNCTION SYMBOL))
11                   (:START (UNSIGNED-BYTE 45))
12                   (:END (OR NULL (UNSIGNED-BYTE 45))) (:FROM-END T)
13                   (:KEY (OR FUNCTION SYMBOL)))
14                  (VALUES SEQUENCE &OPTIONAL))
15  Derived type: (FUNCTION
16                 (T &REST T &KEY (:TEST . #1=((OR FUNCTION SYMBOL)))
17                  (:TEST-NOT . #1#) (:START . #2=((UNSIGNED-BYTE 45)))
18                  (:END (OR NULL . #2#)) (:FROM-END T) (:KEY . #1#))
19                 (VALUES T &OPTIONAL))
20  Documentation:
21    The elements of SEQUENCE are examined, and if any two match, one is
22       discarded. The resulting sequence, which may be formed by destroying the
23       given sequence, is returned.
24    
25       The :TEST-NOT argument is deprecated.
26  Known attributes: call, important-result
27  Source file: SYS:SRC;CODE;SEQ.LISP

`DELETE-IF`

 1COMMON-LISP:DELETE-IF
 2  [symbol]
 3
 4DELETE-IF names a compiled function:
 5  Lambda-list: (PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0)
 6                (KEY NIL) (END NIL) (COUNT NIL))
 7  Dynamic-extent arguments: positional=(0), keyword=(:KEY)
 8  Declared type: (FUNCTION
 9                  ((OR FUNCTION SYMBOL) SEQUENCE &REST T &KEY
10                   (:FROM-END T) (:COUNT (OR NULL INTEGER))
11                   (:START (UNSIGNED-BYTE 45))
12                   (:END (OR NULL (UNSIGNED-BYTE 45)))
13                   (:KEY (OR FUNCTION SYMBOL)))
14                  (VALUES SEQUENCE &OPTIONAL))
15  Derived type: (FUNCTION
16                 (#1=(OR FUNCTION SYMBOL) T &REST T &KEY (:FROM-END T)
17                  (:COUNT (OR NULL INTEGER))
18                  (:START . #2=((UNSIGNED-BYTE 45)))
19                  (:END (OR NULL . #2#)) (:KEY #1#))
20                 (VALUES T &OPTIONAL))
21  Documentation:
22    Return a sequence formed by destructively removing the elements satisfying
23      the specified PREDICATE from the given SEQUENCE.
24  Known attributes: call, important-result
25  Source file: SYS:SRC;CODE;SEQ.LISP

`DELETE-IF-NOT`

 1COMMON-LISP:DELETE-IF-NOT
 2  [symbol]
 3
 4DELETE-IF-NOT names a compiled function:
 5  Lambda-list: (PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0)
 6                (END NIL) (KEY NIL) (COUNT NIL))
 7  Dynamic-extent arguments: positional=(0), keyword=(:KEY)
 8  Declared type: (FUNCTION
 9                  ((OR FUNCTION SYMBOL) SEQUENCE &REST T &KEY
10                   (:FROM-END T) (:COUNT (OR NULL INTEGER))
11                   (:START (UNSIGNED-BYTE 45))
12                   (:END (OR NULL (UNSIGNED-BYTE 45)))
13                   (:KEY (OR FUNCTION SYMBOL)))
14                  (VALUES SEQUENCE &OPTIONAL))
15  Derived type: (FUNCTION
16                 (#1=(OR FUNCTION SYMBOL) T &REST T &KEY (:FROM-END T)
17                  (:COUNT (OR NULL INTEGER))
18                  (:START . #2=((UNSIGNED-BYTE 45)))
19                  (:END (OR NULL . #2#)) (:KEY #1#))
20                 (VALUES T &OPTIONAL))
21  Documentation:
22    Return a sequence formed by destructively removing the elements not
23      satisfying the specified PREDICATE from the given SEQUENCE.
24  Known attributes: call, important-result
25  Source file: SYS:SRC;CODE;SEQ.LISP

`ELT`

 1COMMON-LISP:ELT
 2  [symbol]
 3
 4ELT names a compiled function:
 5  Lambda-list: (SEQUENCE INDEX)
 6  Declared type: (FUNCTION (SEQUENCE (UNSIGNED-BYTE 45))
 7                  (VALUES T &OPTIONAL))
 8  Derived type: (FUNCTION (T (UNSIGNED-BYTE 45)) (VALUES T &OPTIONAL))
 9  Documentation:
10    Return the element of SEQUENCE specified by INDEX.
11  Known attributes: foldable, unsafely-flushable
12  Source file: SYS:SRC;CODE;SEQ.LISP
13
14(SETF ELT) names a compiled function:
15  Lambda-list: (NEWVAL SEQUENCE INDEX)
16  Derived type: (FUNCTION (T SEQUENCE (UNSIGNED-BYTE 45))
17                 (VALUES T &OPTIONAL))
18  Inline proclamation: INLINE (inline expansion available)
19  Source file: SYS:SRC;CODE;SETF-FUNS.LISP
20
21(SETF ELT) has setf-expansion: SB-KERNEL:%SETELT

`EVERY`

 1COMMON-LISP:EVERY
 2  [symbol]
 3
 4EVERY names a compiled function:
 5  Lambda-list: (PRED FIRST-SEQ &REST MORE-SEQS)
 6  Dynamic-extent arguments: positional=(0)
 7  Declared type: (FUNCTION
 8                  ((OR FUNCTION SYMBOL) SEQUENCE &REST SEQUENCE)
 9                  (VALUES BOOLEAN &OPTIONAL))
10  Derived type: (FUNCTION ((OR FUNCTION SYMBOL) SEQUENCE &REST T)
11                 (VALUES BOOLEAN &OPTIONAL))
12  Documentation:
13    Apply PREDICATE to the 0-indexed elements of the sequences, then
14       possibly to those with index 1, and so on. Return NIL as soon
15       as any invocation of PREDICATE returns NIL, or T if every invocation
16       is non-NIL.
17  Known attributes: call, foldable, unsafely-flushable
18  Source file: SYS:SRC;CODE;QUANTIFIERS.LISP

`FILL`

 1COMMON-LISP:FILL
 2  [symbol]
 3
 4FILL names a compiled function:
 5  Lambda-list: (SEQUENCE ITEM &KEY (START 0) END)
 6  Declared type: (FUNCTION
 7                  (SEQUENCE T &REST T &KEY (:START (UNSIGNED-BYTE 45))
 8                   (:END (OR NULL (UNSIGNED-BYTE 45))))
 9                  (VALUES SEQUENCE &OPTIONAL))
10  Derived type: (FUNCTION
11                 (T T &KEY (:START . #1=((UNSIGNED-BYTE 45)))
12                  (:END (OR NULL . #1#)))
13                 (VALUES SEQUENCE &OPTIONAL))
14  Documentation:
15    Replace the specified elements of SEQUENCE with ITEM.
16  Source file: SYS:SRC;CODE;SEQ.LISP

`FIND`

 1COMMON-LISP:FIND
 2  [symbol]
 3
 4FIND names a compiled function:
 5  Lambda-list: (ITEM SEQUENCE &REST ARGS &KEY FROM-END (START 0) END
 6                KEY TEST TEST-NOT)
 7  Dynamic-extent arguments: keyword=(:KEY :TEST :TEST-NOT)
 8  Declared type: (FUNCTION
 9                  (T SEQUENCE &REST T &KEY (:TEST (OR FUNCTION SYMBOL))
10                   (:TEST-NOT (OR FUNCTION SYMBOL))
11                   (:START (UNSIGNED-BYTE 45))
12                   (:END (OR NULL (UNSIGNED-BYTE 45))) (:FROM-END T)
13                   (:KEY (OR FUNCTION SYMBOL)))
14                  (VALUES T &OPTIONAL))
15  Derived type: (FUNCTION
16                 (T T &REST T &KEY (:TEST . #1=((OR FUNCTION SYMBOL)))
17                  (:TEST-NOT . #1#) (:START . #2=((UNSIGNED-BYTE 45)))
18                  (:END (OR NULL . #2#)) (:FROM-END T) (:KEY . #1#))
19                 (VALUES T &OPTIONAL))
20  Known attributes: call, foldable, flushable, unsafely-flushable
21  Source file: SYS:SRC;CODE;SEQ.LISP

`FIND-IF`

 1COMMON-LISP:FIND-IF
 2  [symbol]
 3
 4FIND-IF names a compiled function:
 5  Lambda-list: (PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0)
 6                END KEY)
 7  Dynamic-extent arguments: positional=(0), keyword=(:KEY)
 8  Declared type: (FUNCTION
 9                  ((OR FUNCTION SYMBOL) SEQUENCE &REST T &KEY
10                   (:FROM-END T) (:START (UNSIGNED-BYTE 45))
11                   (:END (OR NULL (UNSIGNED-BYTE 45)))
12                   (:KEY (OR FUNCTION SYMBOL)))
13                  (VALUES T &OPTIONAL))
14  Derived type: (FUNCTION
15                 (#1=(OR FUNCTION SYMBOL) T &REST T &KEY (:FROM-END T)
16                  (:START . #2=((UNSIGNED-BYTE 45)))
17                  (:END (OR NULL . #2#)) (:KEY #1#))
18                 (VALUES T &OPTIONAL))
19  Known attributes: call, foldable, flushable, unsafely-flushable
20  Source file: SYS:SRC;CODE;SEQ.LISP

`FIND-IF-NOT`

 1COMMON-LISP:FIND-IF-NOT
 2  [symbol]
 3
 4FIND-IF-NOT names a compiled function:
 5  Lambda-list: (PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0)
 6                END KEY)
 7  Dynamic-extent arguments: positional=(0), keyword=(:KEY)
 8  Declared type: (FUNCTION
 9                  ((OR FUNCTION SYMBOL) SEQUENCE &REST T &KEY
10                   (:FROM-END T) (:START (UNSIGNED-BYTE 45))
11                   (:END (OR NULL (UNSIGNED-BYTE 45)))
12                   (:KEY (OR FUNCTION SYMBOL)))
13                  (VALUES T &OPTIONAL))
14  Derived type: (FUNCTION
15                 (#1=(OR FUNCTION SYMBOL) T &REST T &KEY (:FROM-END T)
16                  (:START . #2=((UNSIGNED-BYTE 45)))
17                  (:END (OR NULL . #2#)) (:KEY #1#))
18                 (VALUES T &OPTIONAL))
19  Known attributes: call, foldable, flushable, unsafely-flushable
20  Source file: SYS:SRC;CODE;SEQ.LISP

`LENGTH`

 1COMMON-LISP:LENGTH
 2  [symbol]
 3
 4LENGTH names a compiled function:
 5  Lambda-list: (SEQUENCE)
 6  Declared type: (FUNCTION (SEQUENCE)
 7                  (VALUES (UNSIGNED-BYTE 45) &OPTIONAL))
 8  Derived type: (FUNCTION (T) *)
 9  Documentation:
10    Return an integer that is the length of SEQUENCE.
11  Known attributes: dx-safe, foldable, flushable, unsafely-flushable
12  Source file: SYS:SRC;CODE;SEQ.LISP

`MAP`

 1COMMON-LISP:MAP
 2  [symbol]
 3
 4MAP names a compiled function:
 5  Lambda-list: (RESULT-TYPE FUNCTION FIRST-SEQUENCE &REST
 6                MORE-SEQUENCES)
 7  Dynamic-extent arguments: positional=(1)
 8  Declared type: (FUNCTION
 9                  ((OR CONS SYMBOL SB-KERNEL:CLASSOID CLASS)
10                   (OR FUNCTION SYMBOL) SEQUENCE &REST SEQUENCE)
11                  (VALUES
12                   (OR LIST (SIMPLE-ARRAY * (*))
13                       SB-KERNEL:EXTENDED-SEQUENCE)
14                   &OPTIONAL))
15  Derived type: (FUNCTION (T T T &REST T)
16                 (VALUES
17                  (OR LIST (SIMPLE-ARRAY * (*))
18                      SB-KERNEL:EXTENDED-SEQUENCE)
19                  &OPTIONAL))
20  Known attributes: call
21  Source file: SYS:SRC;CODE;SEQ.LISP

`MAP-INTO`

 1COMMON-LISP:MAP-INTO
 2  [symbol]
 3
 4MAP-INTO names a compiled function:
 5  Lambda-list: (RESULT-SEQUENCE FUNCTION &REST SEQUENCES)
 6  Dynamic-extent arguments: positional=(1)
 7  Declared type: (FUNCTION
 8                  (SEQUENCE (OR FUNCTION SYMBOL) &REST SEQUENCE)
 9                  (VALUES SEQUENCE &OPTIONAL))
10  Derived type: (FUNCTION (T T &REST T) (VALUES T &OPTIONAL))
11  Known attributes: call
12  Source file: SYS:SRC;CODE;SEQ.LISP

`MERGE`

 1COMMON-LISP:MERGE
 2  [symbol]
 3
 4MERGE names a compiled function:
 5  Lambda-list: (RESULT-TYPE SEQUENCE1 SEQUENCE2 PREDICATE &KEY KEY)
 6  Dynamic-extent arguments: positional=(3), keyword=(:KEY)
 7  Declared type: (FUNCTION
 8                  ((OR CONS SYMBOL SB-KERNEL:CLASSOID CLASS) SEQUENCE
 9                   SEQUENCE (OR FUNCTION SYMBOL) &KEY
10                   (:KEY (OR FUNCTION SYMBOL)))
11                  (VALUES SEQUENCE &OPTIONAL))
12  Derived type: (FUNCTION (T T T T &KEY (:KEY T)) (VALUES T &OPTIONAL))
13  Documentation:
14    Merge the sequences SEQUENCE1 and SEQUENCE2 destructively into a
15       sequence of type RESULT-TYPE using PREDICATE to order the elements.
16  Known attributes: call, important-result
17  Source file: SYS:SRC;CODE;SORT.LISP

`MISMATCH`

 1COMMON-LISP:MISMATCH
 2  [symbol]
 3
 4MISMATCH names a compiled function:
 5  Lambda-list: (SEQUENCE1 SEQUENCE2 &REST ARGS &KEY FROM-END
 6                (TEST (FUNCTION EQL)) (TEST-NOT NIL) (START1 0)
 7                (END1 NIL) (START2 0) (END2 NIL) (KEY NIL))
 8  Dynamic-extent arguments: keyword=(:TEST :TEST-NOT :KEY)
 9  Declared type: (FUNCTION
10                  (SEQUENCE SEQUENCE &REST T &KEY (:FROM-END T)
11                   (:TEST (OR FUNCTION SYMBOL))
12                   (:TEST-NOT (OR FUNCTION SYMBOL))
13                   (:START1 (UNSIGNED-BYTE 45))
14                   (:END1 (OR NULL (UNSIGNED-BYTE 45)))
15                   (:START2 (UNSIGNED-BYTE 45))
16                   (:END2 (OR NULL (UNSIGNED-BYTE 45)))
17                   (:KEY (OR FUNCTION SYMBOL)))
18                  (VALUES (OR NULL (UNSIGNED-BYTE 45)) &OPTIONAL))
19  Derived type: (FUNCTION
20                 (T T &REST T &KEY (:FROM-END T)
21                  (:TEST . #1=((OR FUNCTION SYMBOL))) (:TEST-NOT . #1#)
22                  (:START1 . #2=((UNSIGNED-BYTE 45)))
23                  (:END1 . #3=((OR NULL . #2#))) (:START2 . #2#)
24                  (:END2 . #3#) (:KEY . #1#))
25                 (VALUES
26                  (OR
27                   (INTEGER -4611686018427387904 4611686018427387904)
28                   NULL)
29                  &OPTIONAL))
30  Documentation:
31    The specified subsequences of SEQUENCE1 and SEQUENCE2 are compared
32       element-wise. If they are of equal length and match in every element, the
33       result is NIL. Otherwise, the result is a non-negative integer, the index
34       within SEQUENCE1 of the leftmost position at which they fail to match; or,
35       if one is shorter than and a matching prefix of the other, the index within
36       SEQUENCE1 beyond the last position tested is returned. If a non-NIL
37       :FROM-END argument is given, then one plus the index of the rightmost
38       position in which the sequences differ is returned.
39  Known attributes: call, foldable, flushable, unsafely-flushable
40  Source file: SYS:SRC;CODE;SEQ.LISP

`NOTANY`

 1COMMON-LISP:NOTANY
 2  [symbol]
 3
 4NOTANY names a compiled function:
 5  Lambda-list: (PRED FIRST-SEQ &REST MORE-SEQS)
 6  Dynamic-extent arguments: positional=(0)
 7  Declared type: (FUNCTION
 8                  ((OR FUNCTION SYMBOL) SEQUENCE &REST SEQUENCE)
 9                  (VALUES BOOLEAN &OPTIONAL))
10  Derived type: (FUNCTION ((OR FUNCTION SYMBOL) SEQUENCE &REST T)
11                 (VALUES BOOLEAN &OPTIONAL))
12  Documentation:
13    Apply PREDICATE to the 0-indexed elements of the sequences, then
14       possibly to those with index 1, and so on. Return NIL as soon
15       as any invocation of PREDICATE returns a non-NIL value, or T if the end
16       of any sequence is reached.
17  Known attributes: call, foldable, unsafely-flushable
18  Source file: SYS:SRC;CODE;QUANTIFIERS.LISP

`NOTEVERY`

 1COMMON-LISP:NOTEVERY
 2  [symbol]
 3
 4NOTEVERY names a compiled function:
 5  Lambda-list: (PRED FIRST-SEQ &REST MORE-SEQS)
 6  Dynamic-extent arguments: positional=(0)
 7  Declared type: (FUNCTION
 8                  ((OR FUNCTION SYMBOL) SEQUENCE &REST SEQUENCE)
 9                  (VALUES BOOLEAN &OPTIONAL))
10  Derived type: (FUNCTION ((OR FUNCTION SYMBOL) SEQUENCE &REST T)
11                 (VALUES BOOLEAN &OPTIONAL))
12  Documentation:
13    Apply PREDICATE to 0-indexed elements of the sequences, then
14       possibly to those with index 1, and so on. Return T as soon
15       as any invocation of PREDICATE returns NIL, or NIL if every invocation
16       is non-NIL.
17  Known attributes: call, foldable, unsafely-flushable
18  Source file: SYS:SRC;CODE;QUANTIFIERS.LISP

`NREVERSE`

 1COMMON-LISP:NREVERSE
 2  [symbol]
 3
 4NREVERSE names a compiled function:
 5  Lambda-list: (SEQUENCE)
 6  Declared type: (FUNCTION (SEQUENCE) (VALUES SEQUENCE &OPTIONAL))
 7  Derived type: (FUNCTION (T) (VALUES SEQUENCE &OPTIONAL))
 8  Documentation:
 9    Return a sequence of the same elements in reverse order; the argument
10       is destroyed.
11  Known attributes: important-result
12  Source file: SYS:SRC;CODE;SEQ.LISP

`NSUBSTITUTE`

 1COMMON-LISP:NSUBSTITUTE
 2  [symbol]
 3
 4NSUBSTITUTE names a compiled function:
 5  Lambda-list: (NEW OLD SEQUENCE &REST ARGS &KEY FROM-END
 6                (TEST (FUNCTION EQL)) (TEST-NOT NIL) (END NIL)
 7                (COUNT NIL) (KEY NIL) (START 0))
 8  Dynamic-extent arguments: keyword=(:TEST :TEST-NOT :KEY)
 9  Declared type: (FUNCTION
10                  (T T SEQUENCE &REST T &KEY (:FROM-END T)
11                   (:TEST (OR FUNCTION SYMBOL))
12                   (:TEST-NOT (OR FUNCTION SYMBOL))
13                   (:START (UNSIGNED-BYTE 45))
14                   (:END (OR NULL (UNSIGNED-BYTE 45)))
15                   (:COUNT (OR NULL INTEGER))
16                   (:KEY (OR FUNCTION SYMBOL)))
17                  (VALUES SEQUENCE &OPTIONAL))
18  Derived type: (FUNCTION
19                 (T T T &REST T &KEY (:FROM-END T)
20                  (:TEST . #1=((OR FUNCTION SYMBOL))) (:TEST-NOT . #1#)
21                  (:START . #2=((UNSIGNED-BYTE 45)))
22                  (:END (OR NULL . #2#)) (:COUNT (OR NULL INTEGER))
23                  (:KEY . #1#))
24                 *)
25  Documentation:
26    Return a sequence of the same kind as SEQUENCE with the same elements
27      except that all elements equal to OLD are replaced with NEW. SEQUENCE
28      may be destructively modified.
29  Known attributes: call
30  Source file: SYS:SRC;CODE;SEQ.LISP

`NSUBSTITUTE-IF`

 1COMMON-LISP:NSUBSTITUTE-IF
 2  [symbol]
 3
 4NSUBSTITUTE-IF names a compiled function:
 5  Lambda-list: (NEW PREDICATE SEQUENCE &REST ARGS &KEY FROM-END
 6                (START 0) (END NIL) (COUNT NIL) (KEY NIL))
 7  Dynamic-extent arguments: positional=(1), keyword=(:KEY)
 8  Declared type: (FUNCTION
 9                  (T (OR FUNCTION SYMBOL) SEQUENCE &REST T &KEY
10                   (:FROM-END T) (:COUNT (OR NULL INTEGER))
11                   (:START (UNSIGNED-BYTE 45))
12                   (:END (OR NULL (UNSIGNED-BYTE 45)))
13                   (:KEY (OR FUNCTION SYMBOL)))
14                  (VALUES SEQUENCE &OPTIONAL))
15  Derived type: (FUNCTION
16                 (T #1=(OR FUNCTION SYMBOL) T &REST T &KEY
17                  (:FROM-END T) (:COUNT (OR NULL INTEGER))
18                  (:START . #2=((UNSIGNED-BYTE 45)))
19                  (:END (OR NULL . #2#)) (:KEY #1#))
20                 *)
21  Documentation:
22    Return a sequence of the same kind as SEQUENCE with the same elements
23       except that all elements satisfying PREDICATE are replaced with NEW.
24       SEQUENCE may be destructively modified.
25  Known attributes: call
26  Source file: SYS:SRC;CODE;SEQ.LISP

`NSUBSTITUTE-IF-NOT`

 1COMMON-LISP:NSUBSTITUTE-IF-NOT
 2  [symbol]
 3
 4NSUBSTITUTE-IF-NOT names a compiled function:
 5  Lambda-list: (NEW PREDICATE SEQUENCE &REST ARGS &KEY FROM-END
 6                (START 0) (END NIL) (COUNT NIL) (KEY NIL))
 7  Dynamic-extent arguments: positional=(1), keyword=(:KEY)
 8  Declared type: (FUNCTION
 9                  (T (OR FUNCTION SYMBOL) SEQUENCE &REST T &KEY
10                   (:FROM-END T) (:COUNT (OR NULL INTEGER))
11                   (:START (UNSIGNED-BYTE 45))
12                   (:END (OR NULL (UNSIGNED-BYTE 45)))
13                   (:KEY (OR FUNCTION SYMBOL)))
14                  (VALUES SEQUENCE &OPTIONAL))
15  Derived type: (FUNCTION
16                 (T #1=(OR FUNCTION SYMBOL) T &REST T &KEY
17                  (:FROM-END T) (:COUNT (OR NULL INTEGER))
18                  (:START . #2=((UNSIGNED-BYTE 45)))
19                  (:END (OR NULL . #2#)) (:KEY #1#))
20                 *)
21  Documentation:
22    Return a sequence of the same kind as SEQUENCE with the same elements
23       except that all elements not satisfying PREDICATE are replaced with NEW.
24       SEQUENCE may be destructively modified.
25  Known attributes: call
26  Source file: SYS:SRC;CODE;SEQ.LISP

`POSITION`

 1COMMON-LISP:POSITION
 2  [symbol]
 3
 4POSITION names a compiled function:
 5  Lambda-list: (ITEM SEQUENCE &REST ARGS &KEY FROM-END (START 0) END
 6                KEY TEST TEST-NOT)
 7  Dynamic-extent arguments: keyword=(:KEY :TEST :TEST-NOT)
 8  Declared type: (FUNCTION
 9                  (T SEQUENCE &REST T &KEY (:TEST (OR FUNCTION SYMBOL))
10                   (:TEST-NOT (OR FUNCTION SYMBOL))
11                   (:START (UNSIGNED-BYTE 45))
12                   (:END (OR NULL (UNSIGNED-BYTE 45))) (:FROM-END T)
13                   (:KEY (OR FUNCTION SYMBOL)))
14                  (VALUES (OR (MOD 35184372088831) NULL) &OPTIONAL))
15  Derived type: (FUNCTION
16                 (T T &REST T &KEY (:TEST . #1=((OR FUNCTION SYMBOL)))
17                  (:TEST-NOT . #1#) (:START . #2=((UNSIGNED-BYTE 45)))
18                  (:END (OR NULL . #2#)) (:FROM-END T) (:KEY . #1#))
19                 (VALUES (OR (MOD 35184372088831) NULL) &OPTIONAL))
20  Known attributes: call, foldable, flushable, unsafely-flushable
21  Source file: SYS:SRC;CODE;SEQ.LISP

`POSITION-IF`

 1COMMON-LISP:POSITION-IF
 2  [symbol]
 3
 4POSITION-IF names a compiled function:
 5  Lambda-list: (PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0)
 6                END KEY)
 7  Dynamic-extent arguments: positional=(0), keyword=(:KEY)
 8  Declared type: (FUNCTION
 9                  ((OR FUNCTION SYMBOL) SEQUENCE &REST T &KEY
10                   (:FROM-END T) (:START (UNSIGNED-BYTE 45))
11                   (:END (OR NULL (UNSIGNED-BYTE 45)))
12                   (:KEY (OR FUNCTION SYMBOL)))
13                  (VALUES (OR (MOD 35184372088831) NULL) &OPTIONAL))
14  Derived type: (FUNCTION
15                 (#1=(OR FUNCTION SYMBOL) T &REST T &KEY (:FROM-END T)
16                  (:START . #2=((UNSIGNED-BYTE 45)))
17                  (:END (OR NULL . #2#)) (:KEY #1#))
18                 (VALUES (OR (MOD 35184372088831) NULL) &OPTIONAL))
19  Known attributes: call, foldable, flushable, unsafely-flushable
20  Source file: SYS:SRC;CODE;SEQ.LISP

`POSITION-IF-NOT`

 1COMMON-LISP:POSITION-IF-NOT
 2  [symbol]
 3
 4POSITION-IF-NOT names a compiled function:
 5  Lambda-list: (PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0)
 6                END KEY)
 7  Dynamic-extent arguments: positional=(0), keyword=(:KEY)
 8  Declared type: (FUNCTION
 9                  ((OR FUNCTION SYMBOL) SEQUENCE &REST T &KEY
10                   (:FROM-END T) (:START (UNSIGNED-BYTE 45))
11                   (:END (OR NULL (UNSIGNED-BYTE 45)))
12                   (:KEY (OR FUNCTION SYMBOL)))
13                  (VALUES (OR (MOD 35184372088831) NULL) &OPTIONAL))
14  Derived type: (FUNCTION
15                 (#1=(OR FUNCTION SYMBOL) T &REST T &KEY (:FROM-END T)
16                  (:START . #2=((UNSIGNED-BYTE 45)))
17                  (:END (OR NULL . #2#)) (:KEY #1#))
18                 (VALUES (OR (MOD 35184372088831) NULL) &OPTIONAL))
19  Known attributes: call, foldable, flushable, unsafely-flushable
20  Source file: SYS:SRC;CODE;SEQ.LISP

`REDUCE`

 1COMMON-LISP:REDUCE
 2  [symbol]
 3
 4REDUCE names a compiled function:
 5  Lambda-list: (FUNCTION SEQUENCE &REST ARGS &KEY (KEY NIL) FROM-END
 6                (START 0) (END NIL) (INITIAL-VALUE NIL IVP))
 7  Dynamic-extent arguments: positional=(0), keyword=(:KEY)
 8  Declared type: (FUNCTION
 9                  ((OR FUNCTION SYMBOL) SEQUENCE &REST T &KEY
10                   (:FROM-END T) (:START (UNSIGNED-BYTE 45))
11                   (:END (OR NULL (UNSIGNED-BYTE 45)))
12                   (:INITIAL-VALUE T) (:KEY (OR FUNCTION SYMBOL)))
13                  (VALUES T &OPTIONAL))
14  Derived type: (FUNCTION
15                 (#1=(OR FUNCTION SYMBOL) T &REST T &KEY
16                  (:FROM-END . #2=(T))
17                  (:START . #3=((UNSIGNED-BYTE 45)))
18                  (:END (OR NULL . #3#)) (:INITIAL-VALUE . #2#)
19                  (:KEY #1#))
20                 (VALUES T &OPTIONAL))
21  Known attributes: call, foldable, flushable, unsafely-flushable
22  Source file: SYS:SRC;CODE;SEQ.LISP

`REMOVE`

 1COMMON-LISP:REMOVE
 2  [symbol]
 3
 4REMOVE names a compiled function:
 5  Lambda-list: (ITEM SEQUENCE &REST ARGS &KEY FROM-END
 6                (TEST (FUNCTION EQL)) (TEST-NOT NIL) (START 0)
 7                (END NIL) (COUNT NIL) (KEY NIL))
 8  Dynamic-extent arguments: keyword=(:TEST :TEST-NOT :KEY)
 9  Declared type: (FUNCTION
10                  (T SEQUENCE &REST T &KEY (:FROM-END T)
11                   (:TEST (OR FUNCTION SYMBOL))
12                   (:TEST-NOT (OR FUNCTION SYMBOL))
13                   (:START (UNSIGNED-BYTE 45))
14                   (:END (OR NULL (UNSIGNED-BYTE 45)))
15                   (:COUNT (OR NULL INTEGER))
16                   (:KEY (OR FUNCTION SYMBOL)))
17                  (VALUES
18                   (OR LIST (SIMPLE-ARRAY * (*))
19                       SB-KERNEL:EXTENDED-SEQUENCE)
20                   &OPTIONAL))
21  Derived type: (FUNCTION
22                 (T T &REST T &KEY (:FROM-END T)
23                  (:TEST . #1=((OR FUNCTION SYMBOL))) (:TEST-NOT . #1#)
24                  (:START . #2=((UNSIGNED-BYTE 45)))
25                  (:END (OR NULL . #2#)) (:COUNT (OR NULL INTEGER))
26                  (:KEY . #1#))
27                 (VALUES T &OPTIONAL))
28  Documentation:
29    Return a copy of SEQUENCE with elements satisfying the test (default is
30       EQL) with ITEM removed.
31  Known attributes: call, flushable, unsafely-flushable
32  Source file: SYS:SRC;CODE;SEQ.LISP

`REMOVE-DUPLICATES`

 1COMMON-LISP:REMOVE-DUPLICATES
 2  [symbol]
 3
 4REMOVE-DUPLICATES names a compiled function:
 5  Lambda-list: (SEQUENCE &REST ARGS &KEY (TEST (FUNCTION EQL))
 6                (TEST-NOT NIL) (START 0) (END NIL) FROM-END (KEY NIL))
 7  Dynamic-extent arguments: keyword=(:TEST :TEST-NOT :KEY)
 8  Declared type: (FUNCTION
 9                  (SEQUENCE &REST T &KEY (:TEST (OR FUNCTION SYMBOL))
10                   (:TEST-NOT (OR FUNCTION SYMBOL))
11                   (:START (UNSIGNED-BYTE 45))
12                   (:END (OR NULL (UNSIGNED-BYTE 45))) (:FROM-END T)
13                   (:KEY (OR FUNCTION SYMBOL)))
14                  (VALUES
15                   (OR LIST (SIMPLE-ARRAY * (*))
16                       SB-KERNEL:EXTENDED-SEQUENCE)
17                   &OPTIONAL))
18  Derived type: (FUNCTION
19                 (T &REST T &KEY (:TEST . #1=((OR FUNCTION SYMBOL)))
20                  (:TEST-NOT . #1#) (:START . #2=((UNSIGNED-BYTE 45)))
21                  (:END (OR NULL . #2#)) (:FROM-END T) (:KEY . #1#))
22                 (VALUES T &OPTIONAL))
23  Documentation:
24    The elements of SEQUENCE are compared pairwise, and if any two match,
25       the one occurring earlier is discarded, unless FROM-END is true, in
26       which case the one later in the sequence is discarded. The resulting
27       sequence is returned.
28    
29       The :TEST-NOT argument is deprecated.
30  Known attributes: call, flushable, unsafely-flushable
31  Source file: SYS:SRC;CODE;SEQ.LISP

`REMOVE-IF`

 1COMMON-LISP:REMOVE-IF
 2  [symbol]
 3
 4REMOVE-IF names a compiled function:
 5  Lambda-list: (PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0)
 6                (END NIL) (COUNT NIL) (KEY NIL))
 7  Dynamic-extent arguments: positional=(0), keyword=(:KEY)
 8  Declared type: (FUNCTION
 9                  ((OR FUNCTION SYMBOL) SEQUENCE &REST T &KEY
10                   (:FROM-END T) (:COUNT (OR NULL INTEGER))
11                   (:START (UNSIGNED-BYTE 45))
12                   (:END (OR NULL (UNSIGNED-BYTE 45)))
13                   (:KEY (OR FUNCTION SYMBOL)))
14                  (VALUES
15                   (OR LIST (SIMPLE-ARRAY * (*))
16                       SB-KERNEL:EXTENDED-SEQUENCE)
17                   &OPTIONAL))
18  Derived type: (FUNCTION
19                 (#1=(OR FUNCTION SYMBOL) T &REST T &KEY (:FROM-END T)
20                  (:COUNT (OR NULL INTEGER))
21                  (:START . #2=((UNSIGNED-BYTE 45)))
22                  (:END (OR NULL . #2#)) (:KEY #1#))
23                 (VALUES T &OPTIONAL))
24  Documentation:
25    Return a copy of sequence with elements satisfying PREDICATE removed.
26  Known attributes: call, flushable, unsafely-flushable
27  Source file: SYS:SRC;CODE;SEQ.LISP

`REMOVE-IF-NOT`

 1COMMON-LISP:REMOVE-IF-NOT
 2  [symbol]
 3
 4REMOVE-IF-NOT names a compiled function:
 5  Lambda-list: (PREDICATE SEQUENCE &REST ARGS &KEY FROM-END (START 0)
 6                (END NIL) (COUNT NIL) (KEY NIL))
 7  Dynamic-extent arguments: positional=(0), keyword=(:KEY)
 8  Declared type: (FUNCTION
 9                  ((OR FUNCTION SYMBOL) SEQUENCE &REST T &KEY
10                   (:FROM-END T) (:COUNT (OR NULL INTEGER))
11                   (:START (UNSIGNED-BYTE 45))
12                   (:END (OR NULL (UNSIGNED-BYTE 45)))
13                   (:KEY (OR FUNCTION SYMBOL)))
14                  (VALUES
15                   (OR LIST (SIMPLE-ARRAY * (*))
16                       SB-KERNEL:EXTENDED-SEQUENCE)
17                   &OPTIONAL))
18  Derived type: (FUNCTION
19                 (#1=(OR FUNCTION SYMBOL) T &REST T &KEY (:FROM-END T)
20                  (:COUNT (OR NULL INTEGER))
21                  (:START . #2=((UNSIGNED-BYTE 45)))
22                  (:END (OR NULL . #2#)) (:KEY #1#))
23                 (VALUES T &OPTIONAL))
24  Documentation:
25    Return a copy of sequence with elements not satisfying PREDICATE removed.
26  Known attributes: call, flushable, unsafely-flushable
27  Source file: SYS:SRC;CODE;SEQ.LISP

`REPLACE`

 1COMMON-LISP:REPLACE
 2  [symbol]
 3
 4REPLACE names a compiled function:
 5  Lambda-list: (TARGET-SEQUENCE1 SOURCE-SEQUENCE2 &REST ARGS &KEY
 6                (START1 0) (END1 NIL) (START2 0) (END2 NIL))
 7  Declared type: (FUNCTION
 8                  (SEQUENCE SEQUENCE &REST T &KEY
 9                   (:START1 (UNSIGNED-BYTE 45))
10                   (:END1 (OR NULL (UNSIGNED-BYTE 45)))
11                   (:START2 (UNSIGNED-BYTE 45))
12                   (:END2 (OR NULL (UNSIGNED-BYTE 45))))
13                  (VALUES SEQUENCE &OPTIONAL))
14  Derived type: (FUNCTION
15                 (T T &REST T &KEY (:START1 . #1=((UNSIGNED-BYTE 45)))
16                  (:END1 . #2=((OR NULL . #1#))) (:START2 . #1#)
17                  (:END2 . #2#))
18                 (VALUES SEQUENCE &OPTIONAL))
19  Documentation:
20    Destructively modifies SEQUENCE1 by copying successive elements
21    into it from the SEQUENCE2.
22    
23    Elements are copied to the subsequence bounded by START1 and END1,
24    from the subsequence bounded by START2 and END2. If these subsequences
25    are not of the same length, then the shorter length determines how
26    many elements are copied.
27  Source file: SYS:SRC;CODE;SEQ.LISP

`REVERSE`

 1COMMON-LISP:REVERSE
 2  [symbol]
 3
 4REVERSE names a compiled function:
 5  Lambda-list: (SEQUENCE)
 6  Declared type: (FUNCTION (SEQUENCE)
 7                  (VALUES
 8                   (OR LIST (SIMPLE-ARRAY * (*))
 9                       SB-KERNEL:EXTENDED-SEQUENCE)
10                   &OPTIONAL))
11  Derived type: (FUNCTION (T) *)
12  Documentation:
13    Return a new sequence containing the same elements but in reverse order.
14  Known attributes: flushable, unsafely-flushable
15  Source file: SYS:SRC;CODE;SEQ.LISP

`SEARCH`

 1COMMON-LISP:SEARCH
 2  [symbol]
 3
 4SEARCH names a compiled function:
 5  Lambda-list: (SUB-SEQUENCE1 MAIN-SEQUENCE2 &REST ARGS &KEY FROM-END
 6                (TEST (FUNCTION EQL)) (TEST-NOT NIL) (START1 0)
 7                (END1 NIL) (START2 0) (END2 NIL) (KEY NIL))
 8  Dynamic-extent arguments: keyword=(:TEST :TEST-NOT :KEY)
 9  Declared type: (FUNCTION
10                  (SEQUENCE SEQUENCE &REST T &KEY (:FROM-END T)
11                   (:TEST (OR FUNCTION SYMBOL))
12                   (:TEST-NOT (OR FUNCTION SYMBOL))
13                   (:START1 (UNSIGNED-BYTE 45))
14                   (:END1 (OR NULL (UNSIGNED-BYTE 45)))
15                   (:START2 (UNSIGNED-BYTE 45))
16                   (:END2 (OR NULL (UNSIGNED-BYTE 45)))
17                   (:KEY (OR FUNCTION SYMBOL)))
18                  (VALUES (OR NULL (UNSIGNED-BYTE 45)) &OPTIONAL))
19  Derived type: (FUNCTION
20                 (SEQUENCE T &REST T &KEY (:FROM-END T)
21                  (:TEST . #1=((OR FUNCTION SYMBOL))) (:TEST-NOT . #1#)
22                  (:START1 . #2=((UNSIGNED-BYTE 45)))
23                  (:END1 . #3=(#4=(OR NULL . #2#))) (:START2 . #2#)
24                  (:END2 . #3#) (:KEY . #1#))
25                 (VALUES #4# &OPTIONAL))
26  Known attributes: call, foldable, flushable, unsafely-flushable
27  Source file: SYS:SRC;CODE;SEQ.LISP

`SOME`

 1COMMON-LISP:SOME
 2  [symbol]
 3
 4SOME names a compiled function:
 5  Lambda-list: (PRED FIRST-SEQ &REST MORE-SEQS)
 6  Dynamic-extent arguments: positional=(0)
 7  Declared type: (FUNCTION
 8                  ((OR FUNCTION SYMBOL) SEQUENCE &REST SEQUENCE)
 9                  (VALUES T &OPTIONAL))
10  Derived type: (FUNCTION ((OR FUNCTION SYMBOL) SEQUENCE &REST T)
11                 (VALUES T &OPTIONAL))
12  Documentation:
13    Apply PREDICATE to the 0-indexed elements of the sequences, then
14       possibly to those with index 1, and so on. Return the first
15       non-NIL value encountered, or NIL if the end of any sequence is reached.
16  Known attributes: call, foldable, unsafely-flushable
17  Source file: SYS:SRC;CODE;QUANTIFIERS.LISP

`SORT`

 1COMMON-LISP:SORT
 2  [symbol]
 3
 4SORT names a compiled function:
 5  Lambda-list: (SEQUENCE PREDICATE &REST ARGS &KEY KEY)
 6  Dynamic-extent arguments: positional=(1), keyword=(:KEY)
 7  Declared type: (FUNCTION
 8                  (SEQUENCE (OR FUNCTION SYMBOL) &REST T &KEY
 9                   (:KEY (OR FUNCTION SYMBOL)))
10                  (VALUES SEQUENCE &OPTIONAL))
11  Documentation:
12    Destructively sort SEQUENCE. PREDICATE should return non-NIL if
13       ARG1 is to precede ARG2.
14  Known attributes: call
15  Source file: SYS:SRC;CODE;SORT.LISP

`STABLE-SORT`

 1COMMON-LISP:STABLE-SORT
 2  [symbol]
 3
 4STABLE-SORT names a compiled function:
 5  Lambda-list: (SEQUENCE PREDICATE &REST ARGS &KEY KEY)
 6  Dynamic-extent arguments: positional=(1), keyword=(:KEY)
 7  Declared type: (FUNCTION
 8                  (SEQUENCE (OR FUNCTION SYMBOL) &REST T &KEY
 9                   (:KEY (OR FUNCTION SYMBOL)))
10                  (VALUES SEQUENCE &OPTIONAL))
11  Documentation:
12    Destructively sort SEQUENCE. PREDICATE should return non-NIL if
13       ARG1 is to precede ARG2.
14  Inline proclamation: MAYBE-INLINE (inline expansion available)
15  Known attributes: call
16  Source file: SYS:SRC;CODE;SORT.LISP

`SUBSEQ`

 1COMMON-LISP:SUBSEQ
 2  [symbol]
 3
 4SUBSEQ names a compiled function:
 5  Lambda-list: (SEQUENCE START &OPTIONAL END)
 6  Declared type: (FUNCTION
 7                  (SEQUENCE (UNSIGNED-BYTE 45) &OPTIONAL
 8                   (OR NULL (UNSIGNED-BYTE 45)))
 9                  (VALUES
10                   (OR LIST (SIMPLE-ARRAY * (*))
11                       SB-KERNEL:EXTENDED-SEQUENCE)
12                   &OPTIONAL))
13  Derived type: (FUNCTION
14                 (T #1=(UNSIGNED-BYTE 45) &OPTIONAL (OR NULL #1#))
15                 (VALUES T &OPTIONAL))
16  Documentation:
17    Return a copy of a subsequence of SEQUENCE starting with element number
18       START and continuing to the end of SEQUENCE or the optional END.
19  Known attributes: flushable, unsafely-flushable
20  Source file: SYS:SRC;CODE;SEQ.LISP
21
22(SETF SUBSEQ) has a complex setf-expansion:
23  Lambda-list: (SEQUENCE START &OPTIONAL END)
24  (undocumented)
25  Source file: SYS:SRC;CODE;DEFSETFS.LISP

`SUBSTITUTE`

 1COMMON-LISP:SUBSTITUTE
 2  [symbol]
 3
 4SUBSTITUTE names a compiled function:
 5  Lambda-list: (NEW OLD SEQUENCE &REST ARGS &KEY FROM-END
 6                (TEST (FUNCTION EQL)) (TEST-NOT NIL) (START 0)
 7                (COUNT NIL) (END NIL) (KEY NIL))
 8  Dynamic-extent arguments: keyword=(:TEST :TEST-NOT :KEY)
 9  Declared type: (FUNCTION
10                  (T T SEQUENCE &REST T &KEY (:FROM-END T)
11                   (:TEST (OR FUNCTION SYMBOL))
12                   (:TEST-NOT (OR FUNCTION SYMBOL))
13                   (:START (UNSIGNED-BYTE 45))
14                   (:END (OR NULL (UNSIGNED-BYTE 45)))
15                   (:COUNT (OR NULL INTEGER))
16                   (:KEY (OR FUNCTION SYMBOL)))
17                  (VALUES
18                   (OR LIST (SIMPLE-ARRAY * (*))
19                       SB-KERNEL:EXTENDED-SEQUENCE)
20                   &OPTIONAL))
21  Derived type: (FUNCTION
22                 (T T T &REST T &KEY (:FROM-END T)
23                  (:TEST . #1=((OR FUNCTION SYMBOL))) (:TEST-NOT . #1#)
24                  (:START . #2=((UNSIGNED-BYTE 45)))
25                  (:END (OR NULL . #2#)) (:COUNT (OR NULL INTEGER))
26                  (:KEY . #1#))
27                 (VALUES T &OPTIONAL))
28  Documentation:
29    Return a sequence of the same kind as SEQUENCE with the same elements,
30      except that all elements equal to OLD are replaced with NEW.
31  Known attributes: call, flushable, unsafely-flushable
32  Source file: SYS:SRC;CODE;SEQ.LISP

`SUBSTITUTE-IF`

 1COMMON-LISP:SUBSTITUTE-IF
 2  [symbol]
 3
 4SUBSTITUTE-IF names a compiled function:
 5  Lambda-list: (NEW PREDICATE SEQUENCE &REST ARGS &KEY FROM-END
 6                (START 0) (END NIL) (COUNT NIL) (KEY NIL))
 7  Dynamic-extent arguments: positional=(1), keyword=(:KEY)
 8  Declared type: (FUNCTION
 9                  (T (OR FUNCTION SYMBOL) SEQUENCE &REST T &KEY
10                   (:FROM-END T) (:COUNT (OR NULL INTEGER))
11                   (:START (UNSIGNED-BYTE 45))
12                   (:END (OR NULL (UNSIGNED-BYTE 45)))
13                   (:KEY (OR FUNCTION SYMBOL)))
14                  (VALUES
15                   (OR LIST (SIMPLE-ARRAY * (*))
16                       SB-KERNEL:EXTENDED-SEQUENCE)
17                   &OPTIONAL))
18  Derived type: (FUNCTION
19                 (T #1=(OR FUNCTION SYMBOL) T &REST T &KEY
20                  (:FROM-END T) (:COUNT (OR NULL INTEGER))
21                  (:START . #2=((UNSIGNED-BYTE 45)))
22                  (:END (OR NULL . #2#)) (:KEY #1#))
23                 (VALUES T &OPTIONAL))
24  Documentation:
25    Return a sequence of the same kind as SEQUENCE with the same elements
26      except that all elements satisfying the PRED are replaced with NEW.
27  Known attributes: call, flushable, unsafely-flushable
28  Source file: SYS:SRC;CODE;SEQ.LISP

`SUBSTITUTE-IF-NOT`

 1COMMON-LISP:SUBSTITUTE-IF-NOT
 2  [symbol]
 3
 4SUBSTITUTE-IF-NOT names a compiled function:
 5  Lambda-list: (NEW PREDICATE SEQUENCE &REST ARGS &KEY FROM-END
 6                (START 0) (END NIL) (COUNT NIL) (KEY NIL))
 7  Dynamic-extent arguments: positional=(1), keyword=(:KEY)
 8  Declared type: (FUNCTION
 9                  (T (OR FUNCTION SYMBOL) SEQUENCE &REST T &KEY
10                   (:FROM-END T) (:COUNT (OR NULL INTEGER))
11                   (:START (UNSIGNED-BYTE 45))
12                   (:END (OR NULL (UNSIGNED-BYTE 45)))
13                   (:KEY (OR FUNCTION SYMBOL)))
14                  (VALUES
15                   (OR LIST (SIMPLE-ARRAY * (*))
16                       SB-KERNEL:EXTENDED-SEQUENCE)
17                   &OPTIONAL))
18  Derived type: (FUNCTION
19                 (T #1=(OR FUNCTION SYMBOL) T &REST T &KEY
20                  (:FROM-END T) (:COUNT (OR NULL INTEGER))
21                  (:START . #2=((UNSIGNED-BYTE 45)))
22                  (:END (OR NULL . #2#)) (:KEY #1#))
23                 (VALUES T &OPTIONAL))
24  Documentation:
25    Return a sequence of the same kind as SEQUENCE with the same elements
26      except that all elements not satisfying the PRED are replaced with NEW.
27  Known attributes: call, flushable, unsafely-flushable
28  Source file: SYS:SRC;CODE;SEQ.LISP

006 好奇先生在Lisp的花园里挖呀挖呀挖

好奇先生Lisp探索工具explore-lisp

挖一下explore-lisp

DESCRIBE-SYMBOL

DIR

EXPORT-ALL-EXTERNAL-SYMBOLS

EXPORT-DESCRIPTIONS

FORMAT-DESCRIPTIONS

SEARCH-SYMBOLS

挖一下string

挖到了sequence

附录A: Sequence相关的函数

CONCATENATE

COPY-SEQ

COUNT

COUNT-IF

COUNT-IF-NOT

DELETE

DELETE-DUPLICATES

DELETE-IF

DELETE-IF-NOT

ELT

EVERY

FILL

FIND

FIND-IF

FIND-IF-NOT

LENGTH

MAP

MAP-INTO

MERGE

MISMATCH

NOTANY

NOTEVERY

NREVERSE

NSUBSTITUTE

NSUBSTITUTE-IF

NSUBSTITUTE-IF-NOT

POSITION

POSITION-IF

POSITION-IF-NOT

REDUCE

REMOVE

REMOVE-DUPLICATES

REMOVE-IF

REMOVE-IF-NOT

REPLACE

REVERSE

SEARCH

SOME

SORT

STABLE-SORT

SUBSEQ

SUBSTITUTE

SUBSTITUTE-IF

SUBSTITUTE-IF-NOT