ML Again ( Chapter 7) Patterns Local variable definitions Two sorting examples The implementation using functional languages is closer to the concepts of the solutions. 7/2/2018 IT 327

Both n and (a,b) are patterns. fun f n = n*n; fun g (a,b) = a*b; Both n and (a,b) are patterns. n is a pattern of integers; (a, b) is a pattern of 2-tuple of integers. For match and bind (most of the time) f 2; (matched) f (2,3); (not matched) g 2; (not matched) g (2,3); (matched) IT 327 7/2/2018

Underscore is a Pattern - fun f _ = "yes"; val f = fn : 'a -> string - f 34.5; val it = "yes" : string - f []; The underscore matches anything, but does not bind it to a variable fun f x = "yes"; 7/2/2018 IT 327

Constants are Patterns - fun f 0 = "yes"; Warning: match nonexhaustive 0 => ... val f = fn : int -> string - f 0; val it = "yes" : string Any constant of an equality type can be used as a pattern But not: fun f 0.0 = "yes"; 7/2/2018 IT 327

Non-Exhaustive Match “match non-exhaustive” warning Meaning: f was defined using a pattern that didn’t cover all the domain type (int) So you may get runtime errors like this: - f 0; val it = "yes" : string - f 1; uncaught exception nonexhaustive match failure 7/2/2018 IT 327

Lists Of Patterns As Patterns - fun f [a,_] = a; Warning: match nonexhaustive a :: _ :: nil => ... val f = fn : 'a list -> 'a - f [#"f",#"g"]; val it = #"f" : char You can use a list of patterns as a pattern This example matches any list of length 2 It treats a and _ as sub-patterns, binding a to the first list element Why not 1? 7/2/2018 IT 327

Cons Of Patterns As A Pattern - fun f (x::xs) = x; Warning: match nonexhaustive x :: xs => ... val f = fn : 'a list -> 'a - f [1,2,3]; val it = 1 : int You can use a cons of patterns as a pattern x::xs matches any non-empty list, and binds x to the head and xs to the tail Parentheses around x::xs are for precedence 7/2/2018 IT 327

Little Summary A variable is a pattern that matches anything, and binds to it A _ is a pattern that matches anything A constant (of an equality type) is a pattern that matches only that constant A tuple of patterns is a pattern that matches any tuple of the right size, whose contents match the sub-patterns A list of patterns is a pattern that matches any list of the right size, whose contents match the sub-patterns A cons (::) of patterns is a pattern that matches any non-empty list whose head and tail match the sub-patterns 7/2/2018 IT 327

Multiple Patterns for Functions - fun f 0 = "zero" = | f 1 = "one"; Warning: match nonexhaustive 0 => ... 1 => ... val f = fn : int -> string; - f 1; val it = "one" : string You can define a function by listing alternate patterns 7/2/2018 IT 327

Syntax To list alternate patterns for a function <fun-def> ::= fun <fun-bodies> ; <fun-bodies> ::= <fun-body> <fun-bodies> ::= <fun-body> | <fun-bodies> <fun-body> ::= <fun-name> <pattern> = <expression> To list alternate patterns for a function You must repeat the same function name in each alternative We just hit the limitation of CFG 7/2/2018 IT 327

Overlapping Patterns Patterns may overlap - fun f 0 = "zero" = | f _ = "non-zero"; val f = fn : int -> string; - f 0; val it = "zero" : string - f 34; val it = "non-zero" : string Patterns may overlap ML uses the first match for a given argument 7/2/2018 IT 327

Pattern-Matching Style Two alternatives: fun f 0 = "zero" | f _ = "non-zero"; fun f n = if n = 0 then "zero" else "non-zero"; Pattern-matching style is preferred in ML shorter and more legible 7/2/2018 IT 327

Pattern-Matching Examples fun fact n = if n = 0 then 1 else n * fact(n-1); fun fact 0 = 1 | fact n = n * fact(n-1); fun reverse L = if null L then nil else reverse(tl L) @ [hd L]; fun reverse nil = nil | reverse (first::rest) = reverse rest@[first]; 7/2/2018 IT 327

A Restriction How to explain this? This is not legal, but why? fun f (a,a) = … | f (a,b) = … This is not legal, but why? fun f (a,b) = if (a=b) then … else … 7/2/2018 IT 327

Patterns in val - val (a,b) = (1,2.3); val a = 1 : int val b = 2.3 : real - val a::b = [1,2,3,4,5]; Warning: binding not exhaustive a :: b = ... val b = [2,3,4,5] : int list 7/2/2018 IT 327

Local Variable Definitions <let-exp> ::= let <definitions> in <expression> end - let val x = 1 val y = 2 in x+y end; val it = 3 : int; - x; Error: unbound variable or constructor: x let val x = 1 val y = 2 in x+y End; This alone is not very useful! We can put it into a function definition 7/2/2018 IT 327

Long Expressions with let fun days2ms days = days*24.0*60.0*60.0*1000.0; fun days2ms days = let val hours = days * 24.0 val minutes = hours * 60.0 val seconds = minutes * 60.0 in seconds * 1000.0 end; 7/2/2018 IT 327

Merge Sort You should have known this well. 3 5 7 8 1 2 6 (if you have taken 279) Merge two sorted lists 3 5 7 8 1 2 6 7/2/2018 IT 327

Merge Sort 7 5 3 8 2 1 6 7 5 3 8 2 1 6 7 5 3 8 2 1 6 7 5 3 8 2 1 5 7 3 8 1 2 3 5 7 8 1 2 6 1 2 3 5 6 7 8 7/2/2018 IT 327

How to split 7 5 3 8 2 1 6 7 5 3 8 2 1 6 In ML, it’s a bit difficult to do this We have hd, tl and :: 7 5 3 8 2 1 6 7 3,8,2,1,6 5 Recursively 7/2/2018 IT 327

halve fun halve nil = (nil, nil) | halve [a] = ([a], nil) | halve (a::b::cs) = let val (x, y) = halve cs in (a::x, b::y) end; -halve [1]; val it = ([1],[]) : int list * int list halve [1,2]; val it = ([1],[2]) : int list * int list - halve [1,2,3,4,5,6]; val it = ([1,3,5],[2,4,6]) : int list * int list 7/2/2018 IT 327

merge Recursively 7 xs 5 ys 5 fun merge (nil, ys) = ys | merge (xs, nil) = xs | merge (x::xs, y::ys) = if (x < y) then x :: merge(xs, y::ys) else y :: merge(x::xs, ys); 7/2/2018 IT 327

Merge Sort int list -> int list, fun mergeSort nil = nil | mergeSort [a] = [a] | mergeSort theList = let val (x, y) = halve theList in merge(mergeSort x, mergeSort y) end; int list -> int list, 7/2/2018 IT 327

Merge Sort At Work These two functions can be defined locally. - fun mergeSort nil = nil = | mergeSort [a] = [a] = | mergeSort theList = = let = val (x, y) = halve theList = in = merge(mergeSort x, mergeSort y) = end; val mergeSort = fn : int list -> int list - mergeSort [4,3,2,1]; val it = [1,2,3,4] : int list - mergeSort [4,2,3,1,5,3,6]; val it = [1,2,3,3,4,5,6] : int list here 7/2/2018 IT 327

val (x, y) = halve theList in merge(mergeSort x, mergeSort y) end; fun mergeSort nil = nil | mergeSort [e] = [e] | mergeSort theList = let (* fun and var defined locally *) fun halve nil = (nil, nil) | halve [a] = ([a], nil) | halve (a::b::cs) = let val (x, y) = halve cs in (a::x, b::y) end; fun merge (nil, ys) = ys | merge (xs, nil) = xs | merge (x::xs, y::ys) = if (x < y) then x :: merge(xs, y::ys) else y :: merge(x::xs, ys); val (x, y) = halve theList in merge(mergeSort x, mergeSort y) end; 7/2/2018 IT 327

Quick Sort < < < < < < < < < < < < 7 5 8 14 6 1 16 2 11 10 9 13 3 15 12 4 < 7 5 8 4 6 1 3 2 11 10 9 13 16 15 12 14 < < < 2 3 1 4 6 8 5 7 11 10 9 12 16 15 13 14 < < < < < < < 2 1 3 4 6 5 8 7 9 10 11 12 14 13 15 16 < < < < < < < < < < < < < < < 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 7/2/2018 IT 327

pivot Quick Sort 7 5 8 14 6 1 16 2 11 10 9 13 3 15 12 4 4 3 2 16 14 8 2 5 4 3 6 1 7 16 11 10 9 13 14 15 12 8 1 2 4 3 6 5 7 8 11 10 9 13 14 15 12 16 1 2 3 4 6 5 7 8 11 10 9 13 14 15 12 16 1 2 3 4 5 6 7 8 9 10 11 13 14 15 12 16 1 2 3 4 5 6 7 8 9 10 11 12 13 15 14 16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Using imperative PL’s, we have to explicitly implement these iterations. 7/2/2018 IT 327

Quick Sort in Java We have to explicitly implement these iterations. private void SwapTwo(int A[], int i, int j){ int temp = A[i]; A[i]=A[j]; A[j]=temp; } public void QuickSort(int A[], int h, int t){ if (h == t) return; int i=h+1, j=t; if (i==j) { if (A[h] > A[i]) SwapTwo(A,h,i); return; while (i < j) { while (A[h] >= A[i] && i < t) i++; while (A[h] <= A[j] && j > h) j--; if (i < j) SwapTwo(A,i++,j--); if (i==j && A[h]>A[i]) SwapTwo(A,h,i); QuickSort(A,h,i-1); QuickSort(A,i,t); Quick Sort in Java We have to explicitly implement these iterations. 7/2/2018 IT 327

Quick Sort in ML pivot Anything wrong? How about split [2,2] ? fun split nil = (nil,nil) | split [a] = ([a],nil) | split (a::b::tail) = let val (x,y) = split (a::tail) in if (a < b) then (x, b::y) else (b::x, y) end; fun quicksort nil = nil | quicksort [a] = [a] | quicksort a = val (x,y) = split a quicksort(x)@quicksort(y) pivot This is more conceptual to the understanding of the problem Anything wrong? How about split [2,2] ? 7/2/2018 IT 327

Quick Sort in ML Force to split when there are two elements. fun split nil = (nil,nil) | split [a] = ([a],nil) | split [a,b] = if (a <= b) then ([a],[b]) else ([b],[a]) | split (a::b::c) = let val (x,y) = split (a::c) in if (a < b) then (x, b::y) else (b::x, y) end; fun quicksort nil = nil | quicksort [a] = [a] | quicksort a = val (x,y) = split a quicksort(x)@quicksort(y) Force to split when there are two elements. 7/2/2018 IT 327

Exercise Chapter 7.  Exercise: 2, 3, 5, 7, 8, 9, 10 7/2/2018 IT 327