Control in LISPControl in LISP

More on Predicates & ConditionalsMore on Predicates & Conditionals

Equality TestsEquality Tests

LISP provides multiple equality testsLISP provides multiple equality tests– EQUAL and =EQUAL and =– EQL and EQEQL and EQ

Serve different purposesServe different purposes– they give different answers in some casesthey give different answers in some cases

Equal and =Equal and =

EQUAL is for general comparisonsEQUAL is for general comparisons = is used for numeric comparisons= is used for numeric comparisons

– an error to use = with non-numbersan error to use = with non-numbers = does type conversion; EQUAL does not= does type conversion; EQUAL does not

– (= 15 15.0) returns T(= 15 15.0) returns T– (equal 15 15.0) returns NIL(equal 15 15.0) returns NIL

EqEq

EQ is “pointer” equalityEQ is “pointer” equality– are these “two” objects pointing to the same are these “two” objects pointing to the same

hunk of memoryhunk of memory T if same atom or same variableT if same atom or same variable MaybeMaybe T if same number & type T if same number & type> > (list (eq ‘a ‘a) (eq ‘(a) ‘(a)))(list (eq ‘a ‘a) (eq ‘(a) ‘(a)))

(T NIL)(T NIL)

Eq and SetFEq and SetF

> > (setf a ‘(1 2 3))(setf a ‘(1 2 3))

> > (setf b ‘(1 2 3))(setf b ‘(1 2 3))

> > (setf c a)(setf c a)

> > (list (eq a ‘(1 2 3)) (eq a a) (eq a b) (eq a c))(list (eq a ‘(1 2 3)) (eq a a) (eq a b) (eq a c))

(NIL T NIL T)(NIL T NIL T) A and B are different, but A and C are sameA and B are different, but A and C are same

– even tho’ they all look exactly the sameeven tho’ they all look exactly the same

Eql and EqEql and Eq

EQL is just like EQ EQL is just like EQ except for numbersexcept for numbers A number is always EQL to itselfA number is always EQL to itself

– it it may not bemay not be EQ to itself EQ to itself– neither EQ nor EQL if different typesneither EQ nor EQL if different types

> > (list (eql 100 100) (eql 100 100.0) (eq 100 100))(list (eql 100 100) (eql 100 100.0) (eq 100 100))

(T NIL T)(T NIL T) oror (T NIL NIL)(T NIL NIL)

EqualEqual

EQUAL is general purposeEQUAL is general purpose– except for numbers it’s what you’d expectexcept for numbers it’s what you’d expect

> > (setf a ‘(1 2 3))(setf a ‘(1 2 3))

> > (setf b ‘(1 2 3))(setf b ‘(1 2 3))

> > (list (equal a ‘(1 2 3)) (equal a a) (equal a b))(list (equal a ‘(1 2 3)) (equal a a) (equal a b))

(T T T)(T T T)

> > (list (equal 1 1.0) (equal a ‘(1.0 2.0 3.0)))(list (equal 1 1.0) (equal a ‘(1.0 2.0 3.0)))

(NIL NIL)(NIL NIL)

Equal is EqualEqual is Equal

EQUAL goes all the way downEQUAL goes all the way down– lists with lists treated properlylists with lists treated properly

> > (equal ‘(1 (2 (3 4) (5 6))) ‘(1 (2 (3 4) (5 6))))(equal ‘(1 (2 (3 4) (5 6))) ‘(1 (2 (3 4) (5 6))))

TT

> > (equal ‘(1 2 (3 4)) ‘(1 2 3 4))(equal ‘(1 2 (3 4)) ‘(1 2 3 4))

NILNIL

Testing for EqualityTesting for Equality

Use EQUAL if need to compare listsUse EQUAL if need to compare lists Use EQ or EQL for atoms/integersUse EQ or EQL for atoms/integers

– more efficient than equalmore efficient than equal Use = for general numbersUse = for general numbers

– only one that equates integers with floatsonly one that equates integers with floats

ExerciseExercise

True, false, either or error:True, false, either or error:(eq ‘a ‘a)(eq ‘a ‘a)

(eq 10 10)(eq 10 10)

(eq 10 10.0)(eq 10 10.0)

(eq ‘(10) ‘(10.0))(eq ‘(10) ‘(10.0))

(equal 10 10.0)(equal 10 10.0)

(equal ‘(10) ‘(10.0))(equal ‘(10) ‘(10.0))

(eql ‘a ‘a)(eql ‘a ‘a)

(eql 10 10)(eql 10 10)

(eql 10 10.0)(eql 10 10.0)

(eql ‘(10) ‘(10.0))(eql ‘(10) ‘(10.0))

(= 10 10.0)(= 10 10.0)

(= ‘(10) ‘(10.0))(= ‘(10) ‘(10.0))

Data Type PredicatesData Type Predicates

Can test an object to see whether it’s a Can test an object to see whether it’s a particular typeparticular type– ATOM, NUMBERP, SYMBOLP, LISTPATOM, NUMBERP, SYMBOLP, LISTP– (no P at the end of ATOM)(no P at the end of ATOM)

Numbers and symbols are also atomsNumbers and symbols are also atoms NIL is an atom and a listNIL is an atom and a list

Testing for TypeTesting for Type

> > (list (atom ‘a) (numberp ‘a) (symbolp ‘a) (listp ‘a))(list (atom ‘a) (numberp ‘a) (symbolp ‘a) (listp ‘a))(T NIL T NIL)(T NIL T NIL)

> > (list (atom 5) (numberp 5) (symbolp 5) (listp 5))(list (atom 5) (numberp 5) (symbolp 5) (listp 5))(T T NIL NIL)(T T NIL NIL)

> > (list (atom ()) (numberp ()) (symbolp ()) (listp ()))(list (atom ()) (numberp ()) (symbolp ()) (listp ()))(T NIL T T)(T NIL T T)

> > (list (atom ‘(a 1)) (numberp ‘(a 1))(list (atom ‘(a 1)) (numberp ‘(a 1))(symbolp ‘(a 1)) (listp ‘(a 1)))(symbolp ‘(a 1)) (listp ‘(a 1)))

(NIL NIL NIL T)(NIL NIL NIL T)

ExerciseExercise

Evaluate:Evaluate:> > (setf a ‘(+ 2 5))(setf a ‘(+ 2 5))

> > (list (atom ‘a) (numberp ‘a))(list (atom ‘a) (numberp ‘a))

> > (list (atom a) (numberp a))(list (atom a) (numberp a))

> > (list (atom (+ 2 5)) (numberp (+ 2 5)))(list (atom (+ 2 5)) (numberp (+ 2 5)))

> > (list (listp ‘a) (listp a) (listp (+ 2 5)))(list (listp ‘a) (listp a) (listp (+ 2 5)))

> > (list (symbolp ‘a) (symbolp a) (symbolp (+ 2 5)))(list (symbolp ‘a) (symbolp a) (symbolp (+ 2 5)))

Number TestsNumber Tests

Simple tests on numbersSimple tests on numbers– ZEROP, PLUSP, MINUSP, EVENP, ODDPZEROP, PLUSP, MINUSP, EVENP, ODDP

All do what you’d expect, butAll do what you’d expect, but– errors if not given numberserrors if not given numbers– errors if given more than one argumenterrors if given more than one argument

> > (list (zerop 0) (plusp 1) (minusp 2) (evenp 3))(list (zerop 0) (plusp 1) (minusp 2) (evenp 3))

(T T NIL NIL)(T T NIL NIL)

Compound ConditionsCompound Conditions

LISP provides functions for logical LISP provides functions for logical combination of conditionscombination of conditions– AND, OR, NOTAND, OR, NOT

Can be used anywhere a condition is Can be used anywhere a condition is requiredrequired

Logical AndLogical And

All arguments must be true (All arguments must be true (i.e. i.e. non-NIL)non-NIL)– returns NIL if one argument is NILreturns NIL if one argument is NIL– returns last argument if all non-NILreturns last argument if all non-NIL

> > (and (member ‘a ‘(d a d)) (member ‘o ‘(m o m)))(and (member ‘a ‘(d a d)) (member ‘o ‘(m o m)))

(O M)(O M)

> > (and (member ‘a ‘(d a d)) (member ‘b ‘(m o m)))(and (member ‘a ‘(d a d)) (member ‘b ‘(m o m)))

NILNIL

ExerciseExercise

Evaluate the following:Evaluate the following:> > (and (member ‘a ‘(d a d)) (member ‘u ‘(b u d)))(and (member ‘a ‘(d a d)) (member ‘u ‘(b u d)))

> > (and (member ‘a ‘(d a d)) (atom ‘(b u d)))(and (member ‘a ‘(d a d)) (atom ‘(b u d)))

> > (and (eq ‘a ‘a) (eql ‘a ‘a) (equal ‘a ‘a))(and (eq ‘a ‘a) (eql ‘a ‘a) (equal ‘a ‘a))

> > (and (eql 10 10.0) (= 10 10.0))(and (eql 10 10.0) (= 10 10.0))

> > (and (atom nil) (listp nil) (numberp nil))(and (atom nil) (listp nil) (numberp nil))

> > (and (numberp 10) (numberp 20) (+ 10 20))(and (numberp 10) (numberp 20) (+ 10 20))

Logical OrLogical Or

One argument must be non-NILOne argument must be non-NIL– returns NIL if all are NILreturns NIL if all are NIL– returns first non-NIL if one is non-NILreturns first non-NIL if one is non-NIL

> > (or (member ‘a ‘(d a d)) (member ‘b ‘(m o m)))(or (member ‘a ‘(d a d)) (member ‘b ‘(m o m)))

(A D)(A D)

> > (or (member ‘a ‘(d u d)) (member ‘b ‘(m i m)))(or (member ‘a ‘(d u d)) (member ‘b ‘(m i m)))

NILNIL

ExerciseExercise

Evaluate the following:Evaluate the following:> > (or (member ‘a ‘(d a d)) (member ‘u ‘(b u d)))(or (member ‘a ‘(d a d)) (member ‘u ‘(b u d)))

> > (or (member ‘a ‘(b u d)) (atom ‘(b u d)))(or (member ‘a ‘(b u d)) (atom ‘(b u d)))

> > (or (eq ‘a ‘a) (eql ‘a ‘a) (equal ‘a ‘a))(or (eq ‘a ‘a) (eql ‘a ‘a) (equal ‘a ‘a))

> > (or (eql 10 10.0) (= 10 10.0))(or (eql 10 10.0) (= 10 10.0))

> > (or (atom ‘a) (listp ‘a) (numberp ‘a))(or (atom ‘a) (listp ‘a) (numberp ‘a))

> > (or (numberp 10) (numberp 20) (+ 10 20))(or (numberp 10) (numberp 20) (+ 10 20))

Logical NotLogical Not

Reverses its one argumentReverses its one argument– returns T if argument is NILreturns T if argument is NIL– returns NIL if argument is non-NILreturns NIL if argument is non-NIL

> > (not (member ‘a ‘(d a d)))(not (member ‘a ‘(d a d)))

NILNIL

> > (not (member ‘b ‘(m o m)))(not (member ‘b ‘(m o m)))

TT

ExerciseExercise

Evaluate the following:Evaluate the following:> > (not (member ‘a ‘(d a d)))(not (member ‘a ‘(d a d)))

> > (not (member ‘u ‘(b a d)))(not (member ‘u ‘(b a d)))

> > (not (or (member ‘a ‘(d a)) (member ‘u ‘(u p))))(not (or (member ‘a ‘(d a)) (member ‘u ‘(u p))))

> > (not (and (member ‘a ‘(d a)) (member ‘u ‘(u p))))(not (and (member ‘a ‘(d a)) (member ‘u ‘(u p))))

> > (or (not (atom ‘a)) (not (listp ‘a)))(or (not (atom ‘a)) (not (listp ‘a)))

> > (and (not (evenp 3)) (or (oddp 8) (zerop 0)))(and (not (evenp 3)) (or (oddp 8) (zerop 0)))

ExerciseExercise

Write a function that takes an atom and two Write a function that takes an atom and two lists, and says how many of the lists the lists, and says how many of the lists the atom is in: ‘none, ‘one, or ‘bothatom is in: ‘none, ‘one, or ‘both

> > (two-member ‘a ‘(s a d) ‘(d a d))(two-member ‘a ‘(s a d) ‘(d a d))

BOTHBOTH

> > (two-member ‘o ‘(c a l m) ‘(m o m))(two-member ‘o ‘(c a l m) ‘(m o m))

ONEONE

““Short-Circuit” EvaluationShort-Circuit” Evaluation

AND & OR are special formsAND & OR are special forms– only evaluate arguments until answer knownonly evaluate arguments until answer known– can “guard” conditionscan “guard” conditions

> > (defun eqn (M N)(defun eqn (M N)(and (numberp N) (numberp M) (= N M)))(and (numberp N) (numberp M) (= N M)))

> > (eqn 15 15.0)(eqn 15 15.0)TT> > (eqn ‘a ‘a)(eqn ‘a ‘a)NILNIL

Short CircuitsShort Circuits

> > (eqn 15 15.0)(eqn 15 15.0)

(and(and

(numberp 15) => T(numberp 15) => T

(numberp 15.0) => T(numberp 15.0) => T

(= 15 15.0) => T(= 15 15.0) => T

) => T) => T

> > (eqn ‘a ‘a)(eqn ‘a ‘a)

(and(and

(numberp ‘a) => NIL(numberp ‘a) => NIL

) => NIL) => NIL Doesn’t do:Doesn’t do:

(numberp ‘a) => NIL(numberp ‘a) => NIL

(= ‘a ‘a) => ERROR(= ‘a ‘a) => ERROR

AND stops as soon as it sees a NIL

Short CircuitsShort Circuits

OR stops as soon as it sees non-NILOR stops as soon as it sees non-NIL(setf L ‘(a))(setf L ‘(a))

(or (null L) (= (length L) 1) (eq (first L) (second L))(or (null L) (= (length L) 1) (eq (first L) (second L))

(or(or

(null ‘(a)) => NIL(null ‘(a)) => NIL

(= (length ‘(a)) 1) => (= 1 1) => T(= (length ‘(a)) 1) => (= 1 1) => T

) => T) => T Does not compare (first L) = a with (second L) = NIL

ExerciseExercise

Write “safe” versions of EVENP & PLUSPWrite “safe” versions of EVENP & PLUSP– don’t give errors when called with non-don’t give errors when called with non-

numbersnumbers Version 1: use if, when or unlessVersion 1: use if, when or unless Version 2: use and, or or notVersion 2: use and, or or not

CaseCase

CASE special form simplifies CONDsCASE special form simplifies CONDs– all conditions (except else) involve checking all conditions (except else) involve checking

one object against othersone object against others

> > (defun fib (N)(defun fib (N)(cond ((= N 0) 1)(cond ((= N 0) 1)

((= N 1) 1)((= N 1) 1)(T (+ (fib (– N 1)) (fib (– N 2))))))(T (+ (fib (– N 1)) (fib (– N 2))))))

FIBFIB

CaseCase

CASE is a special formCASE is a special form– first argument is evaluatedfirst argument is evaluated– remaining arguments are notremaining arguments are not

> > (defun fib (N)(defun fib (N)(case N(case N

(0(0 1)1)(1(1 1)1)(T (T (+ (fib (– N 1)) (fib (– N 2))))))(+ (fib (– N 1)) (fib (– N 2))))))

Case CasesCase Cases

Cases appear a (LABEL FORM) pairsCases appear a (LABEL FORM) pairs First matching case is selectedFirst matching case is selected

– the form paired with it is evaluated & returnedthe form paired with it is evaluated & returned Matching:Matching:

– if LABEL is T or OTHERWISE, matchif LABEL is T or OTHERWISE, match– if LABEL is an atom, use EQL to compareif LABEL is an atom, use EQL to compare– if LABEL is a list, use member on that listif LABEL is a list, use member on that list

Compound CaseCompound Case

> > (defun fib2 (N)(defun fib2 (N)(case N(case N

((1 2)((1 2) 1)1)(T (T (+ (fib2 (– N 1)) (fib2 (– N (+ (fib2 (– N 1)) (fib2 (– N

2))))))2)))))) Calls (member N ‘(1 2)) for first caseCalls (member N ‘(1 2)) for first case Just succeeds for second caseJust succeeds for second case

ExerciseExercise

Write a function to expand three-letter Write a function to expand three-letter abbreviations for days of the week to the abbreviations for days of the week to the full day name. Use a case statement.full day name. Use a case statement.– return NIL if the day is not recognizedreturn NIL if the day is not recognized

>> (day-full-name ‘wed) (day-full-name ‘wed)

WEDNESDAYWEDNESDAY

ExerciseExercise

Write a function with case statement to Write a function with case statement to return the number of days in a month (given return the number of days in a month (given as a 3-letter abbr.). Ignore leap years.as a 3-letter abbr.). Ignore leap years.– Thirty days hath September,Thirty days hath September,

April, June and November.April, June and November.All the rest have thirty-one,All the rest have thirty-one,

Save February all alone,Save February all alone,Which hath twenty eight days clear, Which hath twenty eight days clear, & so on& so on

Next TimeNext Time

More Control in LISPMore Control in LISP– Chapters 4, 5 & 7Chapters 4, 5 & 7