introduction to lisp

Introduction to LISP

COP 4020 Programming Languages I

Dr. Euripides Montagne

Scribed by Nate Smith

Introducing LISP

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.


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


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


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.


Function Notation

(function_name argument1 argument2 … argument n)

(+ 5 7) = 12


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.


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


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.


Primitive Functions on Numeric Atoms

+addcan 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


Primitive Functions on Numeric Atoms (continued)

Expressions Values34 34(* 3 7) 21(+ 5 7 3) 15(- 5 6) -1(- 24 (* 4 3)) 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.


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))


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))))


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.


Output Functions

• Format (display <expression>) (newline)

• Example(display “Hello, world!”)


Numeric Predicates

Function Meaning= Equal<> Not equal> Greater than< Less than>= Greater than or equal to<= Less than or equal toEVEN? Is it an even number?ODD? Is it an odd number?ZERO? Is it equal to zero?


Boolean Values

Expression Value#T True#F False


Control Flow

• Uses recursion and conditional expressions

• Two way selection• Multiple selection


Two Way Selection

• Format(if predicate then_expression else_expression)

• Example(define (factorial n)

(if (= n 0)1(* n (factorial (- n 1)))

))


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)>)

)


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”))

))


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)


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


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))



• The following example returns the second element from a list.

(define (second list)(car (cdr list))

)


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



• 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>)



• 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)


Predicate Functions

• Returns whether two atoms are equal• Format

(EQ? atom1 atom2)• Example

(EQ? ‘A ‘A) = #T(EQ? ‘A ‘B) = #F(EQ? ‘A ‘(A B)) = ()(EQ? ‘(A B) ‘(A B)) = ()*

* possibly #T depending on the implementation


Predicate Functions (continued)

• Examines whether a parameter is a list

• Format(LIST? <expression>)

• Example(LIST? ‘(X Y)) = #T(LIST? ‘X) = ()(LIST? ‘()) = #T



• Examines whether a given list is empty• Format

(NULL? list)• Example

(NULL? ‘(A B)) = ()(NULL? ‘()) = #T(NULL? ‘A) = ()(NULL? ‘(())) = #T



• 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



• 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)))

))

introduction to lisp

Documents