Introduction to LISP

1. Introduction to LISP COP 4020 Programming Languages I Dr. Euripides Montagne

2. IntroducingLISP List Processing Language • Developed by John McCarthy in the late 1950s • McCarthy thought LISP could be used to study computability. • The main idea was to approach computability from a functional programming standpoint. Scribed by Nate Smith

3. Data Types & Structures • Two fundamental data types • Atoms • An atom is an alphanumeric string, used either as a variable name or a data item • Lists • A list is a sequence of elements, where each element is either an atom or a list Scribed by Nate Smith

4. Lists • Simple lists (A B C D) • Nested lists (A (B C) D (E (F G))) • Both these lists contain four elements. • A, B, C, D, E, F, G are atoms Scribed by Nate Smith

5. Lists – Internal Representation • (A B C D) • Here we have a list with four elements. • (A (B C) D (E (F G))) • This list also has four elements, but two of those are nested lists. Scribed by Nate Smith

6. Function Notation (function_name argument1 argument2 … argument n) (+ 5 7) = 12 Scribed by Nate Smith

7. LISP and Lambda Calculus Lambda calculus was modified to allow the binding of functions to names so that functions could be referenced by other functions and themselves. (function_name (LAMBDA (arg1 arg2 … arg n) expression)) LISP functions specified in this new notation were called s-expressions (symbolic expressions). An s-expression can be an atom or a list. Scribed by Nate Smith

8. Scheme • A dialect of lisp developed at MIT in the mid-70s (Sussman and Steele 1975) • Main Features • Small size • Static scope • Treatment of functions as first class entities • As first class entities, scheme functions can be • values of expressions • elements of lists • assigned to variables • passed as parameters • Simple syntax and semantics • Well-suited to educational applications Scribed by Nate Smith

9. The Interpreter • In 1965 McCarthy developed a function called “eval” used to evaluate other functions (an interpreter). • It is a read-evaluate-write infinite loop. • Expressions are interpreted by the function “eval.” • Literals are evaluated to themselves. For example, if you type in 5, the interpreter will return 5. • Expressions that are calls to primitive functions are evaluated as follows: • Each parameter is evaluated first. • The primitive function is applied to the parameter values. • The result is displayed. Scribed by Nate Smith

10. Primitive Functions on Numeric Atoms + add can have zero or more parameters (returns zero if there are no parameters) - subtract * multiply can have zero or more parameters (returns one if there are no parameters) / divide Scribed by Nate Smith

11. Primitive Functions on Numeric Atoms (continued) Expressions Values 34 34 (* 3 7) 21 (+ 5 7 3) 15 (- 5 6) -1 (- 24 (* 4 3)) 12 Scribed by Nate Smith

12. Defining Functions • A Lisp program is a collection of function definitions • Nameless functions include the word “lambda.” • (lambda (x) (* x x)) Which can be applied as follows (lambda (x) (* x x)) 5 = 25 • Here x is the bounded variable within the lambda expression. Scribed by Nate Smith

13. Binding Names to Functions • Define or defun is used to bind a name to a value or a lambda expression. • Format (define (function_name parameters) <expression(s)>) • Example (define (square num) (* num num)) Scribed by Nate Smith

14. Binding Names to Functions (continued) • Once the function is evaluated by the interpreter, it can be used as in (square 7) = 49 • Example (define (hypotenuse side1 side2) (sqrt (+ (square side1) (square side2))) ) Scribed by Nate Smith

15. Binding Names to Values • (define pi 3.14) (define twopi (* 2 pi)) • Once these two expressions are typed in to the Lisp interpreter, typing pi will return 3.14. • Names consist of letters, digits, and special characters (except parenthesis) but cannot begin with a digit. Scribed by Nate Smith

16. Output Functions • Format (display <expression>) (newline) • Example (display “Hello, world!”) Scribed by Nate Smith

17. Numeric Predicates FunctionMeaning = Equal <> Not equal > Greater than < Less than >= Greater than or equal to <= Less than or equal to EVEN? Is it an even number? ODD? Is it an odd number? ZERO? Is it equal to zero? Scribed by Nate Smith

18. Boolean Values ExpressionValue #T True #F False Scribed by Nate Smith

19. Control Flow • Uses recursion and conditional expressions • Two way selection • Multiple selection Scribed by Nate Smith

20. Two Way Selection • Format (if predicate then_expression else_expression) • Example (define (factorial n) (if (= n 0) 1 (* n (factorial (- n 1))) ) ) Scribed by Nate Smith

21. Multiple Selection • Each parameter is a pair of expressions in which the first is a predicate. • Format (cond (predicate1 <expression(s)>) (predicate2 <expression(s)>) … (predicate n <expression(s)>) (else <expression(s)>) ) Scribed by Nate Smith

22. Multiple Selection (continued) • Example (define (compare x y) (cond ((> x y) (display “x greater than y”)) ((< x y) (display “y greater than x”)) (else (display “x equal to y”)) ) ) Scribed by Nate Smith

23. List Functions • To avoid the evaluation of parameters when we are dealing with lists, we use “quote.” • Format (quote <expression>) • Example (quote A) = A (quote (A B C)) = (A B C) • Usually quote is replaced by an apostrophe. ‘(A B C) = (A B C) Scribed by Nate Smith

24. Primitives for Manipulating Lists • Car returns the first element from a list. • Format (car <list>) • Example (car ‘(A B C)) = A (car ‘((A B) C D)) = (A B) (car ‘A) = error because A is not a list Scribed by Nate Smith

25. Primitives for Manipulating Lists (continued) • Cdr removes the first element in the list and returns the remainder. • Format (cdr <list>) • Example (cdr (A B C)) = (B C) (cdr ((A B C) D (E F))) = (D (E F)) Scribed by Nate Smith

26. Primitives for Manipulating Lists (continued) • The following example returns the second element from a list. (define (second list) (car (cdr list)) ) Scribed by Nate Smith

27. Why CAR and CDR? • The names refer to the IBM system 704 where car and cdr were used as pointers to registers: CAR = contents of address register CDR = contents of decrement register Scribed by Nate Smith

28. Primitives for Manipulating Lists (continued) • Cons is a primitive list constructor. It builds a list from its two arguments, the first being an atom or list, the second usually a list. • Cons inserts its first argument as the new car of its second argument. • Format (cons <atom or list> <list>) Scribed by Nate Smith

29. Primitives for Manipulating Lists (continued) • Example (cons ‘A ‘()) = (A) (cons ‘A ‘(B C)) = (A B C) (cons ‘() ‘(A B)) = (() A B) (cons ‘(A B) ‘(C D)) = ((A B) C D) Scribed by Nate Smith

30. Predicate Functions • Returns whether two atoms are equal • Format (EQ? atom1 atom2) • Example (EQ? ‘A ‘A) = #T (EQ? ‘A ‘B) = () (EQ? ‘A ‘(A B)) = () (EQ? ‘(A B) ‘(A B)) = ()* * possibly #T depending on the implementation Scribed by Nate Smith

31. Predicate Functions (continued) • Examines whether a parameter is a list • Format (LIST? <expression>) • Example (LIST? ‘(X Y)) = #T (LIST? ‘X) = () (LIST? ‘()) = #T Scribed by Nate Smith

32. Predicate Functions (continued) • Examines whether a given list is empty • Format (NULL? list) • Example (NULL? ‘(A B)) = () (NULL? ‘()) = #T (NULL? ‘A) = () (NULL? ‘(())) = #T Scribed by Nate Smith

33. Predicate Functions (continued) • Whether an entity is a member of a given list • Format (MEMBER entity list) • Example (MEMBER ‘B ‘(A B C)) = #T (MEMBER ‘B ‘(A C D E)) = #F Scribed by Nate Smith

34. Predicate Functions (continued) • The member function is defined as follows: (define (member atom list) (cond ((null? List) #F) ((eq? atom (car list)) #T) (else (member atom (cdr list))) ) ) Scribed by Nate Smith