maclennan chap9 lisp

7/31/2019 Maclennan Chap9 Lisp

1/90

List ProcessingList Processing

LISPLISPMacLennan- Chap. 9MacLennan- Chap. 9


2/90

22

History and MotivationHistory and Motivation


3/90

33

The Fifth Generation ComprisesThe Fifth Generation Comprises

Three Overlapping ParadigmsThree Overlapping Paradigms

functional programmingfunctional programmingobject-oriented programmingobject-oriented programminglogic programminglogic programming

Lisp is for functional programming.Lisp is for functional programming.


4/90

44

The Desire for an Algebraic List-The Desire for an Algebraic List-

Processing LanguageProcessing LanguageLisp is developed in the 1950s for artificialLisp is developed in the 1950s for artificialintelligence programming.intelligence programming.

In these applications complexIn these applications complexinterrelationships among data must beinterrelationships among data must berepresented.represented.

Natural data structures are:Natural data structures are: PointersPointers Linked listsLinked lists


5/90

55

In the 1950s Newell, Shaw, and Simon (atIn the 1950s Newell, Shaw, and Simon (at

Carnegie institute of technology and theCarnegie institute of technology and theRand Corporation) developed many of theRand Corporation) developed many of theideas of list processing in the IPL family ofideas of list processing in the IPL family of

programming languages. these ideasprogramming languages. these ideasincluded the linked representation of listincluded the linked representation of liststructures and the use of a stackstructures and the use of a stack(specifically, a push-down list) to(specifically, a push-down list) toimplement recursion.implement recursion.


6/90

66

In the summer of 1956, the first major workshopIn the summer of 1956, the first major workshopon artificial intelligence was held at Dartmouth.on artificial intelligence was held at Dartmouth.At this workshop john McCarthy, then at MIT,At this workshop john McCarthy, then at MIT,

heard a description of the ipl2 programmingheard a description of the ipl2 programming

language.language.which had a low-level pseudo-code, orwhich had a low-level pseudo-code, or

assembly-language-like syntax.assembly-language-like syntax.McCarthy realized that an algebraic list-McCarthy realized that an algebraic list-

processing language, on the style of the recentlyprocessing language, on the style of the recentlyannounced FORTRAN I system, would be veryannounced FORTRAN I system, would be veryuseful.useful.


7/90

77

FLPL Was Based on FortranFLPL Was Based on Fortran

That summer Gerlernter and Gerberich of IBMThat summer Gerlernter and Gerberich of IBMwere working, with the advice of McCarthy, on awere working, with the advice of McCarthy, on ageometry program. As a tool they developedgeometry program. As a tool they developed

FLPL, the Fortran list-processing language, byFLPL, the Fortran list-processing language, bywriting a set of list-processing subprograms forwriting a set of list-processing subprograms foruse with Fortran programs.use with Fortran programs.

One result of this work was the development ofOne result of this work was the development of

the basic list-processing primitives that werethe basic list-processing primitives that werelater incorporated into lisp.later incorporated into lisp.


8/90

88

McCarthy Developed the CentralMcCarthy Developed the Central

Ideas of LISPIdeas of LISP

FORTRAN I had only one conditional constructFORTRAN I had only one conditional constructthe arithmetic IF-statement.the arithmetic IF-statement.This construct was very inconvenient for listThis construct was very inconvenient for list

processing.processing.which led McCarthy, in 1957, to write an IFwhich led McCarthy, in 1957, to write an IFfunction with three arguments:function with three arguments:

X = IF (N .EQ. 0, ICAR(Y) , ICDR(Y))X = IF (N .EQ. 0, ICAR(Y) , ICDR(Y))If N were zero, then X = ICAR(Y) else X =If N were zero, then X = ICAR(Y) else X =

ICDR(Y)ICDR(Y)


9/90

99

An important consequence of thisAn important consequence of thisinvention was that it made it feasible toinvention was that it made it feasible tocompose IF function and the list-compose IF function and the list-processing functions to achieve moreprocessing functions to achieve morecomplicated actionscomplicated actions..Since FORTRAN does not permitSince FORTRAN does not permitrecursive definitions, it became apparentrecursive definitions, it became apparentthat a new language was needed.that a new language was needed.

In 1958 McCarthy began using recursionIn 1958 McCarthy began using recursionin conjunction with conditional expressionin conjunction with conditional expressionin his definition of list-processing functions.in his definition of list-processing functions.


10/90

1010

The Lisp List-Handling RoutinesThe Lisp List-Handling Routines

Were Developed FirstWere Developed Firstin the fall of 1958, implementation of a LISPin the fall of 1958, implementation of a LISPsystem began.system began.

One important component of this was a setOne important component of this was a setof primitive list-handling subroutines for theof primitive list-handling subroutines for the

lisp run-time environment.lisp run-time environment.These were the first parts of the system thatThese were the first parts of the system that

were implemented.were implemented.

The original intention was to develop aThe original intention was to develop a

compiler like FORTRAN.compiler like FORTRAN.Therefore, to gain experience in codeTherefore, to gain experience in codegeneration, a number of LISP programs weregeneration, a number of LISP programs werehand compiled into assembly language.hand compiled into assembly language.


11/90

1111

A LISP Universal FunctionA LISP Universal Function

Resulted in an InterpreterResulted in an InterpreterMcCarthy became convinced thatMcCarthy became convinced thatrecursive list-processing functions withrecursive list-processing functions withconditional expressions formed an easier-conditional expressions formed an easier-

to-understand basis for the theory ofto-understand basis for the theory ofcomputation than other formalisms suchcomputation than other formalisms suchas Turing machines.as Turing machines.

Recursive Functions of SymbolicRecursive Functions of SymbolicExpressions and Their Computation byExpressions and Their Computation byMachine.Machine.


12/90

1212

He defined a universal LISP function thatHe defined a universal LISP function thatcould interpret any other lisp function.could interpret any other lisp function.

he wrote a LISP interpreter in LISP. Sincehe wrote a LISP interpreter in LISP. Sincemanipulates only lists, writing a universalmanipulates only lists, writing a universalfunction required developing a way offunction required developing a way ofrepresenting LISP program as listrepresenting LISP program as list

structures.structures.


13/90

1313

For example the function callFor example the function call

f [x+y; u*z]f [x+y; u*z]

Would be represented by a list whose firstWould be represented by a list whose firstelement is f and whose second and thirdelement is f and whose second and third

element are the lists representing x+yelement are the lists representing x+yand u*z. in LISP this list is written asand u*z. in LISP this list is written as

(f (plus x y) (times u z) )(f (plus x y) (times u z) )


14/90

1414

The algol-like notation (e,g., f[x+y;The algol-like notation (e,g., f[x+y;u*z]) is called M-u*z]) is called M-expressionsexpressions (M for(M for

meta-language).meta-language).The list notation is called S-The list notation is called S-expressionsexpressions (S for symbolic language)(S for symbolic language)


15/90

1515

LISP Became Widely Used inLISP Became Widely Used in

Artificial IntelligenceArtificial IntelligenceThe first implementation of LISP was on IBM 704The first implementation of LISP was on IBM 704LISP systems rapidly spread to other computers,LISP systems rapidly spread to other computers,and they now exist on virtually all machines,and they now exist on virtually all machines,

including microcomputers.including microcomputers.LISP has become the most widely usedLISP has become the most widely usedprogramming language for artificial intelligenceprogramming language for artificial intelligenceand other symbolic applications.and other symbolic applications.

LISP was standardized after a period ofLISP was standardized after a period ofdivergent evolutiondivergent evolution


16/90

1616

DESIGN: STRUCTURALDESIGN: STRUCTURAL

ORGANIZATIONORGANIZATION

An Example LISP Program (in the S-An Example LISP Program (in the S-expression)expression)

Page 312Page 312


17/90

1717

Function Application Is theFunction Application Is the

Central IdeaCentral Idea

programming language are often dividedprogramming language are often dividedinto two classes:into two classes:Imperative languageImperative language

Depend heavily on an assignmentDepend heavily on an assignmentstatement and a changeable memory forstatement and a changeable memory foraccomplishing a programming task.accomplishing a programming task.

Applicative languageApplicative languageThe central idea is function application, thatThe central idea is function application, thatis, applying a function to its argument .is, applying a function to its argument .


18/90

1818

In the LISP almost everything is a functionIn the LISP almost everything is a functionapplicationapplication

((f a1 a2an)f a1 a2an)where f is the function and a1, a2, , an are thewhere f is the function and a1, a2, , an are the

arguments. This notation is calledarguments. This notation is called CombridgeCombridgePolish (prefix notation).Polish (prefix notation).Example:Example:

(plus 2 3)(plus 2 3)

(plus 10 5 8 64)(plus 10 5 8 64)LISP isLISP is fullyfullyparenthesizedparenthesized


19/90

1919

ExampleExample

(set Freq (make-table text nil))(set Freq (make-table text nil))is a nested function application : set isis a nested function application : set isapplied to two arguments:applied to two arguments:

FreqFreqthe result of applying make-table to thethe result of applying make-table to thearguments text and nil.arguments text and nil.

In an Algol-like language this would beIn an Algol-like language this would bewrittenwrittenset (Freq, make-table (text, nil))set (Freq, make-table (text, nil))


20/90

2020

ExampleExample

(cond(cond

((null x) 0)((null x) 0)

((eq x y) (f x))((eq x y) (f x))

(t (g y)) )(t (g y)) )

In an Algol-like language this would be writtenIn an Algol-like language this would be written

IfIf null(x)null(x) thenthen 00

elseifelseif x = yx = y thenthen f(x)f(x)elseelse g(y)g(y) endifendif


21/90

2121

function definition is accomplished byfunction definition is accomplished by

calling a function,calling a function, defundefun, with three, with three

arguments: the name of the function,arguments: the name of the function,

its formal parameter list, and its body.its formal parameter list, and its body.


22/90

2222

Why is everything a functionWhy is everything a functionapplication in LISP?application in LISP?

Simplicity PrincipleSimplicity Principle

If there is only one basic mechanism in aIf there is only one basic mechanism in alanguage, the language is easier to learn,language, the language is easier to learn,understand, and implement.understand, and implement.


23/90

2323

The List is the Primary DataThe List is the Primary Data

Structure ConstructorStructure Constructor

We said that one of LISPs goals was to allowWe said that one of LISPs goals was to allowcomputation with Symbolic data.computation with Symbolic data.This is accomplished by allowing the programmer toThis is accomplished by allowing the programmer to

manipulate lists of data.manipulate lists of data.Example:Example:

((set text (to be or not to be))set text (to be or not to be))the second argument to set is the listthe second argument to set is the list

(to be or not to be)(to be or not to be)This list above is composed of four distinct atoms:This list above is composed of four distinct atoms:to be or notto be or not


24/90

2424

LISP manipulates list just like otherLISP manipulates list just like otherlanguages manipulate number; they canlanguages manipulate number; they canbe compared, passed to functions, putbe compared, passed to functions, puttogether, and taken apart.together, and taken apart.


25/90

2525

Programs Are Represented asPrograms Are Represented as

ListsListsFunction application and lists look the same.Function application and lists look the same.

(make-table text nil)(make-table text nil)

could either be a three-element list whosecould either be a three-element list whoseelements are the make-table, text, nil; or it couldelements are the make-table, text, nil; or it couldbe an application of the function make-table tobe an application of the function make-table tothe arguments named text and nil. Because athe arguments named text and nil. Because a

LISP program is itself a list.LISP program is itself a list.If the list is quoted, then it is treated as data; thatIf the list is quoted, then it is treated as data; thatis, it is unevaluated.is, it is unevaluated.


26/90

2626

If the list is quoted, then it is treated asIf the list is quoted, then it is treated asdata; that is, it is unevaluated.data; that is, it is unevaluated.

Example:Example:

(set text (to be or not to be))(set text (to be or not to be))

(set text (to be or not to be))(set text (to be or not to be))

What happens?What happens?


27/90

2727

the fact that LISP represents both programsthe fact that LISP represents both programs

and data in the same wayand data in the same way isis of the utmostof the utmostimportance:importance:

it makes it very easy to write a LISP interpreterit makes it very easy to write a LISP interpreterin LISP.in LISP.it makes it convenient to have one LISP programit makes it convenient to have one LISP programgenerate and call for the execution of anothergenerate and call for the execution of anotherLISP program.LISP program.It also simplifies writing LISP programs thatIt also simplifies writing LISP programs thattransform and manipulate other LISP programs.transform and manipulate other LISP programs.


28/90

2828

These capabilities are important in artificialThese capabilities are important in artificialintelligence and other advanced programintelligence and other advanced program--development environmentsdevelopment environments..

These amplification come with a reductionThese amplification come with a reductionof readabilityof readability..


29/90

2929

LISP is often InterpretedLISP is often Interpreted

Most LISP systems provide interactive interpreters. WeMost LISP systems provide interactive interpreters. Weinteract with the LISP interpreter by typing in functioninteract with the LISP interpreter by typing in functionapplications. The LISP system then interprets them andapplications. The LISP system then interprets them andpoint out the result.point out the result.Example:Example:

(plus 2 3)(plus 2 3)the system will respondthe system will respond55Similarly if we typeSimilarly if we type

(eq (plus 2 3) (difference 9 4))(eq (plus 2 3) (difference 9 4))the system will respondthe system will respondtt


30/90

3030

Pure FunctionPure Function

functions likefunctions like eqeq andandplusplus are pureare purefunctionsfunctions ((or simply functionsor simply functions)) becausebecausethey have no effect other than thethey have no effect other than the

computation of a valuecomputation of a value..Pure functions obey the Manifest InterfacePure functions obey the Manifest InterfacePrinciple because their interfaces arePrinciple because their interfaces are

apparentapparent ((manifestmanifest).).

Th M if t I t f


31/90

3131

The Manifest InterfaceThe Manifest Interface

PrinciplePrinciple

All interfaces should beAll interfaces should be

apparent (manifest) in theapparent (manifest) in the

syntax.syntax.


32/90

3232

ProceduresProcedures

Some function in LISP are pseudo-function (orSome function in LISP are pseudo-function (orprocedure). These are functions that have a sideprocedure). These are functions that have a sideeffect on the state of computer in addition toeffect on the state of computer in addition tocomputing a result.computing a result.

Example:Example:(set text (to be or not to be))(set text (to be or not to be))binds the name (atom) text to the (to be or not tobinds the name (atom) text to the (to be or not tobe) that it is a list and return this list.be) that it is a list and return this list.

The atom n can now be used as a name for thisThe atom n can now be used as a name for thislist in any expression, for examplelist in any expression, for example(set Freq (make-table text nil))(set Freq (make-table text nil))


33/90

3333

FunctionFunction

another importananother importantt pseudo-function is defun,pseudo-function is defun,which define a function.which define a function.Example:Example:

(defun f (x1,x2, , xn) b)(defun f (x1,x2, , xn) b)defines a function with the name f, formaldefines a function with the name f, formalparameters x1, x2, , xn; and body bparameters x1, x2, , xn; and body bThe function application used to defineThe function application used to define

functions is different in many dialects.functions is different in many dialects.in LISP the binding process is dynamic, that is, itin LISP the binding process is dynamic, that is, ittaketakess place at run-time.place at run-time.


34/90

3434

DESIGN: DATA STRUCTUREDESIGN: DATA STRUCTURE


35/90

3535

The Primitives Include NumericThe Primitives Include Numeric

AtomsAtoms

We classify LISP data structure (like otherWe classify LISP data structure (like otherlanguages) intolanguages) intoprimitiveprimitive andand constructorsconstructors..The principThe principalalconstructorconstructoris the list: it permitsis the list: it permits

more complicated structures to be built frommore complicated structures to be built fromsimpler structures.simpler structures.The primitive data structures are the startingThe primitive data structures are the startingpoints to building process. Thus, the primitivepoints to building process. Thus, the primitivess

are those data structure that are not build fromare those data structure that are not build fromany other: they have no parts. It is for this reasonany other: they have no parts. It is for this reasonthat they are called atoms.that they are called atoms.


36/90

3636

There are at least tThere are at least twowo types of atoms intypes of atoms inall LISP systems:all LISP systems:

NumericNumeric

NonnumericNonnumeric


37/90

3737

LISP provides a very large set of primitiveLISP provides a very large set of primitivefunctions for manipulating numeric atoms:functions for manipulating numeric atoms:

Arithmetic operations (plus, difference,Arithmetic operations (plus, difference,

etc.)etc.)Predecessor and successor functionPredecessor and successor function(sub1, add1)(sub1, add1)

Maximum and minimum functionsMaximum and minimum functionsRelation tests (equal, lessp, greaterp)Relation tests (equal, lessp, greaterp)Predicates (i.e., tests, such as zerop,Predicates (i.e., tests, such as zerop,

onep, minusp)onep, minusp)


38/90

3838

All of these functions take both integer andAll of these functions take both integer andfloating-point (and in some systems,floating-point (and in some systems,multiple-precision) arguments and returnmultiple-precision) arguments and returnresults of the appropriate type.results of the appropriate type.


39/90

3939

ExampleExample

LISPs use of Combridge Polish limits itsLISPs use of Combridge Polish limits itsnumerical applications.numerical applications.Example:Example:

(-b + (b - 4ac) ) /2a(-b + (b - 4ac) ) /2amust be writtenmust be written(quotient (plus (minus b)(quotient (plus (minus b)

(sqrt (difference (expt b 2)(sqrt (difference (expt b 2)

(times 4 a c))))(times 4 a c))))(times 2 a)(times 2 a)


40/90

4040

Nonnumeric Atoms Are AlsoNonnumeric Atoms Are Also

ProvidedProvided

These atoms are strings of characters thatThese atoms are strings of characters thatwere originally intended to representwere originally intended to representwords or symbols.words or symbols.


41/90

4141

ExampleExample

With few exceptions, the only operationsWith few exceptions, the only operationsthat can be performed on nonnumericthat can be performed on nonnumericatoms are comparisions for equality andatoms are comparisions for equality and

inequality. This is done with functioninequality. This is done with function eq:eq:Example:Example:

((eqeq x y)x y)

t if x and y are the same atom,t if x and y are the same atom,

nnil if x and y are not the same atom,il if x and y are not the same atom,


42/90

4242

the atom nil has many uses in LISPthe atom nil has many uses in LISP.. ThisThisoperation is often used as a base foroperation is often used as a base forrecursive definitionsrecursive definitions..

((eq x nileq x nil))((null xnull x))

nil is the noun and null is thenil is the noun and null is thecorresponding adjectivecorresponding adjective..


43/90

4343

Some LISP systems provide additionalSome LISP systems provide additionaltypes of atoms, such as strings. In thesetypes of atoms, such as strings. In thesecases special operations for manipulatingcases special operations for manipulatingthese values are also providedthese values are also provided


44/90

4444

Abstract Data TypeAbstract Data Type

An abstract data type is a set of dataAn abstract data type is a set of datavalues together with a set of operationsvalues together with a set of operations

on those values.on those values.


45/90

4545

The Principal Constructor is theThe Principal Constructor is the

ListList

The characteristic method of data structuringThe characteristic method of data structuringprovided by LISP is called theprovided by LISP is called the list.list.Lists are written in the S-expression notation byLists are written in the S-expression notation bysurrounding with parentheses the lists elements,surrounding with parentheses the lists elements,which are separated by blanks.which are separated by blanks.Lists can have none, one, or more elements, soLists can have none, one, or more elements, so

they satisfy the Zero-One-Infinity Principle. Thethey satisfy the Zero-One-Infinity Principle. The

elements of lists can themselves be lists, so theelements of lists can themselves be lists, so theZero-One-Infinity Principle is also satisfied by theZero-One-Infinity Principle is also satisfied by thenesting level of lists.nesting level of lists.


46/90

4646

The empty list, ( ) is considered equivalentThe empty list, ( ) is considered equivalentto the atomto the atom nil:nil:

(eq ( ) nil)(eq ( ) nil)

oror

(null ( ) )(null ( ) )

Except the null list all lists are nonatomic,Except the null list all lists are nonatomic,they are sometimes called composite datathey are sometimes called composite datavalues.values.


47/90

4747

We caWe cann find out whether or not something is an atom byfind out whether or not something is an atom byusing the atom predicate.using the atom predicate.Example:Example:

(atom to)(atom to)tt(atom (plus 2 3))(atom (plus 2 3))

tt

(atom nil)(atom nil)tt(atom (to be) )(atom (to be) )

nilnil

(atom ( ( ) ) )(atom ( ( ) ) )nilnil

Notice neither ( ( ) ) nor (nil) is the null listNotice neither ( ( ) ) nor (nil) is the null list


48/90

4848

Constructor and SelectorConstructor and Selector

Operations that build a structure areOperations that build a structure are

called constructors.called constructors.

OperationOperation that extract their parts arethat extract their parts are

called selectors.called selectors.

C C fC d Cd A th P t f


49/90

4949

Car and Cdr Access the Parts ofCar and Cdr Access the Parts of

ListsLists

Car : return the first element of the list.Car : return the first element of the list.

Cdr : returns all of a list except its first element.Cdr : returns all of a list except its first element.

Example:Example:

(car (to be or not to be) )(car (to be or not to be) )returns the atom toreturns the atom to

(cdr (to be or not to be) )(cdr (to be or not to be) )

returns the listreturns the list

(be or not to be)(be or not to be)


50/90

5050

Notice that the argument to car and cdr isNotice that the argument to car and cdr isalways a nonnull listalways a nonnull list..

Unlike car, cdr always returns a listUnlike car, cdr always returns a list..

Car and Cdr are pure functionsCar and Cdr are pure functions.. TheTheeasiest way to think of the way they workeasiest way to think of the way they workis that they make a new copy of the listis that they make a new copy of the list..

Car and Cdr can be used inCar and Cdr can be used in


51/90

5151

Car and Cdr can be used inCar and Cdr can be used in

combination to access thecombination to access the

components of a listcomponents of a listExample:Example:

(set DS (Don Smith) 45 30000(set DS (Don Smith) 45 30000

(august 25 1980) ) )(august 25 1980) ) )

(car (cdr (cdr (cdr DS))))(car (cdr (cdr (cdr DS))))

returns the listreturns the list

(august 25 1980)(august 25 1980)


52/90

5252

In general, the nth element of a list can beIn general, the nth element of a list can beaccess by n-1 cdrs followed by a car.access by n-1 cdrs followed by a car.

The composition of cars and cdrs is representedThe composition of cars and cdrs is representedby the sequence of as and ds between theby the sequence of as and ds between theinitial c and the final r.initial c and the final r.

This can be seen more clearly if the list is writtenThis can be seen more clearly if the list is writtenas a linked data structure; then a d moves toas a linked data structure; then a d moves tothe right and an a moves down.the right and an a moves down.


53/90

5353

Figure 9.2Figure 9.2


54/90

5454

Clearly, these sequence of as and dsClearly, these sequence of as and ds

can become quite complicated to read.can become quite complicated to read.Writing them is also error-prone.Writing them is also error-prone.One solution to this is to write a set ofOne solution to this is to write a set ofspecial-purpose functions for accessingspecial-purpose functions for accessing

the part of a record. For example athe part of a record. For example afunction for accessing the hire date couldfunction for accessing the hire date couldbe defined asbe defined as

(defun hire-date (r) (cadddr))(defun hire-date (r) (cadddr))Then (hire-date DS) returns Don SmithThen (hire-date DS) returns Don Smithhire datehire date

I f ti C B R t dI f ti C B R t d


55/90

5555

Information Can Be RepresentedInformation Can Be Represented

by Property Listsby Property Lists

A personnel record wouldA personnel record would notnot probably be represented inprobably be represented inLISP in the way we have just described: it is too inflexible.LISP in the way we have just described: it is too inflexible.A better arrangement is to precede each information withA better arrangement is to precede each information withan indicator identifying the property.an indicator identifying the property.

Example:Example:(name (Don Smith) age 45 salary 30000 hire-date(name (Don Smith) age 45 salary 30000 hire-date(august 25 1980) )(august 25 1980) )this method of representing information is called athis method of representing information is called a

property listproperty list

or p-list.or p-list.

(P1 v1 P2 v2 Pn vn)(P1 v1 P2 v2 Pn vn)each Pi is the indicator for a property and each vi is theeach Pi is the indicator for a property and each vi is thecorresponding property valuecorresponding property value

H th ti fH th ti f li tli t


56/90

5656

How can the properties of a pHow can the properties of a p--listlist

be accessed?be accessed?

(defun getprop (p x)(defun getprop (p x)

(if (eq (car x) p)(if (eq (car x) p)

(cadr x)(cadr x)

(getprop p (cddr x)) ))(getprop p (cddr x)) ))

Example:Example:

(getprop name DS)(getprop name DS)

ReturnReturn (Don Smith)(Don Smith)


57/90

5757

What will this function do ifWhat will this function do ifwewe ask for aask for aproperty that is not in the property list?property that is not in the property list?

(getprop weight DS)(getprop weight DS)

Error: car of nilError: car of nil


58/90

5858

One way to do this is to have getpropOne way to do this is to have getprop

return a distinguished value if thereturn a distinguished value if theproperty does not exist.property does not exist.

An obvious choice is nil,An obvious choice is nil, but this would not be abut this would not be a good choicegood choice

since it would then be impossible tosince it would then be impossible todistinguish an undefined property fromdistinguish an undefined property fromone that is defined but whose value isone that is defined but whose value isnil.nil.


59/90

5959

A better decision is to pick some atom,A better decision is to pick some atom,such as undefined-property, which issuch as undefined-property, which isunlikely to be used for any other purposeunlikely to be used for any other purpose..(getprop weight DS)(getprop weight DS)

undefined-propertyundefined-property

I f ti C B R t d iInformation Can Be Represented in


60/90

6060

Information Can Be Represented inInformation Can Be Represented inAssociation ListAssociation List

The property list data structure works bestThe property list data structure works bestwhen exactly one value is to be associatedwhen exactly one value is to be associatedwith each property.with each property.Some properties are flags that have noSome properties are flags that have noassociated value for example retired flag in ourassociated value for example retired flag in ourpersonnel record.personnel record.if a property has several associated values, forif a property has several associated values, forexample theexample the managesmanages property, might beproperty, might beassociated with the names of everyoneassociated with the names of everyonemanaged by Don Smith.managed by Don Smith.


61/90

6161

These problems are solved by another commonThese problems are solved by another common

LISP data structure, theLISP data structure, the association list,association list, orora-lista-list..AnAn a-lista-listis a list of pairs.is a list of pairs.

The general form of anThe general form of an a-lista-listis a list of attribute-is a list of attribute-

value pairs:value pairs:((a1 v1) (a2 v2)(an vn))((a1 v1) (a2 v2)(an vn))

( (name (Don Smith)( (name (Don Smith)

(age 45)(age 45)(salary 30000)(salary 30000)

(hire-date (August 25 1980)) )(hire-date (August 25 1980)) )


62/90

6262

AssocAssoc

The function that does the forwardThe function that does the forwardassociation.association.

For exampleFor example

(assoc hire-date DS )(assoc hire-date DS )

ReturnReturn (August 25 1980)(August 25 1980)


63/90

6363

Cons Constructs ListsCons Constructs Lists

If the constructors undo what the selectorsIf the constructors undo what the selectorsdo and vice versa, we will have moredo and vice versa, we will have moreregular data typesregular data types..

cons adds a new element to thecons adds a new element to thebeginning of a list.beginning of a list.

cons is the inverse of car and cdrcons is the inverse of car and cdr


64/90

6464

Example:Example:(cons to (be or not to be))(cons to (be or not to be))

return the listreturn the list

(to be or not to be)(to be or not to be)(car (to be or not to be)) = to(car (to be or not to be)) = to

(cdr (to be or not to be)) = (be or not to(cdr (to be or not to be)) = (be or not to

be))be))(cons to (be or not to be)) = (to be or not to(cons to (be or not to be)) = (to be or not tobe)be)


65/90

6565

QuizQuiz::

((cons cons ((a ba b)) ((c dc d))))


66/90

6666

Notice that the second argument of consNotice that the second argument of consmust be a list.must be a list.

Cons is a pure function.Cons is a pure function.


67/90

6767

ListListss Are Usually ConstructedAre Usually Constructed

RecursivelyRecursively


68/90

6868

AppendAppend

(append M L) will return the(append M L) will return the

concatenation of the lists L and M.concatenation of the lists L and M.

(append ( ) L) = L(append ( ) L) = L

(append L ( )) = L(append L ( )) = L

(append (b c) (d e f)) = (b c d e(append (b c) (d e f)) = (b c d e

f)f)


69/90

6969

Atoms Have PropertiesAtoms Have Properties

LISP was originally developed for artificialLISP was originally developed for artificialintelligence application.intelligence application.

AI applications often must deal withAI applications often must deal with the properties of objects andthe properties of objects and the relationship among objects.the relationship among objects.


70/90

7070

In LISP,In LISP, objects are represented by atoms,objects are represented by atoms, each atom has an associated p-listeach atom has an associated p-list

represents the properties of the atom andrepresents the properties of the atom andthe relationship in which it participates.the relationship in which it participates.


71/90

7171

(set Europe (England France Spain Germany ))(set Europe (England France Spain Germany ))>> (England France Spain Germany )>> (England France Spain Germany )

(car Europe)(car Europe)

>> England>> England

(eq England (car Europe))(eq England (car Europe))>> t>> t

(eq France (car Europe))(eq France (car Europe))>> nil>> nil

How are other properties attachedHow are other properties attached


72/90

7272

How are other properties attachedHow are other properties attachedto an atom?to an atom?

Example:Example:(putprop France Paris capital)(putprop France Paris capital)

ReturnReturn ParisParisWe can find out the value of a property with theWe can find out the value of a property with thegetgetfunction:function:(get France capital)(get France capital)

ReturnReturn ParisParisFigure 9.7Figure 9.7


73/90

7373



74/90

7474

Each object comes complete with aEach object comes complete with aproperty, itsproperty, itsprint name,print name, which is awhich is acharacter string tagged by pname.character string tagged by pname.

Atoms are pointers to their propertyAtoms are pointers to their property


75/90

7575

Atoms are pointers to their propertyAtoms are pointers to their propertylistslists

In implementation atoms are equivalent toIn implementation atoms are equivalent tomemory locationsmemory locations

Figure 9 13Figure 9 13


76/90

7676



77/90

7777

Binding atoms to lists:Binding atoms to lists:(Set Europe (England France )(Set Europe (England France )

(get Europe apval)(get Europe apval)

(England France Spain )(England France Spain )


78/90

7878

Binding of atoms to functions isBinding of atoms to functions isrepresented by therepresented by the exprexprpropertyproperty

(Get getprop expr)(Get getprop expr)

{function expr){function expr)

Defun equivalent to putpropDefun equivalent to putprop

Lists Have a SimpleLists Have a Simple


79/90

7979

Lists Have a SimpleLists Have a Simple

RepresentationRepresentation

LISP lists are usually implemented asLISP lists are usually implemented aslinked structurelinked structure.. For instance, the listFor instance, the list

((to be or not to beto be or not to be))

is represented asis represented as a sequence of six cells in memory,a sequence of six cells in memory, each containing a pointer to the nexteach containing a pointer to the next..

Each cell also contains a pointer to theEach cell also contains a pointer to theelement of the list it representselement of the list it represents..


80/90

8080



81/90

8181

List containing other lists are representedList containing other lists are representedin the same way. For example, the listin the same way. For example, the list

( (to 2) (be 2) (or 1) (not 1) )( (to 2) (be 2) (or 1) (not 1) )

would be represented in storage as shownwould be represented in storage as shownin below.in below.

Figure 9 9Figure 9.9


82/90

8282


The List Primitive Are SimpleThe List Primitive Are Simple


83/90

8383

The List Primitive Are SimpleThe List Primitive Are Simple

and Efficientand Efficient

CarCar

A := L . left;A := L . left;

CdrCdr

D := L . rightD := L . right


84/90

8484



85/90

8585

ConsCons

new(L);new(L);

LL .. leftleft : =: = A;A;

LL .. rightright :=:= D;D;

Shared sub-listsShared sub-lists


86/90

8686

Shared sub listsShared sub lists(Quiz)(Quiz)

(set L (or not to be))(set L (or not to be))>> (or not to be)>> (or not to be)(set M (to be))(set M (to be))>> (to be)>> (to be)(cadr M)(cadr M)

>> be>> be(set N (cons(cadr M) L))(set N (cons(cadr M) L))>>>>(car M)(car M)>>(set O(cons(car M) N))(set O(cons(car M) N))>>(cons (car M) (cons (cadr M)L))(cons (car M) (cons (cadr M)L))>>

Sublists can be sharedSublists can be shared


87/90

8787

Sublists can be sharedSublists can be shared

A lot of the substructures can be shared.A lot of the substructures can be shared. Memory efficiencyMemory efficiency Danger of Aliasing (and sharing of dataDanger of Aliasing (and sharing of data

structures) only whenstructures) only whenThere is the ability to change the content ofThere is the ability to change the content of

memorymemory

Because car,cdr,cons are pure functions, theyBecause car,cdr,cons are pure functions, they

have no side effect on memory, so they arehave no side effect on memory, so they aredanger freedanger free

Li t b difi dLi t b difi d


88/90

8888

Lists can be modifiedLists can be modified

Pseudo-functionPseudo-function rplaca : replace address partrplaca : replace address part rplacd : replace decrement partrplacd : replace decrement part

(rplaca L A)(rplaca L A)L ^ .left := A;L ^ .left := A;

(rplacd L D)(rplacd L D)L^ .right := D;L^ .right := D;

Fi 9 12Fi 9 12


89/90

8989

Figure 9.12Figure 9.12(set text (to be or not to be))

>> (to be or not to be)((rplacd (cdr text) (is all))

Li t St t C B M difi dLi t St t C B M difi d


90/90

List Structures Can Be ModifiedList Structures Can Be Modified

rplaca (replace address part)rplaca (replace address part)rplacd (replace decrement part)rplacd (replace decrement part)

(set 'text '(to be or not to be))(set 'text '(to be or not to be))(to be or not to be)(to be or not to be)

( set 'x (cdr text))( set 'x (cdr text))(be or not to be)(be or not to be)

(rplacd x '(is all))(rplacd x '(is all))

(be is all)(be is all)ttextext(to be is all)(to be is all)

Danger of unwanted memory changeDanger of unwanted memory change

maclennan chap9 lisp

Documents