LISP Data Types Functional Programming
description
Transcript of LISP Data Types Functional Programming
![Page 2: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/2.jpg)
LISP: basic data types
• Everything is a symbolic expression• Symbolic expressions can be
– Atoms• Numbers• Symbols
– Lists• Atom: a sequence of characters beginning with a
letter, digit or special character other than “(“ or “)”. – numbers, variable names, etc.– Examples
• 2, 30, fibo, this-is-an-atom
![Page 3: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/3.jpg)
Recognizers> (atom 'a) T> (atom 12)T>(atom '(12 23))NIL> (numberp 'a) NIL> (numberp 12)T> (symbolp 'a) T> (symbolp 12)NIL
![Page 4: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/4.jpg)
Basic Math• Predicates:
– (zerop number)– (plusp number)– (oddp integer)– (evenp integer)– (integerp atom)– (floatp atom):
returns true if the argument is zero/positive number/etc.; nil, otherwise.• Comparison:
– (= number more-numbers)– (/= number more-numbers)– (< number more-numbers)– (> number more-numbers)– (<= number more-numbers)– (>= number more-numbers)– (<= 1 3 5 7) T; (< 1 3 3 5) Nil;
![Page 5: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/5.jpg)
Basic Math• Arithmetic Operations:
– (+ numbers)– (- number rest-numbers)– (* numbers)– (/ number rest-numbers)– (1+ number) – (1- number)
• Examples– (1+ 24) 25– (1- 24) 23– (+ 2 5 6) 13– (+ ) = 0– (/ 3 4 5) 3/20– (/ -3) = -1/3– (* ) 1– (+ (* 2 3) (/ 2 5)) 32/5
![Page 6: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/6.jpg)
More Math• (max 1 2 3 4 5) 5• (min 1 2 3 -4) -4• (exp number) = enumber
• (expt base power) = basepower
– (exp 2) 7.389– (expt 2 3) 23 = 8;
• (log number optional base) = logbase number;– (log 8 2) 3; (log 3) 1.09;
• (abs number) – (abs -5) 5
• (signum number) returns -1, 0 or 1 if the number is negative, zero or positive, respectively
• (sqrt number); • (isqrt number) returns the greater inter less than equal to the exact
positive square-root of the number• (round number)• (floor number)• (ceiling number)• (truncate number)
![Page 7: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/7.jpg)
Symbolic Expressions• Everything is an S-expression (Symbolic-
expression).• S-expression = ATOM | LIST • List:
– a collection of S-expression enclosed by parentheses– a sequence of items.– Examples
• (1 apple 200 3.14),• ((peach (orange)) 3.14 (apricot) apple)
– List is treated as function calls• first item as the name of a function.
– Example • (append ’(a b) ’(c d)) (a b c d)
![Page 8: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/8.jpg)
NIL• NIL is a special S-expression• It is both an atom and a list.• It represents the empty list
– can also be written as ()• It represents falsity
– anything else is considered to be true– T is the default value used for true
• Examples(not nil) = t(not t) = nil(not ‘p) = nil(and ‘p ‘q nil ‘r) = nil(and ‘p ‘q ‘r) = r
![Page 9: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/9.jpg)
The List ADT
• A list is either – The empty list ()
• or– The list obtained by adding an element to a list
• The Abstract Data type:– () : -> <list>– cons : <elem> x <list> -> <list>– first : <list> -> <elem>– rest : <list> -> <list>
![Page 10: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/10.jpg)
Lists: examples
• The empty list– NIL, also written ( )
• One element lists– (a)– (1)– ((a))– (())
• Two element lists– (a 1)– (a b)– (a (1))
![Page 11: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/11.jpg)
Operators• atom: returns true if the argument is an atom; nil otherwise.
– (atom ’(a b)) nil– (atom ’a) T
• null: returns true if the argument is nil, nil otherwise.– (null ’(a b)) nil; (null ’a) nil– (null ’()) T
• first, rest:– (first ’(a b)) a– (rest ’(a b)) (b)
• second, third, .., nth:– (second ’(a b)) b– (nth 3 ’(a b c d)) c
![Page 12: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/12.jpg)
On Quoting• Lists are treated as function calls• When given a list, the interpreter attempts to evaluate the 1st term as
the name of a function• The other terms are evaluated using the previously given rules, the
results of their evaluations are passed as parameters.• The quote operator prevents the interpreter from trying to evaluate an
s-expression.
> (setq a 5)5> (+ 6 (* 3 a))21> (list (quote (+ 2 a)) 1 3)((+ 2 a) 1 3)> (list ‘(+ 2 a) 1 3)((+ 2 a) 1 3)
![Page 13: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/13.jpg)
Eval• Quote returns an atom or a list preventing its evaluation.
> (setq a ‘b)b> (setq b ‘c)c
• Eval: is the inverse of the quote operator> (+ 3 6)9> (eval ’(+ 3 6))9> (eval ’a)b> (eval a)c> (eval ’b)c> (eval b)Error: the variable c is unbound
![Page 14: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/14.jpg)
Operators• length: number of elements in a list
– (length ’(a b c)) 3• cons: append an atom and a list
– (cons ’a ’(b c d)) (a b c d)– (cons ’(a) ’(b c d)) ((a) b c d)
• first: return the first element of a list– (first ’(a b c)) a
• rest: return the list without the first element– (rest ’(a b c)) (b c)
• basic properties– (first (cons x y)) = x – (rest (cons x y)) = y
![Page 15: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/15.jpg)
Operators
• list: creates a list out of atoms and lists– (list ’a ’b ’c) (a b c)– (list ’a ’((b) c)) (a ((b) c))– (list ’a ’(1 2) ’((b c) (3 4)))
(a (1 2) ((b c)(3 4)))
– (list 1 2 (* 3 4)) (1 2 12) (* 3 4) gets evaluated!
![Page 16: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/16.jpg)
Basics: list
• append: append two lists> (append ’(a b) ’(c d))
(a b c d)
> (append ’(a b) ’(a b) ’(c d))
(a b a b c d)
> (append ’(a b) ’() ’(c d))
(a b c d)
> (append ’() ’() ’())
()
![Page 17: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/17.jpg)
Basics: list
• member: takes two arguments to search for and a list to search for it in, then returns the item if it finds it and everything after it in the list> (member 3 ’((1 2) 3 4 5))
(3 4 5)
> (member 2 ’((1 2) 3 4 5)
nil
![Page 18: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/18.jpg)
Binding• You can bind variable anywhere in a program with the let or let*
special forms to create a local context.– let and let*: lexical scope (local context)
• (let ( <list of local vars> ) <body> )• (let ((a 20) b (c 30)) <body> )
– With let*, values from previous variables can be used to define new value.• (let* ((a 20) (b (* 2 a)) c) <body> )
– Examples> (let ((a 2)) (+ a 1))3> (let ((a 2) (b 4) (c 0)) (* a b))8> (setq c 3)3> (let ((c 5)) c)5> c3
![Page 19: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/19.jpg)
Lexical scope
• Return value according to the lexical scope where it’s defined.> (setq reg 5)
5
> (defun check-reg () reg)
CHECK-REG
> (check-reg)
5
> (let ((reg 6))
(check-reg))
5
![Page 20: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/20.jpg)
Dynamic scope• Defvar can be used to define a special variable
that is dynamically scoped.> (defvar *sp* 3)*sp*> (defun check-sp () *sp*)CHECK-SP> (check-sp)3> (let ((*sp* 4)) (check-sp))4> *sp*3> (let ((x 23)) (check-sp))3
![Page 21: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/21.jpg)
Conditional Predicates• Predicates
– Returns either T or Nil.– numberp, listp, symbolp, zerop, etc.– atom: test if an s-expression is an atom.– null: tests for nil.– equal: test if the values are the same.– eq: test if the memory locations are the same.– typep: takes two parameters of an element to test and
a type to test it for• e.g.) (typep 6 ’number)
– Logical operators: and, or, not• Nil or the empty list is considered to be false, everything else
is true.• (and 1 2) 2• (and () 2) nil
![Page 22: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/22.jpg)
Control structure• if statement
– (if condition Body1-when-true Body2-when-false)
> (if (< 3 5) (+ 2 3) (* 2 3))5
• cond statement– (cond ((testp1) body1)
((testp2) body2) ....(t (default-body))
> (cond ((> 1 2) (+ 2 3)) ((< 2 3) (* 2 3)) (t 10))6
![Page 23: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/23.jpg)
Length(defun length (l) (if (null l) 0 (+ 1 (length (rest l)))))length
> (length ‘(a b c)) (+ 1 (length ‘(b c))) (+ 1 (+ 1 (length ‘(c)))) (+ 1 (+ 1 (+ 1 (length ‘())))) (+ 1 (+ 1 (+ 1 0)) ... (+ 1 2)3
![Page 24: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/24.jpg)
Iterative Length> (defun length (l) (length-iter l 0))length
> (defun length-iter (l cnt) (if (null l) cnt (length-iter (rest l) (+ 1 cnt)))length-iter
> (length ‘(a b c)) (length-iter ‘(a b c) 0) (length-iter ‘(b c) 1) (length-iter ‘(c) 2) (length-iter ‘() 3)3
![Page 25: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/25.jpg)
Append
(defun append (l1 l2)
(if (null l1) l2
(cons
(first l1)
(append (rest l1) l2)))))
![Page 26: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/26.jpg)
Running Append
> (append ‘(1 2) ‘(3 4 5))
(cons 1 (append ‘(2) ‘(3 4 5)))
(cons 1 (cons 2 (append ‘() ‘(3 4 5)))
(cons 1 (cons 2 ‘(3 4 5)))
(cons 1 ‘(2 3 4 5))
(1 2 3 4 5)
![Page 27: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/27.jpg)
Reverse
(defun reverse (l)
(if (null l) l
(append
(reverse (rest l))
(list (first l)))))
![Page 28: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/28.jpg)
Running reverse> (reverse ‘(a b c))(append (reverse ‘(b c)) ‘(a))(append (append (reverse ‘(c)) ‘(b)) ‘(a))(append (append (append () ‘(c)) ‘(b)) ‘(a))(append (append ‘(c) ‘(b)) ‘(a))(append (cons ‘c ‘(b)) ‘(a))(append ‘(c b) ‘(a))(cons ‘c (append ‘(b) ‘(a)))(cons ‘c (cons ‘b ‘(a)))(cons ‘c ‘(b a))(c b a)
; Notice something wrong?; We traverse the lists too many times!!!
![Page 29: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/29.jpg)
Iteration vs Linear Recursion
• We have seen this happen with numbers
• The return value of the caller function is the return value of the called function
• No need to “wait on stack” for called function to return
• Iteration can be optimized during compilation
![Page 30: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/30.jpg)
Reverse Iterative
(defun reverse (l)
(reverse-iter l ()))
(defun reverse-iter (l acc)
(if (null l) acc
(reverse-iter (rest l) (cons (first l) acc))))
(reverse-iter ‘(a b c) nil)
(reverse-iter ‘(b c) (cons ‘a nil))
(reverse-iter ‘(c) (cons ‘b ‘(a)))
(reverse-iter ‘() (cons ‘c ‘(b a)))
‘(c b a)
![Page 31: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/31.jpg)
Append Iterative(defun append (l1 l2) (append-iter l1 l2 ()))(defun append-iter (l1 l2 acc) (if (null l1) (if (null acc) l2 (append-iter l1 (cons (first acc) l2) (rest acc)) (append-iter (rest l1) l2 (cons (first l1) acc)))))
> (append-iter ‘(a b) ‘(c d e) ‘())(append-iter ‘(b) ‘(c d e) ‘(a))(append-iter ‘() ‘(c d e) ‘(b a))(append-iter ‘() ‘(b c d e) ‘(a))(append-iter ‘() ‘(a b c d e) ‘())(a b c d e)
![Page 32: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/32.jpg)
The Cons ADT• A cons is either
– The empty list ()• Or
– The list obtained by consing two elements• The Abstract Data Type:
– <atom>: -> <sexp>– cons : <sexp> x <sexp> -> <cons>– car : <cons> -> <sexp>– cdr : <cons> -> <sexp>
• Basic properties– (car (cons x y)) = x– (cdr (cons x y)) = y
• Compare with lists: the second element of the last cons of a list is always nil > (cons 1 2)(1 . 2)> (list 1 2)(1 2)> (cons 1 (cons 2 nil))(1 2)
![Page 33: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/33.jpg)
Conses• cons: takes two s-expressions and returns a list
whose car is the 1st item and whose cdr is the 2nd item. i.e. insert the 1st item into the list of 2nd item.– (cons ’a ’(b c)) (a b c)– (cons ’(a) ’(b c)) ((a) b c)
• car: returns 1st element (atom or list)– (car ’(a (b d))) a– (car ’((a b) c)) (a b)
• cdr: returns the rest of a list except the 1st element of a list– (cdr ’(a (b c))) ((b c))– (cadr ’((a b) c)) (c)
• Combinations are possible: cXXXXr where X=(a|r)– (cadr ’(a (b c))) == (car (cdr ’(a (b c))))
(b c)
![Page 34: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/34.jpg)
Dot notation
• A dot is used to represents a cons with infix notation
• The printer will try to avoid printing dots explicitly turning them into list notation:> ’(1 . 2)(1 . 2)> ’(1 . nil)(1)> ’(1 . (2 . 3))’(1 2 . 3)> ’((1 . 2) . (3 . 4))’((1 . 2) 3 . 4)
![Page 35: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/35.jpg)
Counting the atoms> (defun cnt-atom (l) (cond ((null l) 0) ; nil ((atom l) 1) ; not a cons (t (+ (cnt-atom (car l)) (cnt-atom (cdr l)) ) ) ) )cnt-atom> (cnt-atom '(a (b c) d (e f (g h))))8> (cnt-atom '(a (b . c) d (e f (g . h))))8
![Page 36: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/36.jpg)
Flattening a tree(defun flat (x) (cond ((null x) x) ((atom x) (list x)) (t (append (flat (car x)) (flat (cdr x))))))f
>(flat '(1 2 3 4))(1 2 3 4)
>(flat '(1 (2 3) 4))(1 2 3 4)
>(flat '(2 . 3))(2 3)
>(flat '(() 1 (1 (2 4) (5 . 3))))(1 1 2 4 5 3)
![Page 37: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/37.jpg)
Flattening a tree(defun flat1 (x) (cond ((atom x) (list x)) (t (append (flat1 (car x)) (flat1 (cdr x))))))f
>(flat1 '(1 2 3 4))(1 2 3 4 NIL)
>(flat1 '(1 (2 3) 4))(1 2 3 NIL 4 NIL)
>(flat1 '(2 . 3))(2 3)
>(flat1 '(() 1 (1 (2 4) (5 . 3))))(NIL 1 1 2 4 NIL 5 3 NIL)
![Page 38: LISP Data Types Functional Programming](https://reader036.fdocuments.net/reader036/viewer/2022062517/56813956550346895da0f5a8/html5/thumbnails/38.jpg)
Flattening a tree(defun flat2 (x) (cond ((null x) x) ((atom x) (list x)) ((null (car x)) (cons nil (flat2 (cdr x)))) (t (append (flat2 (car x)) (flat2 (cdr x))))))f
>(f '(1 2 3 4))(1 2 3 4)
>(f '(1 (2 3) 4))(1 2 3 4)
>(f '(2 . 3))(2 3)
>(f '(() 1 (1 (2 4) (5 . 3))))(NIL 1 1 2 4 5 3)