Revision as of 09:56, 17 April 2017

[[|]]

1 OpenCyc.org HomepageSubL Reference
2 How to Use this Document
3 0 : Table of Contents
4 1 : Introduction
5 2 : Data Types
6 3 : Scope and Extent
7 4 : Type Specifiers
8 5 : Program Structure
- 8.1 5.3.1 : Defining Named Functions
- 8.2 5.3.2 : Declaring Global Variables and Named Constants
9 6 : Predicates
- 9.1 6.1 : Logical Values
- 9.2 6.2.2 : Specific Data Type Predicates
- 9.3 6.3 : Equality Predicates
- 9.4 6.4 : Logical Operators
10 7 : Control Structure
- 10.1 7.1.1 : Reference
- 10.2 7.1.2 : Assignment
- 10.3 7.2 : Generalized Variables
- 10.4 7.3 : Function Invocation
- 10.5 7.4 : Simple Sequencing
- 10.6 7.5 : Establishing New Variable Bindings
- 10.7 7.6 : Conditionals
- 10.8 7.7 : Blocks and Exits
- 10.9 7.8.2 : General Iteration
- 10.10 7.8.3 : Simple Iteration Constructs
- 10.11 7.8.4 : Mapping
- 10.12 7.10.1 : Constructs for Handling Multiple Values
- 10.13 7.10.2 : Rules Governing the Passing of Multiple Values
- 10.14 7.11 : Dynamic Non-Local Exits
11 8 : Macros
- 11.1 8.1 : Macro Definition
- 11.2 8.3 : Destructuring
- 11.3 8.5 : Environments
12 9 : Declarations
- 12.1 9.1 : Declaration Syntax
- 12.2 9.2 : Declaration Specifiers
13 10 : Symbols
- 13.1 10.1 : The Property List
- 13.2 10.2 : The Print Name
- 13.3 10.3 : Creating Symbols
14 11 : Packages
15 12 : Numbers
- 15.1 12.2 : Predicates on Numbers
- 15.2 12.3 : Comparisons on Numbers
- 15.3 12.4 : Arithmetic Operations
- 15.4 12.5 : Irrational and Transcendental Functions
- 15.5 12.6 : Type Conversions and Component Extractions on Numbers
- 15.6 12.7 : Logical Operations on Numbers
- 15.7 12.8 : Byte Manipulation Functions
- 15.8 12.9 : Random Numbers
- 15.9 12.10 : Implementation Parameters
16 13 : Characters
- 16.1 13.1 : Character Attributes
- 16.2 13.2 : Predicates on Characters
- 16.3 13.3 : Character Construction and Selection
- 16.4 13.4 : Character Conversions
17 14 : Sequences
- 17.1 14.1 : Simple Sequence Functions
- 17.2 14.2 : Concatenating, Mapping and Reducing Sequences
- 17.3 14.3 : Modifying Sequences
- 17.4 14.4 : Searching Sequences for Terms
- 17.5 14.5 : Sorting and Merging
18 15 : Lists
- 18.1 15.1 : Conses
- 18.2 15.2 : Lists
- 18.3 15.3 : Alteration of List Structure
- 18.4 15.4 : Substitution of Expressions
- 18.5 15.5 : Using Lists as Sets
- 18.6 15.6 : Association Lists
19 16 : Hash Tables
- 19.1 16.1 : Hash Table Functions
- 19.2 16.2 : Primitive Hash Function
20 17 : Arrays
- 20.1 17.1 : Vector Creation
- 20.2 17.2 : Vector Access
21 18 : Strings
- 21.1 18.1 : String Access
- 21.2 18.2 : String Comparison
- 21.3 18.3 : String Construction and Manipulation
22 19 : Structures
23 20 : The Evaluator
- 23.1 20.1 : Run-Time Evaluation of Forms
- 23.2 20.2 : The Top-Level Loop
24 21 : Streams
- 24.1 21.1 : Standard Streams
- 24.2 21.2 : Creating new Streams
- 24.3 21.3 : Operations on Streams
25 22 : Input/Output
- 25.1 22.1 : Printed Representation of SubL Objects
- 25.2 22.1.3 : Macro Characters
- 25.3 22.1.4 : Standard Dispatching Macro Character Syntax
- 25.4 22.1.5 : The Readtable
- 25.5 22.1.6 : What the Print Function Produces
- 25.6 22.2.1 : Input from Character Streams
- 25.7 22.2.2 : Input from Binary Streams
- 25.8 22.3.1 : Output to Character Streams
- 25.9 22.3.2 : Output to Binary Streams
- 25.10 22.3.3 : Formatted Output to Character Streams
26 23 : File System Interface
- 26.1 23.1 : File Names
- 26.2 23.2 : Opening and Closing Files
- 26.3 23.3 : Renaming, Deleting and Other File Operations
- 26.4 23.4 : Loading Files
- 26.5 23.5 : Accessing Directories
27 24 : Errors
- 27.1 24.1 : General Error-Signalling Functions
- 27.2 24.2 : Specialized Error-Signalling Forms and Macros
28 25 : Miscellaneous Features
- 28.1 25.1 : The Compiler
- 28.2 25.3 : Debugging Tools
- 28.3 25.4.1 : Time Functions
- 28.4 25.5 : Identity Function
29 28 : Common Lisp Object System
30 SubL-Specific Features
31 Index
- 31.1 A
- 31.2 B
- 31.3 C
- 31.4 D
- 31.5 E
- 31.6 F
- 31.7 G
- 31.8 H
- 31.9 I
- 31.10 J
- 31.11 K
- 31.12 L
- 31.13 M
- 31.14 N
- 31.15 O
- 31.16 P
- 31.17 Q
- 31.18 R
- 31.19 S
- 31.20 T
- 31.21 U
- 31.22 V
- 31.23 W
- 31.24 X
- 31.25 Y
- 31.26 Z

OpenCyc.org Homepage SubL Reference

E-Mail Comments to: opencyc-doc@cyc.com
Last Update: 03/28/2002
CopyrightÂ© 1996-2002 Cycorp. All rights reserved.

How to Use this Document

SubL is a computer language built by members of Cycorp. SubL was written to support the CycÂ® application, allowing it to run both under Lisp environments and as a C application generated by a SubL-to-C translator. This document describes the primitive functions of SubL.

Due to the close similarities between SubL and Common Lisp, the Table of Contents and structure of this document intentionally mirror that of

"Common Lisp: The Language",

2nd Edition,
Guy L. Steele Jr

making it easy to compare and contrast the two languages. For the most part, this document focuses only on the differences between SubL and Common Lisp.

An online version of "Common Lisp: The Language" can be found at

http://www.supelec.fr/docs/cltl/clm/clm.html **not working**

and an index to all Common Lisp functions can be found at

http://www.supelec.fr/docs/cltl/clm/index.html **this is working**

Each section of this document contains a link labelled "CLtL2 Reference" to the corresponding sections of the above online Common Lisp reference. The reader is strongly encouraged to consult that reference in parallel with this document. [[|]]

0 : Table of Contents

CLtL2 Reference

0 : Table of Contents
1 : Introduction
2 : Data Types
3 : Scope and Extent
4 : Type Specifiers
5 : Program Structure
- 5.3.1 : Defining Named Functions
- 5.3.2 : Declaring Global Variables and Named Constants
6 : Predicates
- 6.1 : Logical Values
- 6.2.2 : Specific Data Type Predicates
- 6.3 : Equality Predicates
- 6.4 : Logical Operators
7 : Control Structure
- 7.1.1 : Reference
- 7.1.2 : Assignment
- 7.2 : Generalized Variables
- 7.3 : Function Invocation
- 7.4 : Simple Sequencing
- 7.5 : Establishing New Variable Bindings
- 7.6 : Conditionals
- 7.7 : Blocks and Exits
- 7.8.2 : General Iteration
- 7.8.3 : Simple Iteration Constructs
- 7.8.4 : Mapping
- 7.10.1 : Constructs for Handling Multiple Values
- 7.10.2 : Rules Governing the Passing of Multiple Values
- 7.11 : Dynamic Non-Local Exits
8 : Macros
- 8.1 : Macro Definition
- 8.3 : Destructuring
- 8.5 : Environments
9 : Declarations
- 9.1 : Declaration Syntax
- 9.2 : Declaration Specifiers
10 : Symbols
- 10.1 : The Property List
- 10.2 : The Print Name
- 10.3 : Creating Symbols
11 : Packages
12 : Numbers
- 12.2 : Predicates on Numbers
- 12.3 : Comparisons on Numbers
- 12.4 : Arithmetic Operations
- 12.5 : Irrational and Transcendental Functions
- 12.6 : Type Conversions and Component Extractions on Numbers
- 12.7 : Logical Operations on Numbers
- 12.8 : Byte Manipulation Functions
- 12.9 : Random Numbers
- 12.10 : Implementation Parameters
13 : Characters
- 13.1 : Character Attributes
- 13.2 : Predicates on Characters
- 13.3 : Character Construction and Selection
- 13.4 : Character Conversions
14 : Sequences
- 14.1 : Simple Sequence Functions
- 14.2 : Concatenating, Mapping and Reducing Sequences
- 14.3 : Modifying Sequences
- 14.4 : Searching Sequences for Terms
- 14.5 : Sorting and Merging
15 : Lists
- 15.1 : Conses
- 15.2 : Lists
- 15.3 : Alteration of List Structure
- 15.4 : Substitution of Expressions
- 15.5 : Using Lists as Sets
- 15.6 : Association Lists
16 : Hash Tables
- 16.1 : Hash Table Functions
- 16.2 : Primitive Hash Function
17 : Arrays
- 17.1 : Vector Creation
- 17.2 : Vector Access
18 : Strings
- 18.1 : String Access
- 18.2 : String Comparison
- 18.3 : String Construction and Manipulation
19 : Structures
20 : The Evaluator
- 20.1 : Run-Time Evaluation of Forms
- 20.2 : The Top-Level Loop
21 : Streams
- 21.1 : Standard Streams
- 21.2 : Creating new Streams
- 21.3 : Operations on Streams
22 : Input/Output
- 22.1 : Printed Representation of SubL Objects
- 22.1.3 : Macro Characters
- 22.1.4 : Standard Dispatching Macro Character Syntax
- 22.1.5 : The Readtable
- 22.1.6 : What the Print Function Produces
- 22.2.1 : Input from Character Streams
- 22.2.2 : Input from Binary Streams
- 22.3.1 : Output to Character Streams
- 22.3.2 : Output to Binary Streams
- 22.3.3 : Formatted Output to Character Streams
23 : File System Interface
- 23.1 : File Names
- 23.2 : Opening and Closing Files
- 23.3 : Renaming, Deleting and Other File Operations
- 23.4 : Loading Files
- 23.5 : Accessing Directories
24 : Errors
- 24.1 : General Error-Signalling Functions
- 24.2 : Specialized Error-Signalling Forms and Macros
25 : Miscellaneous Features
- 25.1 : The Compiler
- 25.3 : Debugging Tools
- 25.4.1 : Time Functions
- 25.5 : Identity Function
28 : Common Lisp Object System
SubL-Specific Features
- SubL.1 : Signals
- SubL.2 : System Properties
- SubL.3 : Progress Pacifiers
- SubL.4 : Process Manipulation
- SubL.5 : Memory Interaction
Index

[[|]]

1 : Introduction

CLtL2 Reference

SubL is a programming language intended to be very similar to a simplified version of Common Lisp where those features that are either complex, rarely-used, or difficult to implement in a prodecural language have been excised.

Unlike Common Lisp, SubL is not a purely functional language. Several SubL constructs can only be used procedurally. In order to emphasize this difference, the following naming convention for SubL constructs is used:

A SubL function will have the same name as the analogous Common Lisp function if it is intended to have the exact same basic functionality. The argument list may be simplified, but the intent and use are likely to be the same.

If there is a substantial behavioral difference between a SubL function and its Common Lisp counterpart, its name will be the Common Lisp name prepended with a single character -- either "c", "p" or "f".

"c" indicates a construct that is either only procedural or functional.

"p" indicates the procedural version of a Common Lisp construct.
"f" indicates the functional version of a Common Lisp construct.

A procedural construct in SubL is one which is suitable for evaluation as either one form in an explicit PROGN or as one form in an implicit progn, which occur in the &body; sections of many of the procedural forms such as CLET, PWHEN, CDOLIST etc.

Here is a table of all the procedural constructs in SubL and the Common Lisp analog:

SubL Procedural Construct
Common Lisp Equivalent

PROGN
progn
PIF
if
PWHEN
when
PUNLESS
unless
PCOND
cond
PCASE
case
CSETQ
setq
CSETF
setf
CINC
incf
CDEC
decf
CPUSH
push
CPUSHNEW
pushnew
CPOP
pop
CLET
let*
CMULTIPLE-VALUE-BIND
multiple-value-bind
CDO
do*
CDOLIST
dolist
CSOME
` `
CDOTIMES
dotimes
CDOHASH
` `
CCATCH
catch
CUNWIND-PROTECT
unwind-protect
RET
return-from

A functional construct in SubL is one which returns a value. Here is a table of all the functional constructs in SubL and the Common Lisp analog:

SubL Functional Construct
Common Lisp Equvalent

CAND
and
COR
or
CNOT
not
FIF
if
FWHEN
when
FUNLESS
unless

The body of a function or macro definition is considered an implicit progn, and so all forms in the body should be procedural. A function call can be used as a procedural construct. In this case, the returned value is simply ignored. [[|]]

2 : Data Types

CLtL2 Reference

SubL has a flat type heirarchy. Each type is described in more detail in the sections about the methods for that particular type.

SubL supports these built-in Common Lisp datatypes:

<colgroup> <col width="50%" /> <col width="50%" /> </colgroup> <tbody>
</tbody>

Numbers: fixnum

float

Symbols: symbol

Lists: cons

Arrays: vector

Characters: character

Strings: string

Hashtables: eq hashtable

eql hashtable

equal hashtable

equalp hashtable

Streams: stream

Functions: function

SubL does not support these Common Lisp datatypes:

Multi-dimensional arrays

Packages
Pathnames
Random-states
Lambda-Expressions or Closures

SubL has only special-case support for these datatypes:

{|
| Readtables: | SubL only supports a single internal readtable |}
New data types can be introduced via DEFSTRUCT. [[|]]

3 : Scope and Extent

CLtL2 Reference

Special variables in SubL are all (and only) those variables defined globally with DEFVAR or DEFPARAMETER. In addition, the name of each special variable must begin and end with an asterisk character : '*'.

Special variables have indefinite scope and dynamic extent. All other variables have lexical scope and dynamic extent

Variables are introduced via:

Function call
A new set of variables for the formal parameters of the function are introduced. The extent of the function arguments is the duration of the function invocation.

CLET, CMULTIPLE-VALUE-BIND, CDESTRUCTURING-BIND
These constructs explicitly introduce and initialize new local variables. The extent of these variables is until exit from the constuct.

CDO, CDOLIST, CSOME, CDOTIMES, CDOHASH
These iteration constructs explicitly introduce and update local variables which represent the state of the iteration. The extent of these variables is until exit from the iteration construct.

When a local variable is introduced with the same name as a local variable which is already within the current scope and extent, the new variable shadows the outer variable.

The initialization of a local variable is considered to occur within the scope of the new local variable. Consequently, a variable which is shadowing an outer variable cannot be initialized in terms of the outer value. For example, this is not allowed :

(define foo (x)
  (clet ((x (+ x 1)))
    (print x))
  (ret nil))

However, if the variable is a special variable, the CLET is actually introducing a binding for the special variable, not introducing a new local variable. In this case, the initialization of the binding can be a function of its current value for the variable being bound. For example, this is allowed:

(defvar *some-var* 1)

(define foo (x)
  (clet ((*some-var* (+ *some-var* x)))
    (print *some-var*))
  (ret nil))

The construct RET must be used for a function or macro definition to return its intended result. [[|]]

4 : Type Specifiers

CLtL2 Reference

SubL does not support type specifiers. [[|]]

5 : Program Structure

CLtL2 Reference

Program structure in SubL mirrors that of Common Lisp almost exactly. All objects except lists and symbols are self-evaluating. This includes numbers, characters, strings, vectors and hashtables. In addition :

Keyword symbols are self-evaluating.
The symbols T and NIL are self-evaluating.

[[|]]

5.3.1 : Defining Named Functions

CLtL2 Reference
[[|]]macro DEFINE : (name arglist &body body)

All functions in SubL must be named and therefore defined via the SubL construct DEFINE. See also the similar construct DEFPOLYMORPHIC which is used to define generic functions which switch off the type of the first argument.

Argument lists for user-defined function can only be of this form:

( {var}* [&optional; {var | ( var [initform [supplied-var]] ) }*] )

In short, SubL supports &optional; arguments for user-defined functions but does not support &keyword;, &aux; or &rest; arguments for user-defined functions. [[|]]

5.3.2 : Declaring Global Variables and Named Constants

CLtL2 Reference
[[|]]macro DEFVAR : (variable &optional initialization documentation)
[[|]]macro DEFPARAMETER : (variable initialization &optional documentation)

DEFVAR and DEFPARAMETER are the SubL constructs used to define global variables. The name of each variable must begin and end with an asterisk.

SubL enforces an important distinction between these two constructs, which is described in greater detail under WRITE-IMAGE.
[[|]]macro DEFCONSTANT : (variable initialization &optional documentation)

As with DEFVAR and DEFPARAMETER, the name of each named constant defined via DEFCONSTANT must begin and end with an asterisk. [[|]]

6 : Predicates

CLtL2 Reference [[|]]

6.1 : Logical Values

CLtL2 Reference

The symbols NIL and T are used to represent the logical values "true" and "false" in SubL and behave exactly as they do in Common Lisp. [[|]]

6.2.2 : Specific Data Type Predicates

CLtL2 Reference

For the most part, the following predicates which check for specific data types behave exactly as they do in Common Lisp.
[[|]]function NULL : (x)
[[|]]function SYMBOLP : (x)
[[|]]function ATOM : (x)
[[|]]function CONSP : (x)
[[|]]function LISTP : (x)
[[|]]function NUMBERP : (x)
[[|]]function INTEGERP : (x)
[[|]]function FLOATP : (x)
[[|]]function CHARACTERP : (x)
[[|]]function STRINGP : (x)
[[|]]function VECTORP : (x)
[[|]]function FUNCTIONP : (x)
Follows the CLtL2 implementation
[[|]]function FUNCTION-SPEC-P : (x)
Returns T IFF x is an object suitable for FUNCALL

In SubL, FUNCTIONP only returns T if its argument is a function object. The function FUNCTION-SPEC-P returns T if its argument is suitable for FUNCALL or APPLY. [[|]]

6.3 : Equality Predicates

CLtL2 Reference

6.4 : Logical Operators

CLtL2 Reference

SubL logical operations only return T or NIL. Otherwise, they behave like their Common Lisp counterparts.
[[|]]macro CNOT : (x)
[[|]]macro CAND : (&rest args)
[[|]]macro COR : (&rest args) [[|]]

7 : Control Structure

CLtL2 Reference [[|]]

7.1.1 : Reference

CLtL2 Reference

7.1.2 : Assignment

CLtL2 Reference
[[|]]macro CSETQ : (var value &rest var-val-pairs)

Since CSETQ is procedural in SubL, it does not return a value. Otherwise, it behaves just like setq in Common Lisp.

These SubL functions for setting and unsetting symbol properties behave like their Common Lisp counterparts.
[[|]]function SET : (symbol value)
[[|]]function MAKUNBOUND : (symbol)
[[|]]function FMAKUNBOUND : (symbol) [[|]]

7.2 : Generalized Variables

CLtL2 Reference
[[|]]macro CSETF : (place val)

CSETF is a more restricted version of setf in Common Lisp. First, since it is procedural, like CSETQ it does not return a value. Second, there is a much more restricted set of place-specifiers which are allowable. Here is a complete table of the allowable CSETF forms, and their equivalent SubL expansions:

CSETF form

Equivalent SubL expansion

(CSETF variable value)

(CSETQ variable value)

(CSETF (AREF vector n) value)

(SET-AREF vector n value)

(CSETF (NTH n list) value)

(SET-NTH n list value)

(CSETF (CAR cons) value)

(RPLACA cons value)

(CSETF (CDR cons) value)

(RPLACD cons value)

(CSETF (GET symbol indicator) value)

(PUT symbol indicator value)

(CSETF (GETHASH key hashtable) value)

(SETHASH key hashtable value)

(CSETF (SYMBOL-VALUE symbol) value)

(SET symbol value)

(CSETF (defstruct-slot object) value)

(set-defstruct-slot object value)

In the above table, defstruct-slot refers to any structure slot accessor function which got defined via defstruct, and set-defstruct-slot refers to the corresponding setter function for the given accessor. [[|]]

7.3 : Function Invocation

CLtL2 Reference

These functions behave like their Common Lisp counterparts.
[[|]]function APPLY : (function argument &rest arguments)
[[|]]function FUNCALL : (function &rest args)

The first argument to both APPLY and FUNCALL must satisfy FUNCTION-SPEC-P. [[|]]

7.4 : Simple Sequencing

CLtL2 Reference
[[|]]macro PROGN : (&body body)

In SubL, PROGN is procedural and therefore does not return a value. Since it is intended to be essentially procedural in Common Lisp as well, the same name is used even though they have slightly different semantics. [[|]]

7.5 : Establishing New Variable Bindings

CLtL2 Reference
[[|]]macro CLET : (bindings &body body)

The SubL construct CLET can be used to introduce new local variables or bind special variables. The variables are initialized in order just like LET* in Common Lisp. Since it is procedural, it does not return a value.

SubL has no counterpart to Common Lisp's LET construct.
[[|]]macro CPROGV : (special-vars bindings &body body)

CPROGV is procedural and therefore does not return a value. Otherwise, it is equivalent to progv in Common Lisp. [[|]]

7.6 : Conditionals

CLtL2 Reference
[[|]]macro PIF : (condition action else-action)
[[|]]macro PWHEN : (condition &body body)
[[|]]macro PUNLESS : (condition &body body)

PIF, PWHEN and PUNLESS are the SubL procedural variants of if, when and unless from Common Lisp. For each, the condition argument must be a functional construct. Also, PIF takes exactly three arguments, making the action and else-actions identical in form.
[[|]]macro FIF : (condition true-value false-value)
[[|]]macro FWHEN : (condition true-value)
[[|]]macro FUNLESS : (condition false-value)

FIF, FWHEN and FUNLESS are the SubL functional variants of if, when and unless from Common Lisp.
[[|]]macro PCOND : (&rest clauses)
[[|]]macro PCASE : (test-object &body clauses)

PCOND and PCASE are the SubL procedural equivalents of cond and case from Common Lisp. [[|]]

7.7 : Blocks and Exits

CLtL2 Reference
[[|]]macro RET : (expression)
SubL functions must always return a value, since C functions must return values and all SubL functions must translate into C.

RET is used to return a value from a function or macro definition. All functions and macro definitions behave as if an implicit

(ret nil)

appears at the very end of each function. [[|]]

7.8.2 : General Iteration

CLtL2 Reference
[[|]]macro CDO : (vars endtest &body body)
cdo is procedural. It binds its variables in sequence, as with CommonLisp do* [[|]]

7.8.3 : Simple Iteration Constructs

7.8.4 : Mapping

CLtL2 Reference
[[|]]function MAPCAR : (function list &rest more-lists)
[[|]]function MAPLIST : (function list &rest more-lists)
[[|]]function MAPC : (function list &rest more-lists)
[[|]]function MAPL : (function list &rest more-lists)
[[|]]function MAPCAN : (function list &rest more-lists)
[[|]]function MAPCON : (function list &rest more-lists) [[|]]

7.10.1 : Constructs for Handling Multiple Values

CLtL2 Reference
[[|]]function VALUES : (value &rest more-values)
values returns its args such that they can be bound in a dynamically enclosing multiple-value-bind. The first value is returned as well, since all SubL functions must return a value.
[[|]]variable *MULTIPLE-VALUES-LIMIT*
[[|]]macro MULTIPLE-VALUE-LIST : (form)
[[|]]macro CMULTIPLE-VALUE-BIND : (vars value &body body) [[|]]

7.10.2 : Rules Governing the Passing of Multiple Values

CLtL2 Reference

In SubL, multiple values are governed the same way that they are in Common Lisp, except that if ANY of the return statements in your function are (values ...) then all of them must be. [[|]]

7.11 : Dynamic Non-Local Exits

CLtL2 Reference
[[|]]macro CCATCH : (tag ans-var &body body)
ccatch is procedural, and so does not return values.
[[|]]macro CUNWIND-PROTECT : (protected-form &body body)
[[|]]function THROW : (tag result) [[|]]

8 : Macros

CLtL2 Reference [[|]]

8.1 : Macro Definition

CLtL2 Reference
[[|]]macro DEFMACRO : (name pattern &body body)

SubL Macros are expanded at translation-time. Full Common Lisp macro support is available. However, the macro-expander must use RET to return the expansion. [[|]]

8.3 : Destructuring

CLtL2 Reference
[[|]]macro CDESTRUCTURING-BIND : (pattern datum &body body) [[|]]

8.5 : Environments

CLtL2 Reference
[[|]]function VARIABLE-INFORMATION : (variable)
[[|]]function FUNCTION-INFORMATION : (function) [[|]]

9 : Declarations

CLtL2 Reference [[|]]

9.1 : Declaration Syntax

CLtL2 Reference
[[|]]function DECLARE : (&rest ignore)
[[|]]function PROCLAIM : (declaration-specifier)
[[|]]macro DECLAIM : (&rest declaration-specifiers) [[|]]

9.2 : Declaration Specifiers

CLtL2 Reference
[[|]]function IGNORE : (&rest values)

The IGNORE function can be used to indicate that a particular variable's value is not used. [[|]]

10 : Symbols

CLtL2 Reference
[[|]]function SYMBOLP : (x) [[|]]

10.1 : The Property List

10.2 : The Print Name

CLtL2 Reference
[[|]]function SYMBOL-NAME : (symbol)
Returns the string which is the name of SYMBOL. When called on a keyword, it returns the ":" prefix as part of the name [[|]]

10.3 : Creating Symbols

CLtL2 Reference
[[|]]function MAKE-SYMBOL : (print-name)
[[|]]function GENSYM : (&optional x)
GENSYM returns new, interned symbols, which are combinations of a string prefix and a numeric suffix. It guarantees that the new symbol was not previously interned.
If the argument X is a number, the gensym counter (used to generate the suffix) is set to X before the new symbol is generated.
if the argument X is a string, the gensym prefix is set to X before the new symbol is generated.
The initial gensym counter value is 1 and the initial gensym prefix is 'G'.
[[|]]function GENTEMP : (&optional (prefix "T"))
[[|]]function KEYWORDP : (x)
In SubL, which does not have packages, keywords are any symbol whose name begins with ":" [[|]]

11 : Packages

CLtL2 Reference
[[|]]macro IN-PACKAGE : (name)
[[|]]function INTERN : (string)
Finds and returns a symbol whose name is STRING. INTERN will create the symbol if it does not exist. Unlike Common LISP intern, the SubL version does not allow an argument to specify the package, since SubL does not support packages.
[[|]]function FIND-SYMBOL : (string)
Finds and returns a symbol whose name is STRING. Unlike Common LISP FIND-SYMBOL, the SubL version does not allow an argument to specify the package, since SubL does not support packages. [[|]]

12 : Numbers

CLtL2 Reference

12.2 : Predicates on Numbers

12.3 : Comparisons on Numbers

The above numeric comparison functions take exactly 2 arguments, unlike their Common Lisp counterparts which take variable numbers of arguments.
[[|]]function MAX : (num &rest numbers)
[[|]]function MIN : (num &rest numbers) [[|]]

12.4 : Arithmetic Operations

12.5 : Irrational and Transcendental Functions

CLtL2 Reference

SubL does not currently support any irrational, transcendental or trigonometric functions. [[|]]

12.6 : Type Conversions and Component Extractions on Numbers

12.7 : Logical Operations on Numbers

CLtL2 Reference

SubL does not currently support any logical operations on numbers. [[|]]

12.8 : Byte Manipulation Functions

CLtL2 Reference
[[|]]macro BYTE : (size position)
[[|]]function LDB : (bytespec integer)
[[|]]function DPB : (newbyte bytespec integer) [[|]]

12.9 : Random Numbers

CLtL2 Reference
[[|]]variable *RAND-MAX*

rand-max* is the largest fixnum that the function random can accept.

[[|]]function SEED-RANDOM : (&optional (seed-fixnum (mod (get-internal-real-time) *rand-max*)))
If seed-fixnum is omitted to seed-random, the internal clock is used
in an implementation specific manner.
[[|]]function RANDOM : (number) [[|]]

12.10 : Implementation Parameters

CLtL2 Reference
[[|]]variable *MOST-POSITIVE-FIXNUM*
[[|]]variable *MOST-NEGATIVE-FIXNUM* [[|]]

13 : Characters

CLtL2 Reference
[[|]]function CHARACTERP : (x) [[|]]

13.1 : Character Attributes

CLtL2 Reference

SubL does not currently support any attributes for characters. A character exists for each ASCII character code between 0 and 255 inclusive. Thus, the SubL equivalent of Common Lisp's CHAR-CODE-LIMIT is 256. [[|]]

13.2 : Predicates on Characters

13.3 : Character Construction and Selection

CLtL2 Reference
[[|]]function CHAR-CODE : (char)
[[|]]function CODE-CHAR : (code) [[|]]

13.4 : Character Conversions

CLtL2 Reference
[[|]]function CHAR-DOWNCASE : (char)
[[|]]function CHAR-UPCASE : (char) [[|]]

14 : Sequences

CLtL2 Reference
[[|]]function SEQUENCEP : (x) [[|]]

14.1 : Simple Sequence Functions

14.2 : Concatenating, Mapping and Reducing Sequences

CLtL2 Reference
[[|]]function CCONCATENATE : (seq &rest more-seqs)
[[|]]function CREDUCE : (function sequence &optional (start 0) end (init-value :none)) [[|]]

14.3 : Modifying Sequences

CLtL2 Reference
[[|]]function FILL : (sequence item &optional (start 0) (end (length sequence)))
[[|]]function REPLACE : (sequence1 sequence2 &optional (start1 0) end1 (start2 0) end2)
[[|]]function REMOVE : (item sequence &optional (test #'eql) (key #'identity) (start 0) end count)
[[|]]function REMOVE-IF : (test sequence &optional (key #'identity) (start 0) end count)
[[|]]function DELETE : (item sequence &optional (test #'eql) (key #'identity) (start 0) end count)
[[|]]function DELETE-IF : (test sequence &optional (key #'identity) (start 0) end count)
[[|]]function REMOVE-DUPLICATES : (sequence &optional (test #'eql) (key #'identity) (start 0) end)
[[|]]function DELETE-DUPLICATES : (sequence &optional (test #'eql) (key #'identity) (start 0) end)
[[|]]function SUBSTITUTE : (new old sequence &optional (test #'eql) (key #'identity) (start 0) end count)
[[|]]function SUBSTITUTE-IF : (new test sequence &optional (key #'identity) (start 0) end count)
[[|]]function NSUBSTITUTE : (new old sequence &optional (test #'eql) (key #'identity) (start 0) end count)
[[|]]function NSUBSTITUTE-IF : (new test sequence &optional (key #'identity) (start 0) end count) [[|]]

14.4 : Searching Sequences for Terms

CLtL2 Reference
[[|]]function FIND : (item seq &optional (test #'eql) (key #'identity) (start 0) end)
[[|]]function FIND-IF : (test seq &optional (key #'identity) (start 0) end)
[[|]]function POSITION : (item seq &optional (test #'eql) (key #'identity) (start 0) end)
[[|]]function POSITION-IF : (test seq &optional (key #'identity) (start 0) end)
[[|]]function COUNT : (item seq &optional (test #'eql) (key #'identity) (start 0) end)
[[|]]function COUNT-IF : (test seq &optional (key #'identity) (start 0) end)
[[|]]function MISMATCH : (seq1 seq2 &optional (test #'eql) (key #'identity) (start1 0) end1 (start2 0) end2)
[[|]]function SEARCH : (seq1 seq2 &optional (test #'eql) (key #'identity) (start1 0) end1 (start2 0) end2) [[|]]

14.5 : Sorting and Merging

CLtL2 Reference
[[|]]function SORT : (seq predicate &optional (key #'identity))
[[|]]function STABLE-SORT : (seq predicate &optional (key #'identity))
[[|]]function CMERGE : (seq1 seq2 predicate &optional (key #'identity)) [[|]]

15 : Lists

CLtL2 Reference
[[|]]function LISTP : (x)
[[|]]function CONSP : (x)
[[|]]function ATOM : (x) [[|]]

15.1 : Conses

15.2 : Lists

15.3 : Alteration of List Structure

CLtL2 Reference
[[|]]function RPLACA : (cons newcar)
[[|]]function RPLACD : (cons newcdr)
[[|]]function SET-NTH : (n list value) [[|]]

15.4 : Substitution of Expressions

CLtL2 Reference
[[|]]function SUBST : (new old tree &optional (test #'eql) (key #'identity))
[[|]]function SUBST-IF : (new test tree &optional (key #'identity))
[[|]]function NSUBST : (new old tree &optional (test #'eql) (key #'identity))
[[|]]function NSUBST-IF : (new test tree &optional (key #'identity))
[[|]]function SUBLIS : (alist tree &optional (test #'eql) (key #'identity))
[[|]]function NSUBLIS : (alist tree &optional (test #'eql) (key #'identity)) [[|]]

15.5 : Using Lists as Sets

CLtL2 Reference
[[|]]function MEMBER : (item list &optional (test #'eql) (key #'identity))
[[|]]function MEMBER-IF : (test list &optional (key #'identity))
[[|]]function TAILP : (sublist list)
[[|]]function ADJOIN : (item list &optional (test #'eql) (key #'identity))
[[|]]function UNION : (list1 list2 &optional (test #'eql) (key #'identity))
[[|]]function NUNION : (list1 list2 &optional (test #'eql) (key #'identity))
[[|]]function INTERSECTION : (list1 list2 &optional (test #'eql) (key #'identity))
[[|]]function NINTERSECTION : (list1 list2 &optional (test #'eql) (key #'identity))
[[|]]function SET-DIFFERENCE : (list1 list2 &optional (test #'eql) (key #'identity))
[[|]]function NSET-DIFFERENCE : (list1 list2 &optional (test #'eql) (key #'identity))
[[|]]function SET-EXCLUSIVE-OR : (list1 list2 &optional (test #'eql) (key #'identity))
[[|]]function NSET-EXCLUSIVE-OR : (list1 list2 &optional (test #'eql) (key #'identity))
[[|]]function SUBSETP : (list1 list2 &optional (test #'eql) (key #'identity)) [[|]]

15.6 : Association Lists

CLtL2 Reference
[[|]]function ACONS : (key datum alist)
[[|]]function PAIRLIS : (keys data &optional alist)
[[|]]function ASSOC : (item alist &optional (test #'eql) (key #'identity))
[[|]]function ASSOC-IF : (predicate alist)
[[|]]function RASSOC : (item alist &optional (test #'eql) (key #'identity))
[[|]]function RASSOC-IF : (predicate alist) [[|]]

16 : Hash Tables

CLtL2 Reference

[[|]]

16.1 : Hash Table Functions

16.2 : Primitive Hash Function

CLtL2 Reference
[[|]]function SXHASH : (object) [[|]]

17 : Arrays

CLtL2 Reference

SubL only supports one-dimensional arrays, which are called vectors.
[[|]]function VECTORP : (x) [[|]]

17.1 : Vector Creation

CLtL2 Reference
[[|]]function MAKE-VECTOR : (size &optional initial-element)
[[|]]function VECTOR : (&rest objects) [[|]]

17.2 : Vector Access

CLtL2 Reference
[[|]]function AREF : (vector index)
[[|]]function SET-AREF : (vector index value) [[|]]

18 : Strings

CLtL2 Reference
[[|]]function STRINGP : (x) [[|]]

18.1 : String Access

CLtL2 Reference
[[|]]function CHAR : (string index)
[[|]]function SET-CHAR : (string index value) [[|]]

18.2 : String Comparison

CLtL2 Reference
[[|]]function STRING= : (string1 string2 &optional (start1 0) end1 (start2 0) end2)
[[|]]function STRING-EQUAL : (string1 string2 &optional (start1 0) end1 (start2 0) end2)
[[|]]function STRING< : (string1 string2 &optional (start1 0) end1 (start2 0) end2)
[[|]]function STRING> : (string1 string2 &optional (start1 0) end1 (start2 0) end2)
[[|]]function STRING<= : (string1 string2 &optional (start1 0) end1 (start2 0) end2)
[[|]]function STRING>= : (string1 string2 &optional (start1 0) end1 (start2 0) end2)
[[|]]function STRING/= : (string1 string2 &optional (start1 0) end1 (start2 0) end2)
[[|]]function STRING-LESSP : (string1 string2 &optional (start1 0) end1 (start2 0) end2)
[[|]]function STRING-GREATERP : (string1 string2 &optional (start1 0) end1 (start2 0) end2)
[[|]]function STRING-NOT-GREATERP : (string1 string2 &optional (start1 0) end1 (start2 0) end2)
[[|]]function STRING-NOT-LESSP : (string1 string2 &optional (start1 0) end1 (start2 0) end2)
[[|]]function STRING-NOT-EQUAL : (string1 string2 &optional (start1 0) end1 (start2 0) end2) [[|]]

18.3 : String Construction and Manipulation

CLtL2 Reference
[[|]]function MAKE-STRING : (size &optional (initial-element #\Space))
[[|]]function STRING-TRIM : (char-list string)
[[|]]function STRING-LEFT-TRIM : (char-list string)
[[|]]function STRING-RIGHT-TRIM : (char-list string)
[[|]]function STRING-UPCASE : (string &optional (start 0) end)
[[|]]function STRING-DOWNCASE : (string &optional (start 0) end)
[[|]]function STRING-CAPITALIZE : (string &optional (start 0) end)
[[|]]function NSTRING-UPCASE : (string &optional (start 0) end)
[[|]]function NSTRING-DOWNCASE : (string &optional (start 0) end)
[[|]]function NSTRING-CAPITALIZE : (string &optional (start 0) end)
[[|]]function STRING : (x) [[|]]

19 : Structures

CLtL2 Reference
[[|]]macro DEFSTRUCT : ((name &rest options) &body slots)
Like Common Lisp defstruct except:

(1) slot initializations are not allowed.

(2) the only other options:
(:conc-name whatever)
(:print-function #'whatever)

the default structure print function is
default-struct-print-function : object stream depth

(3) The make constructor takes no arguments and only makes an empty structure.

(4) Reading of structures is not supported by the reader.
[[|]]function DEFAULT-STRUCT-PRINT-FUNCTION : (object stream depth)
[[|]]macro PRINTING-OBJECT : ((object stream) &body body) [[|]]

20 : The Evaluator

CLtL2 Reference

[[|]]

20.1 : Run-Time Evaluation of Forms

CLtL2 Reference
[[|]]function EVAL : (form)
[[|]]function CONSTANTP : (object &optional env)

The Common Lisp functions evalhook and applyhook are not supported in SubL. [[|]]

20.2 : The Top-Level Loop

CLtL2 Reference
[[|]]variable *
[[|]]variable **
[[|]]variable ***

For convenience, the top-level readloop binds the following variables after each form is evaluated:

*  the last value returned
**  the previous value of *
*** the previous value of **

[[|]]

21 : Streams

CLtL2 Reference
[[|]]function STREAMP : (x) [[|]]

21.1 : Standard Streams

CLtL2 Reference
[[|]]variable *STANDARD-INPUT*
[[|]]variable *STANDARD-OUTPUT*
[[|]]variable *ERROR-OUTPUT*
[[|]]variable *NULL-OUTPUT*
A bit-sink output stream. All output is ignored

The other standard streams supported by Common Lisp are not supported by SubL. [[|]]

21.2 : Creating new Streams

CLtL2 Reference
[[|]]function OPEN-TCP-STREAM : (host port) [[|]]

21.3 : Operations on Streams

22 : Input/Output

CLtL2 Reference [[|]]

22.1 : Printed Representation of SubL Objects

CLtL2 Reference [[|]]

22.1.3 : Macro Characters

CLtL2 Reference

The SubL reader supports the following macro characters, whose meaning is identical to their meaning in Common Lisp :

Macro Character

Â Â Â
Reader Action

(
Begin reading a list.
)
End reading a list or a vector.
'
Read in a quoted expression.
;
Read a comment until end-of-line.
"
Begin or end reading a string.
`
Read in a backquoted expression.

In addition, the following comma-readers are supported inside of backquote :

,  
,@  
,.

Their behavior is identical to their Common Lisp counterparts. [[|]]

22.1.4 : Standard Dispatching Macro Character Syntax

CLtL2 Reference

'#' is the SubL standard dispatching macro character. The SubL reader supports the following dispatch macro character sequences, whose meanings are identical to their meanings in Common Lisp :

Dispatch Sequence

Â Â Â
Reader Action

#\(
Read a character constant.
#'
Read a function constant.
#(
Begin reading a vector.
#|
Begin reading a comment section.
|#
End reading a comment section.

Additionally, SubL supports the dispatch sequence #$ as follows :

#$foo reads the Cyc constant whose name is "foo"

[[|]]

22.1.5 : The Readtable

CLtL2 Reference

SubL internally uses a readtable, but it is not visible to the programmer. [[|]]

22.1.6 : What the Print Function Produces

CLtL2 Reference
[[|]]variable *PRINT-ESCAPE* [[|]]

22.2.1 : Input from Character Streams

CLtL2 Reference
[[|]]function READ : (&optional (stream *standard-input*) (eof-error-p t) (eof-value :eof))
Returns FORM if read was successful.
Returns the values NIL :ERROR if there was a reader error.
Returns the values EOF-VALUE :ERROR if EOF-ERROR-P is nil and EOF occurs.
Causes an error if EOF-ERROR-P is not nil and EOF occurs.

Differences from Common Lisp:
`Numbers are only read in decimal notation with no specified radix. No character modifiers: only standard chars plus specials like Space, Return etc. The || notation and \\ syntax for symbols are not supported. []()functionREAD-LINE : (&optional (stream standard-input) (eof-error-p t) (eof-value :eof))[]()functionREAD-CHAR : (&optional (stream standard-input) (eof-error-p t) (eof-value :eof))[]()functionUNREAD-CHAR : (char &optional (stream standard-input))[]()functionREAD-FROM-STRING : (string &optional (eof-error-p t) (eof-value :eof) (start 0) end)`
Returns the values FORM NEW-START if read was successful.
Returns the values NIL :ERROR if there was a reader error.
Returns the values EOF-VALUE :ERROR if EOF-ERROR-P is nil and EOF occurs.
Causes an error if EOF-ERROR-P is not nil and EOF occurs.
Returns a second value which is an integer indicating the position in the string to
start reading from again or :ERROR if there was some kind of reader error. [[|]]

22.2.2 : Input from Binary Streams

CLtL2 Reference
[[|]]function READ-BYTE : (stream &optional (eof-error-p t) (eof-value :eof)) [[|]]

22.3.1 : Output to Character Streams

CLtL2 Reference
[[|]]function WRITE : (object &optional (stream *standard-output*) (escape *print-escape*))
[[|]]function PRIN1 : (object &optional (stream *standard-output*))
[[|]]function PRINT : (object &optional (stream *standard-output*))
[[|]]function PRINC : (object &optional (stream *standard-output*))
[[|]]function WRITE-TO-STRING : (object &optional (escape *print-escape*))
[[|]]function PRIN1-TO-STRING : (object)
[[|]]function PRINC-TO-STRING : (object)
[[|]]function WRITE-CHAR : (char &optional (stream *standard-output*))
[[|]]function WRITE-STRING : (string &optional (stream *standard-output*) (start 0) end)
[[|]]function WRITE-LINE : (string &optional (stream *standard-output*) (start 0) end)
[[|]]function TERPRI : (&optional (stream *standard-output*))
[[|]]function FORCE-OUTPUT : (&optional (stream *standard-output*)) [[|]]

22.3.2 : Output to Binary Streams

CLtL2 Reference
[[|]]function WRITE-BYTE : (integer stream) [[|]]

22.3.3 : Formatted Output to Character Streams

CLtL2 Reference
[[|]]function FORMAT : (destination control-string &rest arguments)
Format ARGUMENTS to the text stream DESTINATION according to the specifications in CONTROL-STRING. SubL format is more limited than the Common Lisp version: the only escapes allowed in the control string are: ~A ~a ~S ~s ~D ~d (with width and pad parameters optional) ~C ~c ~G ~g ~% ~~ [[|]]

23 : File System Interface

CLtL2 Reference [[|]]

23.1 : File Names

CLtL2 Reference
[[|]]variable *DEFAULT-PATHNAME-DEFAULTS*
[[|]]function CONSTRUCT-FILENAME : (directory-list filename &optional extension relative?)

Pathnames are just strings in SubL. Common Lisp pathname objects are not supported. [[|]]

23.2 : Opening and Closing Files

CLtL2 Reference
[[|]]function OPEN-TEXT : (filename direction)
Attempts to open the file FILENAME. If successful, returns an 8-bit character text stream. If DIRECTION is :input, then input operations can be performed on the stream. If DIRECTION is output, then output is directed to the file FILENAME, overwriting any existing file. If DIRECTION is :append, then output is appended to the file. For either output case, a new file is created if no file named FILENAME already exists.
[[|]]function OPEN-BINARY : (filename direction)
Attempts to open the file FILENAME. If successful, returns an 8-bit binary byte stream. If DIRECTION is :input, then input operations can be performed on the stream. If DIRECTION is output, then output is directed to the file FILENAME, overwriting any existing file. If DIRECTION is :append, then output is appended to the file. For either output case, a new file is created if no file named FILENAME already exists.
[[|]]macro WITH-TEXT-FILE : ((stream filestring direction) &body body)
In the scope of a WITH-TEXT-FILE expression, the file FILESTRING is opened for character i/o and a stream to this file is created and bound to the variable STREAM. If DIRECTION is :input, then input operations can be performed on STREAM. If DIRECTION is :output, then output operations can be performed, overwriting any existing file. If DIRECTION is :append, then output is appended to an existing file.
[[|]]macro WITH-BINARY-FILE : ((stream filestring direction) &body body)
In the scope of a WITH-BINARY-FILE expression, the file FILESTRING is opened for binary i/o and a stream to this file is created and bound to the variable STREAM. If DIRECTION is :input, then input operations can be performed on STREAM. If DIRECTION is :output, then output operations can be performed, overwriting any existing file. If DIRECTION is :append, then output is appended to an existing file. [[|]]

23.3 : Renaming, Deleting and Other File Operations

CLtL2 Reference
[[|]]function RENAME-FILE : (filename new-name)
[[|]]function DELETE-FILE : (filename)
[[|]]function PROBE-FILE : (filename)
[[|]]function APPEND-FILES : (filename-1 filename-2 &optional (mode :text))
Append filename-1 to filename-2
[[|]]function FILE-WRITE-DATE : (filename)
[[|]]function FILE-AUTHOR : (filename)
[[|]]function GET-FILE-POSITION : (stream)
[[|]]function SET-FILE-POSITION : (stream n)
[[|]]function FILE-LENGTH : (stream) [[|]]

23.4 : Loading Files

CLtL2 Reference
[[|]]function LOAD : (filename) [[|]]

23.5 : Accessing Directories

CLtL2 Reference
[[|]]function DIRECTORY : (directory-name &optional include-directory) [[|]]

24 : Errors

CLtL2 Reference [[|]]

24.1 : General Error-Signalling Functions

CLtL2 Reference
[[|]]variable *ERROR-ABORT-HANDLER*
If *error-abort-handler* is non-nil, then an ABORT option is available inside ERROR and CERROR.
If chosen, then the handler is funcalled on no arguments.
[[|]]variable *ERROR-HANDLER*
If *ERROR-SIGNAL* is non-nil, then that function is called upon an error. Otherwise, the debugger is invoked.
[[|]]variable *ERROR-MESSAGE*
[[|]]function ERROR : (format-string &rest arguments)
[[|]]variable *CONTINUE-CERROR?*
[[|]]function CERROR : (continue-string format-string &rest arguments)
[[|]]variable *IGNORE-WARNS?*
If T, all warnings forms are ignored
[[|]]function WARN : (format-string &rest arguments)
[[|]]variable *IGNORE-BREAKS?*
If non-NIL, all break forms are ignored
[[|]]function BREAK : (format-string &rest arguments) [[|]]

24.2 : Specialized Error-Signalling Forms and Macros

CLtL2 Reference
[[|]]variable *IGNORE-MUSTS?*
If non-NIL, all must forms are ignored
[[|]]macro MUST : (form format-string &rest arguments)
[[|]]variable *SUSPEND-TYPE-CHECKING?*
CHECK-TYPE tests are performed iff this is non-nil
[[|]]macro CHECK-TYPE : (object pred) [[|]]

25 : Miscellaneous Features

CLtL2 Reference [[|]]

25.1 : The Compiler

CLtL2 Reference

SubL currently does not provide any compilation support. [[|]]

25.3 : Debugging Tools

CLtL2 Reference
[[|]]macro CTIME : (var &body body)
[[|]]function DEBUG : ()
Pauses execution and invokes the debugger. [[|]]

25.4.1 : Time Functions

CLtL2 Reference
[[|]]variable *EPOCH*

epoch* is the current epoch in use, which is a universal time.

The system needs to at least be able to handle epochs back to midnight Jan 1 1970.

epoch* is globally initialized to midnight Jan 1 1970.

All universal times are relative to *epoch*.
[[|]]function GET-UNIVERSAL-TIME : ()
[[|]]function DECODE-UNIVERSAL-TIME : (universal-time)
[[|]]function ENCODE-UNIVERSAL-TIME : (second minute hour date month year)
[[|]]function TIME-FROM-NOW : (delta)
[[|]]function TIME-HAS-ARRIVED? : (time)
[[|]]function ENCODE-TIMESTRING : (second minute hour date month year)
[[|]]function TIMESTRING : (&optional (universal-time (get-universal-time)))
timestring returns a string in the format dd/mm/yy hh:mm:ss from the
universal time given. If none is given, the current time is used.
[[|]]variable *CLOCK-GRANULARITY*

clock-granularity* is the number of internal clock units per second.

time evals form and returns the number of internal clock units it took
to execute.
[[|]]function GET-INTERNAL-REAL-TIME : ()
[[|]]function SLEEP : (seconds) [[|]]

25.5 : Identity Function

CLtL2 Reference
[[|]]function IDENTITY : (object) [[|]]

28 : Common Lisp Object System

CLtL2 Reference
[[|]]macro DEFPOLYMORPHIC : (name lambda-list &body body)
Defines a new polymorphic function that dispatches on the type of its first argument. <body> defines a default method. The function define-method can be used to define additional methods. For example:

(defpolymorphic test (a b)
` `(list a b))

(define-method test ((a cons) b)
` `(cons b a))

(define-method test ((a fixnum) b)
` `(+ a b))

The defpolymorphic form defines the function TEST with a default method.
` `The two define-method forms specialize the behavior of TEST for lists and fixnums.

(test 'foo 'bar) => (FOO BAR)
`(test '(foo) 'bar) => (BAR FOO) (test 2 3) => 5 []()macroDEFINE-METHOD : (name lambda-list &body body)`
Defines a method for the polymorphic function <name> that runs if
<dispatch-arg> is of type <type>. The lambda list must have the same
structure as in the DEFPOLYMORPHIC call. [[|]]

SubL-Specific Features

[[|]] SubL.1 : Signals
[[|]]variable *SIGNAL-MAX*
There are *signal-max* total signals available.
[[|]]function DEFAULT-SIGNAL-HANDLER : (signal)
[[|]]function INSTALL-SIGNAL-HANDLER : (signal function)

[[|]] SubL.2 : System Properties
[[|]]function GET-PROCESS-ID : (&optional default)
Return the current heavyweight process id of this current SubL
program. Return DEFAULT if this cannot be determined.
[[|]]function GET-MACHINE-NAME : (&optional default)
[[|]]function GET-NETWORK-NAME : (&optional default)
[[|]]function GET-USER-NAME : (&optional default)

[[|]] SubL.4 : Process Manipulation
[[|]]function FORK-PROCESS : (function &optional callback output-file)
Spawn a heavyweight child process to call FUNCTION, which takes no arguments.
FUNCTION must return an integer.
CALLBACK, if provided, must be a function of one argument which is called
on the returned value within the address space of the parent process.
OUTPUT-FILE, if provided, is a file to which standard output and error are piped
while executing FUNCTION.
[[|]]function RESTART-PROCESS : (&optional world-spec init-file-pathname init-form-spec)
Restart the current heavyweight process.
WORLD-SPEC, if provided, is the filename of a world to use.
INIT-FILE-PATHNAME, if provided, is a file of initializatio forms to eval.
INIT-FORM-SPEC, if provided, is a form to execute.
The values used for these when the current process was started are used if unprovided.

[[|]] SubL.5 : Memory Interaction
[[|]]function GC : (&optional level)
[[|]]macro WITH-STATIC-AREA : (&body body)
[[|]]function WRITE-IMAGE : (filename &optional do-full-gc)
Save the current state of virtual memory in a file called FILENAME.
If DO-FULL-GC is true, then a full garbage collection is
performed before writing the image. Otherwise, a dynamic
garbage collection is performed and remaining objects are
promoted to being static ones.

During the initialization of a SubL system at startup, variables defined via DEFVAR have their initial values set via their state in the world file used at startup, ignoring the initial value specified by the code. DEFPARAMETER variables and DEFCONSTANT global constants have their values initialized via the code on startup.

The net result of this distinction is as follows: if a world is saved out via WRITE-IMAGE, and then used to restart a SubL system, the values of DEFVAR variables will persist, while any changes to DEFPARAMETER variables will be lost when they are reset to their original code-specified initial values on startup. [[|]]

Index

CLtL2 Reference

A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z

* function
* variable
** variable
*** variable
*CLOCK-GRANULARITY* variable
*CONTINUE-CERROR?* variable
*DEFAULT-PATHNAME-DEFAULTS* variable
*EPOCH* variable
*ERROR-ABORT-HANDLER* variable
*ERROR-HANDLER* variable
*ERROR-MESSAGE* variable
*ERROR-OUTPUT* variable
*IGNORE-BREAKS?* variable
*IGNORE-MUSTS?* variable
*IGNORE-WARNS?* variable
*MOST-NEGATIVE-FIXNUM* variable
*MOST-POSITIVE-FIXNUM* variable
*MULTIPLE-VALUES-LIMIT* variable
*NULL-OUTPUT* variable
*PRINT-ESCAPE* variable
*RAND-MAX* variable
*SIGNAL-MAX* variable
*SILENT-PROGRESS?* variable
*STANDARD-INPUT* variable
*STANDARD-OUTPUT* variable
*SUSPEND-TYPE-CHECKING?* variable
+ function
- function
/ function
/= function
< function
<= function
= function
> function
>= function [[|]]

A

ACONS function
ADJOIN function
ALERT-USER function
ALPHA-CHAR-P function
ALPHANUMERICP function
APPEND function
APPEND-FILES function
APPLY function
AREF function
ASSOC function
ASSOC-IF function
ATOM function [[|]]

B

BOTH-CASE-P function
BOUNDP function
BREAK function
BUTLAST function
BYTE macro [[|]]

C

CAAR function
CADR function
CAND macro
CAR function
CCATCH macro
CCONCATENATE function
CDAR function
CDDR function
CDEC macro
CDESTRUCTURING-BIND macro
CDO macro
CDOHASH macro
CDOLIST macro
CDOTIMES macro
CDR function
CEILING function
CERROR function
CHAR function
CHAR-CODE function
CHAR-DOWNCASE function
CHAR-EQUAL function
CHAR-GREATERP function
CHAR-LESSP function
CHAR-NOT-EQUAL function
CHAR-NOT-GREATERP function
CHAR-NOT-LESSP function
CHAR-UPCASE function
CHAR/= function
CHAR< function
CHAR<= function
CHAR= function
CHAR> function
CHAR>= function
CHARACTERP function
CHECK-TYPE macro
CINC macro
CLET macro
CLOSE function
CLRHASH function
CMERGE function
CMULTIPLE-VALUE-BIND macro
CNOT macro
CODE-CHAR function
CONS function
CONSP function
CONSTANTP function
CONSTRUCT-FILENAME function
COPY-ALIST function
COPY-LIST function
COPY-SEQ function
COPY-TREE function
COR macro
COUNT function
COUNT-IF function
CPOP macro
CPROGV macro
CPUSH macro
CPUSHNEW macro
CREDUCE function
CSETF macro
CSETQ macro
CSOME macro
CTIME macro
CUNWIND-PROTECT macro [[|]]

D

DEBUG function
DECLAIM macro
DECLARE function
DECODE-UNIVERSAL-TIME function
DEFAULT-SIGNAL-HANDLER function
DEFAULT-STRUCT-PRINT-FUNCTION function
DEFCONSTANT macro
DEFINE macro
DEFINE-METHOD macro
DEFMACRO macro
DEFPARAMETER macro
DEFPOLYMORPHIC macro
DEFSTRUCT macro
DEFVAR macro
DELETE function
DELETE-DUPLICATES function
DELETE-FILE function
DELETE-IF function
DIGIT-CHAR-P function
DIRECTORY function
DPB function [[|]]

E

EIGHTH function
ELT function
ENCODE-TIMESTRING function
ENCODE-UNIVERSAL-TIME function
ENDP function
EQ function
EQL function
EQUAL function
EQUALP function
ERROR function
EVAL function
EVENP function [[|]]

J

[[|]]

K

KEYWORDP function [[|]]

L

LAST function
LDB function
LDIFF function
LENGTH function
LIST function
LIST* function
[[#FN-DEF-LIST-LENGTH|]]LIST-LENGTH function function
[[#FN-DEF-LISTP|]]LISTP function
[[#FN-DEF-LOAD|]]LOAD function
[[#FN-DEF-LOG-MESSAGE|]]LOG-MESSAGE function
[[#FN-DEF-LOWER-CASE-P|]]LOWER-CASE-P function[[|]]

M

N

[[#FN-DEF-NBUTLAST|]]NBUTLAST function
[[#FN-DEF-NCONC|]]NCONC function
[[#FN-DEF-NINTERSECTION|]]NINTERSECTION function
[[#FN-DEF-NINTH|]]NINTH function
[[#FN-DEF-NOTE-ACTIVITY|]]NOTE-ACTIVITY function
[[#FN-DEF-NOTE-NUMERIC-PROGRESS|]]NOTE-NUMERIC-PROGRESS function
[[#FN-DEF-NOTE-PERCENT-PROGRESS|]]NOTE-PERCENT-PROGRESS function
[[#FN-DEF-NOTIFY-USER|]]NOTIFY-USER macro
[[#FN-DEF-NOTING-ACTIVITY|]]NOTING-ACTIVITY macro
[[#FN-DEF-NOTING-NUMERIC-PROGRESS|]]NOTING-NUMERIC-PROGRESS macro
[[#FN-DEF-NOTING-PERCENT-PROGRESS|]]NOTING-PERCENT-PROGRESS function
[[#FN-DEF-NRECONC|]]NRECONC function
[[#FN-DEF-NREVERSE|]]NREVERSE function
[[#FN-DEF-NSET-DIFFERENCE|]]NSET-DIFFERENCE function
[[#FN-DEF-NSET-EXCLUSIVE-OR|]]NSET-EXCLUSIVE-OR function
[[#FN-DEF-NSTRING-CAPITALIZE|]]NSTRING-CAPITALIZE function
[[#FN-DEF-NSTRING-DOWNCASE|]]NSTRING-DOWNCASE function
[[#FN-DEF-NSTRING-UPCASE|]]NSTRING-UPCASE function
[[#FN-DEF-NSUBLIS|]]NSUBLIS function
[[#FN-DEF-NSUBST|]]NSUBST function
[[#FN-DEF-NSUBST-IF|]]NSUBST-IF function
[[#FN-DEF-NSUBSTITUTE|]]NSUBSTITUTE function
[[#FN-DEF-NSUBSTITUTE-IF|]]NSUBSTITUTE-IF function
[[#FN-DEF-NTH|]]NTH function
[[#FN-DEF-NTHCDR|]]NTHCDR function
[[#FN-DEF-NULL|]]NULL function
[[#FN-DEF-NUMBERP|]]NUMBERP function
[[#FN-DEF-NUNION|]]NUNION function[[|]]

O

P

Q

[[#FN-DEF-QUOTE|]]QUOTE function[[|]]

R

S

[[#FN-DEF-SCALE-FLOAT|]]SCALE-FLOAT function
[[#FN-DEF-SEARCH|]]SEARCH function
[[#FN-DEF-SECOND|]]SECOND function
[[#FN-DEF-SEED-RANDOM|]]SEED-RANDOM function
[[#FN-DEF-SEQUENCEP|]]SEQUENCEP function
[[#FN-DEF-SET|]]SET function
[[#FN-DEF-SET-AREF|]]SET-AREF function
[[#FN-DEF-SET-CHAR|]]SET-CHAR function
[[#FN-DEF-SET-CONSING-STATE|]]SET-CONSING-STATE function
[[#FN-DEF-SET-DIFFERENCE|]]SET-DIFFERENCE function
[[#FN-DEF-SET-EXCLUSIVE-OR|]]SET-EXCLUSIVE-OR function
[[#FN-DEF-SET-FILE-POSITION|]]SET-FILE-POSITION function
[[#FN-DEF-SET-NTH|]]SET-NTH function
[[#FN-DEF-SETHASH|]]SETHASH function
[[#FN-DEF-SEVENTH|]]SEVENTH function
[[#FN-DEF-SIXTH|]]SIXTH function
[[#FN-DEF-SLEEP|]]SLEEP function
[[#FN-DEF-SORT|]]SORT function
[[#FN-DEF-STABLE-SORT|]]STABLE-SORT function
[[#FN-DEF-STREAMP|]]STREAMP function
[[#FN-DEF-STRING|]]STRING function
[[#FN-DEF-STRING-CAPITALIZE|]]STRING-CAPITALIZE function
[[#FN-DEF-STRING-DOWNCASE|]]STRING-DOWNCASE function
[[#FN-DEF-STRING-EQUAL|]]STRING-EQUAL function
[[#FN-DEF-STRING-GREATERP|]]STRING-GREATERP function
[[#FN-DEF-STRING-LEFT-TRIM|]]STRING-LEFT-TRIM function
[[#FN-DEF-STRING-LESSP|]]STRING-LESSP function
[[#FN-DEF-STRING-NOT-EQUAL|]]STRING-NOT-EQUAL function
[[#FN-DEF-STRING-NOT-GREATERP|]]STRING-NOT-GREATERP function
[[#FN-DEF-STRING-NOT-LESSP|]]STRING-NOT-LESSP function
[[#FN-DEF-STRING-RIGHT-TRIM|]]STRING-RIGHT-TRIM function
[[#FN-DEF-STRING-TRIM|]]STRING-TRIM function
[[#FN-DEF-STRING-UPCASE|]]STRING-UPCASE function
[[#FN-DEF-STRING/=|]]STRING/= function
[[#FN-DEF-427203732|]]STRING< function
[[#FN-DEF-994985164|]]STRING<= function
[[#FN-DEF-STRING=|]]STRING= function
[[#FN-DEF-427203988|]]STRING> function
[[#FN-DEF-995017932|]]STRING>= function
[[#FN-DEF-STRINGP|]]STRINGP function
[[#FN-DEF-SUBLIS|]]SUBLIS function
[[#FN-DEF-SUBSEQ|]]SUBSEQ function
[[#FN-DEF-SUBSETP|]]SUBSETP function
[[#FN-DEF-SUBST|]]SUBST function
[[#FN-DEF-SUBST-IF|]]SUBST-IF function
[[#FN-DEF-SUBSTITUTE|]]SUBSTITUTE function
[[#FN-DEF-SUBSTITUTE-IF|]]SUBSTITUTE-IF function
[[#FN-DEF-SXHASH|]]SXHASH function
[[#FN-DEF-SYMBOL-FUNCTION|]]SYMBOL-FUNCTION function
[[#FN-DEF-SYMBOL-NAME|]]SYMBOL-NAME function
[[#FN-DEF-SYMBOL-PLIST|]]SYMBOL-PLIST function
[[#FN-DEF-SYMBOL-VALUE|]]SYMBOL-VALUE function
[[#FN-DEF-SYMBOLP|]]SYMBOLP function[[|]]

T

U

V

W

X

[[|]]

Y

[[|]]

Z

[[#FN-DEF-ZEROP|]]ZEROP

@@ Line 5: / Line 5: @@
 E-Mail Comments to: [http://web.archive.org/web/20060325065433/mailto:opencyc-doc@cyc.com opencyc-doc@cyc.com]<br />
 Last Update: 03/28/2002<br />
-''CopyrightÂ© 1996-2002 [http://web.archive.org/web/20060325065433/http://www.cyc.com Cycorp]. All rights reserved.''<br />
+''CopyrightÂ© 1996-2002 [http://web.archive.org/web/20060325065433/http://www.cyc.com Cycorp]. All rights reserved.''
@@ Line 19: / Line 18: @@
 <blockquote>'''&quot;Common Lisp: The Language&quot;''',<br />
 nd Edition,<br />
-Guy L. Steele Jr<br />
+Guy L. Steele Jr
 </blockquote>
 making it easy to compare and contrast the two languages. For the most part, this document focuses only on the differences between SubL and Common Lisp.
@@ Line 25: / Line 24: @@
 An online version of [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/clm.html &quot;Common Lisp: The Language&quot;] can be found at
-<blockquote>[http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/clm.html '''<code>http://www.supelec.fr/docs/cltl/clm/clm.html</code>'''] **not working**</blockquote>
+<blockquote>[http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/clm.html '''<code>http://www.supelec.fr/docs/cltl/clm/clm.html</code>'''] **not working**
+</blockquote>
 and an [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/index.html index to all Common Lisp functions] can be found at
-<blockquote>[http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/index.html '''<code>http://www.supelec.fr/docs/cltl/clm/index.html</code>'''] **this is working**</blockquote>
+<blockquote>[http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/index.html '''<code>http://www.supelec.fr/docs/cltl/clm/index.html</code>'''] **this is working**
+</blockquote>
 Each section of this document contains a link labelled '''&quot;CLtL2 Reference&quot;''' to the corresponding sections of the above online Common Lisp reference. The reader is strongly encouraged to consult that reference in parallel with this document. [[|]]
@@ Line 37: / Line 38: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node1.html CLtL2 Reference]
 * [[#Table-of-Contents|0 : Table of Contents]]
@@ Line 173: / Line 172: @@
 Unlike Common Lisp, SubL is not a purely functional language. Several SubL constructs can only be used procedurally. In order to emphasize this difference, the following naming convention for SubL constructs is used:
-<blockquote>A SubL function will have the same name as the analogous Common Lisp function if it is intended to have the exact same basic functionality. The argument list may be simplified, but the intent and use are likely to be the same.</blockquote>
+<blockquote>A SubL function will have the same name as the analogous Common Lisp function if it is intended to have the exact same basic functionality. The argument list may be simplified, but the intent and use are likely to be the same.
+</blockquote>
 If there is a substantial behavioral difference between a SubL function and its Common Lisp counterpart, its name will be the Common Lisp name prepended with a single character -- either &quot;c&quot;, &quot;p&quot; or &quot;f&quot;.
 <blockquote>&quot;c&quot; indicates a construct that is either only procedural or functional.<br />
 &quot;p&quot; indicates the procedural version of a Common Lisp construct.<br />
-&quot;f&quot; indicates the functional version of a Common Lisp construct.<br />
+&quot;f&quot; indicates the functional version of a Common Lisp construct.
 </blockquote>
 A procedural construct in SubL is one which is suitable for evaluation as either one form in an explicit [[#FN-DEF-PROGN|<code>PROGN</code>]] or as one form in an implicit progn, which occur in the <code>&amp;body;</code> sections of many of the procedural forms such as [[#FN-DEF-CLET|<code>CLET</code>]], [[#FN-DEF-PWHEN|<code>PWHEN</code>]], [[#FN-DEF-CDOLIST|<code>CDOLIST</code>]] etc.
 Here is a table of all the procedural constructs in SubL and the Common Lisp analog:
 <blockquote>'''SubL Procedural Construct'''
-<pre>   </pre>
 '''Common Lisp Equivalent'''
@@ Line 194: / Line 191: @@
 -----
-<code> PROGN</code>
+<code>PROGN</code>
-<code> progn</code>
+<code>progn</code>
-<code> PIF</code>
+<code>PIF</code>
-<code> if</code>
+<code>if</code>
-<code> PWHEN</code>
+<code>PWHEN</code>
-<code> when</code>
+<code>when</code>
-<code> PUNLESS</code>
+<code>PUNLESS</code>
-<code> unless</code>
+<code>unless</code>
-<code> PCOND</code>
+<code>PCOND</code>
-<code> cond</code>
+<code>cond</code>
-<code> PCASE</code>
+<code>PCASE</code>
-<code> case</code>
+<code>case</code>
-<code> CSETQ</code>
+<code>CSETQ</code>
-<code> setq</code>
+<code>setq</code>
-<code> CSETF</code>
+<code>CSETF</code>
-<code> setf</code>
+<code>setf</code>
-<code> CINC</code>
+<code>CINC</code>
-<code> incf</code>
+<code>incf</code>
-<code> CDEC</code>
+<code>CDEC</code>
-<code> decf</code>
+<code>decf</code>
-<code> CPUSH</code>
+<code>CPUSH</code>
-<code> push</code>
+<code>push</code>
-<code> CPUSHNEW</code>
+<code>CPUSHNEW</code>
-<code> pushnew</code>
+<code>pushnew</code>
-<code> CPOP</code>
+<code>CPOP</code>
-<code> pop</code>
+<code>pop</code>
-<code> CLET</code>
+<code>CLET</code>
-<code> let*</code>
+<code>let*</code>
-<code> CMULTIPLE-VALUE-BIND</code>
+<code>CMULTIPLE-VALUE-BIND</code>
-<code> multiple-value-bind</code>
+<code>multiple-value-bind</code>
-<code> CDO</code>
+<code>CDO</code>
-<code> do*</code>
+<code>do*</code>
-<code> CDOLIST</code>
+<code>CDOLIST</code>
-<code> dolist</code>
+<code>dolist</code>
-<code> CSOME</code>
+<code>CSOME</code>
-<code> </code>
+` `
-<code> CDOTIMES</code>
+<code>CDOTIMES</code>
-<code> dotimes</code>
+<code>dotimes</code>
-<code> CDOHASH</code>
+<code>CDOHASH</code>
-<code> </code>
+` `
-<code> CCATCH</code>
+<code>CCATCH</code>
-<code> catch</code>
+<code>catch</code>
-<code> CUNWIND-PROTECT</code>
+<code>CUNWIND-PROTECT</code>
-<code> unwind-protect</code>
+<code>unwind-protect</code>
-<code> RET</code>
+<code>RET</code>
-<code> return-from</code>
+<code>return-from</code>
 </blockquote>
 A functional construct in SubL is one which returns a value. Here is a table of all the functional constructs in SubL and the Common Lisp analog:
 <blockquote>'''SubL Functional Construct'''
-<pre>   </pre>
 '''Common Lisp Equvalent'''
@@ Line 298: / Line 292: @@
 -----
-<code> CAND</code>
+<code>CAND</code>
-<code> and</code>
+<code>and</code>
-<code> COR</code>
+<code>COR</code>
-<code> or</code>
+<code>or</code>
-<code> CNOT</code>
+<code>CNOT</code>
-<code> not</code>
+<code>not</code>
-<code> FIF</code>
+<code>FIF</code>
-<code> if</code>
+<code>if</code>
-<code> FWHEN</code>
+<code>FWHEN</code>
-<code> when</code>
+<code>when</code>
-<code> FUNLESS</code>
+<code>FUNLESS</code>
-<code> unless</code>
+<code>unless</code>
 </blockquote>
 The body of a function or macro definition is considered an implicit progn, and so all forms in the body should be procedural. A function call can be used as a procedural construct. In this case, the returned value is simply ignored. [[|]]
@@ Line 335: / Line 329: @@
 SubL supports these built-in Common Lisp datatypes:
-<blockquote>{|
+<blockquote><table>
-|width="50%"| Numbers:
+<colgroup>
-|width="50%"| fixnum
+<col width="50%" />
-|-
+<col width="50%" />
-|
+</colgroup>
+<tbody>
-| float
+<tr class="odd">
-|-
+<td align="left">Numbers:</td>
-| Symbols:
+<td align="left">fixnum</td>
-| symbol
+</tr>
-|-
+<tr class="even">
-| Lists:
+<td align="left"></td>
-| cons
+<td align="left">float</td>
-|-
+</tr>
-| Arrays:
+<tr class="odd">
-| vector
+<td align="left">Symbols:</td>
-|-
+<td align="left">symbol</td>
-| Characters:
+</tr>
-| character
+<tr class="even">
-|-
+<td align="left">Lists:</td>
-| Strings:
+<td align="left">cons</td>
-| string
+</tr>
-|-
+<tr class="odd">
-| Hashtables:
+<td align="left">Arrays:</td>
-| eq hashtable
+<td align="left">vector</td>
-|-
+</tr>
-|
+<tr class="even">
+<td align="left">Characters:</td>
-| eql hashtable
+<td align="left">character</td>
-|-
+</tr>
-|
+<tr class="odd">
+<td align="left">Strings:</td>
-| equal hashtable
+<td align="left">string</td>
-|-
+</tr>
-|
+<tr class="even">
+<td align="left">Hashtables:</td>
-| equalp hashtable
+<td align="left">eq hashtable</td>
-|-
+</tr>
-| Streams:
+<tr class="odd">
-| stream
+<td align="left"></td>
-|-
+<td align="left">eql hashtable</td>
-| Functions:
+</tr>
-| function
+<tr class="even">
-|}
+<td align="left"></td>
+<td align="left">equal hashtable</td>
+</tr>
+<tr class="odd">
+<td align="left"></td>
+<td align="left">equalp hashtable</td>
+</tr>
+<tr class="even">
+<td align="left">Streams:</td>
+<td align="left">stream</td>
+</tr>
+<tr class="odd">
+<td align="left">Functions:</td>
+<td align="left">function</td>
+</tr>
+</tbody>
+</table>
+SubL does '''not''' support these Common Lisp datatypes:
 </blockquote>
-SubL does '''not''' support these Common Lisp datatypes:
 <blockquote>Multi-dimensional arrays<br />
 Packages<br />
 Pathnames<br />
 Random-states<br />
-Lambda-Expressions or Closures<br />
+Lambda-Expressions or Closures
 </blockquote>
 SubL has only special-case support for these datatypes:
 <blockquote>{|
@@ Line 396: / Line 403: @@
 | SubL only supports a single internal readtable
 |}
+New data types can be introduced via [[#FN-DEF-DEFSTRUCT|<code>DEFSTRUCT</code>]]. [[|]]
 </blockquote>
-New data types can be introduced via [[#FN-DEF-DEFSTRUCT|<code>DEFSTRUCT</code>]]. [[|]]
 -----
@@ Line 412: / Line 419: @@
 Variables are introduced via:
+'''Function call'''<br />
+A new set of variables for the formal parameters of the function are introduced. The extent of the function arguments is the duration of the function invocation.
+'''[[#FN-DEF-CLET|<code>CLET</code>]], [[#FN-DEF-CMULTIPLE-VALUE-BIND|<code>CMULTIPLE-VALUE-BIND</code>]], [[#FN-DEF-CDESTRUCTURING-BIND|<code>CDESTRUCTURING-BIND</code>]]'''<br />
+These constructs explicitly introduce and initialize new local variables. The extent of these variables is until exit from the constuct.
-;  '''Function call'''
+'''[[#FN-DEF-CDO|<code>CDO</code>]], [[#FN-DEF-CDOLIST|<code>CDOLIST</code>]], [[#FN-DEF-CSOME|<code>CSOME</code>]], [[#FN-DEF-CDOTIMES|<code>CDOTIMES</code>]], [[#FN-DEF-CDOHASH|<code>CDOHASH</code>]]'''<br />
-: A new set of variables for the formal parameters of the function are introduced. The extent of the function arguments is the duration of the function invocation.
+These iteration constructs explicitly introduce and update local variables which represent the state of the iteration. The extent of these variables is until exit from the iteration construct.
-;  '''[[#FN-DEF-CLET|<code>CLET</code>]], [[#FN-DEF-CMULTIPLE-VALUE-BIND|<code>CMULTIPLE-VALUE-BIND</code>]], [[#FN-DEF-CDESTRUCTURING-BIND|<code>CDESTRUCTURING-BIND</code>]]'''
-: These constructs explicitly introduce and initialize new local variables. The extent of these variables is until exit from the constuct.
-;  '''[[#FN-DEF-CDO|<code>CDO</code>]], [[#FN-DEF-CDOLIST|<code>CDOLIST</code>]], [[#FN-DEF-CSOME|<code>CSOME</code>]], [[#FN-DEF-CDOTIMES|<code>CDOTIMES</code>]], [[#FN-DEF-CDOHASH|<code>CDOHASH</code>]]'''
-: These iteration constructs explicitly introduce and update local variables which represent the state of the iteration. The extent of these variables is until exit from the iteration construct.
 When a local variable is introduced with the same name as a local variable which is already within the current scope and extent, the new variable shadows the outer variable.
@@ Line 465: / Line 472: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node66.html CLtL2 Reference]<br />
-<br />
 [[|]]macro <code>DEFINE : (name arglist &amp;body body)</code>
@@ Line 478: / Line 484: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node67.html CLtL2 Reference]<br />
-<br />
 [[|]]macro <code>DEFVAR : (variable &amp;optional initialization documentation)</code><br />
-<br />
 [[|]]macro <code>DEFPARAMETER : (variable initialization &amp;optional documentation)</code>
@@ Line 486: / Line 490: @@
 SubL enforces an important distinction between these two constructs, which is described in greater detail under [[#FN-DEF-WRITE-IMAGE|<code>WRITE-IMAGE</code>]].<br />
-<br />
 [[|]]macro <code>DEFCONSTANT : (variable initialization &amp;optional documentation)</code>
@@ Line 509: / Line 512: @@
 For the most part, the following predicates which check for specific data types behave exactly as they do in Common Lisp.<br />
-<br />
 [[|]]function <code>NULL : (x)</code><br />
-<br />
 [[|]]function <code>SYMBOLP : (x)</code><br />
-<br />
 [[|]]function <code>ATOM : (x)</code><br />
-<br />
 [[|]]function <code>CONSP : (x)</code><br />
-<br />
 [[|]]function <code>LISTP : (x)</code><br />
-<br />
 [[|]]function <code>NUMBERP : (x)</code><br />
-<br />
 [[|]]function <code>INTEGERP : (x)</code><br />
-<br />
 [[|]]function <code>FLOATP : (x)</code><br />
-<br />
 [[|]]function <code>CHARACTERP : (x)</code><br />
-<br />
 [[|]]function <code>STRINGP : (x)</code><br />
-<br />
 [[|]]function <code>VECTORP : (x)</code><br />
-<br />
 [[|]]function <code>FUNCTIONP : (x)</code><br />
 Follows the CLtL2 implementation<br />
-<br />
 [[|]]function <code>FUNCTION-SPEC-P : (x)</code><br />
 Returns T IFF x is an object suitable for FUNCALL
@@ Line 545: / Line 535: @@
 The SubL equality predicates behave exactly like their Common Lisp counterparts.<br />
-<br />
 [[|]]function <code>EQ : (x y)</code><br />
-<br />
 [[|]]function <code>EQL : (x y)</code><br />
-<br />
 [[|]]function <code>EQUAL : (x y)</code><br />
-<br />
 [[|]]function <code>EQUALP : (x y)</code> [[|]]
@@ Line 559: / Line 545: @@
 SubL logical operations '''only''' return T or NIL. Otherwise, they behave like their Common Lisp counterparts.<br />
-<br />
 [[|]]macro <code>CNOT : (x)</code><br />
-<br />
 [[|]]macro <code>CAND : (&amp;rest args)</code><br />
-<br />
 [[|]]macro <code>COR : (&amp;rest args)</code> [[|]]
@@ Line 578: / Line 561: @@
 These SubL constructs behave exactly like their Common Lisp counterparts.<br />
-<br />
 [[|]]function <code>QUOTE : (data)</code><br />
-<br />
 [[|]]macro <code>FUNCTION : (fspec)</code><br />
-<br />
 [[|]]function <code>SYMBOL-VALUE : (x)</code><br />
-<br />
 [[|]]function <code>SYMBOL-FUNCTION : (x)</code><br />
-<br />
 [[|]]function <code>BOUNDP : (x)</code><br />
-<br />
 [[|]]function <code>FBOUNDP : (x)</code> [[|]]
@@ Line 594: / Line 571: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node79.html CLtL2 Reference]<br />
-<br />
 [[|]]macro <code>CSETQ : (var value &amp;rest var-val-pairs)</code>
@@ Line 600: / Line 576: @@
 These SubL functions for setting and unsetting symbol properties behave like their Common Lisp counterparts.<br />
-<br />
 [[|]]function <code>SET : (symbol value)</code><br />
-<br />
 [[|]]function <code>MAKUNBOUND : (symbol)</code><br />
-<br />
 [[|]]function <code>FMAKUNBOUND : (symbol)</code> [[|]]
@@ Line 610: / Line 583: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node80.html CLtL2 Reference]<br />
-<br />
 [[|]]macro <code>CSETF : (place val)</code>
 [[#FN-DEF-CSETF|<code>CSETF</code>]] is a more restricted version of <code>setf</code> in Common Lisp. First, since it is procedural, like [[#FN-DEF-CSETQ|<code>CSETQ</code>]] it does not return a value. Second, there is a much more restricted set of place-specifiers which are allowable. Here is a complete table of the allowable [[#FN-DEF-CSETF|<code>CSETF</code>]] forms, and their equivalent SubL expansions:
 '''CSETF form'''
-<pre>   </pre>
 '''Equivalent SubL expansion'''
@@ Line 625: / Line 594: @@
 -----
-<code> (CSETF</code> variable value''')'''
+<code>(CSETF</code> variable value''')'''
-<code> (CSETQ</code> variable value''')'''
+<code>(CSETQ</code> variable value''')'''
-<code> (CSETF</code> ([[#FN-DEF-AREF|<code>AREF</code>]] vector n''')''' value''')'''
+<code>(CSETF</code> ([[#FN-DEF-AREF|<code>AREF</code>]] vector n''')''' value''')'''
-<code> (SET-AREF</code> vector n value''')'''
+<code>(SET-AREF</code> vector n value''')'''
-<code> (CSETF</code> ([[#FN-DEF-NTH|<code>NTH</code>]] n list''')''' value''')'''
+<code>(CSETF</code> ([[#FN-DEF-NTH|<code>NTH</code>]] n list''')''' value''')'''
-<code> (SET-NTH</code> n list value''')'''
+<code>(SET-NTH</code> n list value''')'''
-<code> (CSETF</code> ([[#FN-DEF-CAR|<code>CAR</code>]] cons''')''' value''')'''
+<code>(CSETF</code> ([[#FN-DEF-CAR|<code>CAR</code>]] cons''')''' value''')'''
-<code> (RPLACA</code> cons value''')'''
+<code>(RPLACA</code> cons value''')'''
-<code> (CSETF</code> ([[#FN-DEF-CDR|<code>CDR</code>]] cons''')''' value''')'''
+<code>(CSETF</code> ([[#FN-DEF-CDR|<code>CDR</code>]] cons''')''' value''')'''
-<code> (RPLACD</code> cons value''')'''
+<code>(RPLACD</code> cons value''')'''
-<code> (CSETF</code> ([[#FN-DEF-GET|<code>GET</code>]] symbol indicator''')''' value''')'''
+<code>(CSETF</code> ([[#FN-DEF-GET|<code>GET</code>]] symbol indicator''')''' value''')'''
-<code> (PUT</code> symbol indicator value''')'''
+<code>(PUT</code> symbol indicator value''')'''
-<code> (CSETF</code> ([[#FN-DEF-GETHASH|<code>GETHASH</code>]] key hashtable''')''' value''')'''
+<code>(CSETF</code> ([[#FN-DEF-GETHASH|<code>GETHASH</code>]] key hashtable''')''' value''')'''
-<code> (SETHASH</code> key hashtable value''')'''
+<code>(SETHASH</code> key hashtable value''')'''
-<code> (CSETF</code> ([[#FN-DEF-SYMBOL-VALUE|<code>SYMBOL-VALUE</code>]] symbol''')''' value''')'''
+<code>(CSETF</code> ([[#FN-DEF-SYMBOL-VALUE|<code>SYMBOL-VALUE</code>]] symbol''')''' value''')'''
-<code> (SET</code> symbol value''')'''
+<code>(SET</code> symbol value''')'''
-<code> (CSETF</code> (defstruct-slot object''')''' value''')'''
+<code>(CSETF</code> (defstruct-slot object''')''' value''')'''
-<code> (set-defstruct-slot object value)</code>
+<code>(set-defstruct-slot object value)</code>
 In the above table, '''defstruct-slot''' refers to any structure slot accessor function which got defined via defstruct, and '''set-defstruct-slot''' refers to the corresponding setter function for the given accessor. [[|]]
@@ Line 668: / Line 637: @@
 These functions behave like their Common Lisp counterparts.<br />
-<br />
 [[|]]function <code>APPLY : (function argument &amp;rest arguments)</code><br />
-<br />
 [[|]]function <code>FUNCALL : (function &amp;rest args)</code>
@@ Line 678: / Line 645: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node82.html CLtL2 Reference]<br />
-<br />
 [[|]]macro <code>PROGN : (&amp;body body)</code>
@@ Line 686: / Line 652: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node83.html CLtL2 Reference]<br />
-<br />
 [[|]]macro <code>CLET : (bindings &amp;body body)</code>
@@ Line 692: / Line 657: @@
 SubL has no counterpart to Common Lisp's <code>LET</code> construct.<br />
-<br />
 [[|]]macro <code>CPROGV : (special-vars bindings &amp;body body)</code>
@@ Line 700: / Line 664: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node84.html CLtL2 Reference]<br />
-<br />
 [[|]]macro <code>PIF : (condition action else-action)</code><br />
-<br />
 [[|]]macro <code>PWHEN : (condition &amp;body body)</code><br />
-<br />
 [[|]]macro <code>PUNLESS : (condition &amp;body body)</code>
 [[#FN-DEF-PIF|<code>PIF</code>]], [[#FN-DEF-PWHEN|<code>PWHEN</code>]] and [[#FN-DEF-PUNLESS|<code>PUNLESS</code>]] are the SubL procedural variants of <code>if</code>, <code>when</code> and <code>unless</code> from Common Lisp. For each, the condition argument must be a functional construct. Also, [[#FN-DEF-PIF|<code>PIF</code>]] takes exactly three arguments, making the action and else-actions identical in form.<br />
-<br />
 [[|]]macro <code>FIF : (condition true-value false-value)</code><br />
-<br />
 [[|]]macro <code>FWHEN : (condition true-value)</code><br />
-<br />
 [[|]]macro <code>FUNLESS : (condition false-value)</code>
 [[#FN-DEF-FIF|<code>FIF</code>]], [[#FN-DEF-FWHEN|<code>FWHEN</code>]] and [[#FN-DEF-FUNLESS|<code>FUNLESS</code>]] are the SubL functional variants of <code>if</code>, <code>when</code> and <code>unless</code> from Common Lisp.<br />
-<br />
 [[|]]macro <code>PCOND : (&amp;rest clauses)</code><br />
-<br />
 [[|]]macro <code>PCASE : (test-object &amp;body clauses)</code>
@@ Line 726: / Line 682: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node85.html CLtL2 Reference]<br />
-<br />
 [[|]]macro <code>RET : (expression)</code><br />
 SubL functions must always return a value, since C functions must return values and all SubL functions must translate into C.
@@ Line 738: / Line 693: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node88.html CLtL2 Reference]<br />
-<br />
 [[|]]macro <code>CDO : (vars endtest &amp;body body)</code><br />
 cdo is procedural. It binds its variables in sequence, as with CommonLisp do* [[|]]
@@ Line 745: / Line 699: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node89.html CLtL2 Reference]<br />
-<br />
 [[|]]macro <code>CDOLIST : ((var listform) &amp;body body)</code><br />
-<br />
 [[|]]macro <code>CSOME : ((var list endvar) &amp;body body)</code><br />
-<br />
 [[|]]macro <code>CDOTIMES : ((var integer) &amp;body body)</code><br />
-<br />
 [[|]]macro <code>CDOHASH : ((key val table) &amp;body body)</code> [[|]]
@@ Line 757: / Line 707: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node90.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>MAPCAR : (function list &amp;rest more-lists)</code><br />
-<br />
 [[|]]function <code>MAPLIST : (function list &amp;rest more-lists)</code><br />
-<br />
 [[|]]function <code>MAPC : (function list &amp;rest more-lists)</code><br />
-<br />
 [[|]]function <code>MAPL : (function list &amp;rest more-lists)</code><br />
-<br />
 [[|]]function <code>MAPCAN : (function list &amp;rest more-lists)</code><br />
-<br />
 [[|]]function <code>MAPCON : (function list &amp;rest more-lists)</code> [[|]]
@@ Line 773: / Line 717: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node94.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>VALUES : (value &amp;rest more-values)</code><br />
 values returns its args such that they can be bound in a dynamically enclosing multiple-value-bind. The first value is returned as well, since all SubL functions must return a value.<br />
-<br />
 [[|]]variable <code>*MULTIPLE-VALUES-LIMIT*</code><br />
-<br />
 [[|]]macro <code>MULTIPLE-VALUE-LIST : (form)</code><br />
-<br />
 [[|]]macro <code>CMULTIPLE-VALUE-BIND : (vars value &amp;body body)</code> [[|]]
@@ Line 792: / Line 732: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node96.html CLtL2 Reference]<br />
-<br />
 [[|]]macro <code>CCATCH : (tag ans-var &amp;body body)</code><br />
 ccatch is procedural, and so does not return values.<br />
-<br />
 [[|]]macro <code>CUNWIND-PROTECT : (protected-form &amp;body body)</code><br />
-<br />
 [[|]]function <code>THROW : (tag result)</code> [[|]]
@@ Line 810: / Line 747: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node98.html CLtL2 Reference]<br />
-<br />
 [[|]]macro <code>DEFMACRO : (name pattern &amp;body body)</code>
@@ Line 818: / Line 754: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node100.html CLtL2 Reference]<br />
-<br />
 [[|]]macro <code>CDESTRUCTURING-BIND : (pattern datum &amp;body body)</code> [[|]]
@@ Line 824: / Line 759: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node102.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>VARIABLE-INFORMATION : (variable)</code><br />
-<br />
 [[|]]function <code>FUNCTION-INFORMATION : (function)</code> [[|]]
@@ Line 839: / Line 772: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node104.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>DECLARE : (&amp;rest ignore)</code><br />
-<br />
 [[|]]function <code>PROCLAIM : (declaration-specifier)</code><br />
-<br />
 [[|]]macro <code>DECLAIM : (&amp;rest declaration-specifiers)</code> [[|]]
@@ Line 849: / Line 779: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node105.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>IGNORE : (&amp;rest values)</code>
@@ Line 860: / Line 789: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node107.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>SYMBOLP : (x)</code> [[|]]
@@ Line 866: / Line 794: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node108.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>GET : (symbol indicator &amp;optional default)</code><br />
-<br />
 [[|]]function <code>PUT : (symbol indicator new-value)</code><br />
-<br />
 [[|]]function <code>REMPROP : (symbol indicator)</code><br />
-<br />
 [[|]]function <code>SYMBOL-PLIST : (symbol)</code> [[|]]
@@ Line 878: / Line 802: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node109.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>SYMBOL-NAME : (symbol)</code><br />
 Returns the string which is the name of SYMBOL. When called on a keyword, it returns the &quot;:&quot; prefix as part of the name [[|]]
@@ Line 885: / Line 808: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node110.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>MAKE-SYMBOL : (print-name)</code><br />
-<br />
 [[|]]function <code>GENSYM : (&amp;optional x)</code><br />
 GENSYM returns new, interned symbols, which are combinations of a string prefix and a numeric suffix. It guarantees that the new symbol was not previously interned.<br />
@@ Line 893: / Line 814: @@
 if the argument X is a string, the gensym prefix is set to X before the new symbol is generated.<br />
 The initial gensym counter value is 1 and the initial gensym prefix is 'G'.<br />
-<br />
 [[|]]function <code>GENTEMP : (&amp;optional (prefix &quot;T&quot;))</code><br />
-<br />
 [[|]]function <code>KEYWORDP : (x)</code><br />
 In SubL, which does not have packages, keywords are any symbol whose name begins with &quot;:&quot; [[|]]
@@ Line 905: / Line 824: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node111.html CLtL2 Reference]<br />
-<br />
 [[|]]macro <code>IN-PACKAGE : (name)</code><br />
-<br />
 [[|]]function <code>INTERN : (string)</code><br />
 Finds and returns a symbol whose name is STRING. INTERN will create the symbol if it does not exist. Unlike Common LISP intern, the SubL version does not allow an argument to specify the package, since SubL does not support packages.<br />
-<br />
 [[|]]function <code>FIND-SYMBOL : (string)</code><br />
 Finds and returns a symbol whose name is STRING. Unlike Common LISP FIND-SYMBOL, the SubL version does not allow an argument to specify the package, since SubL does not support packages. [[|]]
@@ Line 922: / Line 838: @@
 SubL only supports fixnums and floats. Fixnums have at least 28 bits of precision.<br />
-<br />
 [[|]]function <code>NUMBERP : (x)</code><br />
-<br />
 [[|]]function <code>FIXNUMP : (x)</code><br />
-<br />
 [[|]]function <code>INTEGERP : (x)</code><br />
-<br />
 [[|]]function <code>FLOATP : (x)</code> [[|]]
@@ Line 934: / Line 846: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node123.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>ZEROP : (x)</code><br />
-<br />
 [[|]]function <code>PLUSP : (x)</code><br />
-<br />
 [[|]]function <code>MINUSP : (x)</code><br />
-<br />
 [[|]]function <code>ODDP : (x)</code><br />
-<br />
 [[|]]function <code>EVENP : (x)</code> [[|]]
@@ Line 948: / Line 855: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node124.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>= : (num1 num2)</code><br />
-<br />
 [[|]]function <code>/= : (num1 num2)</code><br />
-<br />
 [[|]]function <code>&lt; : (num1 num2)</code><br />
-<br />
 [[|]]function <code>&gt; : (num1 num2)</code><br />
-<br />
 [[|]]function <code>&lt;= : (num1 num2)</code><br />
-<br />
 [[|]]function <code>&gt;= : (num1 num2)</code>
 The above numeric comparison functions take exactly 2 arguments, unlike their Common Lisp counterparts which take variable numbers of arguments.<br />
-<br />
 [[|]]function <code>MAX : (num &amp;rest numbers)</code><br />
-<br />
 [[|]]function <code>MIN : (num &amp;rest numbers)</code> [[|]]
@@ Line 970: / Line 869: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node125.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>+ : (&amp;rest numbers)</code><br />
-<br />
 [[|]]function <code>- : (num &amp;rest numbers)</code><br />
-<br />
 [[|]]function <code>* : (&amp;rest numbers)</code><br />
-<br />
 [[|]]function <code>/ : (num &amp;rest numbers)</code><br />
-<br />
 [[|]]function <code>INT/ : (num1 num2)</code><br />
-<br />
 [[|]]macro <code>CINC : (place &amp;optional (delta 1))</code><br />
-<br />
 [[|]]macro <code>CDEC : (place &amp;optional (delta 1))</code> [[|]]
@@ Line 994: / Line 886: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node130.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>FLOAT : (x)</code><br />
-<br />
 [[|]]function <code>FLOOR : (x)</code><br />
-<br />
 [[|]]function <code>CEILING : (x)</code><br />
-<br />
 [[|]]function <code>TRUNCATE : (x)</code><br />
-<br />
 [[|]]function <code>ROUND : (x)</code><br />
-<br />
 [[|]]function <code>MOD : (number divisor)</code><br />
-<br />
 [[|]]function <code>REM : (number divisor)</code><br />
-<br />
 [[|]]function <code>SCALE-FLOAT : (float integer)</code><br />
-<br />
 [[|]]function <code>INTEGER-DECODE-FLOAT : (float)</code> [[|]]
@@ Line 1,022: / Line 905: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node132.html CLtL2 Reference]<br />
-<br />
 [[|]]macro <code>BYTE : (size position)</code><br />
-<br />
 [[|]]function <code>LDB : (bytespec integer)</code><br />
-<br />
 [[|]]function <code>DPB : (newbyte bytespec integer)</code> [[|]]
@@ Line 1,032: / Line 912: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node133.html CLtL2 Reference]<br />
-<br />
 [[|]]variable <code>*RAND-MAX*</code><br />
 *rand-max* is the largest fixnum that the function random can accept.<br />
-<br />
 [[|]]function <code>SEED-RANDOM : (&amp;optional (seed-fixnum (mod (get-internal-real-time) *rand-max*)))</code><br />
 If seed-fixnum is omitted to seed-random, the internal clock is used<br />
 in an implementation specific manner.<br />
-<br />
 [[|]]function <code>RANDOM : (number)</code> [[|]]
@@ Line 1,045: / Line 922: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node134.html CLtL2 Reference]<br />
-<br />
 [[|]]variable <code>*MOST-POSITIVE-FIXNUM*</code><br />
-<br />
 [[|]]variable <code>*MOST-NEGATIVE-FIXNUM*</code> [[|]]
@@ Line 1,056: / Line 931: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node135.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>CHARACTERP : (x)</code> [[|]]
@@ Line 1,068: / Line 942: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node137.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>ALPHA-CHAR-P : (char)</code><br />
-<br />
 [[|]]function <code>UPPER-CASE-P : (char)</code><br />
-<br />
 [[|]]function <code>LOWER-CASE-P : (char)</code><br />
-<br />
 [[|]]function <code>BOTH-CASE-P : (char)</code><br />
-<br />
 [[|]]function <code>DIGIT-CHAR-P : (char)</code><br />
-<br />
 [[|]]function <code>ALPHANUMERICP : (char)</code><br />
-<br />
 [[|]]function <code>CHAR= : (char1 char2)</code><br />
-<br />
 [[|]]function <code>CHAR/= : (char1 char2)</code><br />
-<br />
 [[|]]function <code>CHAR&lt; : (char1 char2)</code><br />
-<br />
 [[|]]function <code>CHAR&gt; : (char1 char2)</code><br />
-<br />
 [[|]]function <code>CHAR&lt;= : (char1 char2)</code><br />
-<br />
 [[|]]function <code>CHAR&gt;= : (char1 char2)</code><br />
-<br />
 [[|]]function <code>CHAR-EQUAL : (char1 char2)</code><br />
-<br />
 [[|]]function <code>CHAR-NOT-EQUAL : (char1 char2)</code><br />
-<br />
 [[|]]function <code>CHAR-LESSP : (char1 char2)</code><br />
-<br />
 [[|]]function <code>CHAR-GREATERP : (char1 char2)</code><br />
-<br />
 [[|]]function <code>CHAR-NOT-GREATERP : (char1 char2)</code><br />
-<br />
 [[|]]function <code>CHAR-NOT-LESSP : (char1 char2)</code> [[|]]
@@ Line 1,108: / Line 964: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node138.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>CHAR-CODE : (char)</code><br />
-<br />
 [[|]]function <code>CODE-CHAR : (code)</code> [[|]]
@@ Line 1,116: / Line 970: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node139.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>CHAR-DOWNCASE : (char)</code><br />
-<br />
 [[|]]function <code>CHAR-UPCASE : (char)</code> [[|]]
@@ Line 1,127: / Line 979: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node141.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>SEQUENCEP : (x)</code> [[|]]
@@ Line 1,133: / Line 984: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node142.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>ELT : (sequence index)</code><br />
-<br />
 [[|]]function <code>SUBSEQ : (sequence start &amp;optional end)</code><br />
-<br />
 [[|]]function <code>COPY-SEQ : (sequence)</code><br />
-<br />
 [[|]]function <code>LENGTH : (sequence)</code><br />
-<br />
 [[|]]function <code>REVERSE : (sequence)</code><br />
-<br />
 [[|]]function <code>NREVERSE : (sequence)</code> [[|]]
@@ Line 1,149: / Line 994: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node143.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>CCONCATENATE : (seq &amp;rest more-seqs)</code><br />
-<br />
 [[|]]function <code>CREDUCE : (function sequence &amp;optional (start 0) end (init-value :none))</code> [[|]]
@@ Line 1,157: / Line 1,000: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node144.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>FILL : (sequence item &amp;optional (start 0) (end (length sequence)))</code><br />
-<br />
 [[|]]function <code>REPLACE : (sequence1 sequence2 &amp;optional (start1 0) end1 (start2 0) end2)</code><br />
-<br />
 [[|]]function <code>REMOVE : (item sequence &amp;optional (test #'eql) (key #'identity) (start 0) end count)</code><br />
-<br />
 [[|]]function <code>REMOVE-IF : (test sequence &amp;optional (key #'identity) (start 0) end count)</code><br />
-<br />
 [[|]]function <code>DELETE : (item sequence &amp;optional (test #'eql) (key #'identity) (start 0) end count)</code><br />
-<br />
 [[|]]function <code>DELETE-IF : (test sequence &amp;optional (key #'identity) (start 0) end count)</code><br />
-<br />
 [[|]]function <code>REMOVE-DUPLICATES : (sequence &amp;optional (test #'eql) (key #'identity) (start 0) end)</code><br />
-<br />
 [[|]]function <code>DELETE-DUPLICATES : (sequence &amp;optional (test #'eql) (key #'identity) (start 0) end)</code><br />
-<br />
 [[|]]function <code>SUBSTITUTE : (new old sequence &amp;optional (test #'eql) (key #'identity) (start 0) end count)</code><br />
-<br />
 [[|]]function <code>SUBSTITUTE-IF : (new test sequence &amp;optional (key #'identity) (start 0) end count)</code><br />
-<br />
 [[|]]function <code>NSUBSTITUTE : (new old sequence &amp;optional (test #'eql) (key #'identity) (start 0) end count)</code><br />
-<br />
 [[|]]function <code>NSUBSTITUTE-IF : (new test sequence &amp;optional (key #'identity) (start 0) end count)</code> [[|]]
@@ Line 1,185: / Line 1,016: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node145.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>FIND : (item seq &amp;optional (test #'eql) (key #'identity) (start 0) end)</code><br />
-<br />
 [[|]]function <code>FIND-IF : (test seq &amp;optional (key #'identity) (start 0) end)</code><br />
-<br />
 [[|]]function <code>POSITION : (item seq &amp;optional (test #'eql) (key #'identity) (start 0) end)</code><br />
-<br />
 [[|]]function <code>POSITION-IF : (test seq &amp;optional (key #'identity) (start 0) end)</code><br />
-<br />
 [[|]]function <code>COUNT : (item seq &amp;optional (test #'eql) (key #'identity) (start 0) end)</code><br />
-<br />
 [[|]]function <code>COUNT-IF : (test seq &amp;optional (key #'identity) (start 0) end)</code><br />
-<br />
 [[|]]function <code>MISMATCH : (seq1 seq2 &amp;optional (test #'eql) (key #'identity) (start1 0) end1 (start2 0) end2)</code><br />
-<br />
 [[|]]function <code>SEARCH : (seq1 seq2 &amp;optional (test #'eql) (key #'identity) (start1 0) end1 (start2 0) end2)</code> [[|]]
@@ Line 1,205: / Line 1,028: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node146.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>SORT : (seq predicate &amp;optional (key #'identity))</code><br />
-<br />
 [[|]]function <code>STABLE-SORT : (seq predicate &amp;optional (key #'identity))</code><br />
-<br />
 [[|]]function <code>CMERGE : (seq1 seq2 predicate &amp;optional (key #'identity))</code> [[|]]
@@ Line 1,218: / Line 1,038: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node147.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>LISTP : (x)</code><br />
-<br />
 [[|]]function <code>CONSP : (x)</code><br />
-<br />
 [[|]]function <code>ATOM : (x)</code> [[|]]
@@ Line 1,228: / Line 1,045: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node148.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>CAR : (cons)</code><br />
-<br />
 [[|]]function <code>CDR : (cons)</code><br />
-<br />
 [[|]]function <code>CAAR : (cons)</code><br />
-<br />
 [[|]]function <code>CADR : (cons)</code><br />
-<br />
 [[|]]function <code>CDAR : (cons)</code><br />
-<br />
 [[|]]function <code>CDDR : (cons)</code><br />
-<br />
 [[|]]function <code>CONS : (car cdr)</code><br />
-<br />
 [[|]]function <code>TREE-EQUAL : (tree1 tree2 &amp;optional (test #'eql))</code> [[|]]
@@ Line 1,248: / Line 1,057: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node149.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>ENDP : (object)</code><br />
-<br />
 [[|]]function <code>LIST-LENGTH : (list)</code><br />
-<br />
 [[|]]function <code>NTH : (n list)</code><br />
-<br />
 [[|]]function <code>FIRST : (list)</code><br />
-<br />
 [[|]]function <code>SECOND : (list)</code><br />
-<br />
 [[|]]function <code>THIRD : (list)</code><br />
-<br />
 [[|]]function <code>FOURTH : (list)</code><br />
-<br />
 [[|]]function <code>FIFTH : (list)</code><br />
-<br />
 [[|]]function <code>SIXTH : (list)</code><br />
-<br />
 [[|]]function <code>SEVENTH : (list)</code><br />
-<br />
 [[|]]function <code>EIGHTH : (list)</code><br />
-<br />
 [[|]]function <code>NINTH : (list)</code><br />
-<br />
 [[|]]function <code>TENTH : (list)</code><br />
-<br />
 [[|]]function <code>REST : (list)</code><br />
-<br />
 [[|]]function <code>NTHCDR : (n list)</code><br />
-<br />
 [[|]]function <code>LAST : (list &amp;optional (n 1))</code><br />
-<br />
 [[|]]function <code>LIST : (&amp;rest objects)</code><br />
-<br />
 [[|]]function <code>LIST* : (arg &amp;rest objects)</code><br />
-<br />
 [[|]]function <code>MAKE-LIST : (size &amp;optional initial-element)</code><br />
-<br />
 [[|]]function <code>APPEND : (&amp;rest lists)</code><br />
-<br />
 [[|]]function <code>COPY-LIST : (list)</code><br />
-<br />
 [[|]]function <code>COPY-ALIST : (list)</code><br />
-<br />
 [[|]]function <code>COPY-TREE : (tree)</code><br />
-<br />
 [[|]]function <code>REVAPPEND : (list1 list2)</code><br />
-<br />
 [[|]]function <code>NCONC : (&amp;rest lists)</code><br />
-<br />
 [[|]]function <code>NRECONC : (list1 list2)</code><br />
-<br />
 [[|]]macro <code>CPUSH : (item place)</code><br />
-<br />
 [[|]]macro <code>CPUSHNEW : (item place &amp;optional (test '#'eql) (key '#'identity))</code><br />
-<br />
 [[|]]macro <code>CPOP : (place)</code><br />
-<br />
 [[|]]function <code>BUTLAST : (list &amp;optional (n 1))</code><br />
-<br />
 [[|]]function <code>NBUTLAST : (list &amp;optional (n 1))</code><br />
-<br />
 [[|]]function <code>LDIFF : (list sublist)</code> [[|]]
@@ Line 1,316: / Line 1,093: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node150.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>RPLACA : (cons newcar)</code><br />
-<br />
 [[|]]function <code>RPLACD : (cons newcdr)</code><br />
-<br />
 [[|]]function <code>SET-NTH : (n list value)</code> [[|]]
@@ Line 1,326: / Line 1,100: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node151.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>SUBST : (new old tree &amp;optional (test #'eql) (key #'identity))</code><br />
-<br />
 [[|]]function <code>SUBST-IF : (new test tree &amp;optional (key #'identity))</code><br />
-<br />
 [[|]]function <code>NSUBST : (new old tree &amp;optional (test #'eql) (key #'identity))</code><br />
-<br />
 [[|]]function <code>NSUBST-IF : (new test tree &amp;optional (key #'identity))</code><br />
-<br />
 [[|]]function <code>SUBLIS : (alist tree &amp;optional (test #'eql) (key #'identity))</code><br />
-<br />
 [[|]]function <code>NSUBLIS : (alist tree &amp;optional (test #'eql) (key #'identity))</code> [[|]]
@@ Line 1,342: / Line 1,110: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node152.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>MEMBER : (item list &amp;optional (test #'eql) (key #'identity))</code><br />
-<br />
 [[|]]function <code>MEMBER-IF : (test list &amp;optional (key #'identity))</code><br />
-<br />
 [[|]]function <code>TAILP : (sublist list)</code><br />
-<br />
 [[|]]function <code>ADJOIN : (item list &amp;optional (test #'eql) (key #'identity))</code><br />
-<br />
 [[|]]function <code>UNION : (list1 list2 &amp;optional (test #'eql) (key #'identity))</code><br />
-<br />
 [[|]]function <code>NUNION : (list1 list2 &amp;optional (test #'eql) (key #'identity))</code><br />
-<br />
 [[|]]function <code>INTERSECTION : (list1 list2 &amp;optional (test #'eql) (key #'identity))</code><br />
-<br />
 [[|]]function <code>NINTERSECTION : (list1 list2 &amp;optional (test #'eql) (key #'identity))</code><br />
-<br />
 [[|]]function <code>SET-DIFFERENCE : (list1 list2 &amp;optional (test #'eql) (key #'identity))</code><br />
-<br />
 [[|]]function <code>NSET-DIFFERENCE : (list1 list2 &amp;optional (test #'eql) (key #'identity))</code><br />
-<br />
 [[|]]function <code>SET-EXCLUSIVE-OR : (list1 list2 &amp;optional (test #'eql) (key #'identity))</code><br />
-<br />
 [[|]]function <code>NSET-EXCLUSIVE-OR : (list1 list2 &amp;optional (test #'eql) (key #'identity))</code><br />
-<br />
 [[|]]function <code>SUBSETP : (list1 list2 &amp;optional (test #'eql) (key #'identity))</code> [[|]]
@@ Line 1,372: / Line 1,127: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node153.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>ACONS : (key datum alist)</code><br />
-<br />
 [[|]]function <code>PAIRLIS : (keys data &amp;optional alist)</code><br />
-<br />
 [[|]]function <code>ASSOC : (item alist &amp;optional (test #'eql) (key #'identity))</code><br />
-<br />
 [[|]]function <code>ASSOC-IF : (predicate alist)</code><br />
-<br />
 [[|]]function <code>RASSOC : (item alist &amp;optional (test #'eql) (key #'identity))</code><br />
-<br />
 [[|]]function <code>RASSOC-IF : (predicate alist)</code> [[|]]
@@ Line 1,397: / Line 1,146: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node155.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>MAKE-HASH-TABLE : (size &amp;optional (test #'eql) (area default-cons-area))</code><br />
-<br />
 [[|]]function <code>HASH-TABLE-P : (x)</code><br />
-<br />
 [[|]]function <code>GETHASH : (key table &amp;optional default)</code><br />
-<br />
 [[|]]function <code>SETHASH : (key table value)</code><br />
-<br />
 [[|]]function <code>REMHASH : (key table)</code><br />
-<br />
 [[|]]function <code>MAPHASH : (function table)</code><br />
-<br />
 [[|]]function <code>CLRHASH : (table)</code><br />
-<br />
 [[|]]function <code>HASH-TABLE-COUNT : (table)</code> [[|]]
@@ Line 1,417: / Line 1,158: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node156.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>SXHASH : (object)</code> [[|]]
@@ Line 1,428: / Line 1,168: @@
 SubL only supports one-dimensional arrays, which are called vectors.<br />
-<br />
 [[|]]function <code>VECTORP : (x)</code> [[|]]
@@ Line 1,434: / Line 1,173: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node158.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>MAKE-VECTOR : (size &amp;optional initial-element)</code><br />
-<br />
 [[|]]function <code>VECTOR : (&amp;rest objects)</code> [[|]]
@@ Line 1,442: / Line 1,179: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node159.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>AREF : (vector index)</code><br />
-<br />
 [[|]]function <code>SET-AREF : (vector index value)</code> [[|]]
@@ Line 1,453: / Line 1,188: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node164.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>STRINGP : (x)</code> [[|]]
@@ Line 1,459: / Line 1,193: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node165.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>CHAR : (string index)</code><br />
-<br />
 [[|]]function <code>SET-CHAR : (string index value)</code> [[|]]
@@ Line 1,467: / Line 1,199: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node166.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>STRING= : (string1 string2 &amp;optional (start1 0) end1 (start2 0) end2)</code><br />
-<br />
 [[|]]function <code>STRING-EQUAL : (string1 string2 &amp;optional (start1 0) end1 (start2 0) end2)</code><br />
-<br />
 [[|]]function <code>STRING&lt; : (string1 string2 &amp;optional (start1 0) end1 (start2 0) end2)</code><br />
-<br />
 [[|]]function <code>STRING&gt; : (string1 string2 &amp;optional (start1 0) end1 (start2 0) end2)</code><br />
-<br />
 [[|]]function <code>STRING&lt;= : (string1 string2 &amp;optional (start1 0) end1 (start2 0) end2)</code><br />
-<br />
 [[|]]function <code>STRING&gt;= : (string1 string2 &amp;optional (start1 0) end1 (start2 0) end2)</code><br />
-<br />
 [[|]]function <code>STRING/= : (string1 string2 &amp;optional (start1 0) end1 (start2 0) end2)</code><br />
-<br />
 [[|]]function <code>STRING-LESSP : (string1 string2 &amp;optional (start1 0) end1 (start2 0) end2)</code><br />
-<br />
 [[|]]function <code>STRING-GREATERP : (string1 string2 &amp;optional (start1 0) end1 (start2 0) end2)</code><br />
-<br />
 [[|]]function <code>STRING-NOT-GREATERP : (string1 string2 &amp;optional (start1 0) end1 (start2 0) end2)</code><br />
-<br />
 [[|]]function <code>STRING-NOT-LESSP : (string1 string2 &amp;optional (start1 0) end1 (start2 0) end2)</code><br />
-<br />
 [[|]]function <code>STRING-NOT-EQUAL : (string1 string2 &amp;optional (start1 0) end1 (start2 0) end2)</code> [[|]]
@@ Line 1,495: / Line 1,215: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node167.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>MAKE-STRING : (size &amp;optional (initial-element #\Space))</code><br />
-<br />
 [[|]]function <code>STRING-TRIM : (char-list string)</code><br />
-<br />
 [[|]]function <code>STRING-LEFT-TRIM : (char-list string)</code><br />
-<br />
 [[|]]function <code>STRING-RIGHT-TRIM : (char-list string)</code><br />
-<br />
 [[|]]function <code>STRING-UPCASE : (string &amp;optional (start 0) end)</code><br />
-<br />
 [[|]]function <code>STRING-DOWNCASE : (string &amp;optional (start 0) end)</code><br />
-<br />
 [[|]]function <code>STRING-CAPITALIZE : (string &amp;optional (start 0) end)</code><br />
-<br />
 [[|]]function <code>NSTRING-UPCASE : (string &amp;optional (start 0) end)</code><br />
-<br />
 [[|]]function <code>NSTRING-DOWNCASE : (string &amp;optional (start 0) end)</code><br />
-<br />
 [[|]]function <code>NSTRING-CAPITALIZE : (string &amp;optional (start 0) end)</code><br />
-<br />
 [[|]]function <code>STRING : (x)</code> [[|]]
@@ Line 1,524: / Line 1,233: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node168.html CLtL2 Reference]<br />
-<br />
 [[|]]macro <code>DEFSTRUCT : ((name &amp;rest options) &amp;body slots)</code><br />
-Like Common Lisp defstruct except:<br />
+Like Common Lisp defstruct except:
 (1) slot initializations are not allowed.
 (2) the only other options:<br />
 (:conc-name whatever)<br />
 (:print-function #'whatever)
 the default structure print function is<br />
 default-struct-print-function : object stream depth
 (3) The make constructor takes no arguments and only makes an empty structure.
 (4) Reading of structures is not supported by the reader.<br />
-<br />
 [[|]]function <code>DEFAULT-STRUCT-PRINT-FUNCTION : (object stream depth)</code><br />
-<br />
 [[|]]macro <code>PRINTING-OBJECT : ((object stream) &amp;body body)</code> [[|]]
@@ Line 1,564: / Line 1,263: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node180.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>EVAL : (form)</code><br />
-<br />
 [[|]]function <code>CONSTANTP : (object &amp;optional env)</code>
@@ Line 1,574: / Line 1,271: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node181.html CLtL2 Reference]<br />
-<br />
 [[|]]variable <code>*</code><br />
-<br />
 [[|]]variable <code>**</code><br />
-<br />
 [[|]]variable <code>***</code>
@@ Line 1,594: / Line 1,288: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node182.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>STREAMP : (x)</code> [[|]]
@@ Line 1,600: / Line 1,293: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node183.html CLtL2 Reference]<br />
-<br />
 [[|]]variable <code>*STANDARD-INPUT*</code><br />
-<br />
 [[|]]variable <code>*STANDARD-OUTPUT*</code><br />
-<br />
 [[|]]variable <code>*ERROR-OUTPUT*</code><br />
-<br />
 [[|]]variable <code>*NULL-OUTPUT*</code><br />
 A bit-sink output stream. All output is ignored
@@ Line 1,615: / Line 1,304: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node184.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>OPEN-TCP-STREAM : (host port)</code> [[|]]
@@ Line 1,621: / Line 1,309: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node185.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>STREAMP : (x)</code><br />
-<br />
 [[|]]function <code>INPUT-STREAM-P : (object)</code><br />
-<br />
 [[|]]function <code>OUTPUT-STREAM-P : (object)</code><br />
-<br />
 [[|]]function <code>CLOSE : (stream)</code> [[|]]
@@ Line 1,647: / Line 1,331: @@
 The SubL reader supports the following macro characters, whose meaning is identical to their meaning in Common Lisp :
-<blockquote>'''Macro Character'''
+<blockquote>'''Macro Character'''<br />
-Â Â Â
+Â Â Â <br />
 '''Reader Action'''
 -----
-<code> (</code>
+<code>(</code><br />
-Begin reading a list.
+Begin reading a list.<br />
-<code> )</code>
+<code>)</code><br />
-End reading a list or a vector.
+End reading a list or a vector.<br />
-<code> '</code>
+<code>'</code><br />
-Read in a quoted expression.
+Read in a quoted expression.<br />
-<code> ;</code>
+<code>;</code><br />
-Read a comment until end-of-line.
+Read a comment until end-of-line.<br />
-<code> &quot;</code>
+<code>&quot;</code><br />
-Begin or end reading a string.
+Begin or end reading a string.<br />
-<code> `</code>
+<code>`</code><br />
-Read in a backquoted expression.</blockquote>
+Read in a backquoted expression.
+</blockquote>
 In addition, the following comma-readers are supported inside of backquote :
@@ Line 1,678: / Line 1,364: @@
 '''<code>'#'</code>''' is the SubL standard dispatching macro character. The SubL reader supports the following dispatch macro character sequences, whose meanings are identical to their meanings in Common Lisp :
-<blockquote>'''Dispatch Sequence'''
+<blockquote>'''Dispatch Sequence'''<br />
-Â Â Â
+Â Â Â <br />
 '''Reader Action'''
 -----
-<code> #\(</code>
+<code>#\(</code><br />
-Read a character constant.
+Read a character constant.<br />
-<code> #'</code>
+<code>#'</code><br />
-Read a function constant.
+Read a function constant.<br />
-<code> #(</code>
+<code>#(</code><br />
-Begin reading a vector.
+Begin reading a vector.<br />
-<code> #|</code>
+<code>#|</code><br />
-Begin reading a comment section.
+Begin reading a comment section.<br />
-<code> |#</code>
+<code>|#</code><br />
-End reading a comment section.</blockquote>
+End reading a comment section.
+</blockquote>
 Additionally, SubL supports the dispatch sequence '''<code>#$</code>''' as follows :
-<blockquote><code>#$foo</code> reads the Cyc constant whose name is <code>&quot;foo&quot;</code></blockquote>
+<blockquote><code>#$foo</code> reads the Cyc constant whose name is <code>&quot;foo&quot;</code>
+</blockquote>
 [[|]]
@@ Line 1,708: / Line 1,397: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node193.html CLtL2 Reference]<br />
-<br />
 [[|]]variable <code>*PRINT-ESCAPE*</code> [[|]]
@@ Line 1,714: / Line 1,402: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node195.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>READ : (&amp;optional (stream *standard-input*) (eof-error-p t) (eof-value :eof))</code><br />
 Returns FORM if read was successful.<br />
@@ Line 1,720: / Line 1,407: @@
 Returns the values EOF-VALUE :ERROR if EOF-ERROR-P is nil and EOF occurs.<br />
 Causes an error if EOF-ERROR-P is not nil and EOF occurs.
 Differences from Common Lisp:<br />
-<code>  </code>Numbers are only read in decimal notation with no specified radix.<br />
+<code>`Numbers are only read in decimal notation with no specified radix.</code> <code>No character modifiers: only standard chars plus specials like Space, Return etc.</code> <code>The || notation and \\ syntax for symbols are not supported. []()function</code>READ-LINE : (&amp;optional (stream ''standard-input'') (eof-error-p t) (eof-value :eof))<code>[]()function</code>READ-CHAR : (&amp;optional (stream ''standard-input'') (eof-error-p t) (eof-value :eof))<code>[]()function</code>UNREAD-CHAR : (char &amp;optional (stream ''standard-input''))<code>[]()function</code>READ-FROM-STRING : (string &amp;optional (eof-error-p t) (eof-value :eof) (start 0) end)`<br />
-<code>  </code>No character modifiers: only standard chars plus specials like Space, Return etc.<br />
-<code>  </code>The || notation and \ syntax for symbols are not supported.<br />
-<br />
-[[|]]function <code>READ-LINE : (&amp;optional (stream *standard-input*) (eof-error-p t) (eof-value :eof))</code><br />
-<br />
-[[|]]function <code>READ-CHAR : (&amp;optional (stream *standard-input*) (eof-error-p t) (eof-value :eof))</code><br />
-<br />
-[[|]]function <code>UNREAD-CHAR : (char &amp;optional (stream *standard-input*))</code><br />
-<br />
-[[|]]function <code>READ-FROM-STRING : (string &amp;optional (eof-error-p t) (eof-value :eof) (start 0) end)</code><br />
 Returns the values FORM NEW-START if read was successful.<br />
 Returns the values NIL :ERROR if there was a reader error.<br />
@@ Line 1,745: / Line 1,420: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node196.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>READ-BYTE : (stream &amp;optional (eof-error-p t) (eof-value :eof))</code> [[|]]
@@ Line 1,751: / Line 1,425: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node198.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>WRITE : (object &amp;optional (stream *standard-output*) (escape *print-escape*))</code><br />
-<br />
 [[|]]function <code>PRIN1 : (object &amp;optional (stream *standard-output*))</code><br />
-<br />
 [[|]]function <code>PRINT : (object &amp;optional (stream *standard-output*))</code><br />
-<br />
 [[|]]function <code>PRINC : (object &amp;optional (stream *standard-output*))</code><br />
-<br />
 [[|]]function <code>WRITE-TO-STRING : (object &amp;optional (escape *print-escape*))</code><br />
-<br />
 [[|]]function <code>PRIN1-TO-STRING : (object)</code><br />
-<br />
 [[|]]function <code>PRINC-TO-STRING : (object)</code><br />
-<br />
 [[|]]function <code>WRITE-CHAR : (char &amp;optional (stream *standard-output*))</code><br />
-<br />
 [[|]]function <code>WRITE-STRING : (string &amp;optional (stream *standard-output*) (start 0) end)</code><br />
-<br />
 [[|]]function <code>WRITE-LINE : (string &amp;optional (stream *standard-output*) (start 0) end)</code><br />
-<br />
 [[|]]function <code>TERPRI : (&amp;optional (stream *standard-output*))</code><br />
-<br />
 [[|]]function <code>FORCE-OUTPUT : (&amp;optional (stream *standard-output*))</code> [[|]]
@@ Line 1,779: / Line 1,441: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node199.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>WRITE-BYTE : (integer stream)</code> [[|]]
@@ Line 1,785: / Line 1,446: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node200.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>FORMAT : (destination control-string &amp;rest arguments)</code><br />
 Format ARGUMENTS to the text stream DESTINATION according to the specifications in CONTROL-STRING. SubL format is more limited than the Common Lisp version: the only escapes allowed in the control string are: ~A ~a ~S ~s ~D ~d (with width and pad parameters optional) ~C ~c ~G ~g ~% ~~ [[|]]
@@ Line 1,799: / Line 1,459: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node203.html CLtL2 Reference]<br />
-<br />
 [[|]]variable <code>*DEFAULT-PATHNAME-DEFAULTS*</code><br />
-<br />
 [[|]]function <code>CONSTRUCT-FILENAME : (directory-list filename &amp;optional extension relative?)</code>
@@ Line 1,809: / Line 1,467: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node215.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>OPEN-TEXT : (filename direction)</code><br />
 Attempts to open the file FILENAME. If successful, returns an 8-bit character text stream. If DIRECTION is :input, then input operations can be performed on the stream. If DIRECTION is output, then output is directed to the file FILENAME, overwriting any existing file. If DIRECTION is :append, then output is appended to the file. For either output case, a new file is created if no file named FILENAME already exists.<br />
-<br />
 [[|]]function <code>OPEN-BINARY : (filename direction)</code><br />
 Attempts to open the file FILENAME. If successful, returns an 8-bit binary byte stream. If DIRECTION is :input, then input operations can be performed on the stream. If DIRECTION is output, then output is directed to the file FILENAME, overwriting any existing file. If DIRECTION is :append, then output is appended to the file. For either output case, a new file is created if no file named FILENAME already exists.<br />
-<br />
 [[|]]macro <code>WITH-TEXT-FILE : ((stream filestring direction) &amp;body body)</code><br />
 In the scope of a WITH-TEXT-FILE expression, the file FILESTRING is opened for character i/o and a stream to this file is created and bound to the variable STREAM. If DIRECTION is :input, then input operations can be performed on STREAM. If DIRECTION is :output, then output operations can be performed, overwriting any existing file. If DIRECTION is :append, then output is appended to an existing file.<br />
-<br />
 [[|]]macro <code>WITH-BINARY-FILE : ((stream filestring direction) &amp;body body)</code><br />
 In the scope of a WITH-BINARY-FILE expression, the file FILESTRING is opened for binary i/o and a stream to this file is created and bound to the variable STREAM. If DIRECTION is :input, then input operations can be performed on STREAM. If DIRECTION is :output, then output operations can be performed, overwriting any existing file. If DIRECTION is :append, then output is appended to an existing file. [[|]]
@@ Line 1,825: / Line 1,479: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node216.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>RENAME-FILE : (filename new-name)</code><br />
-<br />
 [[|]]function <code>DELETE-FILE : (filename)</code><br />
-<br />
 [[|]]function <code>PROBE-FILE : (filename)</code><br />
-<br />
 [[|]]function <code>APPEND-FILES : (filename-1 filename-2 &amp;optional (mode :text))</code><br />
 Append filename-1 to filename-2<br />
-<br />
 [[|]]function <code>FILE-WRITE-DATE : (filename)</code><br />
-<br />
 [[|]]function <code>FILE-AUTHOR : (filename)</code><br />
-<br />
 [[|]]function <code>GET-FILE-POSITION : (stream)</code><br />
-<br />
 [[|]]function <code>SET-FILE-POSITION : (stream n)</code><br />
-<br />
 [[|]]function <code>FILE-LENGTH : (stream)</code> [[|]]
@@ Line 1,848: / Line 1,493: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node217.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>LOAD : (filename)</code> [[|]]
@@ Line 1,854: / Line 1,498: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node218.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>DIRECTORY : (directory-name &amp;optional include-directory)</code> [[|]]
@@ Line 1,867: / Line 1,510: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node220.html CLtL2 Reference]<br />
-<br />
 [[|]]variable <code>*ERROR-ABORT-HANDLER*</code><br />
 If *error-abort-handler* is non-nil, then an ABORT option is available inside ERROR and CERROR.<br />
 If chosen, then the handler is funcalled on no arguments.<br />
-<br />
 [[|]]variable <code>*ERROR-HANDLER*</code><br />
 If *ERROR-SIGNAL* is non-nil, then that function is called upon an error. Otherwise, the debugger is invoked.<br />
-<br />
 [[|]]variable <code>*ERROR-MESSAGE*</code><br />
-<br />
 [[|]]function <code>ERROR : (format-string &amp;rest arguments)</code><br />
-<br />
 [[|]]variable <code>*CONTINUE-CERROR?*</code><br />
-<br />
 [[|]]function <code>CERROR : (continue-string format-string &amp;rest arguments)</code><br />
-<br />
 [[|]]variable <code>*IGNORE-WARNS?*</code><br />
 If T, all warnings forms are ignored<br />
-<br />
 [[|]]function <code>WARN : (format-string &amp;rest arguments)</code><br />
-<br />
 [[|]]variable <code>*IGNORE-BREAKS?*</code><br />
 If non-NIL, all break forms are ignored<br />
-<br />
 [[|]]function <code>BREAK : (format-string &amp;rest arguments)</code> [[|]]
@@ Line 1,896: / Line 1,529: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node221.html CLtL2 Reference]<br />
-<br />
 [[|]]variable <code>*IGNORE-MUSTS?*</code><br />
 If non-NIL, all must forms are ignored<br />
-<br />
 [[|]]macro <code>MUST : (form format-string &amp;rest arguments)</code><br />
-<br />
 [[|]]variable <code>*SUSPEND-TYPE-CHECKING?*</code><br />
 CHECK-TYPE tests are performed iff this is non-nil<br />
-<br />
 [[|]]macro <code>CHECK-TYPE : (object pred)</code> [[|]]
@@ Line 1,923: / Line 1,552: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node230.html CLtL2 Reference]<br />
-<br />
 [[|]]macro <code>CTIME : (var &amp;body body)</code><br />
-<br />
 [[|]]function <code>DEBUG : ()</code><br />
 Pauses execution and invokes the debugger. [[|]]
@@ Line 1,932: / Line 1,559: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node232.html CLtL2 Reference]<br />
-<br />
 [[|]]variable <code>*EPOCH*</code><br />
 *epoch* is the current epoch in use, which is a universal time.<br />
@@ Line 1,938: / Line 1,564: @@
 *epoch* is globally initialized to midnight Jan 1 1970.<br />
 All universal times are relative to *epoch*.<br />
-<br />
 [[|]]function <code>GET-UNIVERSAL-TIME : ()</code><br />
-<br />
 [[|]]function <code>DECODE-UNIVERSAL-TIME : (universal-time)</code><br />
-<br />
 [[|]]function <code>ENCODE-UNIVERSAL-TIME : (second minute hour date month year)</code><br />
-<br />
 [[|]]function <code>TIME-FROM-NOW : (delta)</code><br />
-<br />
 [[|]]function <code>TIME-HAS-ARRIVED? : (time)</code><br />
-<br />
 [[|]]function <code>ENCODE-TIMESTRING : (second minute hour date month year)</code><br />
-<br />
 [[|]]function <code>TIMESTRING : (&amp;optional (universal-time (get-universal-time)))</code><br />
 timestring returns a string in the format dd/mm/yy hh:mm:ss from the<br />
 universal time given. If none is given, the current time is used.<br />
-<br />
 [[|]]variable <code>*CLOCK-GRANULARITY*</code><br />
 *clock-granularity* is the number of internal clock units per second.<br />
 time evals form and returns the number of internal clock units it took<br />
 to execute.<br />
-<br />
 [[|]]function <code>GET-INTERNAL-REAL-TIME : ()</code><br />
-<br />
 [[|]]function <code>SLEEP : (seconds)</code> [[|]]
@@ Line 1,967: / Line 1,583: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node234.html CLtL2 Reference]<br />
-<br />
 [[|]]function <code>IDENTITY : (object)</code> [[|]]
@@ Line 1,976: / Line 1,591: @@
 [http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/node260.html CLtL2 Reference]<br />
-<br />
 [[|]]macro <code>DEFPOLYMORPHIC : (name lambda-list &amp;body body)</code><br />
 Defines a new polymorphic function that dispatches on the type of its first argument. &lt;body&gt; defines a default method. The function define-method can be used to define additional methods. For example:
 (defpolymorphic test (a b)<br />
-<code>    </code>(list a b))
+` `(list a b))
 (define-method test ((a cons) b)<br />
-<code>    </code>(cons b a))
+` `(cons b a))
 (define-method test ((a fixnum) b)<br />
-<code>    </code>(+ a b))
+` `(+ a b))
 The defpolymorphic form defines the function TEST with a default method.<br />
-<code>  </code>The two define-method forms specialize the behavior of TEST for lists and fixnums.
+` `The two define-method forms specialize the behavior of TEST for lists and fixnums.
 (test 'foo 'bar) =&gt; (FOO BAR)<br />
-<code>  </code>(test '(foo) 'bar) =&gt; (BAR FOO)<br />
+<code>`(test '(foo) 'bar) =&amp;gt; (BAR FOO)</code> <code>(test 2 3) =&amp;gt; 5 []()macro</code>DEFINE-METHOD : (name lambda-list &amp;body body)`<br />
-<code>  </code>(test 2 3) =&gt; 5<br />
-<br />
-[[|]]macro <code>DEFINE-METHOD : (name lambda-list &amp;body body)</code><br />
 Defines a method for the polymorphic function &lt;name&gt; that runs if<br />
 &lt;dispatch-arg&gt; is of type &lt;type&gt;. The lambda list must have the same<br />
@@ Line 2,017: / Line 1,618: @@
 [[|]] '''SubL.1 : Signals'''<br />
-<br />
 [[|]]variable <code>*SIGNAL-MAX*</code><br />
 There are *signal-max* total signals available.<br />
-<br />
 [[|]]function <code>DEFAULT-SIGNAL-HANDLER : (signal)</code><br />
-<br />
+[[|]]function <code>INSTALL-SIGNAL-HANDLER : (signal function)</code>
-[[|]]function <code>INSTALL-SIGNAL-HANDLER : (signal function)</code><br />
 [[|]] '''SubL.2 : System Properties'''<br />
-<br />
 [[|]]function <code>GET-PROCESS-ID : (&amp;optional default)</code><br />
 Return the current heavyweight process id of this current SubL<br />
 program. Return DEFAULT if this cannot be determined.<br />
-<br />
 [[|]]function <code>GET-MACHINE-NAME : (&amp;optional default)</code><br />
-<br />
 [[|]]function <code>GET-NETWORK-NAME : (&amp;optional default)</code><br />
-<br />
+[[|]]function <code>GET-USER-NAME : (&amp;optional default)</code>
-[[|]]function <code>GET-USER-NAME : (&amp;optional default)</code><br />
 [[|]] '''SubL.3 : Progress Pacifiers'''<br />
-<br />
 [[|]]variable <code>*SILENT-PROGRESS?*</code><br />
-<br />
 [[|]]macro <code>NOTING-ACTIVITY : (string &amp;body body)</code><br />
-<br />
 [[|]]function <code>NOTE-ACTIVITY : ()</code><br />
-<br />
 [[|]]macro <code>NOTING-NUMERIC-PROGRESS : (string &amp;body body)</code><br />
-<br />
 [[|]]function <code>NOTE-NUMERIC-PROGRESS : (num)</code><br />
-<br />
 [[|]]macro <code>NOTING-PERCENT-PROGRESS : (string &amp;body body)</code><br />
-<br />
+[[|]]function <code>NOTE-PERCENT-PROGRESS : (index max)</code>
-[[|]]function <code>NOTE-PERCENT-PROGRESS : (index max)</code><br />
 [[|]] '''SubL.4 : Process Manipulation'''<br />
-<br />
 [[|]]function <code>FORK-PROCESS : (function &amp;optional callback output-file)</code><br />
 Spawn a heavyweight child process to call FUNCTION, which takes no arguments.<br />
@@ Line 2,065: / Line 1,648: @@
 OUTPUT-FILE, if provided, is a file to which standard output and error are piped<br />
 while executing FUNCTION.<br />
-<br />
 [[|]]function <code>RESTART-PROCESS : (&amp;optional world-spec init-file-pathname init-form-spec)</code><br />
 Restart the current heavyweight process.<br />
@@ Line 2,071: / Line 1,653: @@
 INIT-FILE-PATHNAME, if provided, is a file of initializatio forms to eval.<br />
 INIT-FORM-SPEC, if provided, is a form to execute.<br />
-The values used for these when the current process was started are used if unprovided.<br />
+The values used for these when the current process was started are used if unprovided.
 [[|]] '''SubL.5 : Memory Interaction'''<br />
-<br />
 [[|]]function <code>GC : (&amp;optional level)</code><br />
-<br />
 [[|]]macro <code>WITH-STATIC-AREA : (&amp;body body)</code><br />
-<br />
 [[|]]function <code>WRITE-IMAGE : (filename &amp;optional do-full-gc)</code><br />
 Save the current state of virtual memory in a file called FILENAME.<br />
@@ Line 2,100: / Line 1,678: @@
 '''[[#Index-A|A]] | [[#Index-B|B]] | [[#Index-C|C]] | [[#Index-D|D]] | [[#Index-E|E]] | [[#Index-F|F]] | [[#Index-G|G]] | [[#Index-H|H]] | [[#Index-I|I]] | [[#Index-J|J]] | [[#Index-K|K]] | [[#Index-L|L]] | [[#Index-M|M]] | [[#Index-N|N]] | [[#Index-O|O]] | [[#Index-P|P]] | [[#Index-Q|Q]] | [[#Index-R|R]] | [[#Index-S|S]] | [[#Index-T|T]] | [[#Index-U|U]] | [[#Index-V|V]] | [[#Index-W|W]] | [[#Index-X|X]] | [[#Index-Y|Y]] | [[#Index-Z|Z]]'''
-<br />
 [[#FN-DEF-1280|<code>*</code>]] function<br />
 [[#SYM-DEF-1280|<code>*</code>]] variable<br />
@@ Line 2,139: / Line 1,716: @@
 ==== A ====
-<br />
 [[#FN-DEF-ACONS|<code>ACONS</code>]] function<br />
 [[#FN-DEF-ADJOIN|<code>ADJOIN</code>]] function<br />
@@ Line 2,155: / Line 1,731: @@
 ==== B ====
-<br />
 [[#FN-DEF-BOTH-CASE-P|<code>BOTH-CASE-P</code>]] function<br />
 [[#FN-DEF-BOUNDP|<code>BOUNDP</code>]] function<br />
@@ Line 2,164: / Line 1,739: @@
 ==== C ====
-<br />
 [[#FN-DEF-CAAR|<code>CAAR</code>]] function<br />
 [[#FN-DEF-CADR|<code>CADR</code>]] function<br />
@@ Line 2,232: / Line 1,806: @@
 ==== D ====
-<br />
 [[#FN-DEF-DEBUG|<code>DEBUG</code>]] function<br />
 [[#FN-DEF-DECLAIM|<code>DECLAIM</code>]] macro<br />
@@ Line 2,257: / Line 1,830: @@
 ==== E ====
-<br />
 [[#FN-DEF-EIGHTH|<code>EIGHTH</code>]] function<br />
 [[#FN-DEF-ELT|<code>ELT</code>]] function<br />
@@ Line 2,273: / Line 1,845: @@
 ==== F ====
-<br />
 [[#FN-DEF-FBOUNDP|<code>FBOUNDP</code>]] function<br />
 [[#FN-DEF-FIF|<code>FIF</code>]] macro<br />
@@ Line 2,304: / Line 1,875: @@
 ==== G ====
-<br />
 [[#FN-DEF-GC|<code>GC</code>]] function<br />
 [[#FN-DEF-GENSYM|<code>GENSYM</code>]] function<br />
@@ Line 2,322: / Line 1,892: @@
 ==== H ====
-<br />
 [[#FN-DEF-HASH-TABLE-COUNT|<code>HASH-TABLE-COUNT</code>]] function<br />
 [[#FN-DEF-HASH-TABLE-P|<code>HASH-TABLE-P</code>]] function [[|]]
@@ Line 2,328: / Line 1,897: @@
 ==== I ====
-<br />
 [[#FN-DEF-IDENTITY|<code>IDENTITY</code>]] function<br />
 [[#FN-DEF-IGNORE|<code>IGNORE</code>]] function<br />
@@ Line 2,346: / Line 1,914: @@
 ==== K ====
-<br />
 [[#FN-DEF-KEYWORDP|<code>KEYWORDP</code>]] function [[|]]
 ==== L ====
-<br />
 [[#FN-DEF-LAST|<code>LAST</code>]] function<br />
 [[#FN-DEF-LDB|<code>LDB</code>]] function<br />
@@ Line 2,366: / Line 1,932: @@
 ==== M ====
-<br />
 [[#FN-DEF-MAKE-HASH-TABLE|]]<code>MAKE-HASH-TABLE</code> function<br />
 [[#FN-DEF-MAKE-LIST|]]<code>MAKE-LIST</code> function<br />
@@ Line 2,392: / Line 1,957: @@
 ==== N ====
-<br />
 [[#FN-DEF-NBUTLAST|]]<code>NBUTLAST</code> function<br />
 [[#FN-DEF-NCONC|]]<code>NCONC</code> function<br />
@@ Line 2,424: / Line 1,988: @@
 ==== O ====
-<br />
 [[#FN-DEF-ODDP|]]<code>ODDP</code> function<br />
 [[#FN-DEF-OPEN-BINARY|]]<code>OPEN-BINARY</code> function<br />
@@ Line 2,433: / Line 1,996: @@
 ==== P ====
-<br />
 [[#FN-DEF-PAIRLIS|]]<code>PAIRLIS</code> macro<br />
 [[#FN-DEF-PCASE|]]<code>PCASE</code> macro<br />
@@ Line 2,456: / Line 2,018: @@
 ==== Q ====
-<br />
 [[#FN-DEF-QUOTE|]]<code>QUOTE</code> function[[|]]
 ==== R ====
-<br />
 [[#FN-DEF-RANDOM|]]<code>RANDOM</code> function<br />
 [[#FN-DEF-RASSOC|]]<code>RASSOC</code> function<br />
@@ Line 2,490: / Line 2,050: @@
 ==== S ====
-<br />
 [[#FN-DEF-SCALE-FLOAT|]]<code>SCALE-FLOAT</code> function<br />
 [[#FN-DEF-SEARCH|]]<code>SEARCH</code> function<br />
@@ Line 2,547: / Line 2,106: @@
 ==== T ====
-<br />
 [[#FN-DEF-TAILP|]]<code>TAILP</code> function<br />
 [[#FN-DEF-TENTH|]]<code>TENTH</code> function<br />
@@ Line 2,561: / Line 2,119: @@
 ==== U ====
-<br />
 [[#FN-DEF-UNION|]]<code>UNION</code> function<br />
 [[#FN-DEF-UNREAD-CHAR|]]<code>UNREAD-CHAR</code> function<br />
@@ Line 2,569: / Line 2,126: @@
 ==== V ====
-<br />
 [[#FN-DEF-VALUES|]]<code>VALUES</code> function<br />
 [[#FN-DEF-VARIABLE-INFORMATION|]]<code>VARIABLE-INFORMATION</code> function<br />
@@ Line 2,577: / Line 2,133: @@
 ==== W ====
-<br />
 [[#FN-DEF-WARN|]]<code>WARN</code> macro<br />
 [[#FN-DEF-WITH-BINARY-FILE|]]<code>WITH-BINARY-FILE</code> macro<br />
@@ Line 2,600: / Line 2,155: @@
 ==== Z ====
-<br />
 [[#FN-DEF-ZEROP|]]<code>ZEROP</code>

Numbers:	fixnum
	float
Symbols:	symbol
Lists:	cons
Arrays:	vector
Characters:	character
Strings:	string
Hashtables:	eq hashtable
	eql hashtable
	equal hashtable
	equalp hashtable
Streams:	stream
Functions:	function

Difference between revisions of "SubL"

Revision as of 09:56, 17 April 2017

Contents

OpenCyc.org HomepageSubL Reference

How to Use this Document

0 : Table of Contents

1 : Introduction

2 : Data Types

3 : Scope and Extent

4 : Type Specifiers

5 : Program Structure

5.3.1 : Defining Named Functions

5.3.2 : Declaring Global Variables and Named Constants

6 : Predicates

6.1 : Logical Values

6.2.2 : Specific Data Type Predicates

6.3 : Equality Predicates

6.4 : Logical Operators

7 : Control Structure

7.1.1 : Reference

7.1.2 : Assignment

7.2 : Generalized Variables

7.3 : Function Invocation

7.4 : Simple Sequencing

7.5 : Establishing New Variable Bindings

7.6 : Conditionals

7.7 : Blocks and Exits

7.8.2 : General Iteration

7.8.3 : Simple Iteration Constructs

7.8.4 : Mapping

7.10.1 : Constructs for Handling Multiple Values

7.10.2 : Rules Governing the Passing of Multiple Values

7.11 : Dynamic Non-Local Exits

8 : Macros

8.1 : Macro Definition

8.3 : Destructuring

8.5 : Environments

9 : Declarations

9.1 : Declaration Syntax

9.2 : Declaration Specifiers

10 : Symbols

10.1 : The Property List

10.2 : The Print Name

10.3 : Creating Symbols

11 : Packages

12 : Numbers

12.2 : Predicates on Numbers

12.3 : Comparisons on Numbers

12.4 : Arithmetic Operations

12.5 : Irrational and Transcendental Functions

12.6 : Type Conversions and Component Extractions on Numbers

12.7 : Logical Operations on Numbers

12.8 : Byte Manipulation Functions

12.9 : Random Numbers

12.10 : Implementation Parameters

13 : Characters

13.1 : Character Attributes

13.2 : Predicates on Characters

13.3 : Character Construction and Selection

13.4 : Character Conversions

14 : Sequences

14.1 : Simple Sequence Functions

14.2 : Concatenating, Mapping and Reducing Sequences

14.3 : Modifying Sequences

14.4 : Searching Sequences for Terms

14.5 : Sorting and Merging

15 : Lists

15.1 : Conses

15.2 : Lists

15.3 : Alteration of List Structure

15.4 : Substitution of Expressions

15.5 : Using Lists as Sets

15.6 : Association Lists

16 : Hash Tables

16.1 : Hash Table Functions

16.2 : Primitive Hash Function

17 : Arrays

17.1 : Vector Creation

17.2 : Vector Access

18 : Strings

OpenCyc.org Homepage SubL Reference