LISP I Programmer's Manual - Software Preservation Group

Artificial Intelli~cnce GroupJ. McCarthyR. 13raytonD. I!;dwardoP. FoxL, I'l0di.sD. buckham--K. Mql.ingD. ParkS. RussellCOMPUTATION CENTERandRESEARCH LABORATORY OF ELECTRONICSMassachusetts Institute of TechnologyCambridge, Massachusetts

PrefaceLISP I is a programming system for the IBM 704 for computingwith symbolic expressions, It has been used for symboliccalculations in differential and integral calculus, electriccircuit theory, mathematical logic, and artificial intelligence.This manual contains a full description of the features ofLISP I as of March 1960. The system has a central core basedon a class of recursive functions of symbolic expressions whichshould be studied first and if possible used before the moreperipheral features are tried. This core is described in Chapters2 and 3, and LISP programs can be written and run usingthis core provided someone familiar with the operational aspectsof the system i,e, loaders, tapes etc, is available.Later, the advanced features will be found useful although theyare less neat, and less carefully described.This manual applies also to a version of LISP I being'preparedfor the IBM 709.

Contents1 . Introduction ..................................I...e....2+ Recursive Functions of Symbolic Expressions ............2. 1 Functions and Function Definitions ................2.2 Symbol-ic Expreosions ..............................3 . LISP Primer ....................................I.....e.3.1 Di3fini tion of Fur1ct;ions . 0 . . . . 4 . . . e . . . . . . I a I d 1 * * . .3.2 The Usr: of FuncLions ..............................3.3 Lkbugging .........................................3.4 The Wang Algorithm for the Propositional Calculus .4 . The LISP Programming System ...........................a4.1 The APPLY Operator ................................4.2 Definitions of Functions in LISP ..................4.3 Functions Appropriate to APPLY ....................4.4 Numbers in LISP ...................................4.5 The Program Feature ...............................4.6 he compiler .............................I........5 Running a LISP Program .................................5.1 Card Punching and Submitting a Run ................5.2 Tracing Option ....................................5.3 The Flexowriter System ............................6 . List structures ........................................6.1 General Description ...............................6.2 Association Lists .................................6.3 The Free-Storage List and the Garbage Collector ...7 Example Exercises ......................................8 Error Indications Given by LISP ..~...~e.b8.0s*0.be...~9 . Functions Available in the LISP System .................9.1 General Functions .................................9.2 Special Forms ..................I.................e9.3 Further Functions .......................I........e9.4 Functions in the Supplementary LISP System ........9.5 Alphabetic Index to Functions .....................General Index ..............................................

1, IntroductionThe current basic LISP system uses about 12,000 of the32,000 memory of the 704. It includes routines for reading andfor printing, and it contains many LISP functions either codedin machink language or given as S-expressions (see Chapter 2)for the interpreter part of the system. A list of availablefunctions is included in the manual, and other functions maybe defined by the user. Chapters 2 and 3 of the manual shouldgive the user enough information to enable him to use the basicsys tem.Enlargements of the basic system are available for variouspurposes, The compiler version of the LISP system can be usedto compile S-expressions into machine code, Values of compiledfunctions are computed about 60 times faster than the S-expressionsfor the functions could be interpreted and evaluated,The LISP-compiler system uses about half of the 32,000 memory,For on-line operation using M.I.Tts ~lexowriter-704 system,the basic LISP system can be augmented by a special package ofroutines to control the input-output aspects of the Flexowriter,The Flexowriter version of LISP I does not contain the compileroption.Descriptions of the various features of the LISP system aregiven in the manual together with an explanation of the procedureto be followed in submitting, running, and debugging a programwritten in the LISP language.

2. Recursive Functions of Symbolic Expressions 12The LISP I programming system is based on a class of functionsof symbolic expressions which we now proceed to describe.2.1 Functions and Function DefinitionsWe shall need a number of mathematical ideas and notationsconcerning functions in general. Most of the ideas are wellknown but the notion of conditional expression is believed tobe new, and the use of conditional expressions permits functionsto be defined recursively in a new and convenient way.a. Partial FunctionsA partial function is a function that is defined only onpart of its domain. Partial functions necessarily arise whenfunctions are defined by computations because for some valuesof the arguments, the computation defining the value of thefunction may not terminate. However, some of our elementaryfunctions w i l l be defined as partial functions,1 This chapter is taken from the Quarterly Progress Report No. 53,Research Laboratory of Electronics, M.I.T., April 15, 1959:"~ecursive Functions of Symbolic Expressions and Their Computationby Machine" by John McCarthy,2An article on the same subject by McCarthy is to appear inthe April 1960 issue of the Communications of the Associationfor Computing Machinery.

. Propositional Expressions and PredicatesA propositional expression is an expression whose possiblevalues are T (for truth) and F (for falsity), We shall assumethat the reader is familiar with the propositional connectivesA ("and"), V ("or"), and --.("nottt). Typical propositionalexpressions arex is primeA predicate is a function whose range consists of the truthvalues T and F.c . Conditional ExpressionsThe dependence of truth values on the values of quantitiesof other kinds is expressed in mathematics by predicates, andthe dependence of truth values on other truth values by logicalconnectives. However, the notations for expressing symbolicallythe dependence of quantities of other kinds on truth valuesis inadequate, so that English words and phrases are generallyused for expressing these dependences in texts that describeother dependences symbolically. For example, the function 1x1is usually defined in words.Conditional expressions are a device for expressing the dependenceof quantities on propositional quantities. A conditionalexpression has the form(PI el, + ,Pn en)where the pls are propositional expressions and the els are expressionsof any kind. It may be read, "1f pi then el, other-11 11wise if p2 then e2,. .., otherwise if pn then en, or pl yieldsel,. . . ,pn yields en.I1

expression was, defined, the meaningless expression O* (0-1)!does not arise. The evaluation of 2! according to this definitionproceeds as follows:We now give two other applications of recursive functiondefinitions. The greatest common divisor, e(m,n), of twopositive integers m and n is computed by means of theEuclidean algorithm. This algorithm is expressed by the recursivefunction definition:where - rem(n,m) denotes the remainder left when n is divided by m.The Newtonian algorithm for obtaining an approximate squareroot of a number a, starting with an initial approximation - xand requiring that an acceptable approximation - y satisfy21 y -a I4 6, may be written as- sqrt (a,x,~) = ( Ix2-aIc E1 ax,T + sqrt (a,2(x+f) ,h).)The simultaneous recursive definition of several' functionsis also possible, and we shall use such definitions if theyare required.There is no guarantee that the computation determined by arecursive definition will ever terminate and, for example, anattempt to compute n! from our definition will only succeed ifn is a non-negative integer. If the computation does not terminate,the function must be regarded as undefined for thegiven arguments.

q,T-T)The propositional connectives themselves can be defined byconditional expressions. We writeI ! 1 ,PAq = (p+q,TICF) t f$q = (P T,T+ q)Np = (p + F,T4 T) I -7PX = + (PIt is readily seen that the right-hand sides of the equationshave the correct truth tables. If we consider situations inwhich p or q may be undefined, the connectives A and V are seento be noncommutative. For example, if p is false and q is undefined,we see that according to the definitions given abovepAq is false, but qAp is undefined. For our applications thisnoncommutativity is desirable, since pAq is computed by firstcomputing p, and if p is false q is not computed. If the computationfor p does not terminate, we never get around to computingq. We shall use propositional connectives in this sensehereafter.e. Functions and FormsIt is usual in mathematics - outside of mathematical logic -to use the word "function" imprecisely and to apply it to forms2such as y +x. Because we shall later compute with expressionsfor functions, we need a distinction between functions and formsand a notation for expressing this distinction. This distinctionand a notation for describing it, from which we deviate4trivially is given by Church. I'A. Church, The Calculi of Larnbda-Conversion (prince tonUniversity Press, Princeton, N.J., 1941).

Let f be an expression that stands for a function of twointeger variables. It should make sense to write f(3,4) andthe value of this expression should be determined. The ex-2 2pression y +x does not meet this requirement; y +x(3,4) is nota conventional notation, and if we attempted to define it wewould be uncertain whether its value would turn out to be 132or 19. Church calls an expression like y +x a form. A formcan be converted into a function if we can determine the correspondencebetween the variables occurring in the form andthe ordered list of arguments of the desired function. Thisis accomplished by Church's h-notation.is a form in variables xl, ..., xn, then h ( (xi, . . . ,xn) ,E)Ifwill be taken to be the function of - n variables whose value isdetermined by substituting the arguments for the variablesxl, . . . ,xn in that order in d and evaluating the resulting ex-2pression. For example, A((x,y),y +x) is a function of two2variables, and h((x,y),y +x) (3,4) = 19.The variables occurring in the list of variables of aA-expression are dummy or bound, like variables of integrationin a definite integral. That is, we may change the names ofthe bound variables in a function expression without changingthe value of the expression, provided that we make the samechange for each occurrence of the variable and do not make twovariables the same that previously were different. Thus h ( (x,y),2 2 2y +x),A((u,v),v +u) and h((y,x),x +y) denote the same function.We shall frequently use expressions in which some of thevariables are bound by A's and others are not. Such an expressionmay be regarded as defining a function with parameters.The unbound variables are called free variables.An adequate notation that distinguishes functions from formsallows an unambiguous treatment of functions of functions. Itwould involve too much of a digression to give examples here,

The symbol - a in label(a,e) is also bound, that is, it maybe altered systematically without changing the meaning of theexpression. It behaves differently from a variable bound by aA, however.2.2 Symbolic ExpresSionsWe shall first define a class of symbolic expressions interms of ordered pairs and lists. Then we shall define fiveelementary functions and predicates, and build from them bycomposition, conditional expressions, and recursive definitionsan extensive class of functions of which we shall give a numberof examples. We shall then show how these functions can beexpressed as symbolic expressions, and we shall define a universalfunction apply that allows us to compute from the expressionfor a given function its value for given arguments.Finally, we shall define some functions with functions as argumentsand give some useful examples.a. A Class of Symbolic ExpressionsWe shall now define the S-expressions (S stands for symbolic).They are formed by. using the special characters.)(and an infinite set of distinguishable atomic symbols. Foratomic symbols, we shall use strings of capital Latin lettersand digits. Examples of atomic symbols areAAB AAPPLEPIENUMBER3

There is a twofold reason for departing from the usualmathematical practice of using single letters for atomic symbols.First, computer programs frequently require hundreds ofdistinguishable symbols that must be formed from the 47 charactersthat are printable by the IBM 704 computer, Second, itis convenient to allow English words and phrases to stand foratomic entities for mnemonic reasons, The symbols are atomicin the sense that any substructure they may have as sequencesof characters is ignored, We assume only that different symbolscan be distinguished,S-expressions are then defined as follows:1. Atomic symbols are S-expressions,2. If el and e2 are S-expressions, so is (elce2)Examples of S-expressions areAB(A0B)( (AB-C) OD)An S-expression is then simply an ordered pair, the termsof which may be atomic symbols or simpler S-expressions~ Wecan represent a list of arbitrary length in terms of S-expressionsas follows, The listis represented by the S-expressionHere NIL is an atomic symbol used to terminate lists,Since many of the symbolic expressions with which we dealare conveniently expressed as lists, we shall introduce a listnotation to abbreviate certain S-expressionso We have1, (m) stands for (m0N1~),2. (mlyo9mn) stands for (mlo( ...( NIL) ...)).3. (m,, . . . ,mnox) stands for (mi. a (mn0x) a ) )

Subexpressions can be similarly abbreviated. Some examplesof these abbreviations are((AB,c),D) for ((AB- (c*NIL))* (DONIL))((A,B),c,D*E) for ((A* (B-NIL)) (c- (DOE)))Since we regard the expressions with commas as abbreviationsfor those not involving commas, we shall refer to them all as S-expressions.b. Functions of S-expressions and the Expressions That RepresentThemWe now define a class of functions of S-expressions. Theexpressions representing these functions are written in a conventionalfunctional notation. However, in order to clearlydistinguish the expressions representing functions from S-expressions,we shall use sequences of lower-case letters forfunction names and variables ranging over the set of S-expressions.We also use brackets and semicolons, instead of parenthesesand commas, for denoting the application of functionsto their arguments. Thus we writecar[xlcar[cons[ (A-B);x] 1In these M-expressions (meta-expressions) any S-expressions thatoccur stand for themselves.c. The Elementary S-functions and PredicatesWe introduce the following functions and predicates:1. atomatom[x] has the value of T or F, accordingly as x is anatomic symbol or not. Thus

2, eq - 4eq[x;y] is defined if and only if eLCher x.'dr, y'i's abbmf-d,eq[x;y] = T if x and y are the same symbol, and eq[x;y] = Fotherwise. -Thus3. - carcar[x] is defined if and only if x is not atomic.car[ (e,*e2)] = el. Thuscar[^] is undefined.4. - cdrcdr[x] is also defined when x is not atomic.cdr[ (elgee) 1' = e2. Thuscdr[x] is undefined.icdr[ (x-A) 1 = Ac~~[((x-A)*Y)] = Y5. - conscons[x;y] is defined for any x and y.cons[el;e2] = (el,*e2). Thuscons[~;A] = (x~A)We haveWe havecar cdr and cons are easily seen to satisfy the relations-J - -cons[car[x];cdr[x]] = x, provided that x is not atomic.

I IThe names cart1 and "cons1' will come to have mnemonic significanceonly when we discuss the representation of the systemin the computer. Compositions of - car and - cdr give the subexpressionsof a given expression in a given position. Compositionsof - cons form expressions of a given structure out of parts.The class of functions which can be formed in this way is quitelimited and not very interesting.d . Recursive S-f unc tionsWe get a much larger class of functions (in fact, all computablefunctions) when we allow ourselves to form new functionsof S-expressions by conditional expressions and recursive definition.We now give some examples of functions that are definablein this way.1. - ff[x]The value of ff [XI is the first atomic symbol of the S-expressionx with the parentheses ignored. Thusff[((A*B)*C)] = AWe haveff[x] = [atom[x] x;T + ff[car[x]]]We now trace in detail the steps in the evaluation offfC ((A*B)*c)I:

2. sub~t[x;~;z]This function gives the result of substituting the S-expressionx - for all occurrences of the atomic symbol - y in the S-expression- z , It is defined byAs an example, we have3. equal[x;ylThis is a predicate that has the value T if x and y are thesame 3-expression, and has the value F otherwise. We haveequal[x;y] = [atorn[x]Aatom[y] Aeq[x;y] ]v[-atom[x]~~atom[y] Aequal[car[x];car[y] ]Aequal[cdr[x];cdr[y] 11It is convenient to see how the elementary functions lookin the abbreviated list notation, The reader will easily verifythat(11 car[ (ml,m2, ..., mn)l = mi(ii) cdr[(ml,m2 ,..., mn)l(iii) cdr[ (m) 1 = NIL= (m2,...,mn)(iv) cons[ml; (m,, . . . ,mn) 1 = (ml,m2, a ," n )(v) cons[m;~1~1 = (m)We defineThis predicate is useful in dealing with lists.

y;T~adar[~]';hCompositions of - car and - cdr arise so frequently that manyexpressions can be written more concisely if we abbreviatecadr[x] for car[cdr[x]],caddr[xf for car[cdr[cdr[x]]],etc.Another useful abbreviation is to write list[el;e2; ...; e ]nfor cons[el; cons[ep; ...; cons[e,;~~~]. .. I]. This functiongives the list, (el,. ..,en), as a function of its elements.The following functions are useful when S-expressions areregarded as lists.1. append[x;y]append[x;y] = [null[x] @ @ cons[car[x];append[cdr[x];y~An example isappend[ (A$); (c,D,~)l = (A,B,c,D,E)1)2. among[x;ylThis predicate is true if the S-expression x occurs amongthe elements of the list y. We haveamong[x;y] = -null[y] h[equal[x; car[y] ]vamong[x; cdr[y] 1 13. pair[x;ylThis function gives the list of pairs of corresponding ele-ments of the lists x and y. We havepair[x;y] = [null[x] hnull[y] -+ ~~b;~atom[x]An example isA-atom[y] -+list[car[x];car[y]];pair[cdr[x];cdr[y] 1 ]]pair[ (A,B,c>; (x, (y,z),u)I = ((~3x1, (B, (Y,z)), (C,U))4. assoc[x;y]-one of the uts then assoc[x;y] is the corresponding v.assoc[x;y] = [caar[y] = x @ assoc[x;cdr[y]If y is a list of the form ( (u1,vl), . . . , (un, vn) ) and x iscons[We have1 ]-An example isassoc[x; ( (w, (A,B> 1, (x, (c,D) ) , (Y, (E,F) 1 11 = (0)5.. sublis[x;y]Here x is assumed to have the form of a list of pairs

z;eq[caar[x];z]sub2[x;~];~((u1,vi) . . , (un,vn)), where the uts are atomic, and y may beany S-expression. The value of sublis[x;y] is the result ofsubstituting each v for the corresponding u in y. In order bodefine sublis, we first define an auxiliary function, We haveandWe. havesub2[x;z]h= -+ [null[x] + cadar[x];~+ sub2[cdr[x] ; z 1 .]sublis[x;y] = [atom[y] -+cons[sublis[x; -+y] I;sub~is[x;cdr[yll11car[e, Representation of S-Functions by S-ExpressionsS-functions have been described by M-expressions. We nowgive a rule for translating M-expressions into S-expressions,in order to be able to use S-functions for making certain computationswith S-functions and for answering certain questionsabout S-functions .The translation is determined by the following rules inwhich we denote the translation of an M-expression !.: by g*.2. Variables and function names that were represented bystrings of lower-case letters are translated to the correspondingstrings of the corresponding upper-case letters. Thus car*is CAR, and subst* is SUBST.3. A form f [el;...;en] is translated to (f*,ef,...,e;).Thus (cons[car[x];cdr[x]]>* is (CONS,(CAR,X),(CDR,X)).

[eq[y;zWith these conventions the substitution function whoseM-expression is label[subst;h[ [x;y;z]; -+ [atom[z] 1 -+x;Tthe S-expressionZ];T -C c~n~[subst[x;y;car[z]];subst[x;y;cdr[z]]] I] 1 hasThis notation is writable and somewhat readable. It can bemade easier to read and write at the cost of making its structureless regular. If more characters were available on thecomputer, it could be improved considerably.1f. The Universal S-Function applyThere is an S-function apply with the property that if f*is an S-expression for an S-function f and args is a list of'arguments of the form (argl, . . . , argn), where argl, . . . ,argn arearbitrary S-expressions, then apply[f*;args] and f[argl; ...; argn]are defined for the same values of argl,...,argn, and are equalwhen defined. For example,1Note that the APPLY operator for the 704 version of LISP I asdescribed and used in the rest of the manual is not identicalwith this apply function.

The S-functLon apply is defined byIwhereandapply[f;args] = eval[cons[f;appq[args]];~~~]Iappq[m] = [null[m] + NIL;T -) cons~list[~~~~~;car[rn]];a~~~[cdr[ml I I 1andandWe now explain a number of points about these definitions.

1. apply itself forms an expression representing the valueof the function applied to the arguments, and puts the work ofevaluating this expression onto a function-eval. It uses - appqto put quotes around each of the arguments, so that - eval willregard them as standing for themselves.2. - eval[e;p] has two arguments, an expression e to beevaluated, and a list of pairs p. - The first item of each pairis an atomic symbol, and the second is the expression for whichthe symbol stands.3. If the expression to be evaluated is atomic, - eval evaluateswhatever is paired with it first on the list p. -4. If e is not atomic but car[e] is atomic, then the expressionhas one of the forms QUOTE,^) or ATOM,^) or (~&,e~,e*)or (COND, (pl,eJ, ...,(pn, en) ), or CAR,^ ) or (CDR, e) or CONS,^^,e2) or (f,el, ..., en) where f is an atomic symbol.In the case QUOTE,^) the expression e, itself, is taken.In the case of ATOM,^) or CAR,^) or (cDR,~) the expression eis evaluated and the appropriate function taken. In the caseof (~&,e~,e~) or CONS,^^,^^) two expressions have to be evaluated.In the case of (COND, (pl,el), ...,(pn,en)) the pls haveto be evaluated in order until a true p is found, and then thecorresponding e must be evaluated. This is accomplished byevcon. Finally, in the case of (f,el,. ..,en) we evaluate theexpression that results from replacing f in this expression bywhatever it is paired with in the list p. -5. The evaluation of LABEL,^,^),^^, ..., en) is accom-plished by evaluating (E,el, ..., en) with the pairing LA LABEL,f,g)) put on the front of the previous list p - of pairs.6. Finally, the evaluation of ( (LAMBDA, (xi, . . . , xn) ,&) ,el,. . . ,en) is accomplished by evaluating g with the list ofpairs ((xl,ei), . . ., (xn,en)) put on the front of the previouslist p. -

The list p - could be eliminated, and LAMBDA and LABEL expressionsevaluated by substituting the arguments for the variablesin the expression E . Unfortunately, difficulties involvingcollisions of bound variables arise, but they are avoided byusing the list - p.g. Functions kt.h Functions as ~rgumentsThere are a number of useful functions some of whose argumentsare functions. They are especially useful in definingother functions. One such function is maplist[x;f] with an S-expression argument x and an argument f that is a function fromS-expressions to S-expressions. We defineThe usefulness of mgplist is illustrated by formulas for thepartial derivative with respect to x of expressions involvingsums and products of x and other variables. The S-expressionsthat we shall differentiate are formed as follows.I' An atomic symbol is an allowed expression.2. If el,e2, . . . ,en are allowed expressions, PLUS,^^, . . . ,en)TIMES,^^, . . . ,en) are also, and represent the sum and product,andrespectively, of el,...,en. 1This is, essentially, the Polish notation for functions, exceptthat the inclusion of parentheses and commas allows functionsof variable numbers of arguments. An example of an allowedexpression is1For more exact information on arithmetic functions see Section 9.4.

TIMES,^, (PLUS,X,A),Y), the conventional algebraic notation forwhich is X(X+A)Y.Our differentiation formula, which gives the derivative ofy with respect to x, isdiff [y;xl = [atom[yl + [eq[y;x] + 0NE;T ~~R~];eq[car[y];PLUS] cons[~L~~;rnaplist[cdr[y];~[[z];diff[car[zl;xll~ l;eq[car[y];T~ME~] cons[~L~~;maplist[cdr[y];h[ [z];cons[~~MES;rnaplist[cdr[y];~[[w~;~eq[z;wl -+ -+ car[w];T diff [car~u?l;xllI,] 11.1 1The derivative of the allowed expression, as computed bythis formula, is (PLUS, (TIMES, ONE, (PLUS, X, A) ,Y) ,(TIMES, X, (PLUS,ONE,ZERO),Y), TIMES,^, (PLUS,X,A),ZERO))Besides maplist, another useful function with functionalarguments is search, which is defined asThe function search is used to search a lsit for an element thathas the property p, and if such an element is found, - f of thatelement is taken. If there is no such element, the function - uof no argument is computed.

3. LISP PrimerThe features of LISP described in this section permit theuser to define a number of S-functions and then compute the resultsof applying them to arguments.3.1 Definition of FunctionsIn,order to define functions we punch the following (usingcolumns 1-72 of as many cards as are necessary):DEFINE (((name of first function, definition of first function),(name of, second function, definition of second function),. .(name of last function, definition of last function)1 1 (1For example, if we wish to define the functions - ff, -9 altand subst given byff [XI = [atom[x] + x;T -+ ff [car[x] 1 ]alt[x] = [null[x]~null[cdr[x]] + x;T4 cons[car[x];alt[cdr[cdr[xlllllsubst[x;y;z] = [atom[z] + [eq[y;z] + x;T + z];~ -) cons[subst[x;y;car[z]];subst[x;y;cdr[z]]]]we writeDEFINE ( ((FF (LAMBDA (x) (COND ((ATOM X) X) (T (FF (CAR x))))))(ALT LAMBDA (x) (COND ((OR (NULL X) (NULL (CDR X)) ) X)(T (CONS (CAR X) (ALT (CDR (CDR X) ) ) ) ) ) ) )

(SUBST (LAMBDA (X Y Z) (COND( (ATOM Z) (COND( (EQ Y Z) X)(T 2))) (T (CONS (SUBST x Y (CAR z)) (SUBST x Y (CDR 2)))))))1 1 (1A few discrepancies between the situation as it is andwhat might be expected from the previous chapter should benoted1. The commas in writing S-expressions may be omitted.This is an accident.2. According to the definition of apply in the previouschapter one would expect to have to write (QUOTE T) in designatingthe left-over case in a conditional expression. Forconvenience, our - apply allows (and in fact requires) that T bewrit ten instead.3. The predicates - null V A and ware built-in. We write(NULL X) and (OR pl pp ... pn) and (AND pi pg p ) and (NOT p).4. The dot notation e.g. (A-B) is not allowed in LISP I.Function definitions may involve other functions which areeither built-in or are defined earlier or later.3.2 The Use of FunctionsAfter the cards which define functions we can put cardswhich cause their values to be computed and printed for givenarguments. This is done by writing a tripletfunctionlist of argumentsp-listIn the simplest case the p-list is null and is written ().For example, in order to compute subs t [ (x, A) ; X; ( (x, A), X) 1 wewriteSUBST ((xA)X ((xB)X)) (1

The answer ( ((x A) B) (X A) ) will be printed,3.3 DebuggingThe main debugging tool is the pseudo-function tracklist.If you put a cardTRACKLIST (fi fp ... fn) (>after the cards which define the functions fl, ..., fn and beforethe functions are used in computations, the computer will printthe arguments and values of fl,,..,fn each time they are usedrecursively in a computation, tracklist acts as a tracing program,but usually it is not necessary to trace more than one ortwo functions.3.4 The Wang Algorithm for the Propositional CalculusAs an extended example of the use of a succession of functiondefinitions to define an algorithm we give a LISP formulationof an algorithm for deciding whether a formula is a theoremof the propositional calculus published recently by Hao Wang. 1Readers completely unacquainted with propositional calculusshould probably skip this example,1Wang, Hao . "~oward Mechanical at he ma tics " , IBM Journal ofResearch and Development, Vol. 4, No. 1, January 1960

2(1) The Wang Algorithm . We quote from pages 5 and 6 ofWangfs paper.11The propositional calculus (~ys tem P)Since we are concerned with practical feasibility, it is preferableto use more logical connectives to begin with-when wewish actually to apply the procedure to concrete cases. Forthis purpose we use the five usual logical constants (not),& (con junction, V (disjunction), 3 (implication, (biconditional),with their usual interpre tati ons.A propositional letter P, Q, R, M or N, et cetera, is aformula (and an "atomic formula"). If , L/f are formulae, thenV , a o u a- ,~f T, pare strings of formulae (each, in particular, might be an emptystring or a single formula) and 4 is a formula, then a, $) , Pis a string and n-*P is a sequent which, intuitively speaking,is true if and only if either some formula in the string -r (the"antecedent") is false or some formula in the string p (theItconsequent") is true, i,e., the conjunction of all formulae inthe antecedent implies the disjunction of all formulae in theconsequent.There are eleven rules of derivation. An initial rulestates that a sequent with only atomic formulae (propositionletters) is a theorem if and only if a same formula occurs onboth sides of the arrow, There are two rules for each of thefive truth functions--one introducing it into the antecedent,2This example is an excerpt from Memo 14 of the Artificial IntelligenceProject--R.L.E. and M.I,T. Computation Center, byJohn McCarthy, The Wang Algorithm for the Propositional CalculusProgrammed in -- LISP,

one introducing it into the consequent. One need only reflecton the intuitive meaning of the truth functions and the arrowsign to be convinced that these rules are indeed correct. Lateron, a proof w i l l be given of their completeness, i.e., allintuitively valid sequents are provable, and of their consistency,i.e., all provable sequents are intuitively valid.PI. Initial rule: if A, Y are strings of atomic formulae,then A is a theorem if some atomic formula occurs onboth sides of the arrow.In the ten rules listed below, h and % are always strings(possibly empty) of atomic formulae. As a proof procedure inthe usual sense, each proof begins with a finite set of casesof PI and continues with successive consequences obtained bythe other rules. As will be explained below, a proof looks likea tree structure growing in the wrong direction. We shall, however,be chiefly interested in doing the step backwards, therebyincorporating the process of searching for a proof.The rules are so designed that given any sequent, we canfind the first logical connective, i.e., the leftmost symbolin the whole sequent that is a connective, and apply the appropriaterule to eliminate it, thereby resulting in one or twopremises which, taken together, are equivalent to the conclusion.This process can be repeated until we reach a finite setof sequents with atomic formulae only. Each connective-freesequent can then be tested for being a theorem or not, by theinitial rule, If all of them are theorems, then the originalsequent is a theorem and we obtain a proof; otherwise we get acounterexample and a disproof. Some simple sampIes w i l l makethis clear,

h,l/f,p,thenzh,,wc#),~.For example, given any theorem of "~rincipia", we can auto-matically prefix an arrow to it and apply the rules to look fora proof, When the main connective is 3, it is simpler, thoughnot necessary, to replace the main connective by an arrow andproceed.For example:-can be rewritten and proved as follows:*2.45, (PVQ) 3 -P(1)-+ -P,PvQ'(2) P " PVQ(3) J? -, P,QVALIDu5.21. +YP&-Q* 3.1' i)( I ) N P $ - ~ - + I ~ ~ Q(2) -P, -Q + 1' -" 13,(3)%~+ P Z Q,P(4) +P5 Q,P,:2(5) p3 Q,P,QVALID(5) Q -, P,P,QVALIDP2a. Rule-+-: 1f4, 5 -+h,p,thcnG -+P2b. R u l e : If A, P4u,$,then A,-~,P+R.P3a. Rule -+& : If -+A,$,P alld 3 ++P3b. ~ u l e . I 4 ~ If h,c#,l/,~-+a,then A,~C!V,P+R.A ,~&$P.~4a. Rule4V : If 5 4~,4,y,~,then'-c4h,4~v,~.P4b. Rule V 4 : If A,$,P4n and h,v,f4?r,then A,$V$P"R.

h,~~,pand)Y,SP5a. Rule4>: If j,++h,ly,f,then3 w~,b>q,~.P5b. Rule>+: If h,I/f,pw~and h,P+~,q,thenh,$2v,P+rr.P6a.~6b.Rule +=: 1f 9,s ++ h,cfi~,p,thenS 4 h,Q~*p.~f~,~,h,~+~andh,P~a,$,~,thenh,~~\Y,9(2) The LISP Program. We define a function theorem [s]whose value is truth or falsity according to whether the sequent,- s is theorem.The sequent-is represented by the S-expressionwhere in each case the ellipsis ... denotes missing terms, andwhere y* denotes the S-expression for 9.Propositional formulae are represented as follows:1. For "atomic formulae" (Wangls terminology) we useItatomic symbols l1 (LISP terminology) ,2, The following table gives our "cambridge ~olish" wayof representing propositional formulae with given main connectives.1. W Cf becomes (NOT, y*)2 . ~ 4 becomes ~(AND, 9% y*)3. 9 V becomes (OR, y*, p)4. 3 y becomes (IMPLIES, v*, *)5. 9 Y/ becomes (EQUIV, Cf*, p)Thus the sequentY P & &Q4is represented byPf Q,RVS(ARR~W,((AND,(N~T,P>,(NOT,Q))),((EQ~I~,P,Q),(~R,R,~)))

c1;Tth2[al;a2;th[al;th2[al;a2;thi?[car[a2];The S-function theorem-[s] is given in terms of auxiliaryfunctions as follows:theorem [s] = thl[~~~;~~~;cadr[s];caddr[s]]-th2[al;a2; cl; c2; c] = -+ [null[c] a2; cl; c2];atom[car[c] 1 @ [member[car[c1;clI @ cons[car[c];cl]];c2;cdr[c] 1; T @ cl; [member[car[c] ; c2] -+ c2;T + cons[car[cl;c2] ];cdr[c]]]th[al; a2; cl; c2] = [null[a2] -) wnull[c2] ~thr[car[c2] ;al;a2;cl;cdr[c2] 1;T @al; cdr[a2]; cl;c2] 1th is the main predicate through which all the recursionstake place. theorem, - thl and - th2 break up and sort the informationin the sequent for the benefit of - th. The four argumentsof th are:al: atomic formulae on left side of arrowa2: other formulae on left side of arrowcl: atomic formulae on right side of arrowc2: other formulae on right side of arrowThe atomic formulae are kept separate from the others inorder to make faster the detection of the occurrence of formulaon both sides of the arrow and the finding of the next formulato reduce. Each use of - th represents one reduction according

to one of the 10 rules. The formula to be reduced is chosenfrom the left side of the arrow if possible. According towhether the formula to be reduced is on the left or right weuse thj or thr. We have - -tha[u; al; a2; cl; c2] = [car[ u] = NOT -* thlr[cadr[u] ;al; a2; cl; c2];car[ u] = AND -) th2a[cdr[u] ; al; a2; cl; c2] ;car[u] = OR 4 thla[cadr[ u] ;al; a2; cl; c2] /\thlj[caddr[u] ; al; a2; cl; c2] ;car[ u] = IMPLIES thla[ caddr[u] ; al; a2; cl; c2] /\thlr[cadr [ u] ; al; a2; cl; c2] ;car[ u] = EQUIV -* th2a[cdr[u] ; al;a2; cl; c2] hth2r[cdr[ u] ; al; a2; cl; c2] ;T error [ list [ THL; u; al; a2; cl; c2] ]thr[ u; al; a2; cl; c2] = [car[u] = NOT -' thl.8[cadr[u] ; al; a2; cl; c2];car[u] = ANDthlr[cadr[ u] ; al; a2; cl; c2] ~thlr[caddr[u] ; al; a2; cl; c2] ;car[u] = OR -' th2r[cdr[u];al;a2; cl; c2];car[ u] = IMPLIES -) thll[ cadr[ u] ; caddr[u] ; al; a2; cl; c2] ;car[u] = EQUIV4 thll[cadr[u];caddr[u];al;a2;cl;c2]~thll[caddr[u] ; cadr[ u] ; al; a2; cl; c2] ;T error[^^^; al; a2; cl; c2] ] ]The functions thla, thlr, th21, th2r, thll distribute theparts of the reduced formula to the appropriate places in thereduced sequent.These functions arethla[v;al;a2; cl;c2] = [atom[v] + member[v; cllvth[cons [v;al]; a2; cl; c2] ;T -* member[v; c21~th[al;cons[v;a2];cl;c2] 1

member[v;a2]~member[v;al]Vmember[vl;thlr[v;al;a2; cl; c2] = [atom[v] @th[al;a2; cons[v; cl]; -+ c21;Tth[al; a2; cl; cons [v; c2] 1 1th2&[v;al;a2; cl; c2] = [atom[car[v] ]@ member[car[v]; cl]~thl&[cadr[v];cons[car[v];al];a2;cl;c2];T -C member[car[vl;c2]~thl&[cadrEv];al; cons[car[v];a2]; cl; c2] 1th2r[v;al;a2;cl;c2] = [atom[car[v] ]-) member[car[v];al]Vthlr[cadr[v];al; a2; cons[car[v]; cl]; c2] ;T member[car[vl;a2]~thll[vl; v2; al; a2; cl; c2] = [atom[vl] -) member[vl; cl] vthlr[v2; cons[vl;al];a2; cl;c2] ; -+ T c2]Vthlr[v2; al; cons[vl; a21 ; cl; c2] 1Finally the function member is defined by(3) The LISP Program as Written in S-expressions. In thissection we give the translation of the functions of the precedingsection into S-expressions, Note that spaces are used inplace of commas.We haveDEFINE: (((THEOREM (LAMBDA (S ) (THI NIL NIL (CADR S ) (CADDR S ) ) ) )

(~111(LAMBDA( ~1 A2 A C) (COND ((NULL A)( T H ~ A1 A2 NIL NIL c)) (T(OR (MEMBER (CAR A) C) (COND ((ATOM (CAR A) i(TH~(COND ((ME~~XR(T (CONS (CAR A) ~ 1 ) )(CAR A) ni ) u)) A2 ( ~ ~ A) 1 3 c))(T (THI AL (COND ((M~sMT~P:~ (CAR A) A;!) ~ 2 )(T (CONS (CAR A) ~ 2 ) ) )(CDR A) c))))))))(TH2 (LAMBDA (AL A2 C1 C2 C) (COND((NULL C) (TH Al A2 C1 ~ 2 ) )((ATOM (CAR C)) (~112 A1 A2 (COND((MEMBER (CAR C) ci) CI) (T(CONS (CAR C) c1) )) c2 (CDR c)) )(T (TH~ A1 A2 C1 (COND ( ( ~ ~ ~ 1 3 1 2 ~(CAR C) c2) c2) (TI (CONS (CAI{ C) c2) ) )(CDR c))))))(THL (LAMBDA (U A 1 A2 C1 C2) (COTTII((EQ (CAR U) (QUOTE NOT)) (ril~~i~ (CAIIII 11) AI. A:? CI- c:?))((EQ (CAR U) (QUOTE AND)) (~1121;( ~ 1 U) 1 ~ A 1 A2 C l ~ 2 ) )( (EQ (CAR U) (!>UOTIS OR) ) (AND (TII~L(CADR U) A1 A2 C1 C2)(THIL (CADDII U) A1 A2 C1 ~ 2 )) )( (EQ (CAR U) ([.)UOT~S IMPLIES) ) (AND (TIIIL (CADDR U) AL A? clc2) (TH~R (CADR u) nl ~2 ci cz) ))((EQ (CAR U) (QUOTI< E~UIV) ) (AND (TH~L(CDR U) A1 A2 C1 ~ 2 )(TH~R(CDR U ) 41 A2 C1 ~ 2 ) )(T (ERROR (~13'1'(~UOTETIIL) U A1 A2 C1 C2) ) )1))

(TH~L(LAMBDA(V A1 A2 C1 C2) (COND( (ATOM V) (OR (MEMBER v CI)(TH (CONS V Al) A2 C1 C2) ) )(T (OR (MEMBER V C2) (TH A1 (CONS V A2) C1 C2) ))1))(TH~L(LAMBDA(V A1 A2 C1 C2) (coND( (ATOM (CAR V) (OR (MEMBER (CAR V) CI)(THIL (CADR V) (CONS (CAR V) Al) A2 C1 ~ 2 )))(T (OR (MEMBER (CAR V) c2) (THIL (CADR V) AL (CONS (CAR V)A2) C1 ~ 2 ) ) )1)

This causes the functions mentioned to be defined.In our test run we next gaveTRACKLIST ((TH)) ()which caused the arguments and values of the function - th to beprinted each time the function came up in the recursion. Accidentally,it turns out that these arguments essentially constitutea proof in Wangfs style of the theorem.In order to apply the method to the sequent- P Pvqwe writeTHEOREM((ARR~W, (PI, ((~R,P,Q))))(>The APPLY operator, for each theorem and argument, evaluatesthe proposition and gives the answer as either true (T)

or false (F).Thus the LISP function theorem in itself suffices to applythe wang algorithm to any trial proposition and determinewhether or not the proposition is a tautology.

4. The LISP Programming SystemIn this section are included descriptions of the mainfeatures of the LISP system. The various ways of defining andevaluating symbolic expressions for functions are given, andsome discussion is added on the use of numbers in LISP. Theprogram feature, which is a somewhat FORTRAN-like feature, isexplained, and finally the LISP compiler is described.4.1 The APPLY OperatorThe basis of LISP programming is the APPLY operator whichisa synthesis of the apply and - eval functions described inChapter 2, The APPLY operator is the interpreter part of theLISP system in the sense that S-expressions representing functionsand their arguments are read, interpreted and evaluatedby apply, The apply now in use is a function of three arguments,wheref = an S-expression representing an S-function f ofn arguments; n3O.x = a list of n argumentsp = a list of pairs, each of the form (atomic symbol,value), used to assign values to free variables.The value of apply[f;%;p] is the value of the S-function, # ,evaluated at x, where the values assigned to any free variablesare the values paired with the corresponding variables on thep-list

As a simple first example consider the functionapplied to the listwhere no free variables need to be assigned. The argumentsf,x, and p for the apply function, written in the form of S-expressions, are,and the value of apply[f;x;p] is (A,D),Note that the p-list must be included even though it isthe NIL list,Example 2:Some care must be exercised in writing the lists x and pcorrectly. In the example,f: CARx: ( (A,B))P: ( 1where apply[f;x;p] = car[ (A,B) 1 = A,since - car is a function of one variable, the list x must bewritten as ((A,B)) where (A,B) is the single argument. Thelist,-would be wrong. Note also that the LAMBDA definition is notneeded in this example since the specification of the argumentsis clear, It would be correct but unnecessary to write

Example 3:The following example, on the other hand, involves twoarguments .givingf: CONSx: ((A),(B))P: ( )The exact descriptions of function formats acceptable to theAPPLY operator are discussed further in Section 4.3.Example 4:As an example involving a p-list we haveIn this example, the A-specified argument, Y, is given as A bythe argument list x, and the free variable, 2, is set by theP-list to (B).Example 5:The following example involves a recursive function sothat a label definition is required:

where apply[f;x;p] = subst[ (A,B);D;(,(D,c),D) 1 = (((A,B),C), (A,B))Note: The system for translating M-expressions into S-expressionsgiven in Chapter 2 would give rise to (QUOTE,T) in lieuof T in the above S-expression. It is simpler to be able towrite T (or F) and so in LISP I the latter usage is required.(QUOTE,T) and (QUOTE,F) must be replaced by T and F respective-'ly, and only the latter expressions will work,A prografi for the LISP system consists of sequences off;x;p triplets strung together, The APPLY operator automaticallyoperates on each triplet in turn and returns with the valueof the triplet. The 'details for submitting and running such aprogram are given in Chapter 5,4.2 Definitions of Functions in LISP-In Chapter '2 functions are connected to their names onlythrough the use of the form LABEL.In the current LISP system,there are two further ways a function can be defined:The first of these relates to functions defined in thesystem by machine-language subroutines,Such a subroutine fora function may be already available as part of the LISP systemitself, in which case it appears among the functions given inSection 9, or it may have been produced by the LISP comp3ler.

In either case, if a machine-language subPoutine.def$nesa function, the association list for the name of the function(see Section 6.2) contains the indicator fSUBRf to indicatethat a subroutine exists. SUBR in turn points to a transferinstruction of the formTXLsubroutine , , nwhere n is the number of arguments of the function.Thus the relevant part of the association list has thestructure,.. SUBR 1-1 .Ia mTXL subroutine , , nThe other way a function can be defined is by means of aLISP S-expression (representing an M-expression), which is tobe interpreted during the running of a LISP program. In thiscase the indicator 'EXPR' is on the association list for thename of the function. EXPR points to the S-expression definingthe function, as follows:L(S-expressiondefining the function)

A function defined by an EXPR may be already available in theLISP system itself, in which case it appears among the functionsgiven in Section 9, or it may be defined by the user byusing the define function, Define is a pseudo-function (seeSection 4.3) whose effect is to assign definitions of the EXPRsort to functions. The atomic symbol for the name of eachfunction to be defined must be paired with the S-expression definingthat function. A list of such pairs is then given asthe argument for define, The APPLY operator acting on defineof this argument creates, for each function defined, the EXPRstructure shown above.If EXPR is already on the association list for a function,it is changed to point to the new S-expression, so that thedefine is really a redefine .Consider for example the two functions, ff and alt dis- - -cussed in Chapter 3,andThese are defined by letting the APPLY operator evaluate thefollowing triplet, f;x;p, where x is a list of two pairs.f: DEFINE,x: (((FF, (LAMBDA, (x),(C~ND((ATOM,X),X),(T,(FF, ( ~~~3x1) ) ) ) ),(ALT,(LAMBDA,(X),(COND,( (OR, (NULL, x ) ,(NULL, (CDR,X>) 1 ,X), (T, (CONS, CAR,^),(ALT, (CDR, (~DR,x> 1) ) >) 1) 1)P: ( 1

Note that the argument x starts with three parentheses: thefirst parenthesis starts the list x, the second indicates thatx is a list of one argument, and the third starts the first pair.After APPLY has evaluated this triplet, the define function willhave put the respective definitions, labelled by EXPR, on theassociation lists of the atomic symbols FF and ALT. Of course,define itself is one of the functions already defined and availableas part of the LISP system.Incidentally, a function can be defined in terms of anotheralready-defined function--in which case the S-expression becomessimply the name of the established function. For examplesuppose one wishes to define the function FRST by the pair(FRST,CAR). After the define has been applied, the associationlist for FRST w i l l contain the structureCARwhere CAR points to the already-established association listfor CAR. Chains of definitions of this sort are perfectly legalin LISP I.The function define makes the use of label desirable onlywhen the labeled function is itself the result of a computationand is not to be put on an association list for storage reasons.4.3 Functions Appropriate to APPLYVarious kinds of functions can be used in LISP programming.One way of classifying functions is to divide them intofunctions and pseudo-functions, A function in LISP is evaluatedfor its value as such, e.g. car[ (A,B,C)] = A, whereas a pseudo-

function is used for its effect rather than its value, e.g.define or compile. There is no difference in form however betweenfunctions and pseudo-functions.In this section the classifying distinction will be madeinstead on the basis of the form of the functions; there areatomic functions and compound functions, If the f of the f;x;p triplet for the APPLY operator can be stated as an atomicsymbol, the function is called atomic. A l l other legal formsfor f are grouped under the heading of compound functions andare discussed below, An atomic function is not necessarily asimple or trivial function; it might be defined by a complicatedsubroutine or S-expression occurring on its association list.Atomic FunctionsWhen the APPLY operator evaluates a function which isatomic, that is, represented by an atomic symbol, it searchesthe association list of the atomic symbol for either SUBR orEXPR (see Section 4,2 just preceeding). If either is found,the function description which it points to, represented by asubroutine or an S-expression respectively, is used to evaluatethe atomic function of x (the list of arguments). Ifneither SUBR or EXPR is found on the association list for thefunction, then the p-list is searched for the function's atomicsymbol, and the expression paired with the symbol is used toevaluate the atomic function of x.Com~ound FunctionsIf a function is compound it is represented by an S-expres-

sion whose first element may be LAMBDA, LABEL, or FUNARG. 1Before treating the different types in detail we recallfrom Chapter 2 that "1f is a form in (the) variables. .X 1 9 " 0 0 ~ x n ~ thenwill be taken to be the function of n variables whose value isdetermined by substituting the arguments for the variablesxl, - .,x nin that order in $ and evaluating the resulting expression,I IFor LABEL, on the other hand, from Chapter 2 we have "1norder to be able to write expressions for recursive functionswe introduce another notation: label(a,g) denotes the expression6 , provided that occurrences of - a within are to beinterpreted as referring to the expression as a whole. IIFUNARG has not been discussed previously; it was introducedfor convenience in writing the 704 system. Generallyspeaking, the use of FUNARG is internal to the system and neednot concern the user, Its purpose is to tie the correct p-listof pairs to the function on which apply is operating. The followingequivalence holds exactly:apply[ (FuNARG,~,~);~;~] = apply[f;x;ql,where q is the list of pairs to be used in place of p in evaluatingf[x].-1If some different element is used here, or if parentheseshave been used incorrectly, the APPLY operator will usuallyfail.

When the APPLY operator evaluates a compound function, itdetermines first of all which of the three possible cases isinvolved.If the S-expression for a compound function begins withLAMBDA, the triplet for the APPLY operator will bef: (LAMBDA, (xi, x2, . . . , XN ) ,5 )X: (YI,Y~, . . . ,YN)P: (list of pairs)1The APPLY operator pairs the dummy variables , Xl,X2, ..., XN,with the values given on the list of arguments, x. If the twolists are not of the same length an error stop occurs. Otherwisethe list of pairs is added to the front of the p-list.Then the third element of the LAMBDA list, the form g for thefunction, is evaluated using the enlarged p-list of pairs ofassigned values.The form in the LAMBDA expression can be either anatomic symbol or a longer S-expression. The following casescan occur:5 = atomic symbol: The APPLY operator searches the associationlist of the atomic symbol to see if it represents a constant(signalled by either IAPVAL1 or 1APVALl1 on the associationlist--cf. Chapter 6), and if so the value of fis that constant. If the atomic symbol does not representa constant, the p-list is searched for the most recentpairing of this atomic symbol, and the value given by thispairing is the value of f. Otherwise an error is indicated,(see Chapter 8).AThe list of dummy variables can be the null list, ( ).

5 = (atomic function, arguments): Cf. Example 4, Section 4.1--the APPLY operator evaluates the atomic function as describedpreviously, and the result is the value of f.5 = (special form, arguments): See the description below ofspecial forms. The value of f is the value given by APPLYafter evaluating the special form.= (atomic symbol): Note the difference between this whichis enclosed in parentheses and the first given above,The APPLY operator performs the function given within theparentheses. For example % = (READ), when operated on byAPPLY would cause a list to be read from cards.5 = (LABEL, t ,F): The APPLY operator carries out the evaluationof the compound LABEL function as described below.The value of f as given by APPLY is the labelling name, t.Recall that in all the LAMBDA cases, the dummy variableshave been paired and put on the p-list before the formis evaluated,If the S-expression for a compound function begins withLABEL, the triplet for the APPLY operator will bef: (LABEL,name,definition)x: (list of arguments)P: (list of pairs)(see Example 5, Section 4.1) The APPLY operator pairs the atomicsymbol for the name of the function (the second element inthe LABEL list), with the definition and adds the pair to thefront of the p-list, It then applies the definition to the listof arguments x using the enlarged p-list, and the result is thevalue of the function.

Note on Special Forms:Certain forms are classified under the heading of specialforms and are evaluated differently from the usual case. Ifthe first element of an S-expression is one of the specialforms, the rest of the elements in the S-expression are treatedin special ways described below under the particular cases. Aspecial form is signalled by either FSUBR or FEXPR in place ofSUBR or EXPR on the association list. Note that special formscannot be used for the atomic functions discussed above.QUOTE is a special form of one argument that prevents itsargument from being evaluated, The value of a list beginningwith QUOTE is always the second element of the list,COND is a special form which is a conditional expression.The part of the S-expression following COND is an arbitrarynumber of arguments, each of which is a pair: For each pairthe first element is the proposition and the second element ofthe pair is the corresponding expression. The propositions areevaluated in sequence from left to right, until one is foundthat is true, and then the expression corresponding to this propositionis evaluated and taken as the value of the entire conditional.If there are no propositions that are true, an erroroccurs.- AND is a special form to test if all of the propositionalexpressions following AND in the list are true, The propositionsare evaluated in sequence until one is found that is false oruntil the end of the list is reached, The value of AND is respectivelyF or To-OR is a special form to test if any of the propositionalexpressions following OR in the list are true. The propositionsare evaluated in sequence until one is found that is true or untilthe end of the list is reached. The value of OR is respectivelyT or F,

- PROG is a special form described under the program featurein Section 4.5.Other special forms are described in Section 9.2.4.4 Numbers in LISPLISP I1 will be able to handle both integers and floatingpointnumbers, but in LISP I integers are not allowed.Floating-point numbers in LISP I can be added, multipliedand raised to a power. The three functions available for thesepurposes are -, sum prdct, -, expt and are described in Chapter 9.The association lists for floating-point numbers alwayscontain the designation IFLO' for float. Floating-point numbersdo not appear 'on the list of atomic symbols (see Section6.2), but on a list of floating-point numbers. These list entriespoint to the association lists for the numbers themselves.If a number is negative the indicator, 'MINUS1 precedesthe association list for the number. The detailedstructure of association lists for floating-point numbers isdiscussed in Section 6.2.Numbers are brought into a LISP program by being definedwithin S-expressions, and they must always be quoted. For examplethe following expression is correct,where X stands for a floating-point number which is, for example,paired with X on the p-list.The exact rules for punching floating-point numbers forthe LISP I read program are:1) A decimal point must be included but not as the firstsymbol :

IncorrectCorrect6 6. or 6.000 0 0 0.42 0.42.003 0.0032) A dlus sign or a minus sign may precede a number. Theplug Bign is not required,,. I3) Exponent indication may be used. The power of ten ispreoeded by a sign and may contain one or two digits. Thus4.21+10 represents 4.21r10~~26.-2 represents 26%10-~4) Numerical values must be less in absolute value then2228 ~,i10~~ ) ,5) Significance is limited to eight decimal digits.As an example of the use of numbers in LISP I consider theTurSqtion- - ..,., . length. which finds bhe number of elements in a list.IbB, definition, in S-expression form, is4.5 The Program FeatureThe program feature in LISP allows sequences of operations(statements) to be expressed in LISP language. The effect israther like a FORTRAN program with LISP statements. Each statementmay be a form to be evaluated, or an atomic symbol, or axist beginning with GO or RETURN. The atomic symbols are usedas location markers within the program.

When a list beginning with GO is encountered, the rest ofthat list is evaluated under the assumption that the value willbe one of the location-marking atomic symbols, Then a searchis made of the program for this symbol, and when it is foundthe statements following the locating symbol are executed.conditional expression to allow conditional branching may beused in a GO listoIf a list beginning with RETURN is encountered, the restof the list is evaluated and the resultant value is the finalvalue of the entire program.The other statement forms appearing in a program are evaluatedin sequence but the resulting values are ignored, This im-plies that these forms are important mainly for their actions,such as changing lists of various sorts, rather than for theirvalues.A program form has the structure,(PROG,L, sequence of statements)where PROG signals to the APPLY operator that a program for se-quential execution is to follow, The list L is a list of programvariables which are handled in a manner similar to thatfor dummy variables, although the two types must be disti.nguishedoThe sequence of statements is the program to be executed.The program variables are set equal to NIL at each (non-recursive) entrance to the program, but their values may bechanged at any point whatsoever in the computation. For ex-ample programs can occur within other (hfgher-level) programsand in such cases an inner program can change any program variableof a higher-level program as well as its own program varfables.The functions available for changing program variables are - setand - setq, The function - set is a function of two variables bothof which are evaluated. Thus to set a program variable V equalA

to the value of an expression E, the V must be quoted in theThe function setq on the other hand treats its first argumentas if quoted and evaluates its second argument only.S-expression becomesThus the(SETQ,V,E)~which is entirely equivalent to the previous, and usually moreconvenient.The following is an example of a program using the programfeature. It is a version of search, (see Chapter 2).Although the entire program is in the form of a large list, forease of reading it has been spaced out below in the form of asequential program, with the location-marking atomic symbolsset out to the left, The program variable is LT.expression for this program for the APPLY operator is,(LAMBDA, (L,P,FN,u>, (PROG,(LT),(SETQ,LT,L),TEST, (GO, (COND, ( (NULLCONT, (GO, (COND, ((P,LT), (QUOTE,RETF)),STEP, (SETQ,LT, (@DR,LT)),GO, (QUOTE, TEST) ) ,RETU, (RETURN, (u) ),RETF, '(RETURN, (FN, L ) )1)The LAMBDA,LT) , (QUOTE ,RETU) ) ,(T,(QuoTE, CONT) ) ) ) ,(T,(QUOTE,STEP)))) ,In the above note that a function of no arguments, such asu, must be put in parentheses in order to be evaluated, Cf, (u)in the line starting with RETU,

Since the program feature will be used frequently in themanual to describe LISP functions, and since M-expressions areeasier to read than S-expressions, programs will usually bewritten down in M-type notation. Program variables will begiven in lower case, but the atomic symbols used as locationmarkingsymbols will be retained in capital letters. The expression(SETQ,X;Y) becomes x = y.Using these rules and other obvious extensions of them the a-bove program is written as follows:program for search[a;p;fn;u] with program variables at:TESTCONTSTEPRETUat = ago[null[at] -* RETU;T -* CONT]go[p[at] -* RETF;T -* STEP]at = cdr[a]go [TEST]return[u]RE TF return[fn[a] ]4.6 The Com~ilerThe LISP compiler is itself a pseudo-function which isavailable to the APPLY operator. The compiler is called in bythe LISP function,where x is a list of names of the functions to be compiled.Each function on the list will be compiled into a binary ma-chine program provided the function is defined on its associationlist by an indicator EXPR pointing to an S-expression.

The value of comdef is a list of the names of the functions itwas able to compile.The compiler proceeds in three stages1) Generation of LISP-SAP2) Generation of binary program3) SUBR put an association listLISP-SAP is SAP in list form, for exampleIn this example, the objects beginning with G are atomic symbolsgenerated for use within the compiler. The BSS,O in thelast element above is used as it is in SAP to tag symbolswhich need to have a memory location assigned to them, but noactual space reserved for them, i.e. the usual location-fieldSAP symbol.The LISP-SAP program for each function compiled is printedout, on-line or off-line depending on 'the sense-switch settings.After the compiler has created the LISP-SAP program for afunction, the binary program is generated from LISP-SAP in twopasses. In the first pass all symbols associated with BSS,Oare assigned locations in memory. In the second pass each instructionis assembled into memory. Then any unassigned symbolsfound during the second pass are assigned locations inmemory following the generated instructions.When the binary program has been generated, the compilerputs the functioLs association list the indicator SUBR pointingto a TXL to the binary program.After a function has been compiled, it can be used as ifit had been defined, but of course it will run much faster thanit would have as an interpreted expression.If a function listed in comdef has SUBR on its associationList already, the compiler ignores the request for compilation

and goes ahead after printing out(function name) HAS BEEN ALREADY COMPILEDIf a function has not been defined at all, i.e. has neitherEXPR or SUBRon its association list, the compiler prints outand goes on.(function name) IS NOT DEFINEDIf a programmer has a collection of functions which hewants to compile and if some of the functions use each other assubfunctions, a certain order of compilation should be followed.If a function f uses a function g as a subfunction, then gshould be included in a comdef which comes before the comdef .involving f except in the following special case: if a closedcircle of function usage occurs, e.g.fl usesfg uses2f3fn usesfi,then all of the functions in the circle must be compiled inthe same comdef. Thus the functions listed in a given comdefshould be either unrelated or related in this circular sense,Any other subfunctions on which they depend should have beencompiled by a pr'evious comdef.-Note: The above rule on order should be followed formaximum compiling efficiency. It is also possible to compileall functions in one comdef regardless of dependency. The oneunbreakable rule is that if a function f uses a function g asa subfunctLon, g cannot be compiled in a comdef which comes afterthe one containing the f.

Another pseudo-function, compile[^], is available to compilefunctions not previously defined, The argument of compileis a list of function definitions, each one of which must be ofthe form(LABEL~NAMB, (LAMBDA, (list of free variables), expression) )The functions - caar,cadr -9 oo.,cddar,cdddr are available tothe compiler, so it is possible to write simply (CADAR,~) inlieu of (CAR, (CDR, CAR,^))) in defining a function. If astring of Ass and Dgs of length greater than three is required,it is again necessary to form the function by composition, foeo(CDADR(CAR,X) ) f OP (CDADAR, X)The compiler will accept any function definition which isacceptable to the APPLY operator, except that the program featureis different insofar as the GO statement is concerned,For the compiler version of PROG the argument of any GO must bean atomic symbol; it cannot be a conditional expression. However,in distinction to the usual program-feature, conditionalstatements are themselves allowed as action statements by thecompiler provided they give rise to a definite action, e.g,~COND, (PI, (Go,A) 1, (~2,Furthermore, conditional expressions as used here do - not needto include a true (T) action. If none of the conditions aresatis.ffed, the next statement in the program following theconditional statement is executed.Thus the example of the PROG for search given in the previoussection must be revised for the compiler to the following(RETURN,X) 1, (P~,(SETQ,B~ (CAR,B)) 1)

eturn[fn[a]In terms of the M-type notation introduced in the previoussection this becomes:compiler program for search[~,p,fn,u] with programvariable at:at = LTEST [null[at] -+ -+ return[u];p[at]at = cdr[at]go [ TEST 1I]-In writing programs for the compiler the function setq mustbe used ---set is not acceptable.Amplification of the compiler system is under way. Inparticular a feature will be included to permit a user to writeSAP-type programs defining functions. Such programs will representa third way (in addition to EXPR and SUBR) of definingfunctions on their association lists, and should add flexibilityto the system. SAP-program definitions of functions w i l l betermed tMacros' and will be described in a later memo.Two examples of compiled functions are given below.1) memlis[x;y]The function memlis[x;y] is a predicate whose value is trueif x is a member of the list y, and false otherwise. x can bean atomic symbol or a list.In the program below the compiler has generated certainatomic symbols (~0005, G0006, G0008, ~0009) as location referencesin the program, and other symbols to be used as temporarystorage as indicated below.G0001) Index Register 4 at entry to memlis subroutineG0002) Storage for xG0003) Storage for yG0004) Storage for final answer (true or false)

00007) Storage for the program variable MIG0010) Temporary s torageG0011) Temporary storageThe arguments x and y are stored in the AC and MQand the answer is in the AC at exit.at entry,The subroutine for equal[a;b] expects its two arguments inthe AC and MQ and comes back with either zero (false) or one(true) in the AC.The resulting LISP-SAP program is listed below exactly asthe compiler gives it on the output sheet, except for explanatorycomments to the right of the instructions.FUNCTION APPLY (F, L, A) HAS BEEN ENTERED, ARGUMENTS. .COMPILE(((LABEL~MEMLIS, (LAMBDA, (x,Y), (FROG, (Ml), (sETQ,M~,Y),M~, (COND,((WLL,M~),(~TuRN,F)),((EQUAL, (cAR,M~),x),(R~X'URN,T))), (SET&,M19 (cDR,M~)>,(G0$~2))))))(MEMLIS,BSS, 0)( ,SXD,GOOOl,4) save index register 4( , STO, G0002) store x( , STQ, GOO03 ) store y( , CLA, GO003 )( , STOP GO007 ) set MI = y( ~ 0 0 0 60) , ~ ~ ~ ~ location M2( ,CLA,@OO07)( , TNZ , GO008 ) to ~0008 if null[Ml] = F, or( , CLA, $ZERO) return with AC = F if null[MI] = T( , TRA, G0005)(GOOO~,BSS, 0)( , LXD, G0007,4)( 9CLA9094)( 9PAX9094)

( , SXD, G0011,4),LD&,G0002)( ,C;LA,G&I~)( ,TSX,EQUAL,4)( ,STO,GOOO~O)( , CLA, GOOO~O)( , TZE, G0009)( ,CLA,$ONE)( ,TRA,GOOO~)(GOOO~ ,BSS, 0)( , LXD, G0007,4)( YCLAYOY4)( ,PDX,O,4)( , SXD,GOOO7,4)( ,T~A,G0006)( ~ 0 0 0 50), ~ ~ ~ ~( ,STO,GOOO~)( ,C~~,G0004)( ,LXDY G0001, 4)( 9TR~,1,4)END OF APPLY, VALUE IS ...(MEMLIS )2) maplist[x;g]result of equal test (note that thecompiler stores everything it computes)transfer if car[M1] f xotherwise return with AC = Tcdr [ MI 1set MI = cdr[M1]answer (true (one) or false (zero))restore original index register 4re turnThe function maplist[x;g] is more complicated than the pre-vious example, due both to its use of a function g, and to thefact that maplist may itself be used recursively by g. The lat-ter fact requires that the arguments be saved each time theroutine is entered, and this is done by storing them in a publicpush-down list.' The current next available space in this1See page 144 of the Quarterly Report referred to on the firstpage of Chapter 2.-

push-down list is indicated by the (complement of the) compilerpublic push-down list indicator, $CPPI. This indicator is testedby the program against the last available space in the list,($ENPDL, or end of push-down list), and when there is no morespace available an error transfer to $NOPDLAnother use of storage is illustrated below by the - consstops the computation.function which sends the result of the - cons to free storage.Each time the - cons is used, a test is made of the indicator,$FREE, which gives the (complement of the) next free-storage lo-cation available. When free storage has been used up the subroutine$FROUT is used to call in the garbage collector to retrievesome storage, (see Section 6.3.)The treatment of the function g depends on whether it is de-fined by a subroutine or by an S-expression to be interpreted.If there is a subroutine for g, g will be in the form of an fnstructionstored in location G0003, so that the TSX,GOOO~,~ in the programbelow amounts to a transfer to the subroutine. If g is definedby an S-expression, then g, as stored in G0003, will have a dec-rement pointing to the S-expression.The subroutine COMPAT be-low carries out the interpretation of the expression using theAPPLY operator.Incidentally, the 1 in the line following theuse of COMPAT has been set up by the compiler to indicate thatg is a function of one argument.The LISP-SAP program is the following:FUNCTION APPLY (F, X, P ) HAS BEEN ENTERED, ARGUMENTS. .COMPILE( ( (LABEL, MAPLIST, (LAMBDA,(x, G ),(PROG, (MI, M2), (COND, ( (NULL, X) ,(RETURN,NIL))), (SETQ,MI~ CONS^ (G,x),NIL)), (sETQ,M~,M~),AI,(SETQ, X, (CDR, X) ),(COND,( (NULL, X) ,(RETURN, MI) ) ),(RPLACD, M2,(CONS, (G,x),NIL)),(~ETQ,M~, (CDR,M~)19 (G0,Al)) 1) 1)

push-down(MAPLIST,BSS, 0)( ,SXD,GOOO~,~)( , ST&, $ARG~)( ,LXD, $CPPI, 4)( ,TXH,*+~,~,$ENPDL)( ,TSX,$NOPDL+~,~)( ,LD&,G0001)( ,STQ90,4)( ,LD&,G0003( ,STQ,1,4)( , LDQ, GO011 )( ,STQ,2,4)( , LDQ, G0002)( ,STQ,3,4)( , LDQ, GOO09 )( ,sTQ,~,~)( ,TIX,*+1,4,5)( , SXD, $CPPI, 4)( ,LDQ,$ARG~)( ,STO,G0002)( , STQ, GOO03 )( , CLA, G0002)( , TNZ , GO008 )( , CLA, $ZERO)( ,TRA,G0005)(GO~O~,ASS, 0)(GOOO~ ,BSS, 0)( , CLA, GO002 )( ,LXD9 G0003,4)( ,TXH,*+3,4,0)( ,TSX,GOOO3,4)( ,TRA,*+~)( ,SXD,*+2,4)save index register 4store g in temporary storage to free MQcompiler push-down list indicatortransfer to *+2 if space availableotherwise (no more left), stop on errorcurrent index register 4 -+current g -+ push-down listcurrent M2 -+ push-down listcurrent x -+push-down listcurrent Mie push-down listupdate push-down list indicatorstore xstore glistnull[xl = Fnull[x] = Treturn, value = NILnull[x] = Fextra (unused) line due to compilerx -+ ACgtransfer if g is S-expressionotherwise use g as subroutinereturns here from subroutine for gset up pointer to S-expression for COMPAT

( , TSX, COMPAT, 4)( ,091)( , STO, G0010)( , LXD, $FREE, 4 )( ,TXH, *+2,4,0)( , TSX, $FROUT, 4 )( ,CLA,0,4)( , STD, $FREE )( , CLA, GOOLO)( ,ARS,18)( , ADD, $ZERO)( ,ST0,0,4)( , SXDY GO009,4)( ,CLA,GOOO~)( y~~~,~ooii)(GOOO~,BSS, 0)( ,LXD, G0002,4)( ,CL~,0,41( YPDX,OY4)( , SXD, G0002,4)( ,CLA,G0002)( , TNz , ~0013 )( , CLA, GOOO~ )( ,TRA,GOOO~)(GOO~~,BSS, 0)(GOO~~,BSS, 0)( ,CLA,G0002)( ,LXD,G0003,4)( ,TXH,*+3,4,0)( , TSX, G0003,4)( ,TRA,*+4)( ,sXD,*+2,4)( , TSX, COMPAT, 4)II 1" means g has one argumentg(x>next free-storage locationout of free storage--retrieve someupdate next free-storage locationcons[g(x);N~~]set M1 = cons[g(x);N~L]set M2 = M1location A1set x = cdr[x]null[xl = Fnull[x] = Treturn, value = MIetc.

Ls.( ,O,U( ,STO,G0015)( , LXD, $FREE, 4 )( ,TXH,"+2,4,0)( , TSX, $FROUT, 4)( ,CLA,O,4)( , STD, $FREE )( ,CLA,GOO~~)( ,ARS,18)( , ADD, $ZERO)( ,ST0,0,4)( , SXD, G0014,4)( ,LXD, G0011,4)( ,CLA,G0014)( ,STD,O,4)( ,LXD,G0011,4)( 9CLA,0,4)( ,PDX,0,4)( ,SXD,G0011,4)( ,TR~,G0006)(GOOO~,BSS, 0)( ,STO,G0004)( ,LXD,$CPPI,~)( ,TXI,*+l,4,5)( ,SXD, $CPPI, 4)( ,LDQ,0,4)( , STQ, G0001). ( ,LDQ,1,4)( , STQ, GOO03 )( ,LDQ,2,4)( , STQ, ~ooii )( 9LDQ9394)( , STQ, G0002)all as before, g(x)all as before, cons[g(x);~~~]M2 = cdr[~2]go to A1re turnstore answer temporarilyprepare to restore itemsfrom the push-down listrestore index register 4restore grestore M2restore x

estore MIanswer + ACEND OF APPLY, VALUE IS . . .(MAPLI ST )re turn

Running a LISP ProgramIn this section, various aspects of running a LISP programare discussed. In Section 5.1, we discuss how to punch cards,put together a running deck, and submit a run. In Section 5.2,the tracing program is described. Section 5.3 encompasses abrief discussion of the current state of the LISP-Flexo system.The error indications given by the LISP I system when runninga LISP program have been relegated to a late section (chapter 8)since they are in the nature of a reference look-up list.5.1 Submitting a RunAs stated in the previous section, the foundation of LISPprogramming is the APPLY operator, which is based on the functionapply[f;x;p]. The function f must have been defined by thedefine function or by one of the other ways mentioned previously.A LISP program consists of sets of triplets, f;x;p, which arepunched on cards and submitted in the appropriate order in adeck,Card PunchingColumns 1-72 (inclusive) of a punched card are read by theLISP read program. The S-expression for the 2, 5, and - p of eachtriplet should be punched on cards with one or more spaces (blanks)between each member of the triplet. There are no rules about thelocation of the expression on the card; a new card may be startedat any point in an expression, and the punching on a given cardmay stop at any column before column 73. In other words, cardboundaries are ignored. The read program reads until it finds

the correct number of final parentheses.The current version of the read program interprets a blank(space) as a comma, so that no blanks are allowed within atomicsymbols.The read program ignores redundant commas so that adouble blank for example is read as a single comma.Deck FormatA LISP program to be run must be preceded by an LCON deckwhich calls the LISP system from tape. The LCON deck consistsof five cards labelled NYBOLI followed by six cards labelledLCON. If the LISP program is being run at the M.I.T. ComputationCenter, copies of the LCON deck may be found in room 26-265in the drawer labelled "utility ~ecks".There are five possible direction cards that can be usedfollowing the LCON deck. These cards have the direction (TST,SET,FLX, CRD, or FIN) in columns 8-10 of the card and have thefollowing effects:TST:Subsequent triplets are read in until a STOP card(see 4. of the deck format below) is reached. Thelists read are put out onto tape 2 for off-line printingtogether with a list of the atomic symbols in themachine. Control is then sent to the APPLY operatorwhich operates on each triplet in turn, putting out ontape 2 the triplet f;x;p followed by the value ofapply[f;x;p]. If any errors are found, an error indicationis printed out. After all the triplets havebeen evaluated, the memory is restored to its state atthe beginning of this TST.

SET :Note:FLX*:CRD*:FIN:This card works the same way as TST except thatimmediately after all the triplets have been evaluatedthe state of the memory as it stands is read out ontotape 8 as the new "base" image for the memory. FutureI ITST cards will restore the memory to this new base"state. If more SET cards are used, the functions fol-I Ilowing them will be compounded into the base1' image.If an error occurs during the evaluation of a tripletin a SET the new base image for that SET is not writtenout on tape.The variable field (columns 12-72) for both SETand TST cards should contain the problem number, theprogrammer's number and name, and any other identificationdesired.The Flexowriter mode of operation (see Section5.3) is called into control.Control is returned from the Flexowriter back tothe card reader.The computer stops,Any other card, such as a SAP REM card, may be includedin a deck between a STOP card and the next direction card. Thecard w i l l be printed out but will have no other effect. Such acard in any other position in the deck will cause trouble.\Vhe FLX and CRD direction cards are not understood by the basicLISP system; only the LISP-flexo system can interpret them.

A running deck (assuming no use of FLX or CRD) has thefollowing format.1. The LCON deck2. A TST or SET card3. The sequence of triplets f;x;p, on which the applyfunction is to operate4. A STOP card which contains the word STOP followedby a large number of right parentheses followed bythe word STOP again,This information may be placed anywhere withincolumns 1-72 on the card. It is used to guaranteethe safe completion of the reading program.5. Cards such as in (2,3,4) above, repeated as of tenas desired.6. A FIN card7. Two blank cards ( to prevent the card reader fromhanging up)Operating InstructionsTapes used:TAPE NUMBER2USE -Off -line printed output (suppressed bysense switch 5 down)Off-line card input (only if sense switch1 UP)Off-line punched card outputTemporary storageLISP system tape

Sense switches used:SWITCH NUMBERUSE -1 UP: Off-line card input (tape 4)DOWN:On-line card inputUP:DOWN:Suppress on-line printingPrint on-lineUP:Write all printing on tape 2 foroff-line printingDOWN: No off-line printingBoth on-line and off-line printing can be done at the same time.All the above swihches. take, effect: immediately.If a LISP program is being run at M.I.T. the following indicationsshould be given on the performance request card:1) Production run2) Switch 1 down3) LISP system tape on tape drive 9. The currentnumber of this tape is posted in room 20-265 andon the bulletin board in the 704 schedulerts room4) Machine tape on tape drive 85) Output tape (usually machine tape) on tape drive 26) Tapes 8 and 9 are rewbund by the program7) Operating instructions areCLR (clear)LCD (~oad cards)The deck should be submitted along with its performance requestcard to the "regular runs" file in the schedulerts office.

5.2 Tracing OptionA LISP tracing function called tracklist is available tohelp the user locate his program errors. Of course, as withany tracing system, tracklist consumes both time and paper, butin some cases it may prove helpful.The function tracklist is a function of one argument, x,which is a list of the LISP functions to be traced. Each functionmentioned in the list must be a function which has EXPR,FEXPR, SUBR or FSUBR on its association list. Further iftracklist is to trace a function which is on the ''topLkevelYx .of APPLY, i.e. the f in apply[f;x;p], then the S-expression forf must start with LAMBDA or LABEL. Finally tracklist cannottrace the functionscarcdrcons'listWhenever one of the functions included in the argument oftracklist is encountered during the running of the LISP program,tracklist gives a print-out (on or off-line depending onsense switch 3) of the name of the function, its type, e.g.SUBR, its arguments, and finally its value. Thus the path ofcomputation followed by the program is recorded.If tracklist is called into action within a computationpreceded by a SET direction card (see Section 5.1), it continuesto trace its arguments for the rest of the run (providedthe SET card is successful and determines a new "base" image).If tracklist occurs within a computation preceded by a TST directioncard it continues only up to the STOP card.

The Flexowriter Sys tem (for M.1.T. users only) 1The possibility of running LISP programs on line using theFlexowriter as access to the 704, and time-sharing with anI Iinnocent victim" is under development at M,I,T. The currentversion of the LISP-Flexo system is described here, but it issubject to change. The reader who might wish first of all tobecome familiar with the Flexowriter system, can find a writeupof it, although for a different purpose, in ProfessorHerbert M. Teagerls memo, Programming Manual for the M.I.T.Flexowriter Monitor Interpreter System of Time-Shared ProgramTesting.The LISP-Flexo System enables the user to read functiondefinitions into the 704 from cards or to type them in on theFlexowriter, and to control the operation of LISP via Flexowritertype-ins .Operating InstructionsTo use the LISP-Flexo System on the M.I.T. 704 one must(1) Turn on the two power switches for the Flexowriter(2) Turn off the alarm clock(3) Turn off the back interrupt switch(4) Put the LISP-Flexo System tape on tape drive '10The output w i l l be either on the on-line printer or on theFlexowriter, at the option of the user. The input deck to beput into the card reader has the following format,1The LISP-Flexo system does not contain the compiler option.

1. GETOPFLEX card to call the M.I.T. Automatic Operatorprogram and the Flexowriter programs in fromthe M,I,T. System tape2. GETLISP card to get the LISP-Flexo System in from tape 103. Binary or octal correction cards currently needed for theLISP-Flexo System (obtainable along with the three GET----cards from room 26-265)4. GETLISP2 card to transfer into operating program5. FLX direction card--see Section 5.16. Cards containing the triplets on which the APPLY operator isto operate, provided the triplets are to be read in ratherthan typed in on the Flexowriter.-followed by two cards of the formThe last triplet must bewhere the extra parentheses are used as insurance, See belowfor a description of the function IOFLIP. If no tripletsare to be read in, no cards need be placed between theabove FLX card and the FIN card below,7. FIN direction card--see Section 5.18. 2 blank cards for the card readerIn the following description of the Flexowriter system,, and b will be used, wherethe three symbols 3 , @

indicates carriage returnindicates a tabindicates a blank (space)When cards are read in on the card reader the FLX cardtransfers control to the Flexo-APPLY operator. The Flexowriterthen types out GO and waits for an input. The systemat this time expects a LISP program to be typed on the Flexowriter.However, if there are cards in the card reader whichcontain the LISP program, the type-in to send control to thereader isIOFLIP (READ), () jlAfter the carriage return, cards containing the triplets forthe APPLY operator will be read in from the card reader andapplied.If a program is to be typed in on the Flexowriter thereare two possible modes of operation, the Sequence-Mode and theTEN-Mode. In the Sequence-Mode the entire S-expression for atriplet f;x;p for the APPLY operator is typed in sequentially,and at the end of the thre.e lists the APPLY operator operateson them. This is satisfactory theoretically; but in practice,due to the difficulty of typing S-expressions, it is inconvenient,since error anywhere the expression requires correcting, andif the error was in a previous line (see Errors below) it cannotbe deleted at all. The TEN-Mode was developed to obviate thisdifficulty and to allow the user to type S-expressions in smallfragments independently erasable. Below we describe in more detailthe use of the two modes.Sequence-ModeWhen the FLX card of the input has transferred control to

the Flexo-APPLY operator, and the Flexowriter has "yped out GO,the S-expressions for an APPLY triplet, f;x;p, should be typedon the Flexowriter. The typing is done by typing up to 72criarac ters (fewer if desired) followed by a carriage return.The Flexowriter then types out STOP and digests the informationto date.If a full triplet has not been completed, the Flexo-writer types out GO as a request for more of the triplet,triplet has been completed, the APPLY operator takes over andperli'orn!s il.e triplet, typins out the answer followed cy a GOrequesting the next triplet,If aTo stop the computation, one may respond to an initial GO,or to a GO following the use of the APPLY operator, or to a GOfollowing an error* (but not to a GO at other points, such asin the middle of list type-ins), by typing in+ STOPjThe Flexowriter then types - out STOF and returns control to thecontrol ?outine which types out GO and expects a direction type-in.One can then type eitherto end the run, orto return control to the card-reader for the next directioncard, e,g. TST, SET, FLX, FIN,*Such a GO w i l l hereafter be referred to as a "fresh" GO.

TEN-ModeThere are ten buffers of core storage for S-expressionsset aside for use by the TEN-Mode of operation. Pieces of anS-expression can be typed into these buffers in any sequence,with overwriting allowed, and the Flexo-APPLY operator can beasked to operate on any set of consecutive buffers, e.g. 0through 6, or 4 through 9.To use the TEN-Mode, one may respond to a "fresh" GO (seepreceding footnote) by typing in+ TEN>Then type in a number from 0 to 9 representing one of the tenbuffers, and then a tab, and then a (piece of a) S-expressionand then a carriage return, as inThe Flexowriter will then type out a colon, :, and one can typeinto another buffer register in the same way as above by typinga buffer-register number, a tab, the information, and finally acarriage re turn.When an entire triplet has been typed in, the APPLY operatorcan be called for by typing, in response to the colon type-out,the read-line direction,- RLN 3Then two numbers followed by a carriage return must be typed in,n1 n2 , e.g. 01 , or 69 , or 99 . All the buffer registers,nl to n2 inclusive, are then turned over to the read program,which reads them in, printing out the number of each register asit is read. When a complete triplet f;x;p has been found by theread program, the APPLY operator operates on the triplet, printsout the answer, and then returns control to the read program,

-+ ONEbFINbbThe read program reads ahead until it finds either three morelists for a triplet or until it has read n2. In the first case,the APPLY-operator takes over as above. In the second case, theFlexowriter types out GO. The typed-in response to this GO maybe either another read-line direction, or a type-in into a bufferregister as described previously. Note that the read programas used in the TEN-Mode remembers any incomplete lists itmay have been reading at the end of the previous RLN request,and considers this information to be the initial part of thenext material read.To stop the operation of the TEN-Mode, provided no errorhas occurred, one types into two consecutive registers, in re-Itsponse to a fresh" GO (see previous footnote),: nl -+STOP3.Then one does a RLN of these two buffer registers to end therun completely. One can instead replace the above FIN by aCRD if one wishes to send control back to the card reader.To stop the operation of the TEN-Mode after an error hasoccurred, one types, in response to - any GO, into three cwsecutiveregisters ni, ni+l, and ni+2several--+ : ni+2 &(or CRD in place of FIN).Then one does a RLN of these three buffer registers.To get from the TEN-Mode back to the Sequence-Mode onetypes in, in response to a GO,3-

ErrorsTyping errors may be erased by hitting the backspace keywhich will erase the preceding character, or by hitting theunderline key, which will erase the entire line. Several charactersat a time can be erased by using the backspace key the appropriatenumber of times, but lines above the current line cannever be recovered for erasure.Extra right parentheses give a read error.The error type-outs described in Chapter 8 appear on theFlexowriter without the sentence describing the error, for ex-ample,ERROR NUMBER : A 2 :and this type-out is followed by the argument of the error ifit had one. The read program does not stop at the error; in theTEN-Mode the read program goes on to read a new triplet in theregister following that in which the error occurred, in the Sequence-Modethe read program starts reading the next line typedin.Other Flexowriter Monitor Type-insAt any time except when the Flexowriter is itself typingout a message one may type in any of the monitor directions, describedin Professor Teagerls memo, QUE, ENT, EXE, LDC, BKP, TEN..The Functions ioflex(x) and ioflip (y )Two special functions ioflex and ioflip are available inthe LISP-Flexo System. They are functions of one argument anda null - p-list, and they have the following effects:

Ioflex(x) is a predicate which has the value true (T) orfalse (F). If x = READ the predicate asks if the Flexowriteris in the reading (type-in) mode; if x = PRINT the predicateasks if the Flexowriter is in the printing (type-out) mode; andif x is something else an error message followed by F is typedout.1oflip (y) is an operative function which changes controlas follows:y = READflips control between reading fromcards or reading from type-in onthe Flexowritery = PRINTflips control between printing onthe on-line printer or by Flexowritertype-outsy = anything else flips the last pair that was flipped.It assumes initially that this was aREAD.Note At certain times the LISP-Flexo System may hang up tryingto read the card reader. How it gets into this trouble, andhow to get out of it are described below.An input of the form IOFLIP, (READ),() given when operatingin the Flexowriter type-in control will select the cardreader and cause the read program to try to read in cards containinglists of triplets. If no cards of this form are inthe reader, andp EOF (end-of-file) error from the read programoccurs, and the card reader is selected again. The card readerwill not be in ready status, and if the START button on thecard reader is selected another EOF error will occur. To getout of this cycle one can type a tab on the Flexowriter. Thetab will not be processed, but the Flexowriter keyboard willlock. At this point, pressing the START button on the cardreader will get the 704 back on the line so that the interrupt

(from the tab type-in) will be processed and return controlto the innocent victim.Exam~le Flexowriter RunAn example follows of an actual run with the Flexowriter.The Flexowriter types out in a different color from the typein,and this is indicated below by underlining. At presentthe commas separating elements of lists can be replaced byblanks since the comma is inconveniently upper case. Howeverin the example the commas are used for clarity. Explanatorycomments have been put in below in lower case to the right ofthe actual output.The card-reader which was called in by IOFLIP(READ) belowhad cards in it defining the function RVSE (reverse a list),followed by a card IOFLIP(READ) to return to control to theFlexowriter.Flexowriter SheetExplanation- FLXGOCG ((A,B,c)) 0STOPthe Flexowriter takes over, andrequests a type-in (sequence Mode )(type-in)the Flexowriter digests the information(B,c)and finds the answer,- GOand asks for more.STOP

GO -(>STOPthe Flexowriter does not have afulltriplet f;x;p, so asks for the rest(B,C)- GOTENanswer0 CAR (((A,B)>c)) 0:1 CDR ((D>(E,F))) 0:2 CONS ((G,H), (type -ins ):3 (1,JN 0: RLN(the TEN-Mode is entered)01 (read lines 0 and 1)- 0line 0answerline 1answer22- 2GO-RLNRLN32WRONG ORDERRLN(read line 2)line 2the Flexowriter asks for the rest(read lines 3 to 2)error(read line 3)-line 2 has been remembered

answerTENCAR ((A@) 0- LINE NUMBER MISSING RETYPE error indication2 IOFLIP(READ) ():3 RVSE ((A,B,C,D)) 0:4 IOFLEX(PRINT) () type-ins: 5 IOFLEX(NG) ( ):6 STOP: 7 FINRLN252-- READ(read lines 2 through 5)go to card-reader to read indefinition of RVSE and REV1(used in RVSE)READ -flips back to Flexowriterread line 3 and find -answer to RVSEread line 4True-the Flexowriter is printingread line 5ERROR NUMBER :F 1:NG is not a valid argument forIOFLEX, so

F -GO -RLN6767 -answer is False. .(read line 6 and 7)end of -computation- FIN

6. List StructuresMuch of the following is taken from the M.I.T. report citedin Chapter 2. In Section 6.1 the representation of S-expressionsby list structures is described and an example of listconstruction is included. In Section 6.2 association lists foratomic symbols and for floating-point numbers are described.Finally, in Section 6.3, a discussion of the use of free storageand the operation of the "garbage collector" is given.6.1 General Descri~tion(1) Representation of S-expressions by List StructureA list structure is a collection of computer wordsarranged as in Fig. la or Ib. Each word of the list structureis represented by one of the subdivided rectangles in thefigure. The left box of a rectangle represents the addressfield of the word and the right box represents the decrementfield. An arrow from a box to another rectangle means thatthe field corresponding to the box contains the location of bheword corresponding to the other rectangle.It is permitted for a substructure to occur in morethan one place in a list structure, as in Fig. Ib, but it isnot permitted for a structure to have cycles, as in Fig. -1c.Fig. 1

An atomic symbol or a floating-point number is representedin the computer by a list structure of special formcalled the association - list of the symbol. Such lists are describedin Section 6.2'which follows.An S-expression x that is not atomic is representedby a word, the address and decrement parts of which contain thelocations of the subexpressions car[x] and cdr[x], respectively.In the list form of expressions the S-expression (A, (B,c),D) isrepresented by the list. structure of Fig. 2.Fig. 2When a list structure is regarded as representing a list, wesee that each term of the list occupies the address part of aword, the decrement part of which points to the word containingthe next term, while the last word has NIL in its decrement.The dot notation, e.g. (A~B), which is discussed in Section 2.2is not allowed in LISP I; all lists and sublists must end withNIL.An expression that has a given subexpression occurringmore than once can be represented in more than one way. Whetherthe list structure for the subexpression is or is not repeateddepends upon the history of t6e program. Whether or not a subexpressionis repeated will make no difference in the resultsof a program as they appear outside the machine, although itwill affect the time and storage requirements. For example,the S-expression in list form ( (A,B), (A,B) 1 can be represented

y either the list structure of Fig. 3a or 3b.The prohibition against circular structures is essentiallya prohibition against an expression being a subexpressionof itself. Such an expression could not exist on paper ina world with our topology. Circular list structures would havesome advantages in the machine, for example, for representingrecursive functions, but difficulties in printing them, and incertain other operations, make it seem advisable not to usethem for the present.The advantages of list structures for the storage ofsymbolic expressions are:1. The size and even the number of expressions withwhich the program will have to deal cannot be predicted in advance.Therefore, it is difficult to arrange blocks of storageof fixed length to contain them.2. Registers can be put back on the free-storage listwhen they are no longer needed. Even one register returned tothe list is of value, but if expressions are stored linearly, itis difficult to make use of blocks of registers of odd sizesthat may become available.

3. An expression that occurs as a subexpression ofseveral expressions need be represented in storage only once.(2) Construction of List StructuresThe following simple example has been included to illustratethe exact construction of list structures. Two typesof structure are shown, and the recipe for using LISP to deriveone from the other is given.In the list structures below the word 'NIL! is shownin the decrement of the final element of lists and sublists,Strictly speaking in the current 704 representation of liststhis decrement contains zero rather than the indicator NIL whichwould point to the association list for the atomic symbol NIL,but the replacement generally will not affect the user,In the following example we assume that we have alist of the formwhich is represented asIT4/WBI HC I N I L ~ NIL Z 1 N I ~and that we wish to construct a list of the form

which is represented asFirst we consider the typical substructure, (A, (B,c))of the second list a2. This may be constructed from A, B, andC by the operationcons [A; cons [cons [B; cons [ C; NIL] 1 ;NIL] 1Or, using the list operation, we can write the same thing asIn any case, given a list, t, of three atomic symbols,the arguments A, B, and C to be used in the previous constructionare found fromThe first step in obtaining a2 from ,f?l is to define afunction, -3 grp of three arguments which creates (x, (Y,z)) froma list of the form (x,Y,z). I

Then grp is used on the list al, assuming aL to be ofthe form given. For this purpose a new function, mltgrp, is definedrecursively,So mltgrp applied to the list al takes each threesome, (x,Y,z),in turn and applies - grp to it to put it in the new form,(x,(Y,z)) until the list aL has been exhausted and the newlist achieved.-Note: Any list which is read into the computer byLISP I can have only NIL (zero) in the final decrement. Thatis, the dot notation (AOB) cannot be read by the current readroutine, so that the only way to get (AOB) is by a cons withinthe machine. Generally the use of such a - cons to create afull machine word should be avoided.6.2 Association ListsWithin the LISP I system there is a list of atomic symbolsalready available in the system. Each of these atomicsymbols has an association list* associated with it, and infact the atomic symbol on the list of atomic symbols points to-In the local M.I.T. patois, association lists are also referredI Ito as property lists'" and atomic symbols are sometimes called

the location of the association list. Integers are includedin the list of atomic symbols, but floating-point numbers arelisted on a separate list which will be discussed below.When an atomic symbol is read by the read program acheck is made to see if it is already available o.n the list ofatomic symbols. If it is not, it is added to the list and anassociation list is created for it.An association list is characterized by having the specialconstant 7777T8 (i-e. minus 1) in the address section of thefirst word. The rest of the list carries any other informationthat is to be associated with the atomic symbol. This informationmay include: the print - name (signalled by the indicatorIPNAME1), that is, the string of -letters and digits which representthe symbol outside the machine; a numerical value ifthe symbol represents a number; another S-expression if thesymbol, in some way, serves as a name for'it; or the locationof a routine if the symbol represents a function for which thereis a machine-language subroutine.Two kinds of value indicators are used on associationlists: APVAL and APVALI, Both indicate a value, but APVALpoints to a single word which has the value in the address partand NIL (zero) in the decrement part, whereas APVALI points toa list. The indicator APVAL acts like a stop to the garbagecollector (see Section 6.3 below) whereas APVALI allows thegarbage collector to look ahead through the part of the listpointed to by APVALI. Whenever a programmer wishes to putsome value on an association list for an atomic symbol, he mayuse the function attrib discussed in Chapter 9 to put a sublistof the form (APVAL,()) on the association list.For example, on the association list for NIL, APVAL isused as follows:

NIL40 I NIL 1 I NIL(A similar structure holds for APVALI list-segments. The lastword of a print name is filled out with a 6-bit combination(here shown as "?") that does not represent a character printableby the computer. Note incidentally that the print nameis depressed two levels to allow for names longer than one registerlength, for example,On the association lists for integers the indicator INTpoints to the integral value. The integral value is given asa full machine word with the value pushed to the right-handend of the register.On the association lists of those atomic symbols whichrepresent functions, SUBR indicates a SAP subroutine for performinga function. SUBR points to a TXL to the subroutine,

and the decrement of the TXL instruction contains the number ofarguments belonging to the function. Thus the following fragmentof an association list belongs to a function of two argumentswhose subroutine is located at 377218.The indicator EXPR on an association list of a functionpoints to the S-expression for the function, : as in@-expressionde-[fining the function------The special forms discussed at the end of Section 4.3 haveFSUBR or FEXPR on their association lists.Either attrib or define (see Chapter 4) may be used to putsomething on an association list. Attrib puts the item at theend of the list, and define puts it at the beginning. Thusdefine can be used to redefine an atomic symbol. Define putsEXPR followed by the associated S-expression on the associationlist of a function. Comdef (see Section 4.6) puts SUBR on theassociation list of the function compiled, and the SUBR pointsto the TXL to the compiled subroutine.

Floating-Point NumbersFloating-point numbers are listed in a separate list. Afloating-point number is put on this list either as it is readin or as it is generated within a calculation. Neither thislist nor the list of atomic symbols has any duplications. Anassociation list is created for a floating-point number whenthe number is put on the list of numbers.The association list for floating-point numbers containsthe indicators NUMB and FLO (for floating-point), but the indicatorPNAME is not put on the list until a request for printingthe number is encountered. Only positive numerical valuesare put on the association listsfor floating-point numbers; ifa number is negative the association list for the number ispreceded by the indicator MINUS, and the entry in the list offloating-point numbers points to the MINUS indicator. Thus wehaveJust as a matter of interest we give below the associationlists for atom and for the constant 1, just as they are representedin the 704. We use the bar notation, add, to represent

the 2's (8's) complement of an octal address.*Preceding all the individual association lists in the 704LISP I system is the list of all atomic symbols. Each registerof this list has an entry of the formwhere x is the address of the first register of the associationlist for this atomic symbol, and y is the address of the nextentry in the list of atomic symbols. Thus for - atom whose associationlist starts in 25146 the entry in the list of atomicsymbols islocationentry24657 0531.20052632representing25146, ,-The association lists which appear in the following areatomic symbollocation of association listpname(integer) - int- atom25146constant 1subrapval*-The term "findex" is sometimes used for the 2's complementof an octal location.

locationThen for - atom the association list looks as follows:or, in list form,entry052631 077777052630 051547052625 052627oooooo 052626216346 447777052624 051073oooooo 052623700000 010762representing-1, ,2514726231, ,2515025151, ,2515325152, ,oBCD ATOM!? (77 9 )26705, ,2515rF2rj155, ,oTXL10762, ,1 cation of SAPsubroutine for atom) -25146 25147 25150 25153 25154- : 1-11 ~~1 PNAME . r1 SUBRI 1 = j NIL(b5ATOM! ?For the constant 1, the association list looks as follows:location entry representing25201 052576 077777 -1, ,2520225202 052575 051547 26231, ,2520325203 052572 052574 m, ,2520625204 000000 052573 25205, ,o25205 017777 777777 BCD I?????25206 052571 052113 25665, ,25207

25207 052567 05257025210 000000 00000125211 052566 05264425212 oooooo 05256525213 000000 000001or, in list formIn this case, the constant 1 is tagged both as an integerINT of value 1, and as a constant which when evaluated (APVAL)yields the value 1.6,3 The Free-Storage List and the Garbage CollectorAt any given time only a part of the memory reserved forlist structures will actually be in use for storing S-expressions.The remaining registers are arranged in a single list called thefree-storage - list. A certain register, FREE, in the programcontains the location of the first register in this list. Whena word is required to form some additional list structure, thefirst word on the - free-storage list is taken and the number inregister FREE is changed to become the location of the secondword on the free storage list. No provision need be made for

the user to program the return of registers to the free-storagelist.This return takes place automatically whenever the free-storage list has been exhausted during the running of a LISP Iprogram. The program which retrieves the storage is a SAPcodedprogram called the garbage collector.Any piece of list structure that is accessible to programsin the machine is considered an active list and is not touchedby the garbage collector. The active lists are accessible tothe program through certain fixed sets of base registers suchas the registers in the list of atomic symbols, the registerswhich contain partial results of the LISP computation in progress,etc. The list structures involved may be arbitrarilylong but each register which is active must be connected to abase register through a car-cdr chain of registers. Any registerthat cannot be so reached is not accessib1,e to any programand is non-active; therefore its contents are no longer ofinterest .'The non-active, i.e. available, registers are reclaimedfor the free-storage list by the garbage collector as follows.First every active register which can be reached through acar-cdr chain is marked by setting its sign negative.* Whenevera negative register is reached in a chain during thisprocess, the garbage collector knows that the rest of the listinvolving that register has already been marked. Then the*Special provision is made for the rare case when the sign ofa register is already negative.

garbage collector does a linear sweep of the free storage area,collecting all registers with a positive sign into a new freestoragelist, and restoring the original signs of the activeregisters. Partial experience has indicated that about a thirdof the running time is taken up by the garbage collector.

7 Example Exercises----Four exercises together with their solutions are given inthis section. The first two exercises involve formulatingLISE functions to treat list structures. In case the readershou::: like to try his hand at these before looking at the solution,the first two problems to be solved are:II(1) Formulate a function which will collapse" a liststructure, i,e. which will make a one-level list out of amultilevel list, so that, for example,(2) Formulate a function which will reverse a list, sothat, for example,(A,B,c,D) becomes (D,c,B,A)The third example shows how to define a length functionwhich w i l l operate more efficiently than the one defined inSection 4.4.The fourth example involves applying a function to itsarguments when the function is specified only at the time theAPPLY operator is in control.(1) Function to Collapse a List of ElementsThe function formulated below uses the function append,which is described in Chapter 9 and also in Chapter 2. Roughlyspeaking append makes one list out of two, so that, forexample,

The function collapse, is defined as follows:For this particular example a complete record of the cardspunched for the run and of the computer results is given below.In the run the APPLY operator operated on the define func-tion to define collapse, and then applied the defined functionto three test cases,The following is a listing of the cards punched for the run:TST M948-371-PO FOX-EERCISE 1DEFINE1( ( (COLLAPSE, (LAMBDA,(L),(COND((ATOM,L), (CONS,L,NIL))( (NULL, (~DR,L) 1 9(COND, ( (ATOM, (CAR,L) ) ,L), (T, (COLLAPSE,(CAR,L) ) ) ) )(T, (APPEND, (COLLAPSE, (CAR,L) ) ,(COLLAPSE(CDR,L) ) ) ))))'I)) 0COLLAPSE ((((A,B), ((c))),( ( ~ 9 (E,F)), (GI, ((H))))) 0COLLAPSE ((A, (B, (C, ( ~ (E) 9 ) ,F, (G, (H9 J) ) 1) ()COLLAPSE ((((((A),B),C),D)~E)) 0STOP))))))))))STOPFIN M948-371-~. FOX-EXERCISE 1These cards were then submitted for a run, following thevarious directions as to deck format and so on given in Chapter5. The results printed out during the running of the problemby the APPLY operator, were the following (where comments on thecomputer output have been added in square brackets) :

TST ~948-371-P. FOX-EXERCISE 1APPLY OPERATOR AS OF SEPTEMBER 1, 1959THE TIME IS NOW 2/16 1139.5READ IN LISTS ...DEFINE( ( (COLLAPSE, (LAMBDA,(L)@ND,( (ATOM, L) ,L, (CDR,X> 1, (COND, ( (ATOM,(CAR,L) ) ,L), (T,~LLAPSE, (CAR,L)) ) ) ) , (T, (APPEND, (COLLAPSE, (CAR,X) ) ,(COLLAPSE,(CDR,L) ) ) ) ) ) ) ) )COLLAPSE( (A, (BY (C, (D, (E) > ) YF, (G, (H, J) ) ) ) )COLLAPSE((((((A>,B>,~>,D),E>>STOPTHE TIME IS NOW 2/16 1139.7.[At this point all the cards through the STOP card have beenread in].OBJECT LIST NOW IS . . .. ere the entire list of atomic symbols, including those justread in, is printed out].

THE TIME IS NOW 2/16 1139.7FUNCTIONAPPLY(F,X,P) HAS BEEN ENTERED, ARGUMENTS..DEFINE( ( (COLLAPSE, (LAMBDA,(L),(COND,( (ATOM,L),(CONS,L, NIL) ),( (NULL, (CDR,L> 1, (C~ND, ( (ATOM, (CAR,L) ) ,L), (T, (COLLAPSE, (CAR,L) 1 ) ) 1 9 0 ,(APPEND, (COLLAPSE,(CAR,L)), (COLLAPSE,(CDR,L)) ) ) ) ) ) ) )END OF APPLY, VALUE IS a ..h he function collapse has now been defined by having EXPR followedby the defining S-expression put on its ,association list].h he function collapse is now used on the three examples].THE TIME IS NOW 2/16.1139.7FUNCTION APPLY (F, X, P) HAS BEEN ENTERED, ARGUMENTS. .COLLAPSE((((A,@, ((c))), ((D, (E,F)), (GI,((H)))))THE TIME IS NOW 2/16 1139.8FUNCTION APPLY (F, X, P ) HAS BEEN ENTERED, ARGUMENTS. .COLLAPSE( (A, (B, (C, (D, (El > 1 ,F, (G, (H, J) ) 1)END OF APPLY, VALUE IS ...(A,B,c,D,E,F,G,H, J)

THE TIME IS NOW 2/16 1139.8FUNCTION APPLY (F, X, P ) HAS BEEN ENTERED, ARGUMENTS. .COLLAPSE((((((A>,B>,C>,D>,E>)END OF APPLY, VALUE IS ...(A,B,c,D,E)he FIN card is read and the run terminates].(2) Function to Reverse a ListTwo different functions are shown which purport to reverselists, but only the second definition is correct.First DefinitionSecond DefinitionCrvde 6 a] = rev[ 1; NIL]rev[j;kl = [null[j]k;T+ rev[cdr[j];cons[car[j];k]]]To show the effect of these two definitions on a givenlist the following cards were punched and run:

DEFINE( ( (RVRSE, (LAMBDA, (L ) JCOND, ( (NULL, L ) , NIL) ,0, (CONS, ( R~R~E,(RVDE(CDR,L) 1, (CONS, (CAR,L) ,NIL) 1) ) ) ),,(LAMBDA, (L),(REV, L, NIL ) ) ),(REV, (LAMBDA, (J,K>,(COND, ( (NULL, J) ,a,(T, (REV, (CDR, J), (CONS,(CAR, J),K)) ) ) ) 1) )(1RVRSE ((A,B,c,D,E)) 0RVDE ((A,B,c,D,E)) 0The results given for the two cases by the APPLY operator wererespectivelyRVR~E((A,B,C,D,E))and0 = (((((N~L,E),D),C),B),A)Thus only the second definition does the job intended;the first function, rvrse, erroneously creates a multilevellist.(3) Function to Count the Number of Elements in a ListThe function given in Section 4.4 for the length of a list islengthEd] = [null[J] -+0,O;T-sum[length[cdr[.8]];1.0]]This function will work correctly, but it is slow and inefficientin the sense that it must follow the recursion oflength down to the end of the list before it starts counting,Then it counts out backwards through the list, The followingpair of functions counts forwards through the list, and thereforeoperates faster:

(4) Specification of a Function During Run TimeThe following somewhat obscure example shows how one canleave the specification of a function until the time a programis run, and at that time specify it in a particular way.Thiscannot be done by the usual method of using the APPLY operation0.n a f;x;p triplet since the APPLY operator expects f to bealready available. Instead one must use the APPLY operator ona triplet whose f is the function -, eval as inEVAL((APPLY, (CAR,X),Y,NIL),(0,(1(CADR,CDR) 1, (Y, ( (A,B,C) 1) 1)Here the second argument of -' eval the p-list is used to set .the function (CAR,X) equal to CADR, and the result of the evaiis

8. Error Indications Given by LISPBelow are listed the print outs that occur (on-line oroff-line depending on sense switch 3) when an error is foundin a LISP program. Generally after an error is found controlis returned to the APPLY operator which starts to operate onthe next triplet. After errors which are more drastic, suchas no input data available or no more free storage available,the run is terminated. The word bracketed by dashes in theprintouts below is the name of the LISP system subroutine involved,e.g. -APP2-in Al, and need not concern the user.Errors durin~ the o~erati.on of the APPLY o~erator:A1,'I2A3A5A7TOO MANY ARGUMENTS FOR A FUNCTION -APP2-1.e. there are more arguments than the APPLY operator isbuilt to handle, (currently ten).FUNCTION OBJECT HAS NO DEFINITION -APF2-1.e. the f'unction represented by an atomic symbol has neitherSUBR nor EXPR on its association list, nor is it paired withsomething on the p-list. The atomic symbol for the name ofthe function is printed out after the A2 print-out.CONDITIONAL UNSATISFIED -EVCON-1.e. none of the conditional expressions in a conditionalwere evaluated as true.SET& GIVEN ON A NON-EXISTENT PROGRAM VARIABLE -EVAL-1.e. (see the program feature, Section 4.5) the programvariable is not within this program, nor is it in somehigher-level program in this run. The name of the programvariable is printed out.SET GIVEN ON A NON-EXISTENT PROGRAM VARIABLE -EVAL-See A5 above.

ERROR,A9A10AllA12A13UNBOUND VARIABLE USED -EVAL-1.e. a free or unbound variable has neither APVAL orAPVALl (see Section 6.2) on its association list to signalits value, nor is the variable paired with something onthe p-list.The name of the variable is printed out.FUNCTION OBJECT HAS NO DEFINITION -EVAL-1.e. a function does not have EXPR, FEXPR, SUBR, nor FSUBRon its association list, nor is the function paired withsomething on the p-list.printed out.GO TO A POINT NOT LABELLED -1NTER-The name of the function is1.e. (see the program feature, Section 4.5) there is nolocation-marking atomic symbol whose value corresponds tothe value given by evaluating the rest of the GO list.RAN OUT OF STATEMENTS -1NTER-1.e. the interpreter didnDt find a RETURN statement in aprogram using the program feature.TOO MANY ARGUMENTS -SPREAD-I.e, there are more arguments than the APPLY operator isbuilt to handle, (currently ten),~ 1 4 APPLIED FUNCTION CALLED ERRORIf the APPLY operator reaches an "ERROR" in an expression,for example -+ T is printed out followed bythen ~ 1 4the argument of ERROR, if one has been assigned, It isnot necessary to assign an argument, but it is possible toassign a single argument, for example

Errors due to computer inadequacies:B1 OUT OF PUBLIC PUSH DOWN LIST -SAVE-1.e. the program has run out of space allotted to thepublic push-down list .' Currently about 1000 registersare allotted, and, if they are used up, the recursionI Ibeing done is either too deep" for the given capacity ornon-terminating.B2 FREE STORAGE COUNTER PANIC STOP. PRESS START TO CONTINUEThere is a free storage counter, called the "CONS counter",associated with the LISP system. Every time a register istaken from free storage, the counter is increased by one,The counter is not changed by the garbage collector operation.Thus to some extent the counter indicates how a programis operating--how much storage it is using, and so on,or, for a program whose operation is known, how long it hasbeen running. The counter is initially set to zero, andwhen it has reached 100,000, the computer stops after givingthe error print out B2. When the start button hasbeen pressed to restart the computer the counter continuescounting, but no further stop occurs,B3 DIVIDE ERROR -OCTAL TO DECIMAL CONVERTER-This error arises only when the computer malfunctions orwhen some of the program has been written over.1See page 144 of the Quarterly Report referred to on the firstpage of Chapter 2.

Errors in list structures:C2F1c; 2NDOBJECT GIVEN TO DESC AS LIST1.e. (see desc in Chapter 9) in desc[x;y], x is an atomicsymbol instead of the required list of A's and D1s,UNEQUAL LENGTH LISTS -MAP2-This error can occur only during the differentiation func-tion; it implies a machine error,1ST ARG.LIST TOO SHORT -PAIR-AM. LIST TOO SHORT PAIR-F2 'and F3 occur when a list of pairs is being created outof two lists, for example when a list of dummy variablesand their values is being appended to the p-list,Theitems still remaining on the larger list are printed outfollowing the error indication.' F4 CANNOT PAIR OBJECTS. PLEASE USE LIST -PAIR-1.e. one of the lists to be paired is, erroneously, an(~5LF~atomic symbol.This usually happens when the user gives asingle dummy variable in a LAMBDA expression as an atomicsymbol instead of as a list. The list is printed out fol-lowing the error indication,FLVAL ASKED TO FIND VALUE OF NON-OBJECTFLVAL ASKED TO FIND VALUE OF NON-FLOATING POINT NUMBERF5 and F6 occur when the program is looking for the valueof a floating-point number,and finds either that it is notan atomic symbol (~5), or that it is not a floating-pointnumber ( ~ 6 ) ~

Errors during the operation of the garbage collector:G1 I HAVE FAILED TO FIND ANY GARBAGE. PANIC STOP.-GARBAGE COLLECTOR-1.e. there is simply no more memory space available.G2 TOO MUCH MARKING OF NON-LIST STRUCTURE. PANIC STOP.G3-GARBAGE CQLLECTOR-This error is given after G3 below has occurred ten times.The leniency allowed here has been inserted to permit agreat deal of information to be gleaned from one runrather than stopping immediately on an early error.MARKING IN NON-LIST AREA AT OCTAL/This error occurs when illegal list structure is foundduring the garbage-collector phase.Errors during the operation of the direction cards on input:01 NO INPUT DATA -0VERLORD-Overlord is the LISP routine which is controlled by thedirection cards, Error 01 arises when an end-of-file isfound in the wrong place, due to wrong input data.03 AN ERROR HAS OCCURRED IN THE PRECEDING SET1.e. an error has been found somewhere in the program fol-lowing the last SET direction card. This SET, see Section5.1, will not create a new base image of the memory on tape.04 END OF FILE ON INPUTSame as 01.05 ERROR IN READING TAPEThis is a machine error in reading either tape 8 or 9.

Errors during pri nting:P1P2PRINI ASKED TO PRINT NON-OBJECTIoee the printing program tried to print an item whichwas not an atomic symbol,PRINI ASKED TO PRINT UNPRINTABLE OBJECT1,e. the printing program tried to print an atomic symbolwhich does not have PNAME on its association list.Errors during read-in:RIR2R3R5R6ILLEGAL PUNCHING IN ON-LINE DATA -RTX-Sic1ST OBJECT ON INPUT LIST ILLEGAL -READ-This error may arise when there is an error in the numberof parentheses on the previous list read.OBJECT INSIDE AN INPUT LIST IS ILLEGAL -READl-1.e. an illegal character appeared in some atomic symbol,END OF FILE -RDA-The tape or card-reader ran out of cards before the correctnumber of parentheses were read, \NUMBER TOO LARGE IN CONVERSIONThe conversion program can convert a floating-point numberx of up to nine digits and an exponent, provided(x 1 L 2128- 10 38

9. Functions Available in LISPIn this section, a brief description is given of all thefunctions available in the LISP system as of March 1, 1960,A brief account is given for each function explaining the formof its argument, and its value. Whether the function is inmachine language (otherwise it must be interpreted by the APPLYoperator), and whether it is a special form is also included.In some cases, an M-expression for the function in terms of morebasic functions is appended, and in other cases a program writtenin the notation of the program feature (section 4.5) isgiven. The user of course need only give the function name andarguments--the M-expression or program are just included hereas amplified description.Since there are about ninety functions in the LISP system,they have been grouped into subgroups for easier reading. Thefunction index of Section 9.5 provides an alphabetic index forlooking up a function. Sections 9.1 and 9.2 include all thefunctions which are generally used. Section 9.1 discusses predicates,apply and -9eval simple functions, pseudo-functions fordefining other functions, functions to operate on lists, simplearithmetic functions, input-output functions, and the compilerfunctions. Section 9.2 consists of some special forms, such as- cond and quote. Section 9.3 discusses some of the less frequentlyused functions and could be skipped at first reading. Section9.4 contains rather specialized functions which have been relegatedto the Supplementary LISP System. To find out how to usea function from this last category one must consult the localexperts on LISP at M.I.T.

9.1 General FunctionsPredicates:I-atorn[x] : machine languageThe argument of atom is evaluated and the value of atomis true or false depending on whether the argument is or isnot an atomic symbol, In list terminology (see Chapter 6)the argument is an atomic symbol if and only if car[x] = -1.- --null[x] : machine languageThe value of - null is true if its argument is zero, andfalse otherwise.I -and[xl;x2; . . . ;xn] : machine language; special formThe arguments of - and are evaluated in sequence, from leftto right, until one is found that is false, or until the endof the list is reached. The value of - and is false or true respectively .or[xl;x2;*-;x 1 : machine language; special form- nThe arguments of - or are evaluated in sequence, from leftto right, until one is found that is true, or until the end ofthe list is reached. The value of - or is true or false respectively.-not [ x] : machine languageThe value of - not is true if its argument is false, andfalse if its argument is true,

s[x;y] : machine languageThe value of - eq is true if x = y and false if x # y,equal [x; y 1 : machine languageThe function equal compares the lists x and y and has thevalue true if the two lists are identical, and false otherwise,&[ x; y 1 : machine languageThe function - eql compares lists x and y of the followingspecial two-level form, where each element of the top levelpoints to a full word:- ---I-g e t r...IThe value of eql[x;y] is true if the two lists are identical,and false otherwise.(cwr[n] is the 36-bit contents of register n)Apply and Eval:apply[ f; x; p 1 : machine languageThe reader usually w i l l not have occasion to use thisfunction because essentially it gets done for him, but itoperates as follows,

apply~cadr[jl;x;pl];apply[cadr[f];x;caddr[f]];~apply[f;x;p] = [atomlf 1 -) app2Cf;x;pI; 4car[f] = LAMBDA -) evalEcaddr[f];append[pair[cadr[f];xI;PII;car[f 1 = LABEL + apply[caddr[f ];x;append[list[list[~adr[f];caddr[f]]];~]];car[f] = FUNARG +1 - - apply[eval[f;pI;x;pl IaThe forms involving LAMBDA, LABEL, and FUNARG are discussedin Section 4.3. The satellite functions for apply are the following:app2[f ;x;p] : machine languageThe function app2 is the apply operator (see apply) in thecase when f is atomic.app2[f;x;p] = select[f; [c~R;caar[x]]; [C~R;cdar[x]l;[CONS;cons[car[x]~cadr[x]]];[~~~~jx];search~A[ [ j];[eq[car[ jl;~UB~l~eq[car[jl;~~~~l11;A[[ jl;[eq[car[ j1;SUBRI + app3[cadr6jl;xl;T -+See the function select.A[[ jl;app~y[car[sassoc[f;p;errorIl~x;plapp3 [ f; x] : machine languageIn the case when - app2 (see above) in the apply functionfinds an atomic function specified by a machine-language subroutine,- app3 applies that subroutine to the list x of arguments.I I I

eval[e;b] - : machine languageThe reader should have no occasion to use this functionas such, since it is called in by the APPLY operator, but hemight be interested in its modus operandi which is as follows,(b is' the list of pairs of bound variables) :evlis[x;b] : machine language-The function evlis Zs used by ' $he function eval above..The arguments of'-.evlis are a list, 5, of expressions, and alist, b, - of bound variables. The function evlis constructsa list of the values obtained by evaluating each element ofthe list x - J using - eval and the list - b, and the resultant list

is the value of evlis.evlis[x;b] = maplist[x;h[[j];eval[car[j];b]]]Sim~le Functions:-car[x] : machine languageSee Chapter 2,Examples :-car[ (A,B) 3 = Acar[ ((A,B) )I.= (A$)cdr[x] : machine languageSee Chapter 2.Examples :cdr[ (A,B) 1 = (B)cdr[((A,B))] = NIL = ()- cad&r[x] car[cdr[cdr[cdr[x]]]~The APPLY operator can perform some multiple - carts and- cdrts, e.g.A depth of up to (and including) four a's or dts between thec and the r is permissible.- --cons [x;y] : machine languagecons[x;yl = (xoy)See Chapter 2,The value of - cons is the (location of the) stored word,

Defining Functions:The argument of define, x, is a lis-t of pairswhere each u is a name and each v is a A-expression or afunction, For each pair, define uses defl to make the EXPRon the association list for u point to vc The functiondefine puts things on at the front of the association list,The value of define is the list of uvs.The function deflist is usually used to tie the EXPR-searchrequired by define to the PRO-search in the program for -- defl.The argument of deflisl is a list of pairs. The functiondeflisl does a defl of each pair and has as value the list ofthe first element of each pair.Thus the functions deflist and -- deflisl carry out the pupposeof define by tying the PRO in ---- defl to EXPR and by carryingout the entire list of definitions (by the recursive functiondeflislj,

defl[x;e] -The function - defl puts a pointer to the expression e onthe rest of the list x from the point where it finds the attributePRO. If no such attribute is found, one is created,The value of - defl is x, In practice, PRO is usually pairedwith EXPR on the p-list,- defl is equivalent to the following (where the programfeature has been used)A[ 6x;el; ] where is the following program with no programvariables,rplaca6prop&x;~~0;h66 () 1 jcdr[attrib[x;list[pro;~~~] 11 ]] je)return[xlThus the association list will end up with PRO pointing to e asfollows :at trib[x; e 1 : rnachf ne languageThe function attrib concatenates its two arguments bychanging the last element of its first argument to point to thesecond argument, Thus it is commonly used to tack somethingonto the end of an association list. The value of attrib is thesecond argument. For exampleattrib[FF, (EXPR, (LADD~DA, (x), (COMD~((AToM~x),~),(T, (FF, CAR,^) ) ) ) ) ) 1would put EXPR followed by the LAMBDA expression for FF ontothe end of the association list fop FF.attrfb can be used to define a function provided no otherdefinition comes earlfer on the functionOs association lfst,but in general it is better to use define,

MORE]nconc[x;y]: machine languageThe function nconc concatenates its arguments withoutcopying the first one, The operation is identical to that ofattrib except that the value is the entire result, (i.e. themodified first argument, x),.The- program for nconc[x;y] has the program variable m andis as follows:nc~nc[x;~]-= prog[[ml;go[null[x] RETU;Tw CONT]C ONT m=xA1 go[null[cdr[x] ] * A2;T @MORE m = cdr[m]go[~llA2 cdr[m] = yRETN return[x]RETU re turn[y 1O~erations on Lists:list[xl;x2; ...; x n 1: machine language; special formThe function list of any number of arguments has as valuethe list of its arguments,For the APPLY operator, if p is the associated p-list,and x represents the string of xits above,append[x;y] : machine languageThe function append combines its two arguments into onenew list. The value of append is the resultant list. Forexample,

Note that append copies the top level of the first list; appendis like nconc except that nconc does no$ copy its first argument, --copy[xI : machine languageThis function makes a copy of the list x.copy is the location of the copied list,-The value ofmaplis t Cx; f IThe function maplist is a mapping of the list x onto anew list f[x],maplist[x;f 1 = [null[xI N1L;T consif [x];maplist[cdr[x1;fIllmapcon[x; f 1The function mapcon is like the function maplist exceptthat the resultant list is a concatenated one instead ofhaving been created by cons-ing,map[x;f IThe function - map is like the function maplist except thatthe value of - map is MIL, and - map does - not do a cons of the

evaluated functions. - map is used only when the action ofdoing f(x) is important,The program for - map[x;f] has the program variable m andis the following:map[x;fl E prog[[mljm=xLOOP ~o[~u~I.[~]~END;T-*coNT]CONT f[mlm = cdr[m]go [LOOPEND1re t UP~[NIL']conc[x;y] : special formThe function conc evaluates the items on the list x, and. .concatenates the values, The value of cone is the final con-catenated list, The items on the list x must either be boundon the list of pairs, y, or have APVAL or APVALI on their associationlists,let x = (x,Y,z)-and let Y have APVAL on its list pointing tothe value Y, thenwconc[x;yl = (w,Y,R)pair[x;y] - : machine languageThe function pair has as value the list of pairs of correspondingelements of the lists x and y. The arguments x andy must be lists ~f the same number of elements. They should - not

e atomic symbols,search[x;p; f;u] :The function search looks through a list x for an elementthat has the property p, and if such an element is found thefunction f of that element is the value of search. If there isno such element, the function u of one argument, x, is taken asthe value of search (in this case x is, of course, NIL)subs t [x; y; z 1 : machine languageThe function subst has as value the result of substitutingx for all occurrences of the atomic symbol y in the S-expressionsublis[x;y] : machine languageHere x is a list of pairs,((u19vl), ( ~ ~ 3 "', ~ ~ ( ) ~ ' ~ 9 ~ ~ ) )where the uls are atomic. The value of sublis[x;y] is theresult of substituting each v for the corresponding u in y.Note that the following M-expression is different fromthat given in Chapter 2, though the result is the same.

-ins t [x;y; z]: machine languageHere x is assumed to be an incomplete list of pairs((ul,vl), (u2,v2),. . ,(un9vn)), where the ud s are atomic andwhere some v's may be missing, The value of - inst is false ifz cannot be obtained as sublis[%;y] where r;?r is a completion ofx obtained by substituting appropriate pairs (u,v) for the unpairedelements (u). If z can be obtained in this way, inst[x;y;z] has as value the completed list x, The purpose ofinst is to determine whether z is a substitution instance ofthe expression y,sassoc[x;y; u] : machine languageThe function sassoc searches y, which is a list of lists,for a sublist whose first element is identical with x, Ifsuch a sublist is found, the value of sassoc is the sublistwith the first element removed. Otherwise the function u ofno arguments is taken as the value of sassoc,

ArithmeticFunctions:sum[x; y] : machine languageThe function - sum computes the sum of two floating-pointnumbers. The arguments x and y can be quoted numbers, or canrepresent numbers by being paired with numbers on the p-list,Thus the following two cases are equivalent:(1) (suM,(QuoTE,~.o),(QuoTE,~~.~))(2) (SUM, QUOTE,^.^),^) with (~,21,4) on the p-list.prdct[x;y] : machine languageThe function prdct computes the floating-point product oftwo floating-point numbers. The arguments x and y must be expressedin one of the forms given under the function - sum,expt[x,n] : machine languageThe value of expt is the floating-point number xn where xis a floating-point number and n is a floating-point positiveor negative integer, The arguments must follow one of theforms described under the function - sum.Input-Output Functions-read : machine languageThe function read of no arguments reads one list fromcards or tape (depending on the sense-switch settings), Thevalue of read is the list it has read,

prog[prin2[d~rinl[~];The function print prints out (on-line or off-line dependingon sense-switch settings) its argument x if x is a legallist structure, and malfunctions if it is not, If x is NIL ablank line is printed. The value of print is always zero,In the following explanation of print, prin2 is a routinewhich places in the line to be printed up to six BCD characterswhen the characters are pushed to the left with the restof the register filled in by the illegal character 77. Thelocations A, , , and d mentioned below contain respectivelyBCD representations of left-parenthesis, right-parenthesis,comma, and blank (space) in the form appropriate for~rin2.Here terpri (terminate print) is a machine language functionwhich prints out the line of characters which have been placedthere by the function prin2,printa[x] '= -+ [null[xl I -+ ;atom[xlT + [all; (printa subprogram) ]Jwhere the (printa subprogram) is the following:a1 = xPLENDprin2[~]printa[car[Jl]]null[cdr[al] -+ ] go [END]prin2['1~ 111 = cdr[al]~OCPLIprin2[p]re turn

prinl[x] : machine languageThe routine prinl prints the print name of the atomicsymbol x. The value of prinl is NIL. If x is not an atom,an error occurs.printprop[x] :The function printprop prints the properties on the associationlist of the atomic symbol, x. The parts of thelist pointed to by any of FLO, SUBR, FSUBR, PNAME, APVAL, orINT are not printed,The function prog2[x;y] used by printprop has the valuey, though x may be used to effect some action. For example,prints outand then goes to printpl below.printpl[x](see printprop[x])The function printpl, which does the printing of theproperties is

puncha[x] : machine languageThe function punchi writes the list x out onto tape 7 inBCD form for off-line punching. The resultant cards have thelist information in consolidated form, i.e. extra blanks havebeen left out and commas inserted in the correct locations.All 72 columns of the card are used,-punchs[x] : machine languageThe function punchs writes the list x out onto tape 7for off-line punching. Each sublist of the top level of listx appears as a separate card punched in SAP format. punchs isused with the LISP compiler.punchdef [x] :The function punchdef writes the definition of the functionsnamed in the list x out on tape 7 in BCD for off-linepunching. If any item of the list x does not have EXPR orits association list, punchdef gives an error indication.Error Function:errorix] : machine languageThe function error of one argument (the list x) causesan error print-out followed by a print-out of x. x can begiven as NIL.Com~iler Functions:The pseudo-function comdef compiles all the functions

PR0GA;Tprintlist[named on the list x provided that the functions have EXPR anda definition on their association lists. See Section 4.6.The function comdef uses the function compile (see below)as shown in the following:comdef [x] = compile [mapcon[x;~[[ j 1 ;"program"'] 1 1where the "program" involved is as follows with program vari-ables k and p:P = car[ jlk = get[p;ExPR]return[null[k] @ -+ PROGB]PROGA [null[get[p; SUBR] 1 +PROGB[ cons[p; (IS,NOT,DEFINED) 1 I;T -+ print [cons[p; (HAS, ALREADY,BEEN, COMPILED) 1 1return[NIL]remprop[p;Ex~R]-+ return[eq[car[k];LAB~L] list[k];Tlist LABEL;^;^] ] ]-+- get[x;yl :The function - get is used by comdef above. It searchesthe list x for an item identical with y. When such an element- -ginning immediately after the element.is found the value of get is car of the rest of the list be-compile[xl :The pseudo-function compile can be used to compile func-tions not previously defined. The argument of compile is alist of function definitions, each one of which must be ofthe form(LABEL,NAME, (LAMBDA, (list of free variables) ,Expression) ).

9.2 Special Formsquote : machine language; special formThe value of a list beginning with QUOTE is always therest of the list. Note that QUOTE must be used in expressionsbeing evaluated whenever one wishes to avoid evaluating anitem--for example QUOTE,^) yields x itself rather than avalue assigned to X by some other means.cond[xl;x2; ...; x 1 : machine language; special form - nThe function cond has a variable number of arguments,each one of which is a pair of expressions of the formThe propositions are evaluated until one is found that is true.The expression corresponding to this proposition is evaluatedand taken as the value of the entire conditional.Except for its use with the compiler at least one of thepropositions of cond must be true or an error will occur. -label [ a; b 1 : machine language; special functionThe effect of label as the first element of an expressionis described in Section 4.3 of this manual.The function format has the value x. x is an atomic symbol,f is a list structure, and v is a list of variables occurringin f. The function format causes x and the variablesof v to become functions which are available to the APPLY operator.The following example of its use is taken from anearlier version of the programmer's manual.

Consider ~~~~~~[SHAKESPEARE;(UNDER,GREENWOOD,TREE);(GREENWOOD, TREE) 1There are two variables involved, GREENWOOD and TREE.Then the execution of format generates three functions towhich we could give argumentsshake speare [ SPREADING; CHESTNUT 1greenwood [ (BENEATH, SPREADING, CHESTNUT) 1tree [ (BENEATH, SPREADING, CHESTNUT) ]Executing these functions in turn gives(UNDER,SPREADING,CHESTNUT)SPREADINGand CHESTNUT respectively.Thus shakespeare has as argument a list u which must containas many terms as v; and substitutes in f for one occurrenceof each variable in v the corresponding variable in u,greenwood and tree have as argument a list structure gand pick out the element in g which occupies a position correspondingto their's in f.

function[ f ] : machine language; special formIf the first element of an S-expression is FUNCTION, thesecond element is understood to be the function. A new list isconstructed with first element FUNARG, second element equal tof, and third element equal to the current list of bound variables.1.e.Having such a list of bound variables carried along withthe function insures that the proper values of the bound variablesare used when the function is evaluated. Thusprog[pv; el; e2; e3; . . . ; e ] : machine language; special formnThe program feature is discussed in Section 4.5. For interestwe include here the program which the interpreter usesto work out a program given by the list pv of program variables,and the sequence, elye2,.*.,en of program statements.In the following p is the usual p-list of pairs, and estands for the entire list(pv,el'e2,e3," >en)'so that car[e] = pv.The program variables used below for the program -- for progare t2, p2,pr, and r.t2 = maplist[car[e];h[[ j];list[car[ NIL] 11p2 = append[t2;p]pr = cdr[e]r = prgo[atom[car[r] 1+ A~~;eq[caar[r];~~] GO;eq[caar[r];~~~uRN] + RET;T + NORM]

NORMADVeval[car[r];p2]r = cdr[r]go[M~lRET return[eval[cadar[r];p2] 1GOt2 = eval[cadar[r];p2]sear~h[~r;h[[ j];eq[car[ jl;t2l;~[[jl;setq~~;~~~~~~A[[ j1;errorIlgo[~IJlselect[q; (ql,eL); (q2,e2);. . .; (qn,en);el: special formThe qits in select are evaluated in sequence from left toright until one is found such thatand the value of select is the value of the corresponding el.If no such qi is found the value of select is that of e.9.3 Further Functionsrplaca[x;y] : machine languageThis pseudo-function replaces the address part of thefirst argument x by the second argument y. 1.e. y is storedin the address part of the location pointed to by the firstargument. The value of rplaca is NIL.rplacd[x;y]: machine languageThis pseudo-function replaces the decrement part of thefirst argument x by the second argument y. 1.e. y is stored inthe decrement part of the location pointed to by the first ar-gument.The value of rplacd is NIL.

desc[cdr[x];cdr[y]-desc[x;y] : machine languageThe function desc (descend) is a function of two arguments,the first of which must be a list of the atomic symbols A (for- car) and D (for- cdr). The value of - desc is the result of executingon the second argument the sequence of - car's and - cdrlsspecified by the first argument. The operation indicated bythe first element of the list of Ags and D1s is executed first.Illegal list structure is not checked for,desc[x;y] = [null[x] -* y;atom[x] -* error; eq[car[x];A] +desc[cdr[x];car[y] -+ ];T11The function pick - finds the atomic symbol, x, in the liststructure, y. The value of pick is a list of A's (for-car) andD1s (for-cdr) which give the location of x in y. This valuecould be used for example as the first argument of - desc.Example :pick[x;y] =pick[v; (((u,v)),w)l = (A,A,D,A)null[^] -) N~;equal[x;~] -* N~~;atom[~] -* NO;T -* A[[ j]; [equal[ A NO] + h[[k]; [equal[k;~~l + NO;T -* cons[~;k]]][pick[x;cdr[ylll;~~ cons[~;jlll[pick[x;car[y] 111~rop[x;y; u] : machine languageThe function prop searches the list x, for an item identicalwith y. If such an element is found, the value of - prop is therest of the list beginning immediately after the element, Otherwisethe value is u, where u is a function of no arguments.

empropCx;p] :The function remprop searches the list, x, looking for a11occurrences of the property p. When such a property is found,its name and the succeeding element are removed from the list.The two "ends" of the list are tied together as indicated bythe dashed line below,I &nameof the propertyThe value of remprop is NIL.where,where prog2[u;v] has the value v, and uses u to effect an action.- se t [x; y 1 : machine language- setq[x;y] : machine language; special formThe - set and setq functions are used to change the valuesof the program variables when using the program feature (seeSection 4.5). The program variables are initially bound tonull lists.Note that (in S-expression form),

eturn[^]intv[x] : machine language; special functionThe function intv finds the address of the value of theinteger on the association list of xaf lval [x] : machine languageThe function flval finds the address of the floatingpointnumber on the association list xd The value of flvalis the address of the floating-point number,The program for flval istsf lo t [XIflval[x] E pr~g[[]; ' 1 1not[atom[x] ] return[error]B1 null[cdr[x] ]-+ return[error]x = cdr[x]car[x] f FLO -+ go[B1]return[cadr[x]]: machine languageThe proposition tsflot is true if the association list forx contains FLO pointing to a floating-point number, Otherwisethe proposition is false,The program for tsflot istsflotB1prog[ [I;not[atom[x] I -+ return[F]-+ null[x]car[x] = FLO*return[~lx = cdr[x]goC~11

count: machine languageThe function count is a function of no arguments. Itsvalue is identically zero. Its effect is to turn on the CONScounter. If the counter is already on, count resets thecounter to zero.The CONS counter is a counter which is incremented everytimea word is constructed by the LISP system and put intofree storage. This counter is to some extent a measure ofthe length of a program and an indicator of the amount offree storage it is using up.uncount : machine languageThe function uncount of no arguments turns off the CONScounter. See the function count for a description of thiscounter.speak : machine languageThe function speak of no arguments, causes the contentsof the CONS counter to be printed on-line or off-line dependingon the sense-switch settings. See the function count fora description of this counter.The function compsrch composes an S-expression which willbe interpreted by the APPLY operator as a search. The purposeof this new function is to speed up the operation of the searchon its recursive paths. The search, at each recursion, requiresthe APPLY operator to rebind - all of the variables x, d,f, and u, whereas generally only the x need be revised. Thesearch in compsrch rebinds only the x at each recursion.

The program for compsrch has the program variable v andis the following:compsrch[x;d;f; u] prog[ [v];v =. gensym(see the function gensym)return[defL[x; [searchf[x;v; substh:~; car[bndv[d] 1;fo~m&d]];subst[v;ca~[bndv[f]];for"m6:f]];fo~m[u]]]]]*In this program the PRO of defL has been tied to EXPR on thep-list,Note that compsrch avoids the rebinding of d and f bysubstituting the uniquely generated atomic symbol for v intod and f,The functions searchf, bndv, and - form are described below.As an example of the use of compsrch, assume that a func-tion, called FINDNAME, is to be defined for the interpreter,where FINDNAME is to search any list for PNAME and have theportion of the list pointed to by PMAME as its value,Below are examples of how this function may be defined. (using the APPLY operator), by using DEFINE, and then, on theother hand, by using COMPSRCH>CCDEFINE(FINDNAME, (LAMBDA, (L),(SEARCH, L Y ~(FUNCTION, (LA~DA, (J) (EQ~(CAR, J), (QUOTE, PNAME) ) ) ),orCOMPSRCH(FINDNAME,(FUNCTION, (LAMBDA, (J) , (CADR,J) )(FUNCTION, ERROR ),( ,11) i,

ndv[x] :This function has been introduced into the functioncompsrch as a function whose form later may change.bndv = cadr[x]form [XI :This function has been introduced into the functioncompsrch as a function whose form later may change.searchf [x;v;p; f; u] :See the function compsrch; the function searchf is thefast search whose S-expression is set up by compsrch.searchf[x;v;p;f;u] = h[[x;v;p;f;u];sublis[ N NAME,^), (VAR,V),(PF~P),(FF, f ),(UF, u ) );(LAMBDA,(VAR) ,(COND,((NULL,VAR) ,uF), (PF,FF), (T, (NAME,(CDR,VAR)) ) ) ) I I Icpl : machine languageThe function - cpl copies into free storage a list of thefollowing special two-level form (see the function - eql), whereeach element of the top level points to a full word.{Full word [

NIL;T+The value of - cpl is the location of the copied list.cpl[x] = [null[x] -+cons[consw[cwr[car[x]]];cpl[cdr[xlllle ere cwr[n] is the 36-bit contents of register n.)consw : machine languageThe function consw (construct word) is not strictlygrammatical in the LISP-sense. It takes the contents of theAC and sends them to the next free storage location. As withcons the value of consw is the location of the stored word.gensyrn : machine languageThe function gensym has no arguments. Its value is anew, distinct, and freshly-created atomic symbol with a printname of the form G0001,G0002,.,.,G9999.This function is useful for creating atomic symbols whenone is needed; each one is guaranteed unique.tracklist[x] : See Section 5.2The function tracklist is a function of one argumentwhich is a list of the LISP functions to be traced. Eachfunction mentioned in the list must be a function which hasEXPR, FEXPR, SUBR, or FSUBR on its association list. Thevalue of tracklist is a list of the routines it will be ableto trace.makcblr[x] :This function ("make car or cdr abler") uses the functiondesc to speed up and improve functions such as - caar or caddr,etc. The argument x is a list of pairs of the form, forexample,

The function makcblr takes this list and on the associationlist of the first element of each pair puts EXPR followed bythe lambda expression,where the second list of the pair has been substituted forWAY.-The function funarg is uszd below to bind the PRO usedby def 1 to EXPR.makcblr[x] = funarg[h[ j];maplist[ j;~[[k];defl[car[car[k]];subst[car[cdr[car[k]]];~~~;(LAMBDA, (J), (DESC, (Qu~TE,wAY),K))( (PRO, EXPR) ) I11 111;prog2[x;yl :The value of prog2 is always the value of the second argumenty, but the expression for the first argument x isevaluated first. x generally is used to effect some-action.Cf.the use of prog2 in the function printprop.Functions on the Supplementary LISP Systemcompab [x; Y; z 1 : machine languageThe function compab is a predicate whose value is true ifthe absolute value of the difference between x and y is less .than z, and whose value is false otherwise. x, y, and z areall floating-point numbers.

--- ~reaterlp; q] : machine languageThe function greater is a predicate whose value is trueif the fifteen-bit quantity p is greater than the fifteenbitquantity q. Otherwise, the value of greater is false.This function is useful for ordering atomic symbols in a list,e.g. to put the list in some canonical form for comparisonwith other such lists.largerc~;~] : machine languageThe predicate larger is true if list x is larger thanlist y, and false otherwise, Larger is used, as one may notein the definition below, to mean either that some pair ofcorresponding elements obey the greater relation, or, if thisis not relevant, that the list; x is the longer, ._smplfy[x] : machine languageThe function smplfy takes the algebraic expression x andsimplifies it. The resultant expression is the value ofsmplfy.The notation allowed in the algebraic expression is anycompounding of the following modified polish notation:f(TIMES,A,B,C);(any number (71) of arguments)(PLUS, A,B, c); (any number (11) of arguments ), ,(MINUS,X)(POWER,X,Y) = xAY

For example,1(a)(b)(,) - d e is written asFor further discussion of the smplfy function, seeGoldberg, Solomon H., "Solution of an Electrical Network usinga Digital ~omputer", S.M. Thesis, Course VI, M.I.T., August,1959distrb[e;p] : machine languageThe function dstrb will distribute conditionally theproducts of sums appearing in the expression e. The propositionp determines whether a given sum is to be distributed,Thus in the following example let the proposition p of a sumbe that "if y is included in a sum, do not distribute thissum", then(x+a ) (y+z+b ) (w+2)distributes to(xw) (y+z+b )+ (2x) (y+z+b)+ (aw) (y+z+b)+ (2a) (y+z+b)For the correct notation for sums and products in LISP seeabove under the function smplfy.diff [y;x] : machine languageThe function diff differentiates the algebraic expressiony, with respect to x. The value of diff is the (unsimplified)algebraic expression, . Gradients must be provided on3 xthe association lists of all the functions used in the expression,y, except for PLUS and TIMES. See the notation andreference given under smplfy.

matrixmultiply[x;y] : machine languageThis function has as value a matrix' which ,is the productof the row matrix, x, and the column matrix, y. The two matricesare entered either as direct functional arguments inmatrixmultiply or from being given on the p-list, For ex-ample, if the matrixis to be multiplied by itself, the two arguments, for theAPPLY operator are in the formActually any atomic symbols may be used in place of ROW or COL.It is only necessary that the rest of each sublist be the elementsof the row matrix and the column matrix to the right or-der. See page 126 of the following reference where this functionwas developed,Goldberg, Solomon H., "solution of an Electrical Networkusing a Digital Computer", S.M. Thesis, Course VI, M.I.T.,AU~US t , 1959.reduce [ m] : machine language- The function reduce reduces an ngn matrix to an (n-l)g(n-I) matrix. The function has been used in electrical networkreduction. See the references under reducetonxn below.

educetonxn[m;n] : machine languageThis function uses the function reduce to reduce a squarematrix m to an nxn matrix whose rank is less than that of m.The argument n must be given in floating-point form. This\function has been used in electrical network reduction, seeEdwards, Daniel J., "symbolic Circuit Analysis with the704 Electronic ~alculator", S.B. Thesis, Course VI, M.I.T.,June, 1959.Goldberg, Solomon H., "~olution of an Electrical Networkusing a Digital Computer", S.M. Thesis, Course VI, M.I.T.,August , 1959.

9.5 Alphabetic Index to FunctionsFunctionand ........................................ 114app2 ...................................I... 116app3 ....................................... 116al2pend* ..............................I..... 121apply ..................................... 0115atom .............................I......... 114attrib ..................................... 120bndv ............ . . . . . . . . . 4 . e . . e . e . . e . I . . . * a 140.I18cdr ........................................ *118comdef ... l l . D . . . l . . ~ . . . . 0 0 0 ~ . I ~ * 6 e ~ ~ ' ~ 29 ~ .compab 142car ............................................................................compile .......................................................................130compsrch 138conc ............l....e.O1.................. a1 23cond ....................................... 131cons 118.......................................consw ................................... *..141copy .....I.......*..................*.count ................................... 38cp1 ....................I...........6....... 140#t*e.122defl ..................................... 20define ..................................... 119deflist ............................. *.*I19deflisl .................................... 119

Function Page .desc ....................................... 135diff ....................................... 144distrb ................................... 144eq ......................................... 11 5eql .. ...........O......................D... 11 5equal ...................................... 11 5error ...................................... 129eval ....................................... 11 7evlis ...................................... 11 7expt ....................................... 126flval ...................................... 137form ...*................................... 14031133format ................................... *.1function ...................................gensyrn ..................................... 141get ........................................ 130greater .................................... 143inst ....................................... 125intv ....................................... 137.......................................list .......................................label 131larger ......o..........................e.. 14 3121. makcblr ..........o.....................e.. 141map ........................................ 122

Function Page .mapcon ..................................... 122maplist .................................... 122matrixmultiply ............................. 145nconc ...................................... 121not .....................................e.. 114nu11 ...................................... .. 114pair ....................................... 123pick ....................O...o..............135prdct ..................................O... 126print ......................................127prinl ....................................*.128printprop ................................. 128printpl .....o.o......eeo.e.................. 128prog .O .Oa.e . 133prog2 ...................................... 142prop ...O................O............O..... 135.punchdef ................................... 129punch 4 ..................................... 129punchs ..................................... 129quote .....o........o....................... 131read .........................o.O~.e.~.O.... 126reduce ...................................*.145reducetonxn . . . . . . . . ~ O o O O O ~ . . . . . . . . . . . . . o ~ ..I 46remprop ..................................*.136

Function..........................................................................Page~Pla.ca 134rplacd 134sassoc ..................................... 125search ..................................... 124searchf .................................... 140select ..................................*.. 134set ........................................ 136setq ....................................... 136srnplfy ..................................... 143speak ...................................... 138sublis ..................................... 124subst ...........o..O....................... 124sumo .......................................126tracklist .................................. 141tsflot ..................................... 137

GENERAL INDEXActive register, 96APPLY operator, 37APVAL, 46, 89APVAL1, 46, 89Argumentsfunctional, 21number of, 107Arithmetic functions, 126Association list, 84, 88-95Atomic function; see Functions, atomicAtomic symbol, 10list of, 88Base memory image, 67Bound variable; see Variable, boundCard punching, 65Collapsing-list function, 99Commaomission of, 24, 66Compiler, 53-64functions, 129-130Compound function; see Functions , compoundConditionals, 4, 107in program feature, 56Cons counter, 109, 138Conversion, see Numbers, conversion ofCRD, 67cwr, 115

GENERAL INDEXDebugging; see TracingDefinition of functions, 23, 40-43, 91, 119at run time, 105error indication, 107, 108Differentiation, 22, 144Dot notation, 24, 84, 88Dummy variable; see Variable, dummyElementary functions, 12Error indications, 107-112EXPR, 41, 44, 53, 91FEXPR, 48FIN, 67Findex, 93Flexowriter, 71-82FLO, 49, 92Floating-point numbers; see NumbersFLX, 67Forms, 7Fortran, 50Free storage, 60, 95-97Free variable; see Variable, freeFSUBR, 48FUNARG, 45, 133

GENERAL INDEXFunctions, 3alphabetic list of, 147-150arguments for, 107atomic, 44compound, 44computable, 14definition; see Definition of functionspartial, 3pseudo-, 43recursive, 3, 5, 9use of, 24, 37Garbage collector, 89, 95-97, 111GO, 50-51fresh, 74Input-output functions, 126INT, 90Integers, 49, 90, 137Ioflex, 77Ioflip, 77Label, 9, 17, 43, 45, 47 .Lambda, 8, 17, 45LCON deck, 66Length-of-list function, 50, 104LISP-SAP, 54List, 11, 16of atomic symbols, 88of floating-point numbers, 92operations on a, 121-125

List structure, 83-95GENERAL INDEXM (meta) - expressions, 12translation to S-expressions, 17for program feature, 53Macro, 57MINUS, 49, 92NUMB, 92Numbers, 49-50, 137association list for, 92conversion of, 112floating-point, 49-50, 92list of floating-point numbers, 92range of, 50See also: Arithmetic functions, IntegersObject, 88Overlord, 111p-list, 20, 37, 45-47Partial function; see Functions, partialPerformance request card, 69PNAME, 89-90> 92Polish notation, 21Predicates, 4, 114Program feature, 50-53, 133Program variable; see Variable, programProperty list, 88See Association list

GENERAL INDEXPropositionalcalculus; see Wang algorithmconnectives, 4, 7expression, 4Pseudo-function; see Functions, pseudo-Push-down list, 59, 109Quote, 17, 24, 40, 48Recursive function; see Functions, recursiveRequest card, 69REMRETURN, 50-51Reversing-list function, 103S (symbolic) - expressions, 10translation from M-expressions, 17represented by list structure, 83-86Sequence-mode, 73SET, 67Set, 51, 107Setq, 51, 107Special forms, 48, 131-134STOP, 66SUBR, 41, 44, 54, 90Supplementary system, 142Switches, 69

GENERAL INDEXTapes, 68TEN-mode, 75Tracing, 25, 70Tracklist, 25, 70Triplet, 40TST, 66TXL to subroutine, 41, 54Variablebound, 8, 9dummy, 8, 46free, 8, 37, 108program, 51Wang algorithm, 25