Lisp Internals

1
Lisp Internals
2
A problem with lists

• In Lisp, a list may contain another list
• For example, (A (B C)) contains (B C)
• So, how much storage do we need to allocate for a
  list?
• If any list can contain any other list, there is
  no limit to the size of storage block we may need
• This is impractical we need another solution

3
Pointers

• Instead of actually putting one list inside
  another, we put a pointer to one list inside
  another
• A pointer is a fixed, known size
• This partially solves the problem, but...
• A list can contain any number of elements
• For example, the list ((A)(B)(A)(C)) contains
  four lists
• This still leaves us needing arbitrarily large
  blocks of storage

4
CAR and CDR

• We can describe any list as the sum of two parts
  its head (CAR) and its tail (CDR)
• The head is the first thing in the list
• The head could itself be an arbitrary list
• The tail of a list is another (but shorter) list
• Thus, any list can be described with just two
  pointers
• This provides a complete solution to our problem
  of arbitrarily large storage blocks

5
S-expressions

• In Lisp, everything is an S-expression
• An S-expression is an atom or a list
• You can think of these as using two different
  kinds of storage locations--one kind for atoms,
  another kind for the parts of a list
• This is an oversimplification, but it will do for
  now

6
Atoms

• An atom is a simple thing, and we draw it in a
  simple way

HELLO
ABC
NIL

• Sometimes we dont bother with the boxes

HELLO
ABC
NIL
7
Lists

• A list has two parts a CAR and a CDR
• We draw this as a box , called a cons cell, with
  two compartments, called the car field and the
  cdr field

• In each of these compartments we put an arrow
  pointing to its respective value

8
Example I
( A )
9
Example II
( A B C )
10
Example III
((A) B)
11
Example IV
((A B) (C D))
12
Dotted pairs

• In a simple list, every right-pointing arrow
  points to a cons cell or to NIL
• If a right-pointing arrow points to an atom, we
  have a dotted pair

(A . B)
13
Lisp lists are implemented with dotted pairs
( A )
(A . NIL)

• Therefore, (A) (A . NIL)
• All structures in Lisp can be created from atoms
  and dotted pairs

14
Example V
((A . B) . (C . D))
15
Writing dotted pairs

• A dotted pair is written (and printed) using
  parentheses and a dot (A . B)
• If the CDR of a dotted pair is NIL, the dot and
  the NIL are omitted (A . NIL) (A)
• If the CDR is another cons cell, Lisp doesnt
  print the dot or the parentheses
• (A . (B . (C . NIL))) (A B C)
• (A . (B . (C . D))) (A B C . D)

16
Efficiency of CDR

• Suppose L is the list (A B C D E)
• Then (CDR L) is the list (B C D E)
• Isnt it expensive to create this new list?
• Answer NO! Its incredibly cheap!
• Lisp just copies a pointer

17
Efficiency of CAR and CONS

• CAR is just like CDR you just copy a pointer
• CONS takes more work you have to allocate and
  fill one cons cell

18
Sharing structure

• List L and list (CDR L) are said to share
  structure
• But if L (A B C D E) and M (CDR L), then when
  you change L, wont M be changed?
• Yes, but...
• this is where the real genius of Lisp comes in...
• You never change L !
• None of the basic functions ever change anything
  thats already there
• Only CONS adds anything
• The result is an extraordinarily efficient
  language!

19
Memory

• If you only add structure, and never change or
  delete anything, wont you run out of memory?
• Lisp uses garbage collection to recover
  structures that you are no longer using
• More convenient for the programmer
• Safer (less subject to human error)
• Extremely effective in general

20
Java isnt Lisp

• Although Lisps way of handling lists is elegant
  and efficient, its not the only way
• Modifying the middle or end of a list is
  expensive
• There are many ways we might implement lists in
  Java
• Lisps implementation of lists is a great
  example, but not necessarily the final word

21
A possible Java implementation

• class Cell
• class Atom extends Cell String
  value Atom(String value) //
  constructor this.value value
• class ConsCell extends Cell Cell car Cell
  cdr ConsCell(Cell car, Cell cdr) //
  constructor this.car car this.cdr
  cdr

22
Another possible implementation

• class Cell boolean isAtom String
  value Cell car, cdr
• Cell(String value) // constructor isAtom
  true this.value value
• Cell(Cell car, Cell cdr) // constructor isAto
  m false this.car car this.cdr
  cdr

23
Implementing the functions I

• class Lisp
• static Cell car(Cell c) return c.car
• static Cell cdr(Cell c) return c.cdr
• static Cell cons(Cell c1, Cell c2) return
  new Cell(c1, c2)

24
Implementing the functions II

• static boolean atom(Cell c) return
  c.isAtom
• static boolean eq(Cell c1, Cell c2) return
  c1.value.equals(c2.value)

25
The End