Revision as of 00:16, 3 July 2019 (view source) DavidWhitten (talk | contribs) (→‎20.2 : The Top-Level Loop) ← Older edit		Latest revision as of 19:39, 7 February 2020 (view source) DavidWhitten (talk | contribs)
(One intermediate revision by the same user not shown)
Line 1:		Line 1:
−	[http://web.archive.org/web/20060325065433/http://www.opencyc.org [[File:/web/20060325065433im_/http://www.cyc.com/cycdoc/img/opencyc-logo-small.gif|OpenCyc.org Homepage]]]	+	[http://web.archive.org/web/20060325065433/http://www.opencyc.org/web/20060325065433im_/http://www.cyc.com/cycdoc/img/opencyc-logo-small.gif|OpenCyc.org Homepage]
		+
	SubL Reference		SubL Reference
	Last Update: 03/28/2002 ''Copyright© 1996-2002 Cycorp. All rights reserved.		Last Update: 03/28/2002 ''Copyright© 1996-2002 Cycorp. All rights reserved.

---

Latest revision as of 19:39, 7 February 2020

Homepage

SubL Reference 
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://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/clm.html http://www.supelec.fr/docs/cltl/clm/clm.html or an index to all Common Lisp functions was found at http://web.archive.org/web/20060325065433/http://www.supelec.fr/docs/cltl/clm/index.html original link (non-working in 2019) was: http://www.supelec.fr/docs/cltl/clm/index.html

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.

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:

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)	Same as Common Lisp
function SYMBOLP : (x)	Same as Common Lisp
function ATOM : (x)	Same as Common Lisp
function CONSP : (x)	Same as Common Lisp
function LISTP : (x)	Same as Common Lisp
function NUMBERP : (x)	Same as Common Lisp
function INTEGERP : (x)	Same as Common Lisp
function FLOATP : (x)	Same as Common Lisp
function CHARACTERP : (x)	Same as Common Lisp
function STRINGP : (x)	Same as Common Lisp
function VECTORP : (x)	Same as Common Lisp
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

The SubL equality predicates behave exactly like their Common Lisp counterparts.

function EQ : (x y)

function EQL : (x y)

function EQUAL : (x y)

function EQUALP : (x y)

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

These SubL constructs behave exactly like their Common Lisp counterparts.

function QUOTE : (data)

macro FUNCTION : (fspec)

function SYMBOL-VALUE : (x)

function SYMBOL-FUNCTION : (x)

function BOUNDP : (x)

function FBOUNDP : (x)

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 (Java).

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

CLtL2 Reference

macro CDOLIST : ((var listform) &body body)

macro CSOME : ((var list endvar) &body body)

macro CDOTIMES : ((var integer) &body body)

macro CDOHASH : ((key val table) &body body)

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

CLtL2 Reference

function GET : (symbol indicator &optional default)

function PUT : (symbol indicator new-value)

function REMPROP : (symbol indicator)

function SYMBOL-PLIST : (symbol)

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

SubL only supports fixnums and floats. Fixnums have at least 28 bits of precision.

function NUMBERP : (x)

function FIXNUMP : (x)

function INTEGERP : (x)

function FLOATP : (x)

12.2 : Predicates on Numbers

CLtL2 Reference

function ZEROP : (x)

function PLUSP : (x)

function MINUSP : (x)

function ODDP : (x)

function EVENP : (x)

12.3 : Comparisons on Numbers

CLtL2 Reference

function = : (num1 num2)

function /= : (num1 num2)

function < : (num1 num2)

function > : (num1 num2)

function <= : (num1 num2)

function >= : (num1 num2)

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

CLtL2 Reference

function + : (&rest numbers)

function - : (num &rest numbers)

function * : (&rest numbers)

function / : (num &rest numbers)

function INT/ : (num1 num2)

macro CINC : (place &optional (delta 1))

macro CDEC : (place &optional (delta 1))

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

CLtL2 Reference

function FLOAT : (x)

function FLOOR : (x)

function CEILING : (x)

function TRUNCATE : (x)

function ROUND : (x)

function MOD : (number divisor)

function REM : (number divisor)

function SCALE-FLOAT : (float integer)

function INTEGER-DECODE-FLOAT : (float)

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

CLtL2 Reference

function ALPHA-CHAR-P : (char)

function UPPER-CASE-P : (char)

function LOWER-CASE-P : (char)

function BOTH-CASE-P : (char)

function DIGIT-CHAR-P : (char)

function ALPHANUMERICP : (char)

function CHAR= : (char1 char2)

function CHAR/= : (char1 char2)

function CHAR< : (char1 char2)

function CHAR> : (char1 char2)

function CHAR<= : (char1 char2)

function CHAR>= : (char1 char2)

function CHAR-EQUAL : (char1 char2)

function CHAR-NOT-EQUAL : (char1 char2)

function CHAR-LESSP : (char1 char2)

function CHAR-GREATERP : (char1 char2)

function CHAR-NOT-GREATERP : (char1 char2)

function CHAR-NOT-LESSP : (char1 char2)

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

CLtL2 Reference

function ELT : (sequence index)

function SUBSEQ : (sequence start &optional end)

function COPY-SEQ : (sequence)

function LENGTH : (sequence)

function REVERSE : (sequence)

function NREVERSE : (sequence)

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

CLtL2 Reference

function CAR : (cons)

function CDR : (cons)

function CAAR : (cons)

function CADR : (cons)

function CDAR : (cons)

function CDDR : (cons)

function CONS : (car cdr)

function TREE-EQUAL : (tree1 tree2 &optional (test #'eql))

15.2 : Lists

CLtL2 Reference

function ENDP : (object)

function LIST-LENGTH : (list)

function NTH : (n list)

function FIRST : (list)

function SECOND : (list)

function THIRD : (list)

function FOURTH : (list)

function FIFTH : (list)

function SIXTH : (list)

function SEVENTH : (list)

function EIGHTH : (list)

function NINTH : (list)

function TENTH : (list)

function REST : (list)

function NTHCDR : (n list)

function LAST : (list &optional (n 1))

function LIST : (&rest objects)

function LIST* : (arg &rest objects)

function MAKE-LIST : (size &optional initial-element)

function APPEND : (&rest lists)

function COPY-LIST : (list)

function COPY-ALIST : (list)

function COPY-TREE : (tree)

function REVAPPEND : (list1 list2)

function NCONC : (&rest lists)

function NRECONC : (list1 list2)

macro CPUSH : (item place)

macro CPUSHNEW : (item place &optional (test '#'eql) (key '#'identity))

macro CPOP : (place)

function BUTLAST : (list &optional (n 1))

function NBUTLAST : (list &optional (n 1))

function LDIFF : (list sublist)

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

CLtL2 Reference

function MAKE-HASH-TABLE : (size &optional (test #'eql) (area default-cons-area))

function HASH-TABLE-P : (x)

function GETHASH : (key table &optional default)

function SETHASH : (key table value)

function REMHASH : (key table)

function MAPHASH : (function table)

function CLRHASH : (table)

function HASH-TABLE-COUNT : (table)

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

CLtL2 Reference

function STREAMP : (x)

function INPUT-STREAM-P : (object)

function OUTPUT-STREAM-P : (object)

function CLOSE : (stream)

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 (with width and pad parameters optional)

~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)

26. Loop

CLtL2 Reference
no information

27. Pretty Printing

CLtL2 Reference
no information

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

macro DEFINE-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.3 : Progress Pacifiers

variable *SILENT-PROGRESS?*

macro NOTING-ACTIVITY : (string &body body)

function NOTE-ACTIVITY : ()

macro NOTING-NUMERIC-PROGRESS : (string &body body)

function NOTE-NUMERIC-PROGRESS : (num)

macro NOTING-PERCENT-PROGRESS : (string &body body)

function NOTE-PERCENT-PROGRESS : (index max)

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

F

FBOUNDP function
FIF macro
FIFTH function
FILE-AUTHOR function
FILE-LENGTH function
FILE-WRITE-DATE function
FILL function
FIND function
FIND-IF function
FIND-SYMBOL function
FIRST function
FIXNUMP function
FLOAT function
FLOATP function
FLOOR function
FMAKUNBOUND function
FORCE-OUTPUT function
FORK-PROCESS function
FORMAT function
FOURTH function
FUNCALL function
FUNCTION macro
FUNCTION-INFORMATION function
FUNCTION-SPEC-P function
FUNCTIONP function
FUNLESS macro
FWHEN macro

G

GC function
GENSYM function
GENTEMP function
GET function
GET-CONSING-STATE function
GET-FILE-POSITION function
GET-INTERNAL-REAL-TIME function
GET-MACHINE-NAME function
GET-NETWORK-NAME function
GET-PROCESS-ID function
GET-STRING-FROM-USER function
GET-UNIVERSAL-TIME function
GET-USER-NAME function
GETHASH function

H

HASH-TABLE-COUNT function
HASH-TABLE-P function

I

IDENTITY function
IGNORE function
IN-PACKAGE macro
INPUT-STREAM-P function
INSTALL-SIGNAL-HANDLER function
INT/ function
INTEGER-DECODE-FLOAT function
INTEGERP function
INTERN function
INTERSECTION 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

[[#FN-DEF-MAKE-HASH-TABLE|]]MAKE-HASH-TABLE function
[[#FN-DEF-MAKE-LIST|]]MAKE-LIST function
[[#FN-DEF-MAKE-STRING|]]MAKE-STRING function
[[#FN-DEF-MAKE-SYMBOL|]]MAKE-SYMBOL function
[[#FN-DEF-MAKE-VECTOR|]]MAKE-VECTOR function
[[#FN-DEF-MAKUNBOUND|]]MAKUNBOUND function
[[#FN-DEF-MAPC|]]MAPC function
[[#FN-DEF-MAPCAN|]]MAPCAN function
[[#FN-DEF-MAPCAR|]]MAPCAR function
[[#FN-DEF-MAPCON|]]MAPCON function
[[#FN-DEF-MAPHASH|]]MAPHASH function
[[#FN-DEF-MAPL|]]MAPL function
[[#FN-DEF-MAPLIST|]]MAPLIST function
[[#FN-DEF-MAX|]]MAX function
[[#FN-DEF-MEMBER|]]MEMBER function
[[#FN-DEF-MEMBER-IF|]]MEMBER-IF function
[[#FN-DEF-MIN|]]MIN function
[[#FN-DEF-MINUSP|]]MINUSP function
[[#FN-DEF-MISMATCH|]]MISMATCH function
[[#FN-DEF-MOD|]]MOD macro
[[#FN-DEF-MULTIPLE-VALUE-LIST|]]MULTIPLE-VALUE-LIST macro
[[#FN-DEF-MUST|]]MUST function

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

[[#FN-DEF-ODDP|]]ODDP function
[[#FN-DEF-OPEN-BINARY|]]OPEN-BINARY function
[[#FN-DEF-OPEN-TCP-STREAM|]]OPEN-TCP-STREAM function
[[#FN-DEF-OPEN-TEXT|]]OPEN-TEXT function
[[#FN-DEF-OUTPUT-STREAM-P|]]OUTPUT-STREAM-P function

P

[[#FN-DEF-PAIRLIS|]]PAIRLIS macro
[[#FN-DEF-PCASE|]]PCASE macro
[[#FN-DEF-PCOND|]]PCOND macro
[[#FN-DEF-PIF|]]PIF function
[[#FN-DEF-PLUSP|]]PLUSP function
[[#FN-DEF-POSITION|]]POSITION function
[[#FN-DEF-POSITION-IF|]]POSITION-IF function
[[#FN-DEF-PRIN1|]]PRIN1 function
[[#FN-DEF-PRIN1-TO-STRING|]]PRIN1-TO-STRING function
[[#FN-DEF-PRINC|]]PRINC function
[[#FN-DEF-PRINC-TO-STRING|]]PRINC-TO-STRING function
[[#FN-DEF-PRINT|]]PRINT macro
[[#FN-DEF-PRINTING-OBJECT|]]PRINTING-OBJECT function
[[#FN-DEF-PROBE-FILE|]]PROBE-FILE function
[[#FN-DEF-PROCLAIM|]]PROCLAIM macro
[[#FN-DEF-PROGN|]]PROGN macro
[[#FN-DEF-PUNLESS|]]PUNLESS function
[[#FN-DEF-PUT|]]PUT macro
[[#FN-DEF-PWHEN|]]PWHEN function

Q

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

R

[[#FN-DEF-RANDOM|]]RANDOM function
[[#FN-DEF-RASSOC|]]RASSOC function
[[#FN-DEF-RASSOC-IF|]]RASSOC-IF function
[[#FN-DEF-READ|]]READ function
[[#FN-DEF-READ-BYTE|]]READ-BYTE function
[[#FN-DEF-READ-CHAR|]]READ-CHAR function
[[#FN-DEF-READ-FROM-STRING|]]READ-FROM-STRING function
[[#FN-DEF-READ-LINE|]]READ-LINE function
[[#FN-DEF-REM|]]REM function
[[#FN-DEF-REMHASH|]]REMHASH function
[[#FN-DEF-REMOVE|]]REMOVE function
[[#FN-DEF-REMOVE-DUPLICATES|]]REMOVE-DUPLICATES function
[[#FN-DEF-REMOVE-IF|]]REMOVE-IF function
[[#FN-DEF-REMPROP|]]REMPROP function
[[#FN-DEF-RENAME-FILE|]]RENAME-FILE function
[[#FN-DEF-REPLACE|]]REPLACE function
[[#FN-DEF-REPORT-ERROR|]]REPORT-ERROR function
[[#FN-DEF-REST|]]REST function
[[#FN-DEF-RESTART-PROCESS|]]RESTART-PROCESS macro
[[#FN-DEF-RET|]]RET function
[[#FN-DEF-REVAPPEND|]]REVAPPEND function
[[#FN-DEF-REVERSE|]]REVERSE function
[[#FN-DEF-ROUND|]]ROUND function
[[#FN-DEF-RPLACA|]]RPLACA function
[[#FN-DEF-RPLACD|]]RPLACD function

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

[[#FN-DEF-TAILP|]]TAILP function
[[#FN-DEF-TENTH|]]TENTH function
[[#FN-DEF-TERPRI|]]TERPRI function
[[#FN-DEF-THIRD|]]THIRD function
[[#FN-DEF-THROW|]]THROW function
[[#FN-DEF-TIME-FROM-NOW|]]TIME-FROM-NOW function
[[#FN-DEF-TIME-HAS-ARRIVED?|]]TIME-HAS-ARRIVED? function
[[#FN-DEF-TIMESTRING|]]TIMESTRING function
[[#FN-DEF-TREE-EQUAL|]]TREE-EQUAL function
[[#FN-DEF-TRUNCATE|]]TRUNCATE function

U

[[#FN-DEF-UNION|]]UNION function
[[#FN-DEF-UNREAD-CHAR|]]UNREAD-CHAR function
[[#FN-DEF-UPPER-CASE-P|]]UPPER-CASE-P function
[[#FN-DEF-USER-CONFIRM|]]USER-CONFIRM function

V

[[#FN-DEF-VALUES|]]VALUES function
[[#FN-DEF-VARIABLE-INFORMATION|]]VARIABLE-INFORMATION function
[[#FN-DEF-VECTOR|]]VECTOR function
[[#FN-DEF-VECTORP|]]VECTORP function

W

[[#FN-DEF-WARN|]]WARN macro
[[#FN-DEF-WITH-BINARY-FILE|]]WITH-BINARY-FILE macro
[[#FN-DEF-WITH-STATIC-AREA|]]WITH-STATIC-AREA macro
[[#FN-DEF-WITH-TEXT-FILE|]]WITH-TEXT-FILE function
[[#FN-DEF-WRITE|]]WRITE function
[[#FN-DEF-WRITE-BYTE|]]WRITE-BYTE function
[[#FN-DEF-WRITE-CHAR|]]WRITE-CHAR function
[[#FN-DEF-WRITE-IMAGE|]]WRITE-IMAGE function
[[#FN-DEF-WRITE-LINE|]]WRITE-LINE function
[[#FN-DEF-WRITE-STRING|]]WRITE-STRING function
[[#FN-DEF-WRITE-TO-STRING|]]WRITE-TO-STRING function

X

Y

Z

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