ICS 313: Programming Language Theory

1. ICS 313:Programming Language Theory Module 10: Intro to Lisp

2. Objectives • Understand the basic syntax of Lisp. • Understand the basic evaluation strategy.

3. History: 1960’s • First developed by John McCarthy as a language for symbolic (rather than numeric) computation in 1958, using: • Algebraic syntax from FORTRAN • Symbol manipulation facilities of IPL • Kleene’s recursive function theory • Lambda calculus as basis for function notation and manipulation • very SLOW: • no compilation of source to machine code • inefficient garbage collector • no optimizing of tail recursion

4. History: 1970’s • During 1970’s AI and Lisp began to flourish • MacLisp at MIT; Franz LISP (Berkeley); and UCI-LISP (Stanford); InterLisp (Xerox workstations); ZetaLisp for Lisp Machines • Scheme • the Pascal of Lisp • used for teaching and research • Lisp Machines • Designed from chip level for Lisp • Proved Lisp could be fast • Proved that Lisp could be “systems language”

5. History: 1980’s and 1990’s • Common Lisp developed in 1984 • Common Lisp is to Lisp as PL/I was to FORTRAN and COBOL • Intended to be a unified, commercial, portable, industrial-strength, standard Lisp. • Defines over 750 functions to provide efficient and robust implementations of common Lisp programming constructs • Efficient, highly optimized versions of Common Lisp are now available • CL is THE standard

6. History: 1990’s • Parallel processing versions of Common Lisp released • Death of Lisp Machine • Stock hardware platforms becoming faster than special purpose hardware • Interoperability with other languages

7. Why not scheme for 313? • Scheme is not the standard language • High quality implementations of CL exist for Mac, PC, and Unix environments • You will need to learn only a small fraction of the 750 predefined common lisp functions (25-50). • Common Lisp is well integrated with Emacs (which is also written in a dialect of Lisp)

8. Terminology • Write a program => Define a set of functions • Running a program => Evaluating an expression • Simple syntax: operator precedence issues eliminated • Lists (or S-expressions) are important: • Functions are defined as lists • Lists can be manipulated easily in Lisp • Functions can be manipulated easily

9. Basic Syntax • Number • examples: 3, 8.9, etc. • Symbol • An object written as a sequence of characters • Symbols are usually manipulated as names that are “bound” to other lisp objects • Symbol FOO might be bound to 4.2 • List • An open parenthesis followed by zero or more Lisp objects followed by a closed parenthesis • () the empty list, or NIL. • (3 (4 5 6) a bc) • ((B (3)))

10. Basic Syntax (cont.) • Lisp has a richer set of predefined types than many other PLs. • Vector, array, hashtables, string, bitvector, complex, floating point, streams, pathnames • Atoms: • Symbols, numbers, and NIL are called atoms. • NIL is both a list and an atom. • Parentheses: • Extra parentheses are significant in Lisp: • (a b c) is a list of 3 items • ((a b c)) is a list of one item--the item being a list of 3 items.

11. Programming Note • Efficient programming in Lisp requires automated support for: • Parenthesis matching • Syntax-directed indentation (to determine where missing/extra parentheses are located) • Emacs is ideally suited to Lisp programming.

12. Evaluation • Programs are lisp objects (i.e. functions) • Evaluation of a lisp object returns a new object. • Evaluation is simply a function called EVAL that maps lisp objects to lisp objects: • EVAL: object => object • we will use the symbol => to represent evaluation • The Lisp interpreter is a loop consisting of: • read a lisp expression • call EVAL on it • print out the result

13. Basic types of evaluation • Numbers • are “self-evaluating” • example: 5 => 5 • Symbols • Evaluate to their binding or value. • if COLOR has the value 3, then • COLOR => 3 • Alternatively, it could have the value of another symbol • COLOR => RED • Evaluation of an unbound symbol results in an error.

14. T and Nil • T and NIL are distinguished symbols • Self-evaluating • Cannot be bound to anything else. • NIL represents “false” in logical expressions. • T, or ANYTHING non-NIL, represents true in logical expressions.

15. Function Application • A list of the form: • (<fn-name> <arg1> <arg2> ...) where: • <fn-name> is (normally) a symbol that is the name of a function, and <arg1> to <argN> are arbitrary lisp objects • First each of the arguments are evaluated, and then the function bound to <fn-name> is applied to the arguments.

16. Application Examples • (+ 5.3 8) => 13.3 • (+ (+ 4.5 (* 5.7 3)) (- 7 29) (/ 99 23)) => 3.904347 • if X is bound to 23, then (+ X 4) => 27

17. Function Application (cont.) • Function application can also occur by defining the function directly as a lambda form: • ((lambda (x) (+ 2 x)) 3) => 5 • This form defines an “anonymous” function that has no name and exists only during this particular application. • Common Lisp has dynamic type checking • If the number of arguments or types of arguments are invalid for the function, then an error results (at run-time). • Common lisp uses eager evaluation as its default evaluation mechanism.

18. Special forms • A list of the form (<specialword> <arg1> <arg2> ..) where: • specialword is one of: • if, let, function, quote, setq, defun, setf, etc. • Special forms are not evaluated in the normal way (ie. eager evaluation): • (if (> x 0) (/ 10 x) x) • Why can’t eager evaluation be used for IF ?

19. Quote • Quote takes one parameter and the entire expression evaluates to the parameter • (quote (a b c)) => (a b c) • ‘(a b c) => (a b c) • Quote can’t work under eager evaluation. Why? • Quote allows Lisp to represent functions as data: • (+ 1 2) is a program (computes 3 when evaled) • ‘(+ 1 2) is data (the list of three elements) • (+ 2 (+ 1 2)) is 5, but • (+ 2 ‘(+ 1 2)) is an error (why?)

20. Function Definition • To create a named function, use defun: • (defun <name> (<parameter list>) <documentation string> <forms>) • (defun sumsq (x y) “Returns sum of X and Y squared.” (+ (* x x) (* y y))) • The documentation string is saved in the environment and can be recalled from the editor

21. Conditional statements • If special form: • (if <test> <then form> <else form>) • (if (= x 0) ‘infinity (/ 10 x))

22. Conditional statements (cont.) • Cond special form: • (cond <cond-clause>*) • <cond-clause> ::= (<test form> <form>*) • (cond ((= x 1) (print “a small number”)) ((= x 2) (print “a larger number.”)))

23. Variables • Declared using defvar and defparameter: • (defvar <variable name> <initial value> <documentation string>) • (defvar number-list nil“A list of numbers”) • Assigned values using setf special form: • (setf <place> <new value>) • (setf x 3) => 3 • x => 3 • Imperative Paradigm Alert!

24. Basic List Processing Functions • list • takes any number args, returns a list: • (list ‘x ‘y ‘z) => (x y z) • (list (list ‘x ‘y) (list ‘x ‘y)) => ((x y) (x y)) • car (or first) • returns the first element of a list • (car (list ‘x ‘y)) => x • cdr (or rest) • returns everything but first element: • (cdr ‘(a b c)) => (b c)

25. Basic List Processing Functions • append • takes any number of lists as arguments and returns them appended together • (append ‘(a b c) ‘(d e f)) => (a b c d e f) • equal • takes two arguments, and returns T if they are structurally equal or of equal value. • null • returns T if the list is empty, nil otherwise.

26. A simple program • (defvar balance 0 • “The current balance in the bank.”) • (defun deposit (amount) • “Adds amount to balance.” • (setf balance (+ balance amount))) • (defun withdraw (amount) • “Subtracts amount from balance.” • (setf balance (- balance amount)))

27. Running the program • > (deposit 100) • 100 • > (deposit 1000) • 1100 • > (withdraw 900) • 200 • > (withdraw 300) • -100

28. Things to do • Put this program in a file. • Load the program file into Lisp. • Run the program by evaluating forms.

29. Programming Assignment • Extend the bank balance program as follows: • Disallow negative balances. If a withdrawal leads to a negative balance, don’t do it and leave the balance as it was initially. • Provide a function called “interest” that increases the current balance by 5%. • Support multiple users. Each function should take a symbol which is a user name. That user’s balance should be updated independently of the others. You should use only ONE balance variable (but it should be a list, hint hint.)

30. Negative balance prevention: (deposit 200)200(withdraw 300)200 Interest: (deposit 200)200(interest)210 Multiple users: (deposit ‘joe 200)200(deposit ‘ann 300)300(withdraw ‘joe 100)100(withdraw ‘ann 100)200 (typo fixed!) Examples

31. Resources • There are many online Common Lisp tutorials. Use your favorite search engine to find them. • Www.franz.com has a free downloadable Common Lisp environment trial version for Windows. • Allegro Common Lisp is available on uhunix2. Use “help software” to learn how to set it up.