COMPUTING SCIENCE 370
Programming Languages

LISP -- Data Structures

Primitives

• Numeric -- primitive functions:
  • arithmetic:    +    -    *    /
  • predecessor/successor:    1+    1-
  • other arithmetic:
    max
    min
    abs
    mod
    round
    exp       where (exp n) is eⁿ
    expt     where (expt n m) is n^m
    log
    sqrt
    gcd
    lcm
  • trigonometric: Arguments are in radians. PI (or pi) is a built-in constant.
    sin
    cos
    tan
    asin
    acos
    atan
  • predicates (tests, returning t or nil):
    =
    <
    >
    evenp
    oddp
    minusp
    plusp
    zerop
    numberp
    integerp
    where (< n1 n2 n3 n4) is t iff. n1 < n2 < n3 < n4.
  • logical predicates
    and
    or
    not

• Nonnumeric atoms (literal atoms, symbols)
  • binding:
    set
    setq    (combination of set and quote)
    setf    (a generic alteration function)
  • predicates
    atom
    symbolp    (opposite of numberp)
    eq              (same object as stored)
    equal        (same structure)
    null
    where (null x) is equivalent to (eq x nil).

    In Common LISP, use eql instead of eq, since Common LISP allows implementations to make copies of numbers and characters for efficiency purposes. Two objects are eql if they are eq, or if they are numbers of the same type with the same value, or if they are character objects that represent the same character.

Composite Data Types

The list is the only composite data type in classical LISP; Common LISP also has strings, vectors, arrays, streams, . . .

• constructors
  • cons: Returns a list whose first element is the first argument and whose remaining elements are the elements of the second argument (which must be a list).
    E.g.,
    > (set 'apostles '(Matthew Mark Peter))
    (MATTHEW MARK PETER)
    > (cons 'John apostles)
    (JOHN MATTHEW MARK PETER)
    > apostles
    (MATTHEW MARK PETER)
    > (setq apostles (cons 'John apostles))
    (JOHN MATTHEW MARK PETER)
    > apostles
    (JOHN MATTHEW MARK PETER)
    > (cons 'a nil)
    (A)
    > (cons '(a b) '(c (d e)))
    ((A B) C (D E))

  • append: Returns a list consisting of all the elements of all its list arguments.
    E.g.,
    > (append '(James Thomas) apostles)
    (JAMES THOMAS JOHN MATTHEW MARK PETER)

  • list: Returns a list of all its arguments.
    E.g.,
    > (list '(James Thomas) apostles)
    ((JAMES THOMAS) (JOHN MATTHEW MARK PETER))
    > (list 'Gabriel 'Michael 'Raphael)
    (GABRIEL MICHAEL RAPHAEL)

• selectors
  • car: Returns the first element of the list which is its single argument; "head"; Common LISP: first.
    E.g.,
    > (car '(a b c))
    A
    > (car apostles)
    JOHN
    > (car (list 'a))     [Equivalent to (car '(a))]
    A
    > (car '((Leonardo da Vinci) Donatello Raphael))
    (LEONARDO DA VINCI)

  • cdr: Returns all of the list which is its single argument except for its first element; "tail"; LOGO: "butfirst"; Common LISP: rest. [Say "could'r".]
    E.g.,
    > (cdr '(a b c))
    (B C)
    > (cdr apostles)
    (MATTHEW MARK PETER)
    > (cdr (list 'a))
    NIL     [Equivalent to ()]
    > (cdr '((Leonardo da Vinci) Donatello Raphael))
    (DONATELLO RAPHAEL)

    NOTE: cons is the inverse of car and cdr.
    E.g.,
    > (cons 'a '(b c))
    (A B C)
    > (car (cons 'a '(b c)))
    A
    > (cdr (cons 'a '(b c)))
    (B C)

    Historical note: car = "contents of address field of register" and cdr = "contents of decrement field of register" [IBM 704].

  • selector combinations ("shorthand"):

    c { a | d }+ r

    [Length may be limited; e.g., Common LISP restricts combinations to four a's and d's.]
    E.g.,
    • cadr [say "cadder"] = second
      > (car (cdr apostles)) becomes (cadr apostles)
      MATTHEW
      
    • caddr [say "cadudder"] = third
      > (car (cdr (cdr apostles))) becomes (caddr apostles)
      MARK

    Common LISP also provides second, third, ..., tenth.

  • nth: the n^th element of a list, using zero-based counting.
    E.g.,
    > (nth 4 '(a b c d e f g))
    E

  • nthcdr: the n^th cons cell of a list, using zero-based counting.
    E.g.,
    > (nthcdr 4 '(a b c d e f g))
    (E F G)

  • last: the last cons cell of a list (i.e., returns a list).
    E.g.,
    > (last '(a b c))
    (C)

• predicates
  listp -- Is the object a list?
  member -- Is the object a member of the given list?
  tailp -- Returns list1 if it can be derived by cdring down list2.

  NOTE:
  > (listp nil)
  T
  > (atom nil)
  T
  > (atom '())
  T
  > (null '())
  T

• other: length
  E.g.,
  > (length '(a (b c) d)
  3

Representation

Lists

• Binary tree-like structure: node = cons cell
  • left = car
  • right = cdr

  E.g., (a b c)

  |    ·-	--->	|    ·-	--->	|    ·
  |   v   a		|   v   b		|   v   c

  E.g., (a (b c) d)

  |    ·-	----->	|    ·-	---------->			|    ·
  |   v   a		|   |   v				|   v   d
  		|    ·-	--->	|    ·
  		|   v   b		|   v   c

• Alternate notation: dotted pairs
  E.g.,
  > (cons 'a 'b)
  (A . B)

  |    ·-	---> b
  |   v   a

  List reading and printing facilities (read and print) are designed to simplify the notation of a dotted pair to list form when possible.
  E.g.,
  > '(a . nil)
  (A)

• Shared sublists are efficient and transparent
  E.g.,
  > (set 'aList '(a c d))
  (A C D)

  aList ---->	|    ·-	--->	|    ·-	--->	|    ·
  	|   v   a		|   v   c		|   v   d

  > (set 'bList '(b c))
  (B C)

  c is shared -- each atom is represented only once.

  			^
  			|
  bList ---->	|    ·-	--->	|    ·
  	|   v   b

  > (set 'cList (cons (car bList) (cdr aList)))
  (B C D)

  A new cons cell is created, the left field (car) pointing to the existing atom b,
  the right field (cdr) pointing to the second cons cell of aList.

  	^
  	|
  cList ---->	|    ·-	-- · · · --> [points to second cons cell of aList]

  • This is a form of aliasing: there is more than one named path to a memory location.

  • If the node pointing to atom c is changed by access through aList, then cList is also changed. Since car, cdr, and cons are pure functions (with no side effects), they cannot change this node.

    However, there are two functions which have the side effect of changing a node:

    • rplaca -- change the car pointer (left field)
    • rplacd -- change the cdr pointer (right field)

    E.g.,
    > (rplacd (cdr aList) bList)
    (C B C)
    > aList
    (A C B C)
    > bList
    (B C)
    > cList
    (B C B C)

    This makes infinite loops possible.

    E.g.,
    > (set 'x '(y z))
    (Y Z)

    x ---->	|    ·-	--->	|    ·
    	|   v   y		|   v   z

    > (rplacd (cdr x) x)
    (Z Y Z Y Z Y Z Y . . .

    	v---	----	---|
    x ---->	|    ·-	--->	|    |
    	|   v   y		|   v   z

Atoms

• Print name (pname or "print-name cell") is unique for each atom.

• Address is unique for each atom.
  E.g.,
  > (eq (car '(a b c)) (cadr '(b a d)))
  T

  • Two atoms are the same if they are represented by the same pointer (even if they belong to two different lists).

• An atom may have a value (apval, for applied value, or "value cell"), bound by set.

• An atom may be defined as a function (expr, or "function cell") using defun.

• An atom may have user-defined properties: each atom has a pointer to a property list.
  E.g.,
  > (putprop 'chair 'blue 'colour) or (put 'chair 'colour 'blue)
  Common LISP: (setf (get 'chair 'colour) 'blue)
  BLUE
  > (get 'chair 'colour)
  BLUE

• Atoms are represented differently on different systems.

  • An implementation may use a regular cons cell with an illegal left pointer (e.g., -1) to designate an atom, with a right pointer to a property list.

  • An implementation may use a special structure, such as a record consisting of several pointers: one to the atom's print name, one to its applied value, one to its function expression, and one to its property list.