Appendix 3: XLISP: An Object-oriented Lisp (original) (raw)

Previous Section | Next Section (Index) | Table of Contents | Title Page

Version 2.0

February 6, 1988

by
David Michael Betz
127 Taylor Road
Peterborough, NH 03458

Copyright (c) 1988, by David Michael Betz
All Rights Reserved
Permission is granted for unrestricted non-commercial use

Introduction

XLISP is an experimental programming language combining some of the features of Common Lisp with an object-oriented extension capability. It was implemented to allow experimentation with object-oriented programming on small computers.

Implementations of XLISP run on virtually every operating system. XLISP is completely written in the programming language C and is easily extended with user written built-in functions and classes. It is available in source form to non-commercial users.

Many Common Lisp functions are built into XLISP. In addition, XLISP defines the objects Object and Class as primitives. Object is the only class that has no superclass and hence is the root of the class hierarchy tree. Class is the class of which all classes are instances (it is the only object that is an instance of itself).

This document is a brief description of XLISP. It assumes some knowledge of LISP and some understanding of the concepts of object-oriented programming.

I recommend the book Lisp by Winston and Horn and published by Addison Wesley for learning Lisp. The first edition of this book is based on MacLisp and the second edition is based on Common Lisp.

You will probably also need a copy of Common Lisp: The Language by Guy L. Steele, Jr., published by Digital Press to use as a reference for some of the Common Lisp functions that are described only briefly in this document.

A Note From The Author

If you have any problems with XLISP, feel free to contact me [me being David Betz - RBD] for help or advice. Please remember that since XLISP is available in source form in a high level language, many users [e.g. that Dannenberg fellow - RBD] have been making versions available on a variety of machines. If you call to report a problem with a specific version, I may not be able to help you if that version runs on a machine to which I don't have access. Please have the version number of the version that you are running readily accessible before calling me.

If you find a bug in XLISP, first try to fix the bug yourself using the source code provided. If you are successful in fixing the bug, send the bug report along with the fix to me. If you don't have access to a C compiler or are unable to fix a bug, please send the bug report to me and I'll try to fix it.

Any suggestions for improvements will be welcomed. Feel free to extend the language in whatever way suits your needs. However, PLEASE DO NOT RELEASE ENHANCED VERSIONS WITHOUT CHECKING WITH ME FIRST!! I would like to be the clearing house for new features added to XLISP. If you want to add features for your own personal use, go ahead. But, if you want to distribute your enhanced version, contact me first. Please remember that the goal of XLISP is to provide a language to learn and experiment with LISP and object-oriented programming on small computers. I don't want it to get so big that it requires megabytes of memory to run.

XLISP Command Loop

When XLISP is started, it first tries to load the workspacexlisp.wks from the current directory. If that file doesn't exist, XLISP builds an initial workspace, empty except for the built-in functions and symbols.

Then XLISP attempts to load init.lsp from the current directory. It then loads any files named as parameters on the command line (after appending .lsp to their names).

XLISP then issues the following prompt:

This indicates that XLISP is waiting for an expression to be typed.

When a complete expression has been entered, XLISP attempts to evaluate that expression. If the expression evaluates successfully, XLISP prints the result and then returns to the initial prompt waiting for another expression to be typed.

Special Characters

When XLISP is running from a console, some control characters invoke operations:

Backspace and Delete characters erase the previous character on the input line (if any).
Control-U erases the entire input line.
Control-C executes the TOP-LEVEL function.
Control-G executes the CLEAN-UP function.
Control-P executes the CONTINUE function.
Control-B stops execution and enters the break command loop. Execution can be continued by typing Control-P or (CONTINUE).
Control-E turns on character echoing (Linux and Mac OS X only).
Control-F turns off character echoing (Linux and Mac OS X only).
Control-T evaluates the INFO function.

Break Command Loop

When XLISP encounters an error while evaluating an expression, it attempts to handle the error in the following way:

If the symbol *breakenable* is true, the message corresponding to the error is printed. If the error is correctable, the correction message is printed.

If the symbol *tracenable* is true, a trace back is printed. The number of entries printed depends on the value of the symbol*tracelimit*. If this symbol is set to something other than a number, the entire trace back stack is printed.

XLISP then enters a read/eval/print loop to allow the user to examine the state of the interpreter in the context of the error. This loop differs from the normal top-level read/eval/print loop in that if the user invokes the functioncontinue, XLISP will continue from a correctable error. If the user invokes the function clean-up, XLISP will abort the break loop and return to the top level or the next lower numbered break loop. When in a break loop, XLISP prefixes the break level to the normal prompt.

If the symbol *breakenable* is nil, XLISP looks for a surrounding errset function. If one is found, XLISP examines the value of the print flag. If this flag is true, the error message is printed. In any case, XLISP causes the errset function call to return nil.

If there is no surrounding errset function, XLISP prints the error message and returns to the top level.

Data Types

There are several different data types available to XLISP programmers.

lists - are linked lists of cons cells, where a cons cell is a pair of references called the car or head and cdr ortail. The empty list is the null reference denoted by nil. (There is nocons cell.) A list of 1 element is a cons cell whose car is the element and whose cdr is a list of no elements, i.e. nil. A list of 2 elements is a cons cell whose caris the first element and whose cdr is a list containing the second element, and so on.
symbols - unique strings that serve as names of variables and names of functions. All symbols are in a global symbol table.
strings - non-unique, immutable character strings.
integers
characters - note that characters are not strings.
floats
objects
arrays
streams
subrs (built-in functions)
fsubrs (special forms)
closures (user defined functions)

The Evaluator

The process of evaluation in XLISP:

Strings, integers, characters, floats, objects, arrays, streams, subrs, fsubrs and closures evaluate to themselves.
Symbols act as variables and are evaluated by retrieving the value associated with their current binding.
Lists are evaluated by examining the first element of the list and then taking one of the following actions:
- If it is a symbol, the functional binding of the symbol is retrieved.
- If it is a lambda expression, a closure is constructed for the function described by the lambda expression.
- If it is a subr, fsubr or closure, it stands for itself.
- Any other value is an error.
  Then, the value produced by the previous step is examined:
- If it is a subr or closure, the remaining list elements are evaluated and the subr or closure is called with these evaluated expressions as arguments.
- If it is an fsubr, the fsubr is called using the remaining list elements as arguments (unevaluated).
- If it is a macro, the macro is expanded using the remaining list elements as arguments (unevaluated). The macro expansion is then evaluated in place of the original macro call.

Lexical Conventions

The following conventions must be followed when entering XLISP programs:

Comments in XLISP code begin with a semi-colon character and continue to the end of the line.

Symbol names in XLISP can consist of any sequence of non-blank printable characters except the following:

            ( ) ' ` , " ;

Uppercase and lowercase characters are not distinguished within symbol names. All lowercase characters are mapped to uppercase on input.

Integer literals consist of a sequence of digits optionally beginning with a + or -. The range of values an integer can represent is limited by the size of a C long on the machine on which XLISP is running.

Floating point literals consist of a sequence of digits optionally beginning with a + or - and including an embedded decimal point. The range of values a floating point number can represent is limited by the size of a C float (double on machines with 32 bit addresses) on the machine on which XLISP is running.

Literal strings are sequences of characters surrounded by double quotes. Within quoted strings the “\” character is used to allow non-printable characters to be included. The codes recognized are:

\\ means the character “\”
\n means newline
\t means tab
\r means return
\f means form feed
\nnn means the character whose octal code is nnn

Readtables

The behavior of the reader is controlled by a data structure called a readtable. The reader uses the symbol *readtable* to locate the current readtable. This table controls the interpretation of input characters. It is an array with 128 entries, one for each of the ASCII character codes. Each entry contains one of the following things:

NIL – Indicating an invalid character
:CONSTITUENT – Indicating a symbol constituent
:WHITE-SPACE – Indicating a whitespace character
(:TMACRO . _fun_) – Terminating readmacro
(:NMACRO . _fun_) – Non-terminating readmacro
:SESCAPE – Single escape character ('\')
:MESCAPE – Multiple escape character ('|')

In the case of :TMACRO and :NMACRO, the fun component is a function. This can either be a built-in readmacro function or a lambda expression. The function should take two parameters. The first is the input stream and the second is the character that caused the invocation of the readmacro. The readmacro function should return NIL to indicate that the character should be treated as white space or a value consed with NIL to indicate that the readmacro should be treated as an occurence of the specified value. Of course, the readmacro code is free to read additional characters from the input stream.

XLISP defines several useful read macros:

' == (quote )
#' == (function )
#(...) == an array of the specified expressions
#x == a hexadecimal number (0-9,A-F)
#o == an octal number (0-7)
#b == a binary number (0-1)
#\ == literal of type character
#\Newline == newline character
#\Space == space character
#\Tab == tab character
#| ... |# == a comment
#: == an uninterned symbol
`__ == (backquote __)
, == (comma )
,@ == (comma-at )

Lambda Lists

There are several forms in XLISP that require that a “lambda list” be specified. A lambda list is a definition of the arguments accepted by a function. There are four different types of arguments.

The lambda list starts with required arguments. Required arguments must be specified in every call to the function.

The required arguments are followed by the &optional arguments. Optional arguments may be provided or omitted in a call. An initialization expression may be specified to provide a default value for an &optional argument if it is omitted from a call. If no initialization expression is specified, an omitted argument is initialized to NIL. It is also possible to provide the name of a supplied-p variable that can be used to determine if a call provided a value for the argument or if the initialization expression was used. If specified, the supplied- p variable will be bound to T if a value was specified in the call and NIL if the default value was used.

The &optional arguments are followed by the &rest argument. The&rest argument gets bound to the remainder of the argument list after the required and &optional arguments have been removed.

The &rest argument is followed by the &key arguments. When a keyword argument is passed to a function, a pair of values appears in the argument list. The first expression in the pair should evaluate to a keyword symbol (a symbol that begins with a “:”). The value of the second expression is the value of the keyword argument. Like &optional arguments, &key arguments can have initialization expressions and supplied-p variables. In addition, it is possible to specify the keyword to be used in a function call. If no keyword is specified, the keyword obtained by adding a “:” to the beginning of the keyword argument symbol is used. In other words, if the keyword argument symbol isfoo, the keyword will be :foo.

The &key arguments are followed by the &aux variables. These are local variables that are bound during the evaluation of the function body. It is possible to have initialization expressions for the &aux variables.

Here is the complete syntax for lambda lists:

(rarg...
[&optional [oarg | (oarg [init [_svar_]])]...]
[&rest _rarg_]
[&key
[karg | ([karg | (key karg)] [init [_svar_]])]...
&allow-other-keys]
[&aux
[aux | (aux [_init_])]...])

where:

rarg is a required argument symbol
oarg is an &optional argument symbol
rarg is the &rest argument symbol
karg is a &key argument symbol
key is a keyword symbol
aux is an auxiliary variable symbol
init is an initialization expression
svar is a supplied-p variable symbol

Objects

Definitions:

selector – a symbol used to select an appropriate method
message – a selector and a list of actual arguments
method – the code that implements a message Since XLISP was created to provide a simple basis for experimenting with object-oriented programming, one of the primitive data types included is object. In XLISP, an object consists of a data structure containing a pointer to the object's class as well as an array containing the values of the object's instance variables.

Officially, there is no way to see inside an object (look at the values of its instance variables). The only way to communicate with an object is by sending it a message.

You can send a message to an object using the send function. This function takes the object as its first argument, the message selector as its second argument (which must be a symbol) and the message arguments as its remaining arguments.

The send function determines the class of the receiving object and attempts to find a method corresponding to the message selector in the set of messages defined for that class. If the message is not found in the object's class and the class has a super-class, the search continues by looking at the messages defined for the super-class. This process continues from one super-class to the next until a method for the message is found. If no method is found, an error occurs.

When a method is found, the evaluator binds the receiving object to the symbol self and evaluates the method using the remaining elements of the original list as arguments to the method. These arguments are always evaluated prior to being bound to their corresponding formal arguments. The result of evaluating the method becomes the result of the expression.

Within the body of a method, a message can be sent to the current object by calling the (send self ...). The method lookup starts with the object's class regardless of the class containing the current method.

Sometimes it is desirable to invoke a general method in a superclass even when it is overridden by a more specific method in a subclass. This can be accomplished by calling send-super, which begins the method lookup in the superclass of the class defining the current method rather than in the class of the current object.

The send-super function takes a selector as its first argument (which must be a symbol) and the message arguments as its remaining arguments. Notice that send-super can only be sent from within a method, and the target of the message is always the current object (self). (send-super ...) is similar to (send self ...) except that method lookup begins in the superclass of the class containing the current method rather than the class of the current object.

The “Object” Class

Object – the top of the class hierarchy.

Messages:

:show – show an object's instance variables.

returns – the object

:class – return the class of an object

returns – the class of the object

:isa class – test if object inherits from class

returns – t if object is an instance of class or a subclass of class, otherwise nil

:isnew – the default object initialization routine

returns – the object

The “Class” Class

Class – class of all object classes (including itself)

Messages:

:new – create a new instance of a class

returns – the new class object

:isnew ivars [cvars [_super_]] – initialize a new class

ivars – the list of instance variable symbols

cvars – the list of class variable symbols

super – the superclass (default is object)

returns – the new class object

:answer msg fargs code – add a message to a class

msg – the message symbol

fargs – the formal argument list (lambda list)

code – a list of executable expressions

returns – the object

When a new instance of a class is created by sending the message:new to an existing class, the message :isnew followed by whatever parameters were passed to the :new message is sent to the newly created object.

When a new class is created by sending the :new message to the object Class, an optional parameter may be specified indicating the superclass of the new class. If this parameter is omitted, the new class will be a subclass of Object. A class inherits all instance variables, class variables, and methods from its super-class.

Profiling

The Xlisp 2.0 release has been extended with a profiling facility, which counts how many times and where eval is executed. A separate count is maintained for each named function, closure, or macro, and a count indicates an eval in the immediately (lexically) enclosing named function, closure, or macro. Thus, the count gives an indication of the amount of time spent in a function, not counting nested function calls. The list of all functions executed is maintained on the global *profile* variable. These functions in turn have *profile* properties, which maintain the counts. The profile system merely increments counters and puts symbols on the *profile* list. It is up to the user to initialize data and gather results. Profiling is turned on or off with the profile function. Unfortunately, methods cannot be profiled with this facility.

Symbols

self - the current object (within a method context)
*obarray* - the object hash table
*standard-input* - the standard input stream
*standard-output* - the standard output stream
*error-output* - the error output stream
*trace-output* - the trace output stream
*debug-io* - the debug i/o stream
*breakenable* - flag controlling entering break loop on errors
*tracelist* - list of names of functions to trace
*tracenable* - enable trace back printout on errors
*tracelimit* - number of levels of trace back information
*evalhook* - user substitute for the evaluator function
*applyhook* - (not yet implemented)
*readtable* - the current readtable
*unbound* - indicator for unbound symbols
*gc-flag* - controls the printing of gc messages
*gc-hook* - function to call after garbage collection
*integer-format* - format for printing integers (“%d” or “%ld”)
*float-format* - format for printing floats (“%g”)
*print-case* - symbol output case (:upcase or :downcase)

There are several symbols maintained by the read/eval/print loop. The symbols +, ++, and +++ are bound to the most recent three input expressions. The symbols *, ** and *** are bound to the most recent three results. The symbol - is bound to the expression currently being evaluated. It becomes the value of + at the end of the evaluation.

Evaluation Functions

eval(_expr_) [SAL]
(eval _expr_) [LISP] – evaluate an xlisp expression

expr – the expression to be evaluated

returns – the result of evaluating the expression

apply(_fun_, _args_) [SAL]
(apply _fun_ _args_) [LISP] – apply a function to a list of arguments

fun – the function to apply (or function symbol)

args – the argument list

returns – the result of applying the function to the arguments

funcall(_fun_, _arg_...) [SAL]
(funcall _fun_ _arg_...) [LISP] – call a function with arguments

fun – the function to call (or function symbol)

arg – arguments to pass to the function

returns – the result of calling the function with the arguments

quote(_expr_) [SAL]
(quote _expr_) [LISP] – return an expression unevaluated

expr – the expression to be quoted (quoted)

returns – expr unevaluated

(function _expr_) [LISP] – get the
functional interpretation. Note that in SAL, the function can be accessed as #function.

expr – the symbol or lambda expression (quoted)

returns – the functional interpretation

backquote(_expr_) [SAL]
(backquote _expr_) [LISP] – fill in a template

expr – the template

returns – a copy of the template with comma and comma-at

expressions expanded

lambda(_args_, _expr_...) [SAL]
(lambda _args_ _expr_...) [LISP] – make a function closure

args – formal argument list (lambda list) (quoted)

expr – expressions of the function body

returns – the function closure

get-lambda-expression(_closure_) [SAL]
(get-lambda-expression _closure_) [LISP] – get the lambda expression

closure – the closure

returns – the original lambda expression

macroexpand(_form_) [SAL]
(macroexpand _form_) [LISP] – recursively expand macro calls

form – the form to expand

returns – the macro expansion

macroexpand-1(_form_) [SAL]
(macroexpand-1 _form_) [LISP] – expand a macro call

form – the macro call form

returns – the macro expansion

Symbol Functions

(set _sym_ _expr_) [LISP] – set the value of a symbol. Note that in SAL, the function can be accessed as #set.

sym – the symbol being set

expr – the new value

returns – the new value

setq([_sym_, _expr_]...) [SAL]
(setq [_sym_ _expr_]...) [LISP] – set the value of a symbol. Note that in SAL, the set command is normally used.

sym – the symbol being set (quoted)

expr – the new value

returns – the new value

psetq([_sym_, _expr_]...) [SAL]
(psetq [_sym_ _expr_]...) [LISP] – parallel version of setq

sym – the symbol being set (quoted)

expr – the new value

returns – the new value

setf([_place_, _expr_]...) [SAL]
(setf [_place_ _expr_]...) [LISP] – set the value of a field

place – the field specifier (quoted):

sym – set value of a symbol

(car expr) – set car of a cons node

(cdr expr) – set cdr of a cons node

(nth n expr) – set nth car of a list

(aref expr n) – set nth element of an array

(get sym prop) – set value of a property

(symbol-value sym) – set value of a symbol

(symbol-function sym) – set functional value of a symbol

(symbol-plist sym) – set property list of a symbol

expr – the new value

returns – the new value

(defun _sym_ _fargs_ _expr_...) [LISP] – define a function
(defmacro _sym_ _fargs_ _expr_...) [LISP] – define a macro

sym – symbol being defined (quoted)

fargs – formal argument list (lambda list) (quoted)

expr – expressions constituting the body of the

function (quoted)
returns – the function symbol

gensym([_tag_]) [SAL]
(gensym [_tag_]) [LISP] – generate a symbol

tag – string or number

returns – the new symbol

intern(_pname_) [SAL]
(intern _pname_) [LISP] – make an interned symbol

pname – the symbol's print name string

returns – the new symbol

make-symbol(_pname_) [SAL]
(make-symbol _pname_) [LISP] – make an uninterned symbol

pname – the symbol's print name string

returns – the new symbol

symbol-name(_sym_) [SAL]
(symbol-name _sym_) [LISP] – get the print name of a symbol

sym – the symbol

returns – the symbol's print name

symbol-value(_sym_) [SAL]
(symbol-value _sym_) [LISP] – get the value of a symbol

sym – the symbol

returns – the symbol's value

symbol-function(_sym_) [SAL]
(symbol-function _sym_) [LISP] – get the functional value of a symbol

sym – the symbol

returns – the symbol's functional value

symbol-plist(_sym_) [SAL]
(symbol-plist _sym_) [LISP] – get the property list of a symbol

sym – the symbol

returns – the symbol's property list

hash(_sym_, _n_) [SAL]
(hash _sym_ _n_) [LISP] – compute the hash index for a symbol

sym – the symbol or string

n – the table size (integer)

returns – the hash index (integer)

Property List Functions

get(_sym_, _prop_) [SAL]
(get _sym_ _prop_) [LISP] – get the value of a property

sym – the symbol

prop – the property symbol

returns – the property value or nil

putprop(_sym_, _val_, _prop_) [SAL]
(putprop _sym_ _val_ _prop_) [LISP] – put a property onto a property list

sym – the symbol

val – the property value

prop – the property symbol

returns – the property value

remprop(_sym_, _prop_) [SAL]
(remprop _sym_ _prop_) [LISP] – remove a property

sym – the symbol

prop – the property symbol

returns – nil

Array Functions

aref(_array_, _n_) [SAL]
(aref _array_ _n_) [LISP] – get the nth element of an array

array – the array

n – the array index (integer)

returns – the value of the array element

make-array(_size_) [SAL]
(make-array _size_) [LISP] – make a new array

size – the size of the new array (integer)

returns – the new array

vector(_expr_...) [SAL]
(vector _expr_...) [LISP] – make an initialized vector

expr – the vector elements

returns – the new vector

List Functions

car(_expr_) [SAL]
(car _expr_) [LISP] – return the car of a list node

expr – the list node

returns – the car of the list node

cdr(_expr_) [SAL]
(cdr _expr_) [LISP] – return the cdr of a list node

expr – the list node

returns – the cdr of the list node

c_xx_r(_expr_) [SAL]
(c_xx_r _expr_) [LISP] – all c_xx_r combinations

c_xxx_r(_expr_) [SAL]
(c_xxx_r _expr_) [LISP] – all c_xxx_r combinations

c_xxxx_r(_expr_) [SAL]
(c_xxxx_r _expr_) [LISP] – all c_xxxx_r combinations

first(_expr_) [SAL]
(first _expr_) [LISP] – a synonym for car

second(_expr_) [SAL]
(second _expr_) [LISP] – a synonym for cadr

third(_expr_) [SAL]
(third _expr_) [LISP] – a synonym for caddr

fourth(_expr_) [SAL]
(fourth _expr_) [LISP] – a synonym for cadddr

rest(_expr_) [SAL]
(rest _expr_) [LISP] – a synonym for cdr

cons(_expr1_, _expr2_) [SAL]
(cons _expr1_ _expr2_) [LISP] – construct a new list node

expr1 – the car of the new list node

expr2 – the cdr of the new list node

returns – nil

list(_expr_...) [SAL]
(list _expr_...) [LISP] – create a list of values

expr – expressions to be combined into a list

returns – the new list

append(_expr_...) [SAL]
(append _expr_...) [LISP] – append lists

expr – lists whose elements are to be appended

returns – the new list

reverse(_expr_) [SAL]
(reverse _expr_) [LISP] – reverse a list

expr – the list to reverse

returns – a new list in the reverse order

last(_list_) [SAL]
(last _list_) [LISP] – return the last list node of a list

list – the list

returns – the last list node in the list

member(_expr_, _list_, test: _test_, test-not: _test-not_) [SAL]
(member _expr_ _list_ &key :test :test-not) [LISP] – find an expression in a list

expr – the expression to find

list – the list to search

:test – the test function (defaults to eql)

:test-not – the test function (sense inverted)

returns – the remainder of the list starting with the expression

assoc(_expr_, _alist_, test: _test_, test-not: _test-not_) [SAL]
(assoc _expr_ _alist_ &key :test :test-not) [LISP] – find an expression in an a-list

expr – the expression to find

alist – the association list

:test – the test function (defaults to eql)

:test-not – the test function (sense inverted)

returns – the alist entry or nil

remove(_expr_, _list_, test: _test_, test-not: _test-not_) [SAL]
(remove _expr_ _list_ &key :test :test-not) [LISP] – remove elements from a list

expr – the element to remove

list – the list

:test – the test function (defaults to eql)

:test-not – the test function (sense inverted)

returns – copy of list with matching expressions removed

remove-if(_test_, _list_) [SAL]
(remove-if _test_ _list_) [LISP] – remove elements that pass test

test – the test predicate

list – the list

returns – copy of list with matching elements removed

remove-if-not(_test_, _list_) [SAL]
(remove-if-not _test_ _list_) [LISP] – remove elements that fail test

test – the test predicate

list – the list

returns – copy of list with non-matching elements removed

length(_expr_) [SAL]
(length _expr_) [LISP] – find the length of a list, vector or string

expr – the list, vector or string

returns – the length of the list, vector or string

nth(_n_, _list_) [SAL]
(nth _n_ _list_) [LISP] – return the nth element of a list

n – the number of the element to return (zero origin)

list – the list

returns – the nth element or nil if the list isn't that long

nthcdr(_n_, _list_) [SAL]
(nthcdr _n_ _list_) [LISP] – return the nth cdr of a list

n – the number of the element to return (zero origin)

list – the list

returns – the nth cdr or nil if the list isn't that long

mapc(_fcn_, _list1_, _list_...) [SAL]
(mapc _fcn_ _list1_ _list_...) [LISP] – apply function to successive cars

fcn – the function or function name

listn – a list for each argument of the function

returns – the first list of arguments

mapcar(_fcn_, _list1_, _list_...) [SAL]
(mapcar _fcn_ _list1_ _list_...) [LISP] – apply function to successive cars

fcn – the function or function name

listn – a list for each argument of the function

returns – a list of the values returned

mapl(_fcn_, _list1_, _list_...) [SAL]
(mapl _fcn_ _list1_ _list_...) [LISP] – apply function to successive cdrs

fcn – the function or function name

listn – a list for each argument of the function

returns – the first list of arguments

maplist(_fcn_, _list1_, _list_...) [SAL]
(maplist _fcn_ _list1_ _list_...) [LISP] – apply function to successive cdrs

fcn – the function or function name

listn – a list for each argument of the function

returns – a list of the values returned

subst(_to_, _from_, _expr_, test: _test_, test-not: _test-not_) [SAL]
(subst _to_ _from_ _expr_ &key :test :test-not) [LISP] – substitute expressions

to – the new expression

from – the old expression

expr – the expression in which to do the substitutions

:test – the test function (defaults to eql)

:test-not – the test function (sense inverted)

returns – the expression with substitutions

sublis(_alist_, _expr_, test: _test_, test-not: _test-not_) [SAL]
(sublis _alist_ _expr_ &key :test :test-not) [LISP] – substitute with an a-list

alist – the association list

expr – the expression in which to do the substitutions

:test – the test function (defaults to eql)

:test-not – the test function (sense inverted)

returns – the expression with substitutions

Destructive List Functions

rplaca(_list_, _expr_) [SAL]
(rplaca _list_ _expr_) [LISP] – replace the car of a list node

list – the list node

expr – the new value for the car of the list node

returns – the list node after updating the car

rplacd(_list_, _expr_) [SAL]
(rplacd _list_ _expr_) [LISP] – replace the cdr of a list node

list – the list node

expr – the new value for the cdr of the list node

returns – the list node after updating the cdr

nconc(_list_...) [SAL]
(nconc _list_...) [LISP] – destructively concatenate lists

list – lists to concatenate

returns – the result of concatenating the lists

delete(_expr_, _list_, test: _test_, test-not: _test-not_) [SAL]
(delete _expr_ _list_ &key :test :test-not) [LISP] – delete elements from a list

expr – the element to delete

list – the list

:test – the test function (defaults to eql)

:test-not – the test function (sense inverted)

returns – the list with the matching expressions deleted

delete-if(_test_, _list_) [SAL]
(delete-if _test_ _list_) [LISP] – delete elements that pass test

test – the test predicate

list – the list

returns – the list with matching elements deleted

delete-if-not(_test_, _list_) [SAL]
(delete-if-not) _test_ _list_) [LISP] – delete elements that fail test

test – the test predicate

list – the list

returns – the list with non-matching elements deleted

sort(_list_, _test_) [SAL]
(sort _list_ _test_) [LISP] – sort a list

list – the list to sort

test – the comparison function

returns – the sorted list

Note: The comparison function should have two parameters and return true if the first parameter should come before the second parameter in the sorted result. For a list of numbers, built-in comparison functions can be used, e.g.

(sort '(3 2 1) #'<)

returns

(1 2 3)

. To sort a list of lists by the first element of each list, you can write a function to access the keys and compare them, e.g.

(sort '((3 c) (2 b) (1 a)) #'(lambda (x y) (< (car x) (car y))))

returns

((1 A) (2 B) (3 C))

. In SAL, you could write

function my-sort(a, b) return first(a) < first(b)
print sort({{3 c} {2 b} {1 a}}, quote(my-sort))

, which will print

{{1 A} {2 B} {3 C}}