Programming with Lists
description
Transcript of Programming with Lists
cs776 (Prasad) L5lists 1
Programming with Lists
cs776 (Prasad) L5lists 2
Lists is a type listlist is a type
(* Homogeneous lists. *)
– E.g., (true, [fn i:int => "i"])
: bool * (int -> string) list.– E.g., [1, 2 , 3], 1::2::3::[] : int list;– E.g., (op ::) : ’a * ’a list ->’a list;
– List constructors [] and :: can be used in patterns.
cs776 (Prasad) L5lists 3
Built-in operations on lists
hd : ’a list -> ’a tl : ’a list -> ’a list
null: ’a list -> bool
op @ : ’a list * ’a list -> ’a list (* append operation; infix operator *)
length : ’a list -> int (* sets vs lists -- multiplicity; ordering *)
cs776 (Prasad) L5lists 4
Catalog of List functionsinit [1,2,3] = [1,2]last [1,2,3] = 3
• Specs:init (xs @ [x]) = xslast (xs @ [x]) = x
• Definitions: fun init (x::[]) = [] | init (x::xs) = x :: init xs; fun last (x::[]) = x | last (x::xs) = last xs;
cs776 (Prasad) L5lists 5
take 3 [1,2,3,4] = [1,2,3] drop 2 [1,2,3] = [3]
• Definition: fun take 0 xs = [] | take n [] = [] | take n (x::xs) = x::take (n-1) xs;
fun drop 0 xs = xs | drop n [] = [] | drop n (x::xs) = drop (n-1) xs;
cs776 (Prasad) L5lists 6
takewhile even [2,4,1,6,2] = [2,4]dropwhile even [2,3,8] = [3,8]
• Definition: fun takewhile p [] = [] | takewhile p (x::xs) = if p x then x :: takewhile p xs else [];
fun dropwhile p [] = [] | dropwhile p (x::xs) = if p x then dropwhile p xs else x::xs;
cs776 (Prasad) L5lists 7
• Role of patterns– For testing type (“discrimination”)– For picking sub-expressions apart
• Signatures take, drop : int -> ’a list -> ’a list takewhile, dropwhile : (’a -> bool) -> ’a list -> ’a list
List.take, List.drop : ’a list * int -> ’a list
cs776 (Prasad) L5lists 8
Selectors #i (a1,…, ai, …, an) = ainth ([a0,…,ai,…,an],i) = ai
• Type of #i cannot be described in ML.
List.nth : ’a list * int -> ’a
fun nth (x::xs, 0) = x | nth (x::xs, i) = nth (xs, i-1) (* Patterns not exhaustive. Exception raised for null list input. *)
cs776 (Prasad) L5lists 9
fun filter p [] = [] | filter p (x::xs) = if p x then x::filter p xs else filter p xs
filter : (’a -> bool) -> ’a list -> ’a list
cs776 (Prasad) L5lists 10
fun exists p [] = false | exists p (x::xs) = (p x) orelseorelse (exists p xs) exists : (’a -> bool) -> ’a list -> bool
fun all p [] = true | all p (x::xs) = (p x) andalsoandalso (all p xs)
all : (’a -> bool) -> ’a list -> bool
cs776 (Prasad) L5lists 11
fun pair [] ys = [] | pair (x::xs) [] = [] | pair (x::xs) (y::ys) = (x,y) :: pair xs ys ;
pair: ’a list -> ’b list ->(’a * ’b) list
exception error;fun zip f (x::xs) (y::ys) = (f x y) :: zip f xs ys | zip f [] [] = [] | zip f xs ys = raise error;
zip : (’a -> ’b -> ’c ) -> ’a list -> ’b list -> ’c list
cs776 (Prasad) L5lists 12
Module List- open List;
opening List datatype 'a list = :: of 'a * 'a list | nil exception Empty
val null : 'a list -> bool val hd : 'a list -> 'a val tl : 'a list -> 'a list val last : 'a list -> 'a val getItem : 'a list -> ('a * 'a list) option val nth : 'a list * int -> 'a val take : 'a list * int -> 'a list val drop : 'a list * int -> 'a list val length : 'a list -> int val rev : 'a list -> 'a list …
cs776 (Prasad) L5lists 13
… val @ : 'a list * 'a list -> 'a list val concat : 'a list list -> 'a list val revAppend : 'a list * 'a list -> 'a list val app : ('a -> unit) -> 'a list -> unit val map : ('a -> 'b) -> 'a list -> 'b list val mapPartial : ('a -> 'b option) -> 'a list -> 'b list val find : ('a -> bool) -> 'a list -> 'a option val filter : ('a -> bool) -> 'a list -> 'a list val partition : ('a -> bool) -> 'a list -> 'a list * 'a list val foldr : ('a * 'b -> 'b) -> 'b -> 'a list -> 'b val foldl : ('a * 'b -> 'b) -> 'b -> 'a list -> 'b val exists : ('a -> bool) -> 'a list -> bool val all : ('a -> bool) -> 'a list -> bool val tabulate : int * (int -> 'a) -> 'a list- …
cs776 (Prasad) L5lists 14
Properties of functions
• Semantic Equivalence– Efficiency Transformations– Formal verification ; Debugging tool
map f (map g x) = map (f o g) x all p (filter p x) = true
(map f) o (filter (p o f)) = (filter p) o (map f)
cs776 (Prasad) L5lists 15
Modular Designs using Lists
Abstraction and Reuse
Ref: Structure and Interpretation of Computer Programs (Abelson and Sussman)
cs776 (Prasad) L5lists 16
(define (sum-odd-squares tree) (cond ((null? tree) 0) ((pair? tree) (+ (sum-odd-squares (car tree)) (sum-odd-squares (cdr tree)) ) ) (else (if (odd? tree) (* tree tree) 0))))
• Takes a tree and computes the sum of the squares of the leaves that are odd.
cs776 (Prasad) L5lists 17
(define (even-fibs n)
(define (next k)
(if (> k n) ’( )
(let ((f (fib k))
(if (even? f)
(cons f (next (+ k 1)))
(next (+ k 1)) )) ))
(next 0))
• Takes a number n and constructs a list of even numbers from among the first n Fibonacci numbers.
cs776 (Prasad) L5lists 18
Abstract Descriptions
• enumerates the leaves of a tree
• filters them, selecting the odd ones
• squares each of the selected ones
• accumulates the results using +, starting with 0
• enumerates the integers from 0 to n
• computes the Fibonacci number for each integer
• filters them, selecting the even ones
• accumulates the results using cons, starting with ()
cs776 (Prasad) L5lists 19
(define (filter pred seq)
(cond ((null? seq) ( ))
((pred (car seq))
(cons (car seq) (filter pred (cdr seq))))
(else (filter pred (cdr seq)))
))
(define (accumulate op init seq)
(if (null? seq) init
(op (car seq) (accumulate op init (cdr seq)))
))
cs776 (Prasad) L5lists 20
(define (enum-interval low high)
(if (> low high) ( )
(cons low (enum-interval (+ low 1) high))
))
(define (enum-tree tree)
(if ((null? tree) ( ))
((pair? tree)
(append (enum-tree (car tree))
(enum-tree (cdr tree)) ))
(else (list tree))))
cs776 (Prasad) L5lists 21
(define (sum-odd-squares tree)
(accumulate + 0
(map (lambda (x) (* x x))
(filter odd?
(enum-tree tree)))))
(define (even-fibs n)
(accumulate cons nil
(filter even?
(map fib
(enum-interval 0 n)))))
cs776 (Prasad) L5lists 22
Generality
(define (list-fib-squares n)
(map square (map fib
(enum-interval 0 n) )) )
(define (highest-salary-of-programmer records)
(accumulate max 0
(map salary
(filter programmer? records))))
cs776 (Prasad) L5lists 23
Inefficiencies
• Find the fifth prime in the interval 100 to 1000(caddddr (filter prime? (enum-interval 100 1000))
• Sum all primes between x and y(define (sum-prime x y)
(accumulate + 0
(filter prime? (enum-interval x y))))
cs776 (Prasad) L5lists 24
Rewrite
(define (sum-prime x y)
(define (iter count accum)
(if (> count y) accum
(if (prime? count)
(iter (+ 1 count) (+ accum count))
(iter (+ 1 count) accum)
)))
(iter x 0))