COMPUTING SCIENCE 370
Programming Languages

LISP -- Structural Organization

Structural Organization

• Applicative -- The central idea is the application of a function to its arguments.

  (f a1 a2 . . . an)

  • Cambridge Polish notation -- fully parenthesized prefix notation (i.e., operator first)
  • Functions may be composed, i.e., the result of applying one function to its arguments may be an argument to another function

    (sqrt (+ (* dx dx) (* dy dy)))

• List-processing -- The list is the only data constructor (in classical LISP).

SIMPLICITY PRINCIPLE

A language should be as simple as possible. There should be a minimum number of concepts, with simple rules for their combination.

• Allows representation of complex interrelationships among data (e.g., in AI).
• Uses linked representation of list (i.e., pointers).
• Only two data objects:
  • atom ::= <identifier> | <literal number>
    E.g.,
    
    Sam
5
plus
nil
  • list ::= ( {<atom> | <list>}^* )
    I.e., ordered collection of atoms and/or lists;e.g.,
    
    (Sam)
(Sam Bill)
(Sue (Sam Bill) (Sam))
((Sue (Sam Bill)) (Sam))
()
• Recursive -- Lists, being recursive structures, lend themselves to recursive processing.
  • Recursion is implemented with a stack (i.e., a push-down list).

• Interpreted -- Most LISP systems provide interactive interpreters.
  • John McCarthy wrote the first LISP interpreter (in LISP) when he wrote a universal LISP function which could interpret any other LISP function in order to investigate universal functions as a basis for the theory of computing (cf. the universal Turing machine). See John McCarthy's History of Lisp.
    E.g., if the primary prompt is >
        and the error condition prompt is >>
    
    > (+ 2 3)
    Common LISP
    5
    > 3
    3
    A literal number evaluates to itself.
    > hello
    Error: The variable HELLO is unbound.
    'hello' is undefined.
    >> :q
    > (bye)
    Or Ctrl-D [UNIX]

• Symbolic language -- Since LISP processes lists, the LISP universal function required LISP programs to be represented as lists.

  • A program and data have the same representation.
  • It is easy to write LISP programs to manipulate LISP programs.
  • Notation:
    • M-expression (meta-language)
      E.g.,

      f [x+y; u*z]

    • S-expression (symbolic language) ::= <atom> | <list>
      E.g.,

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

      or, in Common LISP,

      (f (+ x y) (* u z))

      => LISP = Lots of Idiotic Single Parentheses

• Evaluation of S-expressions

  • atoms
    • If the atom is bound to a value, then the atom evaluates to that value.
    • Atoms which are literal numbers are pre-bound to their own value.
    • If an atom is not bound to a value, an error occurs if an attempt is made to evaluate it.
  • lists
    • The first element of the list must evaluate to a function definition (e.g., an atom which is the name of a function definition).
    • All other elements of the list are first evaluated, then the function is applied to these values as arguments.
    • This procedure is recursive (i.e., elements which are lists are evaluated this way too).
    • A special function which just returns its arguments as its result is provided to, in effect, protect data from being evaluated.

      > (quote number)
      number

      'number' was not evaluated.
      > (quote (Sam Sue Bill))
      (Sam Sue Bill)
      > 'hello
      
      Abbreviation.
      hello

    • There are some other exceptions (to be discussed).

• Primitive functions -- Each LISP environment has some atoms which are pre-bound to functions.
  E.g.,
  > (* 3 4)
  12
  > (mult 3 4)
  Error: The variable MULT is unbound.
  >> :q
  > (atom 5)
  T

  'atom' is a predicate; 'T' means 'true'.
  > 3
  3
  >

• Pure functions -- A pure function is a functions which has no effect other than the computation of a value.

MANIFEST INTERFACE PRINCIPLE

All interfaces should be apparent (manifest) in the syntax.

• Many LISP functions have side effects (i.e., they cause changes to the environment).
• Functions are often evaluated for their side effects only:
  • binding

    > (set 'number 5)
    5
    > (* number 2)
    10

  • I/O

    > (print 'Number?)
    Number?
    Number?

    The first 'Number?' is the side effect; the second, the function value.