Programming with Lists

Programming with Lists L5lists

Lists a is a type ----------- alist 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. L5lists

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

Catalog of List functions init [1,2,3] = [1,2] last [1,2,3] = 3 • Specs: init (xs @ [x]) = xs last (xs @ [x]) = x • Definitions: fun init (x::[]) = [] | init (x::xs) = x :: init xs; fun last (x::[]) = x | last (x::xs) = last xs; L5lists

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; L5lists

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; L5lists

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 L5lists

Selectors #i (a1,…, ai, …, an) = ai nth ([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. *) L5lists

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 L5lists

fun exists p [] = false | exists p (x::xs) = (p x) orelse (exists p xs) exists : (’a -> bool) -> ’a list -> bool fun all p [] = true | all p (x::xs) = (p x) andalso (all p xs) all : (’a -> bool) -> ’a list -> bool L5lists

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 L5lists

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 … L5lists

… 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 - … L5lists

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

Modular Designs using Lists Abstraction and Reuse Ref: Structure and Interpretation of Computer Programs (Abelson and Sussman) L5lists

(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. L5lists

(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. L5lists

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 () Abstract Descriptions L5lists

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

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

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

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

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

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

Programming with Lists