simon/beowulf
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

Still preparing for the big shift to property lists.

Browse source
This commit is contained in:
Simon Brooke 2023-04-02 12:57:26 +01:00
parent b61e7c3e8c
commit 50d4b4348e
26 changed files with 435 additions and 445 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

712
doc/lisp1.5.md
View file

@ -14,59 +14,40 @@
> Massachusetts Institute of Technology > Massachusetts Institute of Technology
> Cambridge, Massachusetts > Cambridge, Massachusetts
The Research Laboratory af Electronics is an interdepartmental The Research Laboratory af Electronics is an interdepartmental laboratory in which faculty members and graduate students from numerous academic departments conduct research.
laboratory in which faculty members and graduate students from
numerous academic departments conduct research.
The research reported in this document was made possible in part The research reported in this document was made possible in part by support extended the Massachusetts Institute of Technology, Research Laboratory of Electronics, jointly by the U.S. Army, the U.S. Navy (Office of Naval Research), and the U.S. Air Force (Office of Scientific Research) under Contract DA36-039-sc-78108, Department of the Army Task 3-99-25-001-08; and in part by Contract DA-SIG-36-039-61-G14; additional support was received from the National Science Foundation (Grant G-16526) and the National Institutes of Health (Grant MH-04737-02).
by support extended the Massachusetts Institute of Technology, Re-
search Laboratory of Electronics, jointly by the U.S. Army, the
U.S. Navy (Office of Naval Research), and the U.S. Air Force
(Office of Scientific Research) under Contract DA36-039-sc-78108,
Department of the Army Task 3-99-25-001-08; and in part by Con-
tract DA-SIG-36-039-61-G14; additional support was received from
the National Science Foundation (Grant G-16526) and the National
Institutes of Health (Grant MH-04737-02).
Reproduction in whole or in part is permitted for any purpose Reproduction in whole or in part is permitted for any purpose of the United States Government.
of the United States Government.
SECOND EDITION Fifteenth printing, 1985 SECOND EDITION Fifteenth printing, 1985
ISBN 0 262 130 1 1 4 (paperback) ISBN 0 262 130 1 1 4 (paperback)
-----
#### Note regarding this Markdown document #### Note regarding this Markdown document
This Markdown version of the manual was created by me, This Markdown version of the manual was created by me, [Simon Brooke](mailto:simon@journeyman.cc), by passing the PDF version found at [Software Preservation](https://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf) through a [PDF to
[Simon Brooke](mailto:simon@journeyman.cc), by passing the PDF Markdown processor](https://pdf2md.morethan.io/), and hand-editing the resulting document.
version found at [Software Preservation](https://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf) through a [PDF to
Markdown processor](https://pdf2md.morethan.io/), and hand-editing
the resulting document.
**This document is not authorised by the copyright holders.** It was **This document is not authorised by the copyright holders.** It was made for the purposes of study, only.
made for the purposes of study, only.
Notes which I have added during editing are *NOTE: given in italics, like this*. Generally I have tried to keep the text unaltered. Some minor headings, especially of examples, have been deliberately changed in order to aid navigation, and some apparent typographic errors have been corrected. *I have also added spaces between syntactic elements in M-expression examples to aid legibility.* Page numbers are taken from the original. Notes which I have added during editing are *NOTE: given in italics, like this*.
-----
## PREFACE ## PREFACE
The over-all design of the LISP Programming System is the work of John McCarthy The over-all design of the LISP Programming System is the work of John McCarthy and is based on his paper "[Recursive Functions of Symbolic Expressions and Their Computation by Machine](http://www-formal.stanford.edu/jmc/recursive/recursive.html)" which was published in Communications of the ACM, April 1960.
and is based on his paper NRecursive Functions of Symbolic Expressions and Their Com-
putation by Machinett which was published in Communications of the ACM, April 1960.
This manual was written by Michael I. Levin. This manual was written by Michael I. Levin.
The interpreter was programmed by Stephen B. Russell and Daniel J. Edwards. The interpreter was programmed by Stephen B. Russell and Daniel J. Edwards. The print and read programs were written by John McCarthy, Klim Maling, Daniel J. Edwards, and Paul W, Abrahams.
The print and read programs were written by John McCarthy, Klim Maling,
Daniel J. Edwards, and Paul W, Abrahams.
The garbage collector and arithmetic features Were written by Daniel J. Edwards. The garbage collector and arithmetic features Were written by Daniel J. Edwards. The compiler and assembler were written by Timothy P. Hart and Michael I. Levin. An earlier compiler was written by Robert Brayton.
The compiler and assembler were written by Timothy P. Hart and Michael I. Levin.
An earlier compiler was written by Robert Brayton.
The "LISP 1 Programmer's Manual" March 1, 1960, was written by Phyllis A. Fox. The "LISP 1 Programmer's Manual" March 1, 1960, was written by Phyllis A. Fox. Additional programs and suggestions were contributed by the following members of the Artificial Intelligence Group of the Research Laboratory of Electronics: Marvin L. Minsky, Bertram Raphael, Louis Hodes, David M. R. Park, David C. Luckham, Daniel G. Bobrow, James R. Slagle, and Nathaniel Rochester.
Additional programs and suggestions were contributed by the following members of the Artificial Intelligence Group of the Research Laboratory of Electronics:
Marvin L. Minsky, Bertram Raphael, Louis Hodes, David M. R. Park, David C. Luckham,
Daniel G. Bobrow, James R. Slagle, and Nathaniel Rochester.
August 17, 1962 August 17, 1962
@ -128,39 +109,21 @@ I. LISP for SHARE Distribution
## I. THE LISP LANGUAGE ## I. THE LISP LANGUAGE
The LISP language is designed primarily for symbolic data processing. It has been The LISP language is designed primarily for symbolic data processing. It has been used for symbolic calculations in differential and integral calculus, electrical circuit theory, mathematical logic, game playing, and other fields of artificial intelligence.
used for symbolic calculations in differential and integral calculus, electrical circuit
theory, mathematical logic, game playing, and other fields of artificial intelligence.
LISP is a formal mathematical language. It is therefore podsible to give a con-
cise yet complete description of it. Such is the purpose of this first section of the
manual. Other sections will describe ways of using LISP to advantage and will explain
extensions of the language which make it a convenient programming system.
LISP differs from most programming languages in three important ways. The LISP is a formal mathematical language. It is therefore possible to give a concise yet complete description of it. Such is the purpose of this first section of the manual. Other sections will describe ways of using LISP to advantage and will explain extensions of the language which make it a convenient programming system.
first way is in the nature of the data. In the LISP language, all data are in the form
of symbolic expressions usually referred to as S-expressions. S-expressions are of
indefinite length and have a branching tree type of structure, so that significant sub-
expressions can be readily isolated. In the LISP programming system, the bulk of
available memory is used for storing S-expressions in the form of list structures.
This type of memory organization frees the programmer from the necessity of
allocating storage for the different sections of his program.
The second important part of the LISP language is the source language itself which LISP differs from most programming languages in three important ways. The first way is in the nature of the data. In the LISP language, all data are in the form of symbolic expressions usually referred to as S-expressions. S-expressions are of indefinite length and have a branching tree type of structure, so that significant sub-expressions can be readily isolated. In the LISP programming system, the bulk of available memory is used for storing S-expressions in the form of list structures. This type of memory organization frees the programmer from the necessity of allocating storage for the different sections of his program.
specifies in what way the S-expressions are to be processed. This consists of recur-
sive functions of S-expressions. Since the notation for the writing of recursive func-
tions of S-expressions is itself outside the S-expression notation, it will be called the
meta language. These expressions will therefore be called M-expressions.
Third, LISP can interpret and execute programs written in the form of S- The second important part of the LISP language is the source language itself which specifies in what way the S-expressions are to be processed. This consists of recursive functions of S-expressions. Since the notation for the writing of recursive functions of S-expressions is itself outside the S-expression notation, it will be called the meta language. These expressions will therefore be called M-expressions.
expressions. Thus, like machine language, and unlike most other higher level languages,
it can be used to generate programs for further execution. Third, LISP can interpret and execute programs written in the form of S-expressions. Thus, like machine language, and unlike most other higher level languages, it can be used to generate programs for further execution.
### 1.1 Symbolic Expressions ### 1.1 Symbolic Expressions
The most elementary type of S-expression is the atomic symbol. The most elementary type of S-expression is the atomic symbol.
**Definition**: An atomic symbol is a string of no more than thirty numerals and capital **Definition**: An atomic symbol is a string of no more than thirty numerals and capital letters; the first character must be a letter.
letters; the first character must be a letter.
#### Examples - atomic symbols #### Examples - atomic symbols
@ -170,22 +133,15 @@ letters; the first character must be a letter.
* EXTRALONGSTRINGOFLETTERS * EXTRALONGSTRINGOFLETTERS
* A4B66XYZ * A4B66XYZ
These symbols are called atomic because they are taken as a whole and are not These symbols are called atomic because they are taken as a whole and are not capable of being split within LISP into individual characters, Thus A, B, and AB have no relation to each other except in so far as they are three distinct atomic symbols.
capable of being split within LISP into individual characters, Thus A, B, and AB
have no relation to each other except in so far as they are three distinct atomic
symbols.
All S-expressions are built out of atomic symbols and the punctuation marks All S-expressions are built out of atomic symbols and the punctuation marks
<a name="page2">page 2</a> <a name="page2">page 2</a>
`(` `)` and `.`. The basic operation for forming S-expressions is to combine two `(` `)` and `.`. The basic operation for forming S-expressions is to combine two of them to produce a larger one. From the two atomic symbols A1 and A2, one can form the S-expression `(A1 . A2)`.
of them to produce a larger one. From the two atomic symbols A1 and A2, one can
form the S-expression `(A1 . A2)`.
**Definition**: An S-expression is either an atomic symbol or it is composed of these **Definition**: An S-expression is either an atomic symbol or it is composed of these elements in the following order: a left parenthesis, an S-expression, a dot, an S-expression, and a right parenthesis.
elements in the following order: a left parenthesis, an S-expression, a dot, an S-
expression, and a right parenthesis.
Notice that this definition is recursive. Notice that this definition is recursive.
@ -200,14 +156,9 @@ Notice that this definition is recursive.
### 1.2 Elementary Functions ### 1.2 Elementary Functions
We shall introduce some elementary functions of S-expressions. To distinguish We shall introduce some elementary functions of S-expressions. To distinguish the functions from the S-expressions themselves, we shall write function names in lower case letters, since atomic symbols consist of only upper case letters. Furthermore, the arguments of functions will be grouped in square brackets rather than parentheses. As a separator or punctuation mark we shall use the semicolon.
the functions from the S-expressions themselves, we shall write function names in
lower case letters, since atomic symbols consist of only upper case letters. Furthermore,
the arguments of functions will be grouped in square brackets rather than
parentheses. As a separator or punctuation mark we shall use the semicolon.
The first function that we shall introduce is the function `cons`. It has two arguments The first function that we shall introduce is the function `cons`. It has two arguments and is in fact the function that is used to build S-expressions from smaller S-expressions.
and is in fact the function that is used to build S-expressions from smaller S-expressions.
#### Examples - the cons function #### Examples - the cons function
@ -217,13 +168,11 @@ cons[(A . B); C] = ((A . B) . C)
cons[cons[A; B]; C] = ((A . B) . C) cons[cons[A; B]; C] = ((A . B) . C)
``` ```
The last example is an instance of composition of functions. It is possible to build The last example is an instance of composition of functions. It is possible to build any S-expression from its atomic components by compositions of the function cons. The next pair of functions do just the opposite of cons. They produce the subexpressions of a given expression.
any S-expression from its atomic components by compositions of the function cons.
The next pair of functions do just the opposite of cons. They produce the subexpres-
sions of a given expression.
The function `car` has one argument. Its value is the first part of its composite The function `car` has one argument. Its value is the first part of its composite argument. `car` of an atomic symbol is undefined.
argument. `car` of an atomic symbol is undefined.
*Note that where this says 'car of an atomic symbol is undefined', it seems to mean it literally. There seems to have been no mechanism for distinguishing cons cells from other items in memory, so that the car of, for example, a decimal number could be taken, although the result
#### Examples - the car function #### Examples - the car function
@ -284,13 +233,14 @@ eq[A; A] = T
eq[A; B] = F eq[A; B] = F
eq[A; (A . B)] is undefined eq[A; (A . B)] is undefined
eq[(A . B);(A . B)] is undefined eq[(A . B);(A . B)] is undefined
```
The predicate `atom` is true if its argument is an atomic symbol, and false if its The predicate `atom` is true if its argument is an atomic symbol, and false if its
argument is composite. argument is composite.
#### Examples - atom #### Examples - atom
```` ```
atom[EXTRALONGSTRINGOFLETTERS] = T atom[EXTRALONGSTRINGOFLETTERS] = T
atom[(u . v)] = F atom[(u . v)] = F
atom[car[(u . v)]] = T atom[car[(u . v)]] = T
@ -300,25 +250,17 @@ atom[car[(u . v)]] = T
### 1.3 List Notation ### 1.3 List Notation
The S-expressions that have been used heretofore have been written in dot notation. The S-expressions that have been used heretofore have been written in dot notation. It is usually more convenient to be able to write lists of expressions of indefinite length, such as `(A B C D E)`.
It is usually more convenient to be able to write lists of expressions of indefinite length,
such as `(A B C D E)`.
Any S-expression can be expressed in terms of the dot notation. However, LISP has an Any S-expression can be expressed in terms of the dot notation. However, LISP has an alternative form of S-expression called the list notation. The list `(m1 m2... mn)` can be defined in terms of dot notation. It is identical to `(m1 . (m2 . (... . (mn . NIL)... )))`.
alternative form of S-expression called the list notation. The list `(m1 m2... mn)` can be
defined in terms of dot notation. It is identical to `(m1 . (m2 . (... . (mn . NIL)... )))`.
The atomic symbol NIL serves as a terminator for lists. The null list `()` is iden- The atomic symbol NIL serves as a terminator for lists. The null list `()` is identical to `NIL`. Lists may have sublists. The dot notation and the list notation may be used in the same S-expression,
tical to `NIL`. Lists may have sublists. The dot notation and the list notation may be
used in the same S-expression,
Historically, the separator for elements of lists was the comma `(,)`; however, the Historically, the separator for elements of lists was the comma `(,)`; however, the blank is now generally used. The two are entirely equivalent in LISP. `(A, B, C)` is identical to `(A B C)`.
blank is now generally used. The two are entirely equivalent in LISP. `(A, B, C)` is
identical to `(A B C)`.
#### Examples - list notation #### Examples - list notation
``` ```lisp
(A B C) = (A . (B . (C . NIL))) (A B C) = (A . (B . (C . NIL)))
((A B) C) = ((A . (B . NIL)) . (C . NIL)) ((A B) C) = ((A . (B . NIL)) . (C . NIL))
(A B (C D)) = (A . (B . ((C . (D . NIL)). NIL))) (A B (C D)) = (A . (B . ((C . (D . NIL)). NIL)))
@ -327,9 +269,7 @@ identical to `(A B C)`.
(A (B . C)) = (A . ((B . C) . NIL)) (A (B . C)) = (A . ((B . C) . NIL))
``` ```
It Is important to become familiar with the results of elementary functions on It Is important to become familiar with the results of elementary functions on S-expressions written in list notation. These can always be determined by translating into dot notation.
S-expressions written in list notation. These can always be determined by translating
into dot notation.
#### Examples - list notation 2 #### Examples - list notation 2
@ -342,300 +282,296 @@ cdr[(A)] = NIL
car[cdr[(A B C)]] = B car[cdr[(A B C)]] = B
``` ```
It is convenient to abbreviate multiple `car`s and `cdr`s. This is done by forming It is convenient to abbreviate multiple `car`s and `cdr`s. This is done by forming function names that begin with `c`, end with `r`, and have several `a`s and `d`s between them.
function names that begin with `c`, end with `r`, and have several `a`s and `d`s between
them.
### Examples - composed accessor functions #### Examples - composed accessor functions
``` ```
cadr[(A B C)] = car[cdr[(A B C)]] = B cadr[(A B C)] = car[cdr[(A B C)]] = B
caddr[(A B C )] = C caddr[(A B C)] = C
cadadr[(A (B C) D)] = C cadadr[(A (B C) D)] = C
``` ```
The last a or d in the name actually signifies the first operation in order to be <a name="page5">page 5</a>
The last `a` or `d` in the name actually signifies the first operation in order to be
performed, since it is nearest to the argument. performed, since it is nearest to the argument.
1.4 The LISP Meta-language ### 1.4 The LISP Meta-language
We have introduced a type of data called S-expressions, and five elementary func-
tions of S-expressions. We have also discussed the following features of the meta-
language.
1. Function names and variable names are like atortlfc symbols except that they We have introduced a type of data called S-expressions, and five elementary functions of S-expressions. We have also discussed the following features of the meta-language.
use lower case letters.
2. The arguments of a function are bound by square brackets and separated from
each other by semicolons.
3. Compositions of functions may be written by using nested sets of brackets.
These rules allow one to write function definitions such as
third[x]=car[cdr[cdr[x]]].
This function selects the third item on a list. For example, 1. Function names and variable names are like atomic symbols except that they use lower case letters.
2. The arguments of a function are bound by square brackets and separated from each other by semicolons.
3. Compositions of functions may be written by using nested sets of brackets. These rules allow one to write function definitions such as `third[x]=car[cdr[cdr[x]]]`.
third is actually the same function as caddr. This function selects the third item on a list. For example, `third` is actually the same function as `caddr`.
The class of functions that can be formed in this way is quite limited and hot Very
interesting. A much larger class of functions can be defined by means of the con-
ditional expression, a device for providing branches in function definitions.
A conditional expression has the following form:
``` The class of functions that can be formed in this way is quite limited and not very interesting. A much larger class of functions can be defined by means of the conditional expression, a device for providing branches in function definitions. A conditional expression has the following form:
where each pi is an expression whose value may be truth or falsity, and each ei is
any expression. The meaning of a conditional expression is: if pl is true. then the > where each p<sub>i</sub> is an expression whose value may be truth or falsity, and each e<sub>i</sub> is
value of el is the value of the entire expression. If pl is false, then if p2 is true > any expression. The meaning of a conditional expression is: if p<sub>1</sub> is true. then the
the value of e2 is the value of the entire expression. The pi are searched from left > value of e<sub>1</sub> is the value of the entire expression. If p<sub>1</sub> is false, then if p<sub>2</sub> is true
to right until the first true one is found. Then the corresponding ei is selected. If > the value of e<sub>2</sub> is the value of the entire expression. The p<sub>i</sub> are searched from left
none of the pi are true, then the value of the entire expression is undefined. > to right until the first true one is found. Then the corresponding e<sub>i</sub> is selected. If
Each pi or ei can itselk be either an 6-expression, a function, ta composition of > none of the p<sub>i</sub> are true, then the value of the entire expression is undefined.
functions or may it self be another conditional expression. >
Example > Each p<sub>i</sub> or e<sub>i</sub> can itself be either an S-expression, a function, a composition of
[eq[car[x];~]eons[~ ;cdr[x]]; T-x] > functions or may itself be another conditional expression.
The atomic symbol T represents truth, The value of this expression is obtained
if one replaces car of x by B if it happens to be A, but leaving x unchanged if car of #### Example - conditional expression
`[eq[car[x]; A] -> cons[B; cdr[x]]; T -> x]`
The atomic symbol `T` represents truth. The value of this expression is obtained
if one replaces `car` of `x` by B if it happens to be A, but leaving `x` unchanged if `car` of
it is not A. it is not A.
```
``` <a name="page6">page 6</a>
The main application of conditional expressions is in defining functions recursively. The main application of conditional expressions is in defining functions recursively.
```
Example #### Example
`ff[x] = [atom[x] -> x; T -> ff[car[x]]]`
This example defines the function `ff` which selects the first atomic symbol of any
given expression. This expression can be read: If `x` is an atomic symbol, then `x`
itself is the answer. Otherwise the function `ff` is to be applied to car of `x`.
If `x` is atomic, then the first branch which is `x` will be selected. Otherwise, the
second branch `ff[car[x]]` will be selected, since `T` is always true.
The definition of `ff` is recursive in that `ff` is actually defined in terms of itself. If
one keeps taking `car` of any S-expression, one will eventually produce an atomic symbol; therefore the process is always well defined.
Some recursive functions may be well defined for certain arguments only, but infinitely recursive for certain other arguments. When such a function is interpreted in the LISP programming system, it will either use up all of the available memory, or loop until the program is halted artificially.
We shall now work out the evaluation of `ff[((A. B). C)]`. First, we substitute the
arguments in place of the variable `x` in the definition and obtain
``` ```
ff[x]=[atom[x]-x; T-ff[car[x]]] ff[((A . B) . C)]=[atom[((A . B) . C)]->((A . B) . C); T->ff[car[((A . B) . C)]]]
This example defines the function ff which selects the first atomic symbol of any ```
given expression. This expression can be read: If x is an atomic symbol, then x but `((A. B). C)` is not atomic, and so we have
itself is the answer. Otherwise the function ff is to be applied to car of x. ```
If x is atomic, then the first branch which is x l1 will be selected. Otherwise, the = [T->ff [car[((A . B) . C)]]
second branch nff[car[x]]n will be selected, since T is always true. = ff[car[((A . B) . C)]]
The definition of ff is recursive in that ff is actually deefined in terms of itself. If = ff[(A . B)]
one keeps taking cay of any S-expression, one will eventually produce an atomic sym- ```
bol; therefore the process is always well defined. At this point, the definition of ff must be used recursively. Substituting `(A . B)`
Some recursive functions may be well defined for certain arguments only, but in- for `x` gives
finitely recursive for certain other arguments. When such a function is interpreted in ```
the LISP programming system, it will either use up all of the available memory, or = [atom[(A . B)] -> (A . B); T -> ff[car[(A . B)]]]
loop until the program is halted artificially. = [T -> ff[car[(A . B)]]]
We shall now work out the evaluation of ff[((A. B). c)]. First, we substitute the = ff[car[(A . B)]]
arguments in place of the variable x in the definition and obtain
ff[((~. B). C)]=[atom[((A. B). c)]-((A. B). C); T-ff[car[((A. B). c)]]]
but ((A. B). C) is not atomic, and so we have
= [T-ff [car [((A. B). C )]]I
= ff[car[((A. B). c)]]
= ff[(~. B)]
At this point, the definition of ff must be used recursively. Substituting (A. B)
for x gives
= [atom[(A. B)]-(A. B); Tdff[car[(A. B)]]]
= [T-ff[car[(~. B)]]]
= ff[car[(A. B)]]
= ff[A] = ff[A]
= [atom[A]-A; T-ff [car [A 111 = [atom[A] -> A; T -> ff[car[A]]]
= A
``` ```
The conditional expression is useful for defining numerical computations, as well as computations with S-expressions. The absolute value of a number can be defined by
``` ```
The conditional expression is useful for defining numerical computations, as well |x| = [x<0 -> -x; T -> x]
as computations with S-expressions. The absolute value of a number can be defined by
```
``` ```
The factorial of a nonhnegative integer can be defined by The factorial of a nonhnegative integer can be defined by
n! =[n=0-1; T-n-[n-l]! 3
This recursive definition does not terminate for negative arguments. A function that
``` ```
n! = [n=0 -> 1; T -> n.[n-l]!]
```
This recursive definition does not terminate for negative arguments. A function that
<a name="page7">page 7</a>
is defined only for certain arguments is called a partial function. is defined only for certain arguments is called a partial function.
The Euclidean algorithm for finding the greatest common divisor of two positive
integers can be defined by using conditional expressions as follows:
rem[u;vi is the remainder when u is divided by 2 The Euclidean algorithm for finding the greatest common divisor of two positive integers can be defined by using conditional expressions as follows:
A detailed discussion of the theory of functions defined recursively by conditional
expressions is found in A Basis for a Mathematical Theory of Computation " by
J. McCarthy, Proceedings of the Western Joint Computer Conference, May 1961
(published by the Institute of Radio Engineers).
It is usual for most mathematicians-exclusive of those devoted to logic-to use the
word function imprecisely, and to apply it to forms such as JI^2 ts Because we
shall later compute with expressions that stand for functions, we need a notation that
expresses the distinction between functions and forms. The notation that we shall use
is the lambda notation of Alonzo Church.^1
Let be an expression that stands for a function of two integer variables. It
should make sense to write f[3;4] and to be able to determine the value of this expres-
sion. For example, sum[3;4]=7. The expression y^2 tx does not meet this requirement.
It is not at all clear whether the value of y^2 +x[3;41 is 13 or 19. An expression such as
y^2 tx will be called a form rather than a function. A form can be converted to a func-
tion by specifying the correspondence between the variables in the form and the argu-
ments of the desired function.
If E is a form in the variables x l;.. .;xn, then the expression h[[x l;.. .;xn]; €
represents the function of n variables obtained by substituting the n arguments in
order for the variables xl;. .;xn, respectively. For example, the function ~[[x;~];
y^2 tx] is a function of two variables, and )i[[x;y);y2+x1[3;4]=4^2 +3=19. ~[L~;xJY~+~I[~;~I
=3^2 +4=13.
The variables in a lambda expression are dummy or bound variables because sys-
tematically changing them does not alter the meaning of the expression. Thus X[[u;vk
v^2 tu] means the same thing as A[[X;~~~^2 tx].
We shall sometimes use expressions in which a variable is not bound by a lambda.
For example, in the function of two variables )i[[x;y~xntyn] the variable n is not
bound. This is called a free variable. It may be regarded as a parameter. Unless
n has been given a value before trying to compute with this function, the value of the
function must be undefined.
1. A. Church, The Calculi of Lambda-Conversion (Princeton University Press, ```
Princeton, New Jersey, 194r gcd[x; y]=[x>y -> gcd[y; x];
rem[y;x]=0 -> x]
```
The lambda notation alone is inadequate for naming recursive functions. Not only `rem[u; v]` is the remainder when `u` is divided by `v`.
must the variables be bound, but the name of the function must be bound, since it is
used inside an expression to stand for the entire expression. The function ff was A detailed discussion of the theory of functions defined recursively by conditional expressions is found in [A Basis for a Mathematical Theory of Computation](http://jmc.stanford.edu/articles/basis/basis.pdf) by J. McCarthy, Proceedings of the Western Joint Computer Conference, May 1961 (published by the Institute of Radio Engineers).
previously defined by the identity
It is usual for most mathematicians -- exclusive of those devoted to logic -- to use the word 'function' imprecisely, and to apply it to forms such as y<sup>2</sup>+x. Because we shall later compute with expressions that stand for functions, we need a notation that expresses the distinction between functions and forms. The notation that we shall use is the [lambda notation of Alonzo Church](https://compcalc.github.io/public/church/church_calculi_1941.pdf).
Let `f`be an expression that stands for a function of two integer variables. It
should make sense to write `f[3; 4]` and to be able to determine the value of this expres-
sion. For example, `sum[3; 4] = 7`. The expression y<sup>2</sup> + x does not meet this requirement.
It is not at all clear whether the value of y<sup>2</sup> + x[3; 4] is 13 or 19. An expression such as
y<sup>2</sup> + x will be called a form rather than a function. A form can be converted to a function by specifying the correspondence between the variables in the form and the arguments of the desired function.
If &epsilon; is a form in the variables x<sub>1</sub>;... ;x<sub>n</sub>, then the expression &lambda;[[x<sub>1</sub>;... ;x<sub>n</sub>]&epsilon;] represents the function of n variables obtained by substituting the n arguments in order for the variables x<sub>1</sub>;... ;x<sub>n</sub>, respectively. For example, the function &lambda;[[x; y]; y<sup>2</sup> + x] is a function of two variables, and &lambda;[[x; y]; y<sup>2</sup> + x][3; 4] =4<sup>2</sup> + 3 = 19. &lambda;[[x; y]; y<sup>2</sup> + x][4; 3] = 3<sup>2</sup> + 4 = 13.
*TODO: detail formatting in the above paragraph is still slightly wrong.*
The variables in a lambda expression are dummy or bound variables because systematically changing them does not alter the meaning of the expression. Thus &lambda;[[u; v]; u<sup>2</sup> + v] means the same thing as &lambda;[[x; y]; y<sup>2</sup> + x].
We shall sometimes use expressions in which a variable is not bound by a lambda. For example, in the function of two variables &lambda;[[x; y]; x<sup>n</sup> + y<sup>n</sup>] the variable `n` is not bound. This is called a free variable. It may be regarded as a parameter. Unless `n` has been given a value before trying to compute with this function, the value of the function must be undefined.
<a name="page8">page 8</a>
The lambda notation alone is inadequate for naming recursive functions. Not only must the variables be bound, but the name of the function must be bound, since it is used inside an expression to stand for the entire expression. The function `ff` was previously defined by the identity
`ff[x] = [atom[x] -> x; T -> ff[car[x]]]`
Using the lambda notation, we can write Using the lambda notation, we can write
ff=h[[xh [atorn[x]-x; T-ff [car [x]]j)
The equality sigq in these identities is actually not part of the LISP meta-language `ff =` &lambda;`[x] = [atom[x] -> x; T -> ff[car[x]]]`
and is only a orutch until we develop the correct notation. The right side of the last
equation cannot serve as an expression for the function &because there is nothing to The equality sign in these identities is actually not part of the LISP meta-languageand is only a crutch until we develop the correct notation. The right side of the last equation cannot serve as an expression for the function `ff` because there is nothing to indicate that the occurrence of `ff` inside it stands for the function that is being defined.
indicate that the occurrence of ff inside it stands for the function that is being defined.
In order to be able to write expressions that bear their own name, we introduce In order to be able to write expressions that bear their own name, we introduce
the label notatioe. If E is an expression, and o is its name, we write label[a;~]. the label notation. If &epsilon; is an expression, and &alpha; is its name, we write label[&alpha;; &epsilon;].
The function 3 can now be written without an equal sign:
In this expression, is a bound variable, and ff is a bound function name. The function `ff` can now be written without an equal sign:
1.5 Syntactic $ummaryl `label[ff =` &lambda;`[[x]; [atom[x] -> x; T -> ff[car[x]]]]`
All parts of the LISP language have now been explained. That which follows is a
complete gyntactic definition of the LISP language, together with semantic comments.
The definition is given in Backus notation2 with the addition of three dots(.. .) to avoid
naming unneccessary syntactic types.
In Backus notation the symbols I1::=l1, I1<l1, l1 >", and It I fl are used. The rule
<S-expression >::=<atomic symbol > I (<S-expression >. <S-expression>) means that
an $-expression is either an atomic symbol, or it is a left parenthesis followed by an
S-expression followed by a dot followed by an S-expression followed by a right paren-
thesis. The vertical bar means or " , and the angular brackets always enclose ele-
ments of the syntax that is being defined.
The Data Language
CLETTER>::~AIB cI... IZ
## <number>::=0I112 I .,. ( In this expression, `x` is a bound variable, and `ff` is a bound function name.
``` ### 1.5 Syntactic Summary
c atomic-symbol >::=<LETTER ,<atom pqrt >
<atom part >::=<empty > I <LETTER ><atom part > I <number ><atom part > [This section is for completeness and may be skipped upon first reading.]
Atomic symbols are the smallest entities in LISP. Their decomposition into char-
acter s has no significance. All parts of the LISP language have now been explained. That which follows is a complete syntactic definition of the LISP language, together with semantic comments. The definition is given in [Backus notation](https://www.softwarepreservation.org/projects/ALGOL/paper/Backus-ICIP-1959.pdf) with the addition of three dots(...) to avoid naming unnecessary syntactic types.
In Backus notation the symbols `::=`, `<`, `>`, and `|` are used. The rule
```BNF
<S-expression> ::= <atomic symbol> | (<S-expression> . <S-expression>)
``` ```
1. This election is for completeness and may be skipped upon first reading. means that an S-expression is either an atomic symbol, or it is a left parenthesis followed by an S-expression followed by a dot followed by an S-expression followed by a right parenthesis. The vertical bar means "or" , and the angular brackets always enclose elements of the syntax that is being defined.
2. J. W. Backus, The Syntax and Semantics of the Proposed International Algebraic
Language of the Zurich ACM-Gamm Conference. ICIP Paris, June 1959.
< S-expression >:: =<atomic symbol > ( #### The Data Language
(<S-expression >. <S-expression >) I
(<S-expression >. ,. <S-expression >) ```BNF
When three dots are used in this manner, they mean that any number of the given <LETTER> ::= A|B|C| ... |Z
type of symbol may occur, including none at all. According to this rule, ( ) is a valid <number> ::= 0|1|2| ... |9
S-expression. (It is equivalent to NIL. ) <atomic-symbol> ::= <LETTER><atom part>
The dot notation is the fundamental notation of S-expressions, although the list <atom part> ::= <empty> | <LETTER><atom part> | <number><atom part>
notation is often more convenient. Any Sdexpression can be written in dot notation. ```
The Meta-Language Atomic symbols are the smallest entities in LISP. Their decomposition into characters has no significance.
<letter>::=alb(cl... (z
<identifier >::=<letter ><id part > <a name="page9">page 9</a>
<id part >::=<empty > I <letter ><id part > I <number ><id part >
The names of functions and variables are fornied in the same manner as atomic ```BNF
symbols but with lower -case letters. <S-expression> ::= <atomic symbol> |
(<S-expression> . <S-expression>) |
(<S-expression> ... <S-expression>)
```
When three dots are used in this manner, they mean that any number of the given type of symbol may occur, including none at all. According to this rule, `( )` is a valid S-expression. (It is equivalent to `NIL`. )
The dot notation is the fundamental notation of S-expressions, although the list notation is often more convenient. Any S-expression can be written in dot notation.
#### The Meta-Language
```BNF
<letter> ::= a|b|c| ... |z
<identifier> ::= <letter><id part>
<id part> ::= <empty> | <letter><id part> | <number><id part>
```
The names of functions and variables are fornied in the same manner as atomic symbols but with lower-case letters.
```BNF
<form> ::= <constant> |
<variable> |
<function>[<argument> ... <argument>] |
[<form> -> <form>; ... ; <form> -> <form>]
<constant> ::= <S-expression>
<variable> ::= <identifier>
<argument> ::= <form>
```
A form is an expression that can be evaluated. A form that is merely a constant
has that constant as its value. If a form is a variable, then the value of the form is
the S-expression that is bound to that variable at the time when we evaluate the form,
The third part of this rule states that we may write a function followed by a list of
arguments separated by semicolons and enclosed in square brackets. The expressions
for the arguments are themselves forms; this indicates that cornpasitions of functions
are permitted.
The last part of this rule gives the format of the conditional expression. This is
evaluated by evaluating the forms in the propositional position in order until one is
found whose value is T. Then the form after the arrow is evaluated and give$ the
value of the entire expression.
<function >::=<identifier > (
k[<var list >;<form >] I
label[< identifier >; <function >]
<var list >:: =[<variable >;... ; <variable >]
A function can be simply a name. In this case its meaning must be previously
understood. A function may be defined by using the lambda notation and establishing
a correspondence between the arguments and the variables used in a form. If the
function is recursive, it must be given a name by using a label.
``` ```
1.6 A Universal LISP Function A form is an expression that can be evaluated. A form that is merely a constant has that constant *[sic]* as its value. If a form is a variable, then the value of the form is the S-expression that is bound to that variable at the time when we evaluate the form,
An interpreter or universal function is one that can compute the value of any given
function applied to its arguments when given a description of that function. (Of course, The third part of this rule states that we may write a function followed by a list of arguments separated by semicolons and enclosed in square brackets. The expressions for the arguments are themselves forms; this indicates that compositions of functions are permitted.
if the function that is being interpreted has infinite recursion, the interpreter will
recur infinitely also. ) The last part of this rule gives the format of the conditional expression. This is evaluated by evaluating the forms in the propositional position in order until one is found whose value is `T`. Then the form after the arrow is evaluated and gives the value of the entire expression.
We are now in a position to define the universal LISP function evalquote[fn;args],
When evalquote is given a function and a list of arguments for that function, it computes `<function>::=<identifier> |` &lambda;`[<var list >;<form >] | label[<identifier>; <function>]`
the value of the function applied to the arguments.
LISP functions have S-expressions as arguments. In particular, the argument `<var list> ::= [<variable >; ... ; <variable>]`
"fn" of the function evalquote must be an S-expression. Since we have been writing
functions as M-expressions, it is necessary to translate them into S-expressions. A function can be simply a name. In this case its meaning must be previously understood. A function may be defined by using the lambda notation and establishing a correspondence between the arguments and the variables used in a form. If the function is recursive, it must be given a name by using a label.
The following rules define a method of translating functions written in the meta-
language into S-expressions. <a name="page10">page 10</a>
### 1.6 A Universal LISP Function
An interpreter or universal function is one that can compute the value of any given function applied to its arguments when given a description of that function. (Of course, if the function that is being interpreted has infinite recursion, the interpreter will recur infinitely also. )
We are now in a position to define the universal LISP function `evalquote[fn;args]`. When `evalquote` is given a function and a list of arguments for that function, it computes the value of the function applied to the arguments.
LISP functions have S-expressions as arguments. In particular, the argument `fn` of the function `evalquote` must be an S-expression. Since we have been writing functions as M-expressions, it is necessary to translate them into S-expressions.
The following rules define a method of translating functions written in the meta-language into S-expressions.
1. If the function is represented by its name, it is translated by changing all of the letters to upper case, making it an atomic symbol. Thus `car` is translated to `CAR`.
2. If the function uses the lambda notation, then the expression &lambda;`[x1; ...; xn]`&epsilon;`]` is translated into (LAMBDA (X1... XN) &epsilon;&ast;), where &epsilon;&ast; is the translation of &epsilon;.
3. If the function begins with label, then the translation of label[&alpha;; &epsilon;] is (LABEL
&alpha;&ast; &epsilon;&ast;).
1. If the function is represented by its name, it is translated by changing
all of the letters to upper case, making it an atomic symbol. Thus is translated
to CAR.
2. If the function uses the lambda notation, then the expression k[[x. .;xn]; 1
is translated into (LAMBDA (X1... XN) e*), where E* is the translation of c.
3. If the function begins with label, then the translation of label[= ;€I is (LABEL
a*e*).
Forms are translated as follows: Forms are translated as follows:
1. A variable, like a function name, is translated by using uppercase letters.
Thus the translation of varl is VAR1.
2. The obvious translation of letting a constant translate into itself will not work.
Since the translation of is X, the translation of X must be something else to avoid
ambiguity. The solution is to quote it. Thus X is translated into (QUOTE X).
3. The form fn[argl;.. .;atgn] is translated into (fn*argl*... argn*)
4. The conditional expression [Pl-el;.. .; pn-en] is translated into (COND
* *
``` 1. A variable, like a function name, is translated by using uppercase letters. Thus the translation of `var1` is `VAR1`.
Examples
M-expressions S -expressions 2. The obvious translation of letting a constant translate into itself will not work. Since the translation `x` of is `X`, the translation of `X` must be something else to avoid ambiguity. The solution is to quote it. Thus `X` is translated into `(QUOTE X)`.
X X
car CAR 3. The form `fn[arg`<sub>1</sub>`; ... ;arg`<sub>n</sub>`]` is translated into `(fn* arg`<sub>1</sub>&ast; `... arg`<sub>n</sub>&ast;`)`.
car [x] (CAR X)
T (QUOTE T) 4. The conditional expression [p<sub>1</sub> -> e<sub>1</sub>; ... ; p<sub>n</sub> -> e<sub>n</sub>] is translated into
ff [car [XI] (FF (CAR X))
[atom[x]-x; T-ff [car [x]]] (COND ((ATOM X) X) (COND (p<sub>1</sub>&ast; e<sub>1</sub>&ast;) ... (p<sub>n</sub>&ast; e<sub>n</sub>&ast;))
((QUOTE T) (FF (CAR X))))
label[ff ;h[[x];[atom[x]-x; T-ff[car [XI]]]] (LABEL FF (LAMBDA (X) (COND #### Examples - translation, M-expressions to S-expressions
((ATOM X) X)
((QUOTE T) (FF (CAR X)))))) | M-expressions | S -expressions |
``` | ---- | ---- |
| X | X |
| car | CAR |
| car[x] | (CAR X) |
| T | (QUOTE T) |
| ff[car[X]] | (FF (CAR X)) |
| [atom[x]-x; T-ff [car [x]]] | (COND ((ATOM X) X) ((QUOTE T) (FF (CAR X)))) |
| label[ff ;h[[x];[atom[x]-x; T-ff[car [X]]]] | (LABEL FF (LAMBDA (X) (COND ((ATOM X) X) ((QUOTE T) (FF (CAR X)))))) |
```
Some useful functions for handling S-expressions are given below. Some of them Some useful functions for handling S-expressions are given below. Some of them
```
are needed as auxiliary functions for evalquote. <a name="page11">page 11</a>
are needed as auxiliary functions for `evalquote`.
`equal[x;y]`
equal[x;y]
This is a predicate that is true if its two arguments are identical S-expressions, This is a predicate that is true if its two arguments are identical S-expressions,
and is false if they are different. (The elementary predicate - eq is defined only for and is false if they are different. (The elementary predicate - eq is defined only for
atomic arguments. ) The definition of egual is an example of a conditional expression atomic arguments. ) The definition of equal is an example of a conditional expression
inside a conditional expression. inside a conditional expression.
``` ```
equal[x; y]=[atom[x] atom[^] -eq[x;~]; T-F]; equal[x; y]=[atom[x] -> [atom[y] -> eq[x; y]; T -> F];
equal[car [x]; car [Y]]-equal[cdr [x]; cdr [y]]; equal[car[x]; car[y]] -> equal[cdr[x]; cdr[y]];
T-F] T -> F]
``` ```
This can be translated into the following S-expression: , This can be translated into the following S-expression: ,
``` ```lisp
(LABEL EQUAL (LAMBDA (X Y) (COND (LABEL EQUAL
((ATOM X) (COND ((ATOM Y) (EQ X Y)) ((QUOTE T) (QUOTE F)))) (LAMBDA (X Y)
((EQUAL (CAR X) (CAR Y)) (EQUAL (CDR X) (CDR Y))) (COND ((ATOM X) (COND ((ATOM Y) (EQ X Y))
((QUOTET)(QUOTEF)) )I) ((QUOTE T) (QUOTE F))))
((EQUAL (CAR X) (CAR Y)) (EQUAL (CDR X) (CDR Y)))
((QUOTE T)(QUOTE F)))))
``` ```
- sub st[^;^; z] - sub st[^;^; z]
This function gives the result of substituting the S-expression x for all occurrences This function gives the result of substituting the S-expression x for all occurrences
of the atomic symbol y in the S-expression z. It is defined by of the atomic symbol y in the S-expression z. It is defined by
###### s~bst[x;~;z] = [eq~al[~;z] -- x;atom[z] - z;T - cons[subst ###### s~bst[x;~;z] = [eq~al[~;z] -- x;atom[z] - z;T - cons[subst
@ -933,7 +869,7 @@ Section I. )
eval will evaluate the variables and give it to cons. eval will evaluate the variables and give it to cons.
cons[^;^] = (A. B) cons[^;^] = (A. B)
The actual interpreter skips one step required by the universal function, namely, The actual interpreter skips one step required by the universal function, namely,
apply[~O~~;(A B);((X. A) (Y. B))]. apply[~O~~;(A B);((X. A) (Y. B))].
2.2 Constants 2.2 Constants
It is sometimes assumed that a constant stands for itself as opposed to a variable It is sometimes assumed that a constant stands for itself as opposed to a variable
@ -990,8 +926,8 @@ three ways in which a subroutine can be present in the system.
2. The function is hand-coded by the user in the assembly type language, LAP. 2. The function is hand-coded by the user in the assembly type language, LAP.
3. The function is first defined by an S-expression, and then compiled by the LISP 3. The function is first defined by an S-expression, and then compiled by the LISP
compiler. Compiled functions run from 10 to 100 times as fast as they do when they compiler. Compiled functions run from 10 to 100 times as fast as they do when they
are interpreted. are interpreted.
``` ```
2.5 Special Forms 2.5 Special Forms
@ -1309,9 +1245,9 @@ difference[^;^] has for its value the algebraic difference of its arguments.
* minus[x] has for its value -x. * minus[x] has for its value -x.
times[xl;.. .;xn] is a function of any number of arguments, whose value is the product times[xl;.. .;xn] is a function of any number of arguments, whose value is the product
(with correct sign) of its arguments. (with correct sign) of its arguments.
addl[x] has xtl for its value. The value is fixed-point or floating-point, depending addl[x] has xtl for its value. The value is fixed-point or floating-point, depending
on the argument. on the argument.
* subl[x] has x-1 for its value. The value is fixed-point or floating-point, depending * subl[x] has x-1 for its value. The value is fixed-point or floating-point, depending
on the argument. on the argument.
* max[xl;... ;xn] chooses the largest of its arguments for its value. Note that * max[xl;... ;xn] chooses the largest of its arguments for its value. Note that
@ -1429,13 +1365,13 @@ Length is a function of one argurnentL. The program uses two program variables
by the program. In English the program is written: by the program. In English the program is written:
This is a function of one argument 1. This is a function of one argument 1.
It is a program with two program variables 2 and 1. It is a program with two program variables 2 and 1.
Store 0 in Store 0 in
Store the argument 1 in 2. Store the argument 1 in 2.
A If g contains NIL, then the program is finished, A If g contains NIL, then the program is finished,
and the value is whatever is now in 2. and the value is whatever is now in 2.
Store in u, cdr of what is now in g. Store in u, cdr of what is now in g.
Store in 1, one more than what is now in Store in 1, one more than what is now in
Go to A. Go to A.
``` ```
We now write this program as an M-expression, with a few new notations. This We now write this program as an M-expression, with a few new notations. This
@ -1541,11 +1477,11 @@ the TEST by reading in a core memory image from the temporary tape.
thesis will cause a read error and terminate reading. thesis will cause a read error and terminate reading.
A complete card deck for a LISP run might consist of: A complete card deck for a LISP run might consist of:
a: LISP loader a: LISP loader
b: ID card (Optional) b: ID card (Optional)
c: Several Packets c: Several Packets
.d: FIN card .d: FIN card
e: Two blank cards to prevent card reader from hanging up e: Two blank cards to prevent card reader from hanging up
The ID card may have any information desired by the computation center. It will be The ID card may have any information desired by the computation center. It will be
printed at the head of the output. printed at the head of the output.
@ -1704,9 +1640,9 @@ the garbage collector.
7. 1 Representation of List Structure 7. 1 Representation of List Structure
Lists are not stored in the computer as sequences of BCD characters, but as struc- Lists are not stored in the computer as sequences of BCD characters, but as struc-
tural forms built out of computer words as parts of trees. tural forms built out of computer words as parts of trees.
In representing list structure, a computer word will be depicted as a rectangle In representing list structure, a computer word will be depicted as a rectangle
divided into two sections, the address and decrement. divided into two sections, the address and decrement.
add. I dec. add. I dec.
@ -2729,7 +2665,7 @@ es[x;y - I SUBR predicate
CLA CLA
TRA TRA
TRUE OCT TRUE OCT
X PZE X PZE
``` ```
X X
@ -2793,8 +2729,8 @@ respectively.
- 0r[x1;x2... ;xn] : FSUBR predicate - 0r[x1;x2... ;xn] : FSUBR predicate
The arguments of or are evaluated in sequence from left to right, until one is found The arguments of or are evaluated in sequence from left to right, until one is found
that is true, or until the end of the list is reached. The value of 2 is true or that is true, or until the end of the list is reached. The value of 2 is true or
false respectively. false respectively.
* not [x] SUBR predicate * not [x] SUBR predicate
The value of not is true if its argument is false, and false otherwise. The value of not is true if its argument is false, and false otherwise.
@ -2844,8 +2780,8 @@ erty list for FF.
- pr~p[x;~;u] SUBR functional - pr~p[x;~;u] SUBR functional
The function prop - searches the list x for an item that is - eq to y. If such an element The function prop - searches the list x for an item that is - eq to y. If such an element
is found, the value of prop is the rest of the list beginning immediately after the element. is found, the value of prop is the rest of the list beginning immediately after the element.
Otherwise the value is u[ 1, where 2 is a function of no arguments. Otherwise the value is u[ 1, where 2 is a function of no arguments.
##### prop[^;^; u] = [null[x] - u[ ];eq[car[x];y] -cdr[x] ##### prop[^;^; u] = [null[x] - u[ ];eq[car[x];y] -cdr[x]
@ -2905,11 +2841,11 @@ Table Buildinrr and Table Reference Functions
- pair [x; y] SUBR - pair [x; y] SUBR
The function pair has as value the list of pairs of corresponding elements of the lists The function pair has as value the list of pairs of corresponding elements of the lists
x and y. The arguments x and y must be lists of the same number of elements. They x and y. The arguments x and y must be lists of the same number of elements. They
should & be atomic symbols. The value is a dotted pair list, i. e. ((a (a p2)... should & be atomic symbols. The value is a dotted pair list, i. e. ((a (a p2)...
pair[x;y] = [prog[u;v; m] pair[x;y] = [prog[u;v; m]
u:= x; u:= x;
v:= y; v:= y;
#### A [null[u] - [null[v] - return[m];~ - error[$2]]] #### A [null[u] - [null[v] - return[m];~ - error[$2]]]
@ -2972,8 +2908,8 @@ nconc does not copy its first argument.
* conc[xl;x2;... ;x n ] : FEXPR pseudo-function * conc[xl;x2;... ;x n ] : FEXPR pseudo-function
* conc concatenates its arguments by stringing them all together on the top level. For * conc concatenates its arguments by stringing them all together on the top level. For
example, example,
conc[(~ (B C) D); (F); (G H)] = (A (B C) D F G H). conc[(~ (B C) D); (F); (G H)] = (A (B C) D F G H).
* conc concatenates its arguments without copying them. Thus it changes existing list * conc concatenates its arguments without copying them. Thus it changes existing list
structure and is a pseudo-function. The value of conc is the resulting concatenated list. structure and is a pseudo-function. The value of conc is the resulting concatenated list.
@ -3079,9 +3015,9 @@ go[~oopl1
- sear~h[x;~;f;u] : SUBR functional - sear~h[x;~;f;u] : SUBR functional
The function search looks through a list x for an element that has the property p, The function search looks through a list x for an element that has the property p,
and if such an element is found the function f of that element is the value of search. and if such an element is found the function f of that element is the value of search.
If there is no such element, the function u of one argument x is taken as the value of If there is no such element, the function u of one argument x is taken as the value of
search (in this case x is, of course, NIL). search (in this case x is, of course, NIL).
``` ```
Arithmetic Functions Arithmetic Functions
@ -3258,11 +3194,11 @@ reader. The list that is read is the value of read.
- print [x] SUBR pseudo-function - print [x] SUBR pseudo-function
The execution of - print causes the S-expression x to be printed on SYSPOT and/or The execution of - print causes the S-expression x to be printed on SYSPOT and/or
the on-line printer. The value of print is its argument. the on-line printer. The value of print is its argument.
punchrx] - SUBR pseudo.-function punchrx] - SUBR pseudo.-function
The execution of punch causes S-expression x to be punched in BCD card images The execution of punch causes S-expression x to be punched in BCD card images
on SYSPPT. The value of punch - is its argument. on SYSPPT. The value of punch - is its argument.
prin l [x] SUBR pseudo-function prin l [x] SUBR pseudo-function
* prinl prints an atomic symbol without terminating the print line. The argument * prinl prints an atomic symbol without terminating the print line. The argument
of - prini must be an atomic symbol. of - prini must be an atomic symbol.
@ -4281,7 +4217,7 @@ The character-packing functions are:
1. pack [c] - : SUBR pseudo-function 1. pack [c] - : SUBR pseudo-function
The argument of packmust be a character object. - pack adds the character The argument of packmust be a character object. - pack adds the character
c at the end of the sequence of characters in BOFFO. The value of pack - is NIL. c at the end of the sequence of characters in BOFFO. The value of pack - is NIL.
2. clearbuff [ ] SUBR pseudo -func tion 2. clearbuff [ ] SUBR pseudo -func tion
clearbuff is a function of no arguments. It clears BOFFO and has value NIL. clearbuff is a function of no arguments. It clears BOFFO and has value NIL.
The contents of BOFFO are undefined until a clearbuff has been performed. The contents of BOFFO are undefined until a clearbuff has been performed.
@ -4293,13 +4229,13 @@ BOFFO is automatically cleared. Note that intern [mknam[ ]I yields the object
whose print name is in BOFFO. whose print name is in BOFFO.
4. numob [ ] ' SUBR pseudo -function 4. numob [ ] ' SUBR pseudo -function
numob is a function of no arguments. Its value is the numerical object repre- numob is a function of no arguments. Its value is the numerical object repre-
sented by the sequence of characters in BOFFO. (Positive decimal integers from sented by the sequence of characters in BOFFO. (Positive decimal integers from
0 to 9 are converted so as to point to the corresponding character object. ) 0 to 9 are converted so as to point to the corresponding character object. )
5. unpack [x]: SUBR pseudo-function 5. unpack [x]: SUBR pseudo-function
This function has as argument a pointer to a full word. unpack considers This function has as argument a pointer to a full word. unpack considers
the full word to be a set of 6 BCD characters, and has as value a list of these the full word to be a set of 6 BCD characters, and has as value a list of these
char act er s ignoring all characters including and following the first 77. char act er s ignoring all characters including and following the first 77.
6. h~tern[~name] : SUBR pseudo-function 6. h~tern[~name] : SUBR pseudo-function
This function has as argument a pointer to a PNAME type structure such as - This function has as argument a pointer to a PNAME type structure such as -
@ -4338,7 +4274,7 @@ CURCHAR. There are three functions which affect the value of CURCHAR:
1. startread [ 1: : SUBR ps eudo-function 1. startread [ 1: : SUBR ps eudo-function
startread is a function of no arguments which causes a new card to be read. startread is a function of no arguments which causes a new card to be read.
The value of startread is the first character on that card, or more precisely, The value of startread is the first character on that card, or more precisely,
``` ```
the object corresponding to the first character on the card. If an end-of-file the object corresponding to the first character on the card. If an end-of-file
@ -4351,20 +4287,20 @@ completely read.
2. advance [ 1: SUBR pseudo -function 2. advance [ 1: SUBR pseudo -function
advance is a function of no arguments which causes the next character to be advance is a function of no arguments which causes the next character to be
read. The value of advance is that character. After the 72nd character on the read. The value of advance is that character. After the 72nd character on the
card has been read, the next advance will have value $EOR$. After reading card has been read, the next advance will have value $EOR$. After reading
$EOR$, the next advance will act like a startread, i. e., will read the first char- $EOR$, the next advance will act like a startread, i. e., will read the first char-
acter of the next card unless an end-of-file condition exists. The new value of acter of the next card unless an end-of-file condition exists. The new value of
CURCHAR is the same as the output of advance; executing advance also increases CURCHAR is the same as the output of advance; executing advance also increases
the value of CHARCOUNT by 1. However, CHARCOUNT is undefined when the value of CHARCOUNT by 1. However, CHARCOUNT is undefined when
CURCHAR is either $EOR $ or $EOF $. CURCHAR is either $EOR $ or $EOF $.
3. endread [ 1: SUBR pseudo-function 3. endread [ 1: SUBR pseudo-function
endread is a function of no arguments which causes the remainder of the endread is a function of no arguments which causes the remainder of the
card to be read and ignored. endread sets CURCHAR to $EOR$ and leaves card to be read and ignored. endread sets CURCHAR to $EOR$ and leaves
CHARCOUNT undefined; the value of endread is always $EOR $. An advance CHARCOUNT undefined; the value of endread is always $EOR $. An advance
following endread acts like a startread. If CURCHAR already has value $EOR $ following endread acts like a startread. If CURCHAR already has value $EOR $
and endread is performed, CURCHAR will remain the same and endread will, and endread is performed, CURCHAR will remain the same and endread will,
as usual, have value $EOR $. as usual, have value $EOR $.
Diagnostic Function Diagnostic Function

15
doc/values.md
View file

@ -1,20 +1,23 @@
# Understanding values and properties # Understanding values and properties
I had had the naive assumption that entries on the object list had their CAR pointing to the symbol and their CDR pointing to the related value. Consequently, I could not work out where the property list went. More careful reading of the I had had the naive assumption that entries on the object list had their CAR pointing to the symbol and their CDR pointing to the related value. Consequently, I could not work out where the property list went. More careful reading of [the text] implies, but does not explicitly state, that my naive assumption is wrong.
text implies, but does not explicitly state, that my naive assumption is wrong.
Instead, it appears that the `CAR` points to the symbol, as expected, but the `CAR` points to the property list; and that on the property list there are privileged properties at least as follows: Instead, it appears that the `CAR` points to the symbol, as expected, but the `CAR` points to the property list; and that on the property list there are privileged properties at least as follows:
APVAL APVAL
: the simple straightforward ordinary value of the symbol, considered a variable; : the simple straightforward ordinary value of the symbol, considered as a variable;
EXPR EXPR
: the definition of the function considered as a normal lambda expression (arguments to be evaluated before applying); : the definition of the function considered as a normal lambda expression (arguments to be evaluated before applying);
FEXPR FEXPR
: the definition of a function which should be applied to unevaluated arguments; : the definition of a function which should be applied to unevaluated arguments;
SUBR SUBR
: the definition of a complied subroutine which should be applied to evaluated arguments; : the definition of a complied subroutine which should be applied to evaluated arguments;
FSUBR FSUBR
: the definition of a complied subroutine which should be applied to unevaluated arguments; : the definition of a complied subroutine which should be applied to unevaluated arguments.
I think there was also another privileged property value which contained the property considered as a constant, but I haven't yet confirmed that. I think there was also another privileged property value which contained the property considered as a constant, but I haven't yet confirmed that.
@ -30,6 +33,8 @@ Essentially the properties are tried in turn, and only the first value found is
This means that, while the other potential values can be retrieved from the property list, interpreted definitions (if present) will always be preferred to uninterpreted definitions, and lambda function definitions (which evaluate their arguments), where present, will always be preferred to non-lamda definitions, which don't. This means that, while the other potential values can be retrieved from the property list, interpreted definitions (if present) will always be preferred to uninterpreted definitions, and lambda function definitions (which evaluate their arguments), where present, will always be preferred to non-lamda definitions, which don't.
**BUT NOTE THAT** the `APVAL` value is saught only when seeking a variable value for the symbol, and the others only when seeking a function value, so Lisp 1.5 is a 'Lisp 2', not a 'Lisp 1'. **BUT NOTE THAT** the `APVAL` value is sought only when seeking a variable value for the symbol, and the others only when seeking a function value, so Lisp 1.5 is a 'Lisp 2', not a 'Lisp 1'.
Versions of Beowulf up to and including 0.2.1 used the naive understanding of the architecture; version 0.3.0 *should* use the corrected version. Versions of Beowulf up to and including 0.2.1 used the naive understanding of the architecture; version 0.3.0 *should* use the corrected version.

8
docs/codox/beowulf.bootstrap.html
View file

File diff suppressed because one or more lines are too long

2
docs/codox/beowulf.cons-cell.html
View file

File diff suppressed because one or more lines are too long

2
docs/codox/beowulf.core.html
View file

File diff suppressed because one or more lines are too long

4
docs/codox/beowulf.gendoc.html
View file

File diff suppressed because one or more lines are too long

20
docs/codox/beowulf.host.html
View file

File diff suppressed because one or more lines are too long

6
docs/codox/beowulf.io.html
View file

File diff suppressed because one or more lines are too long

2
docs/codox/beowulf.manual.html
View file

File diff suppressed because one or more lines are too long

2
docs/codox/beowulf.oblist.html
View file

File diff suppressed because one or more lines are too long

2
docs/codox/beowulf.read.html
View file

File diff suppressed because one or more lines are too long

2
docs/codox/beowulf.reader.char-reader.html
View file

File diff suppressed because one or more lines are too long

2
docs/codox/beowulf.reader.generate.html
View file

File diff suppressed because one or more lines are too long

2
docs/codox/beowulf.reader.macros.html
View file

File diff suppressed because one or more lines are too long

2
docs/codox/beowulf.reader.parser.html
View file

File diff suppressed because one or more lines are too long

2
docs/codox/beowulf.reader.simplify.html
View file

File diff suppressed because one or more lines are too long

2
docs/codox/beowulf.scratch.html
View file

File diff suppressed because one or more lines are too long

2
docs/codox/index.html
View file

File diff suppressed because one or more lines are too long

6
docs/codox/intro.html
View file

@ -1,7 +1,7 @@
<!DOCTYPE html PUBLIC "" <!DOCTYPE html PUBLIC ""
""> "">
<html><head><meta charset="UTF-8" /><title>beowulf</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">Beowulf</span> <span class="project-version">0.3.0-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 current"><a href="intro.html"><div class="inner"><span>beowulf</span></div></a></li><li class="depth-1 "><a href="mexpr.html"><div class="inner"><span>M-Expressions</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>beowulf</span></div></div></li><li class="depth-2 branch"><a href="beowulf.bootstrap.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>bootstrap</span></div></a></li><li class="depth-2 branch"><a href="beowulf.cons-cell.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>cons-cell</span></div></a></li><li class="depth-2 branch"><a href="beowulf.core.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>core</span></div></a></li><li class="depth-2 branch"><a href="beowulf.gendoc.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>gendoc</span></div></a></li><li class="depth-2 branch"><a href="beowulf.host.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>host</span></div></a></li><li class="depth-2 branch"><a href="beowulf.io.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>io</span></div></a></li><li class="depth-2 branch"><a href="beowulf.manual.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>manual</span></div></a></li><li class="depth-2 branch"><a href="beowulf.oblist.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>oblist</span></div></a></li><li class="depth-2 branch"><a href="beowulf.read.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>read</span></div></a></li><li class="depth-2"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>reader</span></div></div></li><li class="depth-3 branch"><a href="beowulf.reader.char-reader.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>char-reader</span></div></a></li><li class="depth-3 branch"><a href="beowulf.reader.generate.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>generate</span></div></a></li><li class="depth-3 branch"><a href="beowulf.reader.macros.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>macros</span></div></a></li><li class="depth-3 branch"><a href="beowulf.reader.parser.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>parser</span></div></a></li><li class="depth-3"><a href="beowulf.reader.simplify.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>simplify</span></div></a></li><li class="depth-2"><a href="beowulf.scratch.html"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>scratch</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#beowulf" name="beowulf"></a>beowulf</h1> <html><head><meta charset="UTF-8" /><title>beowulf</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">Beowulf</span> <span class="project-version">0.3.0-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 current"><a href="intro.html"><div class="inner"><span>beowulf</span></div></a></li><li class="depth-1 "><a href="mexpr.html"><div class="inner"><span>M-Expressions</span></div></a></li><li class="depth-1 "><a href="values.html"><div class="inner"><span>Understanding values and properties</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>beowulf</span></div></div></li><li class="depth-2 branch"><a href="beowulf.bootstrap.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>bootstrap</span></div></a></li><li class="depth-2 branch"><a href="beowulf.cons-cell.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>cons-cell</span></div></a></li><li class="depth-2 branch"><a href="beowulf.core.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>core</span></div></a></li><li class="depth-2 branch"><a href="beowulf.gendoc.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>gendoc</span></div></a></li><li class="depth-2 branch"><a href="beowulf.host.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>host</span></div></a></li><li class="depth-2 branch"><a href="beowulf.io.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>io</span></div></a></li><li class="depth-2 branch"><a href="beowulf.manual.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>manual</span></div></a></li><li class="depth-2 branch"><a href="beowulf.oblist.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>oblist</span></div></a></li><li class="depth-2 branch"><a href="beowulf.read.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>read</span></div></a></li><li class="depth-2"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>reader</span></div></div></li><li class="depth-3 branch"><a href="beowulf.reader.char-reader.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>char-reader</span></div></a></li><li class="depth-3 branch"><a href="beowulf.reader.generate.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>generate</span></div></a></li><li class="depth-3 branch"><a href="beowulf.reader.macros.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>macros</span></div></a></li><li class="depth-3 branch"><a href="beowulf.reader.parser.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>parser</span></div></a></li><li class="depth-3"><a href="beowulf.reader.simplify.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>simplify</span></div></a></li><li class="depth-2"><a href="beowulf.scratch.html"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>scratch</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#beowulf" name="beowulf"></a>beowulf</h1>
<p>LISP 1.5 is to all Lisp dialects as Beowulf is to Emglish literature.</p> <p>LISP 1.5 is to all Lisp dialects as Beowulf is to English literature.</p>
<h2><a href="#what-this-is" name="what-this-is"></a>What this is</h2> <h2><a href="#what-this-is" name="what-this-is"></a>What this is</h2>
<p>A work-in-progress towards an implementation of Lisp 1.5 in Clojure. The objective is to build a complete and accurate implementation of Lisp 1.5 as described in the manual, with, in so far as is possible, exactly the same bahaviour - except as documented below.</p> <p>A work-in-progress towards an implementation of Lisp 1.5 in Clojure. The objective is to build a complete and accurate implementation of Lisp 1.5 as described in the manual, with, in so far as is possible, exactly the same bahaviour - except as documented below.</p>
<h3><a href="#status" name="status"></a>Status</h3> <h3><a href="#status" name="status"></a>Status</h3>
@ -25,6 +25,8 @@
-s, --strict Strictly interpret the Lisp 1.5 language, without extensions. -s, --strict Strictly interpret the Lisp 1.5 language, without extensions.
</code></pre> </code></pre>
<p>To end a session, type <code>STOP</code> at the command prompt.</p> <p>To end a session, type <code>STOP</code> at the command prompt.</p>
<h3><a href="#reader-macros" name="reader-macros"></a>Reader macros</h3>
<p>Currently I don’t have </p>
<h3><a href="#functions-and-symbols-implemented" name="functions-and-symbols-implemented"></a>Functions and symbols implemented</h3> <h3><a href="#functions-and-symbols-implemented" name="functions-and-symbols-implemented"></a>Functions and symbols implemented</h3>
<p>The following functions and symbols are implemented:</p> <p>The following functions and symbols are implemented:</p>
<table> <table>

2
docs/codox/mexpr.html
View file

@ -1,6 +1,6 @@
<!DOCTYPE html PUBLIC "" <!DOCTYPE html PUBLIC ""
""> "">
<html><head><meta charset="UTF-8" /><title>M-Expressions</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">Beowulf</span> <span class="project-version">0.3.0-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="intro.html"><div class="inner"><span>beowulf</span></div></a></li><li class="depth-1 current"><a href="mexpr.html"><div class="inner"><span>M-Expressions</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>beowulf</span></div></div></li><li class="depth-2 branch"><a href="beowulf.bootstrap.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>bootstrap</span></div></a></li><li class="depth-2 branch"><a href="beowulf.cons-cell.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>cons-cell</span></div></a></li><li class="depth-2 branch"><a href="beowulf.core.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>core</span></div></a></li><li class="depth-2 branch"><a href="beowulf.gendoc.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>gendoc</span></div></a></li><li class="depth-2 branch"><a href="beowulf.host.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>host</span></div></a></li><li class="depth-2 branch"><a href="beowulf.io.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>io</span></div></a></li><li class="depth-2 branch"><a href="beowulf.manual.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>manual</span></div></a></li><li class="depth-2 branch"><a href="beowulf.oblist.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>oblist</span></div></a></li><li class="depth-2 branch"><a href="beowulf.read.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>read</span></div></a></li><li class="depth-2"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>reader</span></div></div></li><li class="depth-3 branch"><a href="beowulf.reader.char-reader.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>char-reader</span></div></a></li><li class="depth-3 branch"><a href="beowulf.reader.generate.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>generate</span></div></a></li><li class="depth-3 branch"><a href="beowulf.reader.macros.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>macros</span></div></a></li><li class="depth-3 branch"><a href="beowulf.reader.parser.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>parser</span></div></a></li><li class="depth-3"><a href="beowulf.reader.simplify.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>simplify</span></div></a></li><li class="depth-2"><a href="beowulf.scratch.html"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>scratch</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#m-expressions" name="m-expressions"></a>M-Expressions</h1> <html><head><meta charset="UTF-8" /><title>M-Expressions</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">Beowulf</span> <span class="project-version">0.3.0-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="intro.html"><div class="inner"><span>beowulf</span></div></a></li><li class="depth-1 current"><a href="mexpr.html"><div class="inner"><span>M-Expressions</span></div></a></li><li class="depth-1 "><a href="values.html"><div class="inner"><span>Understanding values and properties</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>beowulf</span></div></div></li><li class="depth-2 branch"><a href="beowulf.bootstrap.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>bootstrap</span></div></a></li><li class="depth-2 branch"><a href="beowulf.cons-cell.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>cons-cell</span></div></a></li><li class="depth-2 branch"><a href="beowulf.core.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>core</span></div></a></li><li class="depth-2 branch"><a href="beowulf.gendoc.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>gendoc</span></div></a></li><li class="depth-2 branch"><a href="beowulf.host.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>host</span></div></a></li><li class="depth-2 branch"><a href="beowulf.io.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>io</span></div></a></li><li class="depth-2 branch"><a href="beowulf.manual.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>manual</span></div></a></li><li class="depth-2 branch"><a href="beowulf.oblist.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>oblist</span></div></a></li><li class="depth-2 branch"><a href="beowulf.read.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>read</span></div></a></li><li class="depth-2"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>reader</span></div></div></li><li class="depth-3 branch"><a href="beowulf.reader.char-reader.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>char-reader</span></div></a></li><li class="depth-3 branch"><a href="beowulf.reader.generate.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>generate</span></div></a></li><li class="depth-3 branch"><a href="beowulf.reader.macros.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>macros</span></div></a></li><li class="depth-3 branch"><a href="beowulf.reader.parser.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>parser</span></div></a></li><li class="depth-3"><a href="beowulf.reader.simplify.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>simplify</span></div></a></li><li class="depth-2"><a href="beowulf.scratch.html"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>scratch</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#m-expressions" name="m-expressions"></a>M-Expressions</h1>
<p>M-Expressions (‘mexprs’) are the grammar which John McCarthy origininally used to write Lisp, and the grammar in which many of the function definitions in the <a href="https://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf">Lisp 1.5 Programmer’s Manual</a> are stated. However, I have not seen anywhere a claim that Lisp 1.5 could <em>read</em> M-Expressions, and it is not clear to me whether it was even planned that it should do so.</p> <p>M-Expressions (‘mexprs’) are the grammar which John McCarthy origininally used to write Lisp, and the grammar in which many of the function definitions in the <a href="https://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf">Lisp 1.5 Programmer’s Manual</a> are stated. However, I have not seen anywhere a claim that Lisp 1.5 could <em>read</em> M-Expressions, and it is not clear to me whether it was even planned that it should do so.</p>
<p>Rather, it seems to me probably that M-Expressions were only ever a grammar intended to be written on paper, like <a href="https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form">Backus Naur Form</a>, to describe and to reason about algorithms.</p> <p>Rather, it seems to me probably that M-Expressions were only ever a grammar intended to be written on paper, like <a href="https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form">Backus Naur Form</a>, to describe and to reason about algorithms.</p>
<p>I set out to make Beowulf read M-Expressions essentially out of curiousity, to see whether it could be done. I had this idea that if it could be done, I could implement most of Lisp 1.5 simply by copying in the M-Expression definitions out of the manual.</p> <p>I set out to make Beowulf read M-Expressions essentially out of curiousity, to see whether it could be done. I had this idea that if it could be done, I could implement most of Lisp 1.5 simply by copying in the M-Expression definitions out of the manual.</p>

30
docs/codox/values.html Normal file
View file

@ -0,0 +1,30 @@
<!DOCTYPE html PUBLIC ""
"">
<html><head><meta charset="UTF-8" /><title>Understanding values and properties</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="css/highlight.css" /><script type="text/javascript" src="js/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a></h2><h1><a href="index.html"><span class="project-title"><span class="project-name">Beowulf</span> <span class="project-version">0.3.0-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="intro.html"><div class="inner"><span>beowulf</span></div></a></li><li class="depth-1 "><a href="mexpr.html"><div class="inner"><span>M-Expressions</span></div></a></li><li class="depth-1 current"><a href="values.html"><div class="inner"><span>Understanding values and properties</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>beowulf</span></div></div></li><li class="depth-2 branch"><a href="beowulf.bootstrap.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>bootstrap</span></div></a></li><li class="depth-2 branch"><a href="beowulf.cons-cell.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>cons-cell</span></div></a></li><li class="depth-2 branch"><a href="beowulf.core.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>core</span></div></a></li><li class="depth-2 branch"><a href="beowulf.gendoc.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>gendoc</span></div></a></li><li class="depth-2 branch"><a href="beowulf.host.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>host</span></div></a></li><li class="depth-2 branch"><a href="beowulf.io.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>io</span></div></a></li><li class="depth-2 branch"><a href="beowulf.manual.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>manual</span></div></a></li><li class="depth-2 branch"><a href="beowulf.oblist.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>oblist</span></div></a></li><li class="depth-2 branch"><a href="beowulf.read.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>read</span></div></a></li><li class="depth-2"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>reader</span></div></div></li><li class="depth-3 branch"><a href="beowulf.reader.char-reader.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>char-reader</span></div></a></li><li class="depth-3 branch"><a href="beowulf.reader.generate.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>generate</span></div></a></li><li class="depth-3 branch"><a href="beowulf.reader.macros.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>macros</span></div></a></li><li class="depth-3 branch"><a href="beowulf.reader.parser.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>parser</span></div></a></li><li class="depth-3"><a href="beowulf.reader.simplify.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>simplify</span></div></a></li><li class="depth-2"><a href="beowulf.scratch.html"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>scratch</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#understanding-values-and-properties" name="understanding-values-and-properties"></a>Understanding values and properties</h1>
<p>I had had the naive assumption that entries on the object list had their CAR pointing to the symbol and their CDR pointing to the related value. Consequently, I could not work out where the property list went. More careful reading of the text implies, but does not explicitly state, that my naive assumption is wrong.</p>
<p>Instead, it appears that the <code>CAR</code> points to the symbol, as expected, but the <code>CAR</code> points to the property list; and that on the property list there are privileged properties at least as follows:</p>
<dl>
<dt>APVAL</dt>
<dd>the simple straightforward ordinary value of the symbol, considered a variable;</dd>
<dt>EXPR</dt>
<dd>the definition of the function considered as a normal lambda expression (arguments to be evaluated before applying);</dd>
<dt>FEXPR</dt>
<dd>the definition of a function which should be applied to unevaluated arguments;</dd>
<dt>SUBR</dt>
<dd>the definition of a complied subroutine which should be applied to evaluated arguments;</dd>
<dt>FSUBR</dt>
<dd>the definition of a complied subroutine which should be applied to unevaluated arguments.</dd>
</dl>
<p>I think there was also another privileged property value which contained the property considered as a constant, but I haven’t yet confirmed that.</p>
<p>From this it would seem that Lisp 1.5 was not merely a <a href="http://xahlee.info/emacs/emacs/lisp1_vs_lisp2.html">‘Lisp 2’</a> but in fact a ‘Lisp 6’, with six effectively first class namespaces. In fact it’s not as bad as that, because of the way <a href="https://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf#page=79"><code>EVAL</code></a> is evaluated.</p>
<p>Essentially the properties are tried in turn, and only the first value found is used. Thus the heirarchy is</p>
<ol>
<li>APVAL</li>
<li>EXPR</li>
<li>FEXPR</li>
<li>SUBR</li>
<li>FSUBR</li>
</ol>
<p>This means that, while the other potential values can be retrieved from the property list, interpreted definitions (if present) will always be preferred to uninterpreted definitions, and lambda function definitions (which evaluate their arguments), where present, will always be preferred to non-lamda definitions, which don’t.</p>
<p><strong>BUT NOTE THAT</strong> the <code>APVAL</code> value is saught only when seeking a variable value for the symbol, and the others only when seeking a function value, so Lisp 1.5 is a ‘Lisp 2’, not a ‘Lisp 1’.</p>
<p>Versions of Beowulf up to and including 0.2.1 used the naive understanding of the architecture; version 0.3.0 <em>should</em> use the corrected version.</p></div></div></div></body></html>

4
resources/lisp1.5.lsp
View file

@ -87,7 +87,9 @@
((NULL X) (QUOTE NIL)) ((NULL X) (QUOTE NIL))
((MEMBER (CAR X) Y) (CONS (CAR X) (INTERSECTION (CDR X) Y))) ((MEMBER (CAR X) Y) (CONS (CAR X) (INTERSECTION (CDR X) Y)))
((QUOTE T) (INTERSECTION (CDR X) Y)))) ((QUOTE T) (INTERSECTION (CDR X) Y))))
(LENGTH LAMBDA (L) (COND ((EQ NIL L) 0) (T (ADD1 (LENGTH (CDR L)))))) (LENGTH
LAMBDA
(L) (COND ((EQ NIL L) 0) ((CONSP (CDR L)) (ADD1 (LENGTH (CDR L)))) (T 0)))
(LESSP) (LESSP)
(MAPLIST LAMBDA (L F) (COND ((NULL L) NIL) ((QUOTE T) (CONS (F (CAR L)) (MAPLIST (CDR L) F))))) (MAPLIST LAMBDA (L F) (COND ((NULL L) NIL) ((QUOTE T) (CONS (F (CAR L)) (MAPLIST (CDR L) F)))))
(MEMBER (MEMBER

7
resources/sexpr/length.lsp
View file

@ -1 +1,6 @@
(SETQ LENGTH '(LAMBDA (L) (COND ((EQ NIL L) 0) (T (ADD1 (LENGTH (CDR L))))))) (SETQ LENGTH
'(LAMBDA (L)
(COND
((EQ NIL L) 0)
((CONSP (CDR L)) (ADD1 (LENGTH (CDR L))))
(T 0))))

30
src/beowulf/reader/parser.clj
View file

@ -29,19 +29,25 @@
(str (str
;; we tolerate whitespace and comments around legitimate input ;; we tolerate whitespace and comments around legitimate input
"raw := expr | opt-comment expr opt-comment;" "raw := expr | opt-comment expr opt-comment;"
;; top level: we accept mexprs as well as sexprs. ;; top level: we accept mexprs as well as sexprs.
"expr := mexpr | sexpr ;" "expr := mexpr | sexpr ;"
;; comments. I'm pretty confident Lisp 1.5 did NOT have these. ;; comments. I'm pretty confident Lisp 1.5 did NOT have these.
"comment := opt-space <';;'> opt-space #'[^\\n\\r]*';" "comment := opt-space <';;'> opt-space #'[^\\n\\r]*';"
;; there's a notation comprising a left brace followed by mexprs ;; there's a notation comprising a left brace followed by mexprs
;; followed by a right brace which doesn't seem to be documented ;; followed by a right brace which doesn't seem to be documented
;; but I think must represent a prog(?) ;; but I think must represent assembly code(?)
;; "prog := lbrace exprs rbrace;" ;; "assembly := lbrace exprs rbrace;"
;; mexprs. I'm pretty clear that Lisp 1.5 could never read these,
;; but it's a convenience. ;; mexprs. I'm pretty clear that Lisp 1.5 could never read these,
;; but it's a convenience.
;; TODO: this works for now but in fact the Programmer's Manual
;; gives a much simpler formulation of M-expression grammar on
;; page 9, and of the S-expression grammar on page 8. It would
;; be worth going back and redoing this from the book.
"exprs := expr | exprs;" "exprs := expr | exprs;"
"mexpr := λexpr | fncall | defn | cond | mvar | mconst | iexpr | number | mexpr comment; "mexpr := λexpr | fncall | defn | cond | mvar | mconst | iexpr | number | mexpr comment;
@ -72,12 +78,12 @@
iexp := mexpr | number | opt-space iexp opt-space; iexp := mexpr | number | opt-space iexp opt-space;
iop := '>' | '<' | '+' | '-' | '*' '/' | '=' ;" iop := '>' | '<' | '+' | '-' | '*' '/' | '=' ;"
;; comments. I'm pretty confident Lisp 1.5 did NOT have these. ;; comments. I'm pretty confident Lisp 1.5 did NOT have these.
"opt-comment := opt-space | comment;" "opt-comment := opt-space | comment;"
"comment := opt-space <';;'> #'[^\\n\\r]*' opt-space;" "comment := opt-space <';;'> #'[^\\n\\r]*' opt-space;"
;; sexprs. Note it's not clear to me whether Lisp 1.5 had the quote macro, ;; sexprs. Note it's not clear to me whether Lisp 1.5 had the quote macro,
;; but I've included it on the basis that it can do little harm. ;; but I've included it on the basis that it can do little harm.
"sexpr := quoted-expr | atom | number | subr | dotted-pair | list | sexpr comment; "sexpr := quoted-expr | atom | number | subr | dotted-pair | list | sexpr comment;
list := lpar sexpr rpar | lpar (sexpr sep)* rpar | lpar (sexpr sep)* dot-terminal | lbrace exprs rbrace; list := lpar sexpr rpar | lpar (sexpr sep)* rpar | lpar (sexpr sep)* dot-terminal | lbrace exprs rbrace;
list := lpar opt-space sexpr rpar | lpar opt-space (sexpr sep)* rpar | lpar opt-space (sexpr sep)* dot-terminal; list := lpar opt-space sexpr rpar | lpar opt-space (sexpr sep)* rpar | lpar opt-space (sexpr sep)* dot-terminal;
@ -99,7 +105,7 @@
;; won't be able to access them. ;; won't be able to access them.
"subr := #'[a-z][a-z.]*/[A-Za-z][A-Za-z0-9]*';" "subr := #'[a-z][a-z.]*/[A-Za-z][A-Za-z0-9]*';"
;; Lisp 1.5 supported octal as well as decimal and scientific notation ;; Lisp 1.5 supported octal as well as decimal and scientific notation
"number := integer | decimal | scientific | octal; "number := integer | decimal | scientific | octal;
integer := #'-?[0-9]+'; integer := #'-?[0-9]+';
decimal := integer dot integer; decimal := integer dot integer;

10
test/beowulf/lisp_test.clj
View file

@ -119,11 +119,11 @@
input "(LENGTH '(1 2 3))" input "(LENGTH '(1 2 3))"
actual (reps input)] actual (reps input)]
(is (= actual expected)))) (is (= actual expected))))
(testing "length of dot-terminated list" ;; (testing "length of dot-terminated list"
(let [expected "3" ;; (let [expected "3"
input "(LENGTH '(1 2 3 . 4))" ;; input "(LENGTH '(1 2 3 . 4))"
actual (reps input)] ;; actual (reps input)]
(is (= actual expected)))) ;; (is (= actual expected))))
(testing "length of assoc list" (testing "length of assoc list"
(let [expected "3" (let [expected "3"
input "(LENGTH (PAIR '(A B C) '(1 2 3)))" input "(LENGTH (PAIR '(A B C) '(1 2 3)))"