# Programming Languages and Compilers (CS 421)

Size: px
Start display at page:

## Transcription

1 Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul Agha 9/11/17 1

2 Functions Over Lists # let rec double_up list = match list with [ ] -> [ ] (* pattern before ->, expression after *) (x :: xs) -> (x :: x :: double_up xs);; val double_up : 'a list -> 'a list = <fun> # let fib5_2 = double_up fib5;; val fib5_2 : int list = [8; 8; 5; 5; 3; 3; 2; 2; 1; 1; 1; 1] 9/11/17 2

3 Functions Over Lists # let silly = double_up ["hi"; "there"];; val silly : string list = ["hi"; "hi"; "there"; "there"] # let rec poor_rev list = match list with [] -> [] (x::xs) -> poor_rev [x];; val poor_rev : 'a list -> 'a list = <fun> # poor_rev silly;; - : string list = ["there"; "there"; "hi"; "hi"] 9/11/17 3

4 Structural Recursion n Functions on recursive datatypes (eg lists) tend to be recursive n Recursion over recursive datatypes generally by structural recursion n Recursive calls made to components of structure of the same recursive type n Base cases of recursive types stop the recursion of the function 9/11/17 4

5 Structural Recursion : List Example # let rec length list = match list with [ ] -> 0 (* Nil case *) x :: xs -> 1 + length xs;; (* Cons case *) val length : 'a list -> int = <fun> # length [5; 4; 3; 2];; - : int = 4 n Nil case [ ] is base case n Cons case recurses on component list xs 9/11/17 5

6 Forward Recursion n In Structural Recursion, split input into components and (eventually) recurse on components n Forward Recursion form of Structural Recursion n In forward recursion, first call the function recursively on all recursive components, and then build final result from partial results n Wait until whole structure has been traversed to start building answer 9/11/17 6

7 Forward Recursion: Examples # let rec double_up list = match list with [ ] -> [ ] (x :: xs) -> (x :: x :: double_up xs);; val double_up : 'a list -> 'a list = <fun> # let rec poor_rev list = match list with [] -> [] (x::xs) -> let pr = poor_rev xs in [x];; val poor_rev : 'a list -> 'a list = <fun> 9/11/17 7

8 Question n How do you write length with forward recursion? let rec length l = 9/11/17 8

9 Question n How do you write length with forward recursion? let rec length l = match l with [] -> (a :: bs) -> 9/11/17 9

10 Question n How do you write length with forward recursion? let rec length l = match l with [] -> (a :: bs) -> 1 + length bs 9/11/17 10

11 Question n How do you write length with forward recursion? let rec length l = match l with [] -> 0 (a :: bs) -> 1 + length bs 9/11/17 11

12 Your turn now Try Problem 2 on ML2 9/11/17 12

13 An Important Optimization Normal call h g f n When a function call is made, the return address needs to be saved to the stack so we know to where to return when the call is finished n What if f calls g and g calls h, but calling h is the last thing g does (a tail call)? 9/11/17 13

14 An Important Optimization Tail call h f n When a function call is made, the return address needs to be saved to the stack so we know to where to return when the call is finished n What if f calls g and g calls h, but calling h is the last thing g does (a tail call)? n Then h can return directly to f instead of g 9/11/17 14

15 Tail Recursion n A recursive program is tail recursive if all recursive calls are tail calls n Tail recursive programs may be optimized to be implemented as loops, thus removing the function call overhead for the recursive calls n Tail recursion generally requires extra accumulator arguments to pass partial results n May require an auxiliary function 9/11/17 15

16 Example of Tail Recursion n Forward recursive: # let rec prod l = match l with [] -> 1 (x :: rem) -> x * prod rem;; val prod : int list -> int = <fun> n Tail recursive: # let prod list = let rec prod_aux l acc = match l with [] -> acc (y :: rest) -> prod_aux rest (acc * y) (* Uses associativity of multiplication *) in prod_aux list 1;; val prod : int list -> int = <fun> 9/11/17 16

17 Question n How do you write length with tail recursion? let length l = 9/11/17 17

18 Question n How do you write length with tail recursion? let length l = let rec length_aux list n = in 9/11/17 18

19 Question n How do you write length with tail recursion? let length l = let rec length_aux list n = match list with [] -> (a :: bs) -> in 9/11/17 19

20 Question n How do you write length with tail recursion? let length l = let rec length_aux list n = match list with [] -> n (a :: bs) -> in 9/11/17 20

21 Question n How do you write length with tail recursion? let length l = let rec length_aux list n = match list with [] -> n (a :: bs) -> length_aux in 9/11/17 21

22 Question n How do you write length with tail recursion? let length l = let rec length_aux list n = match list with [] -> n (a :: bs) -> length_aux bs in 9/11/17 22

23 Question n How do you write length with tail recursion? let length l = let rec length_aux list n = match list with [] -> n (a :: bs) -> length_aux bs (n + 1) in 9/11/17 23

24 Question n How do you write length with tail recursion? let length l = let rec length_aux list n = match list with [] -> n (a :: bs) -> length_aux bs (n + 1) in length_aux l 0 9/11/17 24

25 Your turn now Try Problem 4 on MP2 9/11/17 25

26 Mapping Recursion n One common form of structural recursion applies a function to each element in the structure # let rec doublelist list = match list with [ ] -> [ ] x::xs -> 2 * x :: doublelist xs;; val doublelist : int list -> int list = <fun> # doublelist [2;3;4];; - : int list = [4; 6; 8] 9/11/17 26

27 Mapping Functions Over Lists # let rec map f list = match list with [] -> [] (h::t) -> (f h) :: (map f t);; val map : ('a -> 'b) -> 'a list -> 'b list = <fun> # map plus_two fib5;; - : int list = [10; 7; 5; 4; 3; 3] # map (fun x -> x - 1) fib6;; : int list = [12; 7; 4; 2; 1; 0; 0] 9/11/17 27

28 Mapping Recursion n Can use the higher-order recursive map function instead of direct recursion # let doublelist list = List.map (fun x -> 2 * x) list;; val doublelist : int list -> int list = <fun> # doublelist [2;3;4];; - : int list = [4; 6; 8] n Same function, but no rec 9/11/17 28

29 Your turn now Write a function make_app : (( a -> b) * a) list -> b list that takes a list of function input pairs and gives the result of applying each function to its argument. Use map, no explicit recursion. let make_app l = 9/11/17 29

30 Folding Recursion n Another common form folds an operation over the elements of the structure # let rec multlist list = match list with [ ] -> 1 x::xs -> x * multlist xs;; val multlist : int list -> int = <fun> # multlist [2;4;6];; - : int = 48 n Computes (2 * (4 * (6 * 1))) 9/11/17 30

31 Folding Functions over Lists How are the following functions similar? # let rec sumlist list = match list with [ ] -> 0 x::xs -> x + sumlist xs;; val sumlist : int list -> int = <fun> # sumlist [2;3;4];; - : int = 9 # let rec prodlist list = match list with [ ] -> 1 x::xs -> x * prodlist xs;; val prodlist : int list -> int = <fun> # prodlist [2;3;4];; - : int = 24 9/11/17 31

32 Folding Functions over Lists How are the following functions similar? # let rec sumlist list = match list with [ ] -> 0 x::xs -> x + sumlist xs;; val sumlist : int list -> int = <fun> # sumlist [2;3;4];; - : int = 9 Base Case # let rec multlist list = match list with [ ] -> 1 x::xs -> x * multlist xs;; val multlist : int list -> int = <fun> # multlist [2;3;4];; - : int = 24 9/11/17 32

33 Folding Functions over Lists How are the following functions similar? # let rec sumlist list = match list with [ ] -> 0 x::xs -> x + sumlist xs;; val sumlist : int list -> int = <fun> # sumlist [2;3;4];; Recursive Call - : int = 9 # let rec multlist list = match list with [ ] -> 1 x::xs -> x * multlist xs;; val multlist : int list -> int = <fun> # multlist [2;3;4];; - : int = 24 9/11/17 33

34 Folding Functions over Lists How are the following functions similar? # let rec sumlist list = match list with [ ] -> 0 x::xs -> x + sumlist xs;; val sumlist : int list -> int = <fun> # sumlist [2;3;4];; Head Element - : int = 9 # let rec multlist list = match list with [ ] -> 1 x::xs -> x * multlist xs;; val multlist : int list -> int = <fun> # multlist [2;3;4];; - : int = 24 9/11/17 34

35 Folding Functions over Lists How are the following functions similar? # let rec sumlist list = match list with [ ] -> 0 x::xs -> x + sumlist xs;; val sumlist : int list -> int = <fun> # sumlist [2;3;4];; Combining Operation - : int = 9 # let rec multlist list = match list with [ ] -> 1 x::xs -> x * multlist xs;; val multlist : int list -> int = <fun> # multlist [2;3;4];; - : int = 24 9/11/17 35

36 Folding Functions over Lists How are the following functions similar? # let rec sumlist list = match list with [ ] -> 0 x::xs -> x + sumlist Rec value xs;; val sumlist : int list -> int = <fun> # sumlist [2;3;4];; Combining Operation - : int = 9 # let rec multlist list = match list with [ ] -> 1 x::xs -> x * multlist Rec value xs;; val multlist : int list -> int = <fun> # multlist [2;3;4];; - : int = 24R 9/11/17 36

37 Recursing over lists # let rec fold_right f list b = match list with [] -> b (x :: xs) -> f x (fold_right f xs b);; The Primitive Recursion Fairy val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b = <fun> # fold_right (fun s -> fun () -> print_string s) ["hi"; "there"] ();; therehi- : unit = () 9/11/17 37

38 Folding Recursion n multlist folds to the right n Same as: # let multlist list = List.fold_right (fun x -> fun p -> x * p) list 1;; val multlist : int list -> int = <fun> # multlist [2;4;6];; - : int = 48 9/11/17 38

39 Encoding Recursion with Fold # let rec append list1 list2 = match list1 with [ ] -> list2 x::xs -> x :: append xs list2;; val append : 'a list -> 'a list -> 'a list = <fun> Base Case Operation Recursive Call # let append list1 list2 = fold_right (fun x y -> x :: y) list1 list2;; val append : 'a list -> 'a list -> 'a list = <fun> # append [1;2;3] [4;5;6];; - : int list = [1; 2; 3; 4; 5; 6] 9/11/17 39

40 Question let rec length l = match l with [] -> 0 (a :: bs) -> 1 + length bs n How do you write length with fold_right, but no explicit recursion? 9/11/17 40

41 Question let rec length l = match l with [] -> 0 (a :: bs) -> 1 + length bs n How do you write length with fold_right, but no explicit recursion? let length list = List.fold_right (fun x -> fun n -> n + 1) list 0 9/11/17 41

42 Map from Fold # let map f list = fold_right (fun x -> fun y -> f x :: y) list [ ];; val map : ('a -> 'b) -> 'a list -> 'b list = <fun> # map ((+)1) [1;2;3];; - : int list = [2; 3; 4] n Can you write fold_right (or fold_left) with just map? How, or why not? 9/11/17 42

43 Iterating over lists # let rec fold_left f a list = match list with [] -> a (x :: xs) -> fold_left f (f a x) xs;; val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a = <fun> # fold_left (fun () -> print_string) () ["hi"; "there"];; hithere- : unit = () 9/11/17 43

44 Encoding Tail Recursion with fold_left # let prod list = let rec prod_aux l acc = match l with [] -> acc (y :: rest) -> prod_aux rest (acc * y) in prod_aux list 1;; val prod : int list -> int = <fun> Init Acc Value Recursive Call Operation # let prod list = List.fold_left (fun acc y -> acc * y) 1 list;; val prod: int list -> int = <fun> # prod [4;5;6];; - : int =120 9/11/17 44

45 Question let length l = let rec length_aux list n = match list with [] -> n (a :: bs) -> length_aux bs (n + 1) in length_aux l 0 n How do you write length with fold_left, but no explicit recursion? 9/11/17 45

46 Question let length l = let rec length_aux list n = match list with [] -> n (a :: bs) -> length_aux bs (n + 1) in length_aux l 0 n How do you write length with fold_left, but no explicit recursion? let length list = List.fold_left (fun n -> fun x -> n + 1) 0 list 9/11/17 46

47 Folding # let rec fold_left f a list = match list with [] -> a (x :: xs) -> fold_left f (f a x) xs;; val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a = <fun> fold_left f a [x 1 ; x 2 ; ;x n ] = f( (f (f a x 1 ) x 2 ) )x n # let rec fold_right f list b = match list with [ ] -> b (x :: xs) -> f x (fold_right f xs b);; val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b = <fun> fold_right f [x 1 ; x 2 ; ;x n ] b = f x 1 (f x 2 ( (f x n b) )) 9/11/17 47

48 Recall # let rec poor_rev list = match list with [] -> [] (x::xs) -> poor_rev [x];; val poor_rev : 'a list -> 'a list = <fun> n What is its running time? 9/11/17 48

49 Quadratic Time n Each step of the recursion takes time proportional to input n Each step of the recursion makes only one recursive call. n List example: # let rec poor_rev list = match list with [] -> [] (x::xs) -> poor_rev [x];; val poor_rev : 'a list -> 'a list = <fun> 9/11/17 49

50 Tail Recursion - Example # let rec rev_aux list revlist = match list with [ ] -> revlist x :: xs -> rev_aux xs (x::revlist);; val rev_aux : 'a list -> 'a list -> 'a list = <fun> # let rev list = rev_aux list [ ];; val rev : 'a list -> 'a list = <fun> n What is its running time? 9/11/17 50

51 Comparison n poor_rev [1,2,3] = n (poor_rev [1] = n ((poor_rev [1] = n (((poor_rev [ [1] = n (([ [1]) = n [1] = n (3:: ([ [1] = n [1] = n 3 :: [1]) = n 3 :: (2:: ([ [1])) = [3, 2, 1] 9/11/17 51

52 Comparison n rev [1,2,3] = n rev_aux [1,2,3] [ ] = n rev_aux [2,3] [1] = n rev_aux [3] [2,1] = n rev_aux [ ] [3,2,1] = [3,2,1] 9/11/17 52

53 Folding - Tail Recursion - # let rev list = - fold_left - (fun l -> fun x -> x :: l) //comb op [] //accumulator cell list 9/11/17 53

54 Folding n Can replace recursion by fold_right in any forward primitive recursive definition n Primitive recursive means it only recurses on immediate subcomponents of recursive data structure n Can replace recursion by fold_left in any tail primitive recursive definition 9/11/17 54

55 Continuation Passing Style n A programming technique for all forms of non-local control flow: n non-local jumps n exceptions n general conversion of non-tail calls to tail calls n Essentially it s a higher-order function version of GOTO 9/11/17 55

56 Continuations n Idea: Use functions to represent the control flow of a program n Method: Each procedure takes a function as an argument to which to pass its result; outer procedure returns no result n Function receiving the result called a continuation n Continuation acts as accumulator for work still to be done 9/11/17 56

57 Example of Tail Recursion # let rec app fl x = match fl with [] -> x (f :: rem_fs) -> f (app rem_fs x);; val app : ('a -> 'a) list -> 'a -> 'a = <fun> # let app fs x = let rec app_aux fl acc= match fl with [] -> acc (f :: rem_fs) -> app_aux rem_fs (fun z -> acc (f z)) in app_aux fs (fun y -> y) x;; val app : ('a -> 'a) list -> 'a -> 'a = <fun> 9/11/17 57

58 Continuation Passing Style n Writing procedures so that they take a continuation to which to give (pass) the result, and return no result, is called continuation passing style (CPS) 9/11/17 58

59 Example of Tail Recursion & CSP # let app fs x = let rec app_aux fl acc= match fl with [] -> acc (f :: rem_fs) -> app_aux rem_fs (fun z -> acc (f z)) in app_aux fs (fun y -> y) x;; val app : ('a -> 'a) list -> 'a -> 'a = <fun> # let rec appk fl x k = match fl with [] -> k x (f :: rem_fs) -> appk rem_fs x (fun z -> k (f z));; val appk : ('a -> 'a) list -> 'a -> ('a -> 'b) -> 'b 9/11/17 59

60 Continuation Passing Style n A compilation technique to implement nonlocal control flow, especially useful in interpreters. n A formalization of non-local control flow in denotational semantics n Possible intermediate state in compiling functional code 9/11/17 60

61 Terms n A function is in Direct Style when it returns its result back to the caller. n A Tail Call occurs when a function returns the result of another function call without any more computations (eg tail recursion) n A function is in Continuation Passing Style when it passes its result to another function. n Instead of returning the result to the caller, we pass it forward to another function. 9/11/17 61

62 Continuation Passing Style n A compilation technique to implement nonlocal control flow, especially useful in interpreters. n A formalization of non-local control flow in denotational semantics n Possible intermediate state in compiling functional code 9/11/17 62

63 Example n Simple reporting continuation: # let report x = (print_int x; print_newline( ) );; val report : int -> unit = <fun> n Simple function using a continuation: # let plusk a b k = k (a + b) val plusk : int -> int -> (int -> a) -> a = <fun> # plusk report;; 42 - : unit = () 9/11/17 63

64 Simple Functions Taking Continuations n Given a primitive operation, can convert it to pass its result forward to a continuation n Examples: # let subk x y k = k(x + y);; val subk : int -> int -> (int -> 'a) -> 'a = <fun> # let eqk x y k = k(x = y);; val eqk : 'a -> 'a -> (bool -> 'b) -> 'b = <fun> # let timesk x y k = k(x * y);; val timesk : int -> int -> (int -> 'a) -> 'a = <fun> 9/11/17 64

65 Nesting Continuations # let add_three x y z = x + y + z;; val add_three : int -> int -> int -> int = <fun> # let add_three x y z= let p = x + y in p + z;; val add_three : int -> int -> int -> int = <fun> # let add_three_k x y z k = addk x y (fun p -> addk p z k );; val add_three_k : int -> int -> int -> (int -> 'a) -> 'a = <fun> 9/11/17 65

### Functions Over Lists. Programming Languages and Compilers (CS 421) Structural Recursion. Functions Over Lists. Structural Recursion : List Example

Functions Over Lists Programmg Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illois.edu/cs421 Based part on slides by Mattox Beckman, as updated by Vikram Adve and Gul

### Forward Recursion. Programming Languages and Compilers (CS 421) Mapping Recursion. Forward Recursion: Examples. Folding Recursion.

Forward Recursion Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://www.cs.uiuc.edu/class/cs421/ Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul

### # true;; - : bool = true. # false;; - : bool = false 9/10/ // = {s (5, "hi", 3.2), c 4, a 1, b 5} 9/10/2017 4

Booleans (aka Truth Values) Programming Languages and Compilers (CS 421) Sasa Misailovic 4110 SC, UIUC https://courses.engr.illinois.edu/cs421/fa2017/cs421a # true;; - : bool = true # false;; - : bool

### Booleans (aka Truth Values) Programming Languages and Compilers (CS 421) Booleans and Short-Circuit Evaluation. Tuples as Values.

Booleans (aka Truth Values) Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC https://courses.engr.illinois.edu/cs421/fa2017/cs421d # true;; - : bool = true # false;; - : bool =

### Programming Languages and Compilers (CS 421)

Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul Agha 9/18/17

### n What is its running time? 9/18/17 2 n poor_rev [1,2,3] = n (poor_rev [1] = n ((poor_rev [1] =

Recall Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul Agha

### Forward recursion. CS 321 Programming Languages. Functions calls and the stack. Functions calls and the stack

Forward recursion CS 321 Programming Languages Intro to OCaml Recursion (tail vs forward) Baris Aktemur Özyeğin University Last update made on Thursday 12 th October, 2017 at 11:25. Much of the contents

### CS 321 Programming Languages

CS 321 Programming Languages Intro to OCaml Lists Baris Aktemur Özyeğin University Last update made on Monday 2 nd October, 2017 at 19:27. Some of the contents here are taken from Elsa Gunter and Sam Kamin

### CS Lecture 6: Map and Fold. Prof. Clarkson Spring Today s music: Selections from the soundtrack to 2001: A Space Odyssey

CS 3110 Lecture 6: Map and Fold Prof. Clarkson Spring 2015 Today s music: Selections from the soundtrack to 2001: A Space Odyssey Review Course so far: Syntax and semantics of (most of) OCaml Today: No

### FUNCTIONAL PROGRAMMING

FUNCTIONAL PROGRAMMING Map, Fold, and MapReduce Prof. Clarkson Summer 2015 Today s music: Selections from the soundtrack to 2001: A Space Odyssey Review Yesterday: Lists: OCaml's awesome built-in datatype

### Map and Fold. Prof. Clarkson Fall Today s music: Selections from the soundtrack to 2001: A Space Odyssey

Map and Fold Prof. Clarkson Fall 2015 Today s music: Selections from the soundtrack to 2001: A Space Odyssey Question How much progress have you made on A1? A. I'm still figuring out how Enigma works.

### MP 2 Continuation-Passing Style

MP 2 Continuation-Passing Style CS 421 Fall 2017 Revision 1.1 Assigned September 21, 2017 Due September 28, 2017 23:59pm Extension 48 hours (20% penalty) 1 Change Log 1.1 corrections to 9, 10 and 11 as

### CS Lecture 6: Map and Fold. Prof. Clarkson Fall Today s music: Selections from the soundtrack to 2001: A Space Odyssey

CS 3110 Lecture 6: Map and Fold Prof. Clarkson Fall 2014 Today s music: Selections from the soundtrack to 2001: A Space Odyssey Review Features so far: variables, operators, let expressions, if expressions,

### Programming Languages and Compilers (CS 421)

Programming Languages and Compilers (CS 421) #3: Closures, evaluation of function applications, order of evaluation #4: Evaluation and Application rules using symbolic rewriting Madhusudan Parthasarathy

### CSc 520. Gofer III. Accumulative Recursion. Accumulative Recursion... Stack Recursion. Principles of Programming Languages. Christian Collberg

Slide 7 2 Accumulative Recursion We can sometimes get a more efficient solution by giving the function one extra argument, the accumulator, which is used to gather the final result. We will need to use

### Programming Languages and Compilers (CS 421)

Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC https://courses.engr.illinois.edu/cs421/fa2017/cs421d Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul

### CSCI-GA Scripting Languages

CSCI-GA.3033.003 Scripting Languages 12/02/2013 OCaml 1 Acknowledgement The material on these slides is based on notes provided by Dexter Kozen. 2 About OCaml A functional programming language All computation

### School of Computer Science

A27217 No calculator permitted in this examination School of Computer Science First Year - BSc Artificial Intelligence and Computer Science First Year - BSc Natural Sciences First Year - BSc Computer Science

### n (0 1)*1 n a*b(a*) n ((01) (10))* n You tell me n Regular expressions (equivalently, regular 10/20/ /20/16 4

Regular Expressions Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve

### Programming Languages and Compilers (CS 421)

Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul Agha 10/20/16

### Programming Languages & Compilers. Programming Languages and Compilers (CS 421) I. Major Phases of a Compiler. Programming Languages & Compilers

Programming Languages & Compilers Programming Languages and Compilers (CS 421) I Three Main Topics of the Course II III Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 New Programming

### Programming Languages and Compilers (CS 421)

Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul Agha 10/30/17

### CSE341: Programming Languages Lecture 6 Nested Patterns Exceptions Tail Recursion. Zach Tatlock Winter 2018

CSE341: Programming Languages Lecture 6 Nested Patterns Exceptions Tail Recursion Zach Tatlock Winter 2018 Nested patterns We can nest patterns as deep as we want Just like we can nest expressions as deep

### Programming Languages & Compilers. Programming Languages and Compilers (CS 421) Programming Languages & Compilers. Major Phases of a Compiler

Programming Languages & Compilers Programming Languages and Compilers (CS 421) Three Main Topics of the Course I II III Sasa Misailovic 4110 SC, UIUC https://courses.engr.illinois.edu/cs421/fa2017/cs421a

### Topic 5: Examples and higher-order functions

CITS 3242 Programming Paradigms Topic 5: Examples and higher-order functions This lecture includes some larger examples in F# and introduces higher-functions. 1 Examples: append Now that we have lists,

### Two Problems. Programming Languages and Compilers (CS 421) Type Inference - Example. Type Inference - Outline. Type Inference - Example

Two Problems Programming Languages and Compilers (CS 421) Sasa Misailovic 4110 SC, UIUC https://courses.engr.illinois.edu/cs421/fa2017/cs421a Based in part on slides by Mattox Beckman, as updated by Vikram

### Programming Languages and Compilers (CS 421)

Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul Agha 10/3/17

### Programming Languages and Compilers (CS 421)

Programming Languages and Compilers (CS 421) Sasa Misailovic 4110 SC, UIUC https://courses.engr.illinois.edu/cs421/fa2017/cs421a Based in part on slides by Mattox Beckman, as updated by Vikram Adve, Gul

### List Functions, and Higher-Order Functions

List Functions, and Higher-Order Functions Björn Lisper Dept. of Computer Science and Engineering Mälardalen University bjorn.lisper@mdh.se http://www.idt.mdh.se/ blr/ List Functions, and Higher-Order

### Continuations and Continuation-Passing Style

Continuations and Continuation-Passing Style Lecture 4 CS 390 1/16/08 Goal Weʼre interested in understanding how to represent the state of a co-routine Insight into what a thread really means How fundamental

### n Takes abstract syntax trees as input n In simple cases could be just strings n One procedure for each syntactic category

Interpreter Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul

### Functional Programming. Pure Functional Programming

Functional Programming With examples in F# Pure Functional Programming Functional programming involves evaluating expressions rather than executing commands. Computation is largely performed by applying

### max function Next concat function max function What s the pattern? concat function More on recursion Higher-order functions

Next More on recursion Higher-order functions taking and returning functions max function let max x y = if x < y then y else x;; (* return max element of list l *) Along the way, will see map and fold

### F# - LISTS. In this method, you just specify a semicolon-delimited sequence of values in square brackets. For example

http://www.tutorialspoint.com/fsharp/fsharp_lists.htm F# - LISTS Copyright tutorialspoint.com In F#, a list is an ordered, immutable series of elements of the same type. It is to some extent equivalent

### Recap: Functions as first-class values

Recap: Functions as first-class values Arguments, return values, bindings What are the benefits? Parameterized, similar functions (e.g. Testers) Creating, (Returning) Functions Iterator, Accumul, Reuse

### CSE 341 : Programming Languages Midterm, Spring 2015

Name: CSE 341 : Programming Languages Midterm, Spring 2015 Please do not turn the page until 12:30. Rules: Closed book, closed note, except for one side of one 8.5x11in piece of paper. Please stop promptly

### Gain familiarity and practice with folding and mapping. The following supplementary materials may be helpful in completing this assignment:

CS 3110 Spring 2017 Problem Set 2 Version 1 (last modified February 23, 2017) Overview This assignment reinforces the use of recursion when approaching certain types of problems. We will emphasize the

### Continuation Passing Style. Continuation Passing Style

161 162 Agenda functional programming recap problem: regular expression matcher continuation passing style (CPS) movie regular expression matcher based on CPS correctness proof, verification change of

### Factorial. Next. Factorial. How does it execute? Tail recursion. How does it execute? More on recursion. Higher-order functions

Next More on recursion Higher-order functions takg and returng functions Factorial let rec fact n = Along the way, will see map and fold 1 2 Factorial let rec fact n = if n

### Introduction to Objective Caml

Introduction to Objective Caml Stefan Wehr University of Freiburg. October 30, 2006 Motivation Simple Expressions and Types Functions Simple Pattern Matching Compound Datatypes I/O and Compilation Resources

### Haskell: From Basic to Advanced. Part 3 A Deeper Look into Laziness

Haskell: From Basic to Advanced Part 3 A Deeper Look into Laziness Haskell is a lazy language Laziness again A particular function argument is only evaluated when it is needed, and if it is needed then

### Why OCaml? Introduction to Objective Caml. Features of OCaml. Applications written in OCaml. Stefan Wehr

Motivation Introduction to Objective Caml Why OCaml? Stefan Wehr University of Freiburg. October 30, 2006 Motivation Simple Expressions and Types I/O and Compilation Resources Convenient encoding of tree

### Programming Languages and Compilers (CS 421)

Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul Agha 9/25/17

### Next. Tail Recursion: Factorial. How does it execute? Tail recursion. Tail recursive factorial. Tail recursive factorial.

Next Tail Recursion: Factorial More on recursion Higher-order functions takg and returng functions Along the way, will see map and fold let rec fact n = if n

### Konzepte von Programmiersprachen

Konzepte von Programmiersprachen Chapter 5: Continuation-Passing Interpreters Stefan Wehr Universität Freiburg 8. Juni 2009 Konzepte von Programmiersprachen 1 / 43 Motivation Continuations: abstraction

### Compilers: The goal. Safe. e : ASM

Compilers: The goal What s our goal with compilers? Take a high level language, turn it into a low level language In a semantics preserving way. e : ML Safe e : ASM 1 Compilers: The goal What s our goal

### Coq Summer School, Session 2 : Basic programming with numbers and lists. Pierre Letouzey

Coq Summer School, Session 2 : Basic programming with numbers and lists Pierre Letouzey Predened data structures Predened types are actually declared to Coq at load time 1 : Inductive bool := true false.

### CS 421, Fall Sample Final Questions & Solutions

S 421, Fall 2012 Sample Final Questions & Solutions You should review the questions from the sample midterm exams, the practice midterm exams, and the assignments (MPs, MLs and Ws), as well as these question.

### FOFL and FOBS: First-Order Functions

CS251 Programming Languages Handout # 35 Prof. Lyn Turbak April 14, 2005 Wellesley College Revised April 24, 2005 FOFL and FOBS: First-Order Functions Revisions: Apr 24 : In the interpreters for Fofl and

### SNU Programming Language Theory

SNU 4541.574 Programming Language Theory Polymorphism Polymorphism We encountered the concept of polymorphism very briefly last time. Let s look at it now in a bit more detail. # let rec last l = match

### Playing with Fun. Walter Cazzola. Playing with Fun currying partial evaluation map&reduce iteration var args. References.

Currying & Partial Evaluation Currying with Currying, Map-Filter & Reduce, Folding,... with Currying is a technique to transform a function with multiple arguments into a chain of functions each with a

### CSE 130 [Winter 2014] Programming Languages

CSE 130 [Winter 2014] Programming Languages Higher-Order Functions! Ravi Chugh! Jan 23 Today s Plan A little more practice with recursion Base Pattern Base Expression Induction Pattern Induction Expression

### CS3110 Spring 2016 Lecture 6: Modules

CS3110 Spring 2016 Lecture 6: Modules Modules are the O part of OCaml, influenced by objects in Java. We see the evolution: Classic ML, CambridgeML (CAML), and finally OCaml. David McQueen is writing the

### Accurate Step Counting

Accurate Step Counting Catherine Hope and Graham Hutton University of Nottingham Abstract Starting with an evaluator for a language, an abstract machine for the same language can be mechanically derived

### Verification of an ML compiler. Lecture 3: Closures, closure conversion and call optimisations

Verification of an ML compiler Lecture 3: Closures, closure conversion and call optimisations Marktoberdorf Summer School MOD 2017 Magnus O. Myreen, Chalmers University of Technology Implementing the ML

### Today s Plan. Programming Languages. Example : Factorial. Recursion. CSE 130 : Spring Lecture 6: Higher-Order Functions

CSE 130 : Spring 2011 Programming Languages Lecture 6: Higher-Order Ranjit Jhala UC San Diego Today s Plan A little more practice with recursion Base Pattern -> Base Expression Induction Pattern -> Induction

### Principles of Programming Languages Topic: Functional Programming Professor L. Thorne McCarty Spring 2003

Principles of Programming Languages Topic: Functional Programming Professor L. Thorne McCarty Spring 2003 CS 314, LS, LTM: Functional Programming 1 Scheme A program is an expression to be evaluated (in

### Introduction to OCaml

Fall 2018 Introduction to OCaml Yu Zhang Course web site: http://staff.ustc.edu.cn/~yuzhang/tpl References Learn X in Y Minutes Ocaml Real World OCaml Cornell CS 3110 Spring 2018 Data Structures and Functional

### CS558 Programming Languages

CS558 Programming Languages Winter 2017 Lecture 6a Andrew Tolmach Portland State University 1994-2017 Iteration into Recursion Any iteration can be written as a recursion, e.g. while (c) {e Scala is equivalent

### OCaml. ML Flow. Complex types: Lists. Complex types: Lists. The PL for the discerning hacker. All elements must have same type.

OCaml The PL for the discerning hacker. ML Flow Expressions (Syntax) Compile-time Static 1. Enter expression 2. ML infers a type Exec-time Dynamic Types 3. ML crunches expression down to a value 4. Value

### CSE341 Section 3. Standard-Library Docs, First-Class Functions, & More

CSE341 Section 3 Standard-Library Docs, First-Class Functions, & More Adapted from slides by Daniel Snitkovskiy, Nick Mooney, Nicholas Shahan, Patrick Larson, and Dan Grossman Agenda 1. SML Docs Standard

### COSE212: Programming Languages. Lecture 4 Recursive and Higher-Order Programming

COSE212: Programming Languages Lecture 4 Recursive and Higher-Order Programming Hakjoo Oh 2016 Fall Hakjoo Oh COSE212 2016 Fall, Lecture 4 September 27, 2016 1 / 21 Recursive and Higher-Order Programming

### CPS Conversion. Di Zhao.

CPS Conversion Di Zhao zhaodi01@mail.ustc.edu.cn This is the first assignment of the course - Advanced Topics in Software Technologies in the 2014-2015 academic year. During this course, we will explore

Some Advanced ML Features Mooly Sagiv Michael Clarkson, Cornell CS 3110 Data Structures and Functional Programming University of Washington: Dan Grossman ML is small Small number of powerful constructs

### Programming Languages. Tail Recursion. CSE 130: Winter Lecture 8: NOT TR. last thing function does is a recursive call

CSE 130: Winter 2010 News Programming Languages Lecture 8: Higher-Order Od Functions Ranjit Jhala UC San Diego Today s Plan Finish Static Scoping Tail Recursion last thing function does is a recursive

### Processadors de Llenguatge II. Functional Paradigm. Pratt A.7 Robert Harper s SML tutorial (Sec II)

Processadors de Llenguatge II Functional Paradigm Pratt A.7 Robert Harper s SML tutorial (Sec II) Rafael Ramirez Dep Tecnologia Universitat Pompeu Fabra Paradigm Shift Imperative Paradigm State Machine

### CSci 4223 Principles of Programming Languages

Review CSci 4223 Prciples of Programmg Languages Lecture 8 Features learned: functions, tuples, lists, let expressions, options, records, datatypes, case expressions, type synonyms, pattern matchg, exceptions

### CSE 341 Lecture 5. efficiency issues; tail recursion; print Ullman ; 4.1. slides created by Marty Stepp

CSE 341 Lecture 5 efficiency issues; tail recursion; print Ullman 3.3-3.4; 4.1 slides created by Marty Stepp http://www.cs.washington.edu/341/ Efficiency exercise Write a function called reverse that accepts

### News. Programming Languages. Complex types: Lists. Recap: ML s Holy Trinity. CSE 130: Spring 2012

News CSE 130: Spring 2012 Programming Languages On webpage: Suggested HW #1 PA #1 (due next Fri 4/13) Lecture 2: A Crash Course in ML Please post questions to Piazza Ranjit Jhala UC San Diego Today: A

### Ornaments in ML. Thomas Williams, Didier Rémy. April 18, Inria - Gallium

Ornaments in ML Thomas Williams, Didier Rémy Inria - Gallium April 18, 2017 1 Motivation Two very similar functions let rec add m n = match m with Z n S m S (add m n) let rec append ml nl = match ml with

### CMSC 330: Organization of Programming Languages. Functional Programming with Lists

CMSC 330: Organization of Programming Languages Functional Programming with Lists CMSC330 Spring 2018 1 Lists in OCaml The basic data structure in OCaml Lists can be of arbitrary length Implemented as

### CS3110 Spring 2017 Lecture 7 Specifications using types continued

CS3110 Spring 2017 Lecture 7 Specifications using types continued Robert Constable 1 Lecture Plan 1. Repeating schedule of remaining five problem sets and prelim. 2. Fixing OCaml specification and code

### CS4410 : Spring 2013

CS4410 : Spring 2013 Next PS: Map Fish code to MIPS code Issues: eliminating compound expressions eliminating variables encoding conditionals, short- circuits, loops type exp = Var of var Int of int Binop

### CS422 - Programming Language Design

1 CS422 - Programming Language Design Continuation-Passing Style (CPS) Transformation Grigore Roşu Department of Computer Science University of Illinois at Urbana-Champaign 2 On Data Versus Control Context

### MoreIntro_annotated.v. MoreIntro_annotated.v. Printed by Zach Tatlock. Oct 04, 16 21:55 Page 1/10

Oct 04, 16 21:55 Page 1/10 * Lecture 02 Infer some type arguments automatically. Set Implicit Arguments. Note that the type constructor for functions (arrow " >") associates to the right: A > B > C = A

### CSE341 Autumn 2017, Midterm Examination October 30, 2017

CSE341 Autumn 2017, Midterm Examination October 30, 2017 Please do not turn the page until 2:30. Rules: The exam is closed-book, closed-note, etc. except for one side of one 8.5x11in piece of paper. Please

### Wellesley College CS251 Programming Languages Spring, 2000 FINAL EXAM REVIEW PROBLEM SOLUTIONS

Wellesley College CS251 Programming Languages Spring, 2000 FINAL EXAM REVIEW PROBLEM SOLUTIONS This document contains solutions to the problems on the final exam review problems posted earlier except for

### Lecture 4: Higher Order Functions

Lecture 4: Higher Order Functions Søren Haagerup Department of Mathematics and Computer Science University of Southern Denmark, Odense September 26, 2017 HIGHER ORDER FUNCTIONS The order of a function

### CSCI 2041: First Class Functions

CSCI 2041: First Class Functions Chris Kauffman Last Updated: Thu Oct 18 22:42:48 CDT 2018 1 Logistics Assignment 3 multimanager Reading OCaml System Manual: Ch 26: List and Array Modules, higher-order

### Tuples. CMSC 330: Organization of Programming Languages. Examples With Tuples. Another Example

CMSC 330: Organization of Programming Languages OCaml 2 Higher Order Functions Tuples Constructed using (e1,..., en) Deconstructed using pattern matching Patterns involve parens and commas, e.g., (p1,p2,

### CS 11 Ocaml track: lecture 2

Today: CS 11 Ocaml track: lecture 2 comments algebraic data types more pattern matching records polymorphic types ocaml libraries exception handling Previously... ocaml interactive interpreter compiling

### Programming Languages and Compilers (CS 421)

Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul Agha 11/9/17

### n <exp>::= 0 1 b<exp> <exp>a n <exp>m<exp> 11/7/ /7/17 4 n Read tokens left to right (L) n Create a rightmost derivation (R)

Disambiguating a Grammar Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram

### CSE 307: Principles of Programming Languages

1 / 63 CSE 307: Principles of Programming Languages Syntax R. Sekar Topics 1. Introduction 2. Basics 3. Functions 4. Data Structures 5. Overview 6. OCAML Performance 2 / 63 3 / 63 Section 1 Introduction

### The Art of Recursion: Problem Set 10

The Art of Recursion: Problem Set Due Tuesday, November Tail recursion A recursive function is tail recursive if every recursive call is in tail position that is, the result of the recursive call is immediately

### CSE 307: Principles of Programming Languages

CSE 307: Principles of Programming Languages Syntax R. Sekar 1 / 63 Topics 1. Introduction 2. Basics 3. Functions 4. Data Structures 5. Overview 6. OCAML Performance 2 / 63 Section 1 Introduction 3 / 63

### Functional Programming. Pure Functional Programming

Functional Programming Pure Functional Programming Computation is largely performed by applying functions to values. The value of an expression depends only on the values of its sub-expressions (if any).

### Parsing Scheme (+ (* 2 3) 1) * 1

Parsing Scheme + (+ (* 2 3) 1) * 1 2 3 Compiling Scheme frame + frame halt * 1 3 2 3 2 refer 1 apply * refer apply + Compiling Scheme make-return START make-test make-close make-assign make- pair? yes

### Begin at the beginning

Begin at the beginning Expressions (Syntax) Exec-time Dynamic Values (Semantics) Compile-time Static Types 1. Programmer enters expression 2. ML checks if expression is well-typed Using a precise set of

### Functional Programming. Overview. Topics. Definition n-th Fibonacci Number. Graph

Topics Functional Programming Christian Sternagel Harald Zankl Evgeny Zuenko Department of Computer Science University of Innsbruck WS 2017/2018 abstract data types, algebraic data types, binary search

### Scope, Functions, and Storage Management

Scope, Functions, and Storage Management Implementing Functions and Blocks cs3723 1 Simplified Machine Model (Compare To List Abstract Machine) Registers Code Data Program Counter (current instruction)

### News. CSE 130: Programming Languages. Environments & Closures. Functions are first-class values. Recap: Functions as first-class values

CSE 130: Programming Languages Environments & Closures News PA 3 due THIS Friday (5/1) Midterm NEXT Friday (5/8) Ranjit Jhala UC San Diego Recap: Functions as first-class values Arguments, return values,

### Recursion & Iteration

Recursion & Iteration York University Department of Computer Science and Engineering 1 Overview Recursion Examples Iteration Examples Iteration vs. Recursion Example [ref.: Chap 5,6 Wilensky] 2 Recursion

### News. Programming Languages. Recap. Recap: Environments. Functions. of functions: Closures. CSE 130 : Fall Lecture 5: Functions and Datatypes

CSE 130 : Fall 2007 Programming Languages News PA deadlines shifted PA #2 now due 10/24 (next Wed) Lecture 5: Functions and Datatypes Ranjit Jhala UC San Diego Recap: Environments Phone book Variables

### Data Types The ML Type System

7 Data Types 7.2.4 The ML Type System The following is an ML version of the tail-recursive Fibonacci function introduced Fibonacci function in ML in Section 6.6.1: EXAMPLE 7.96 1. fun fib (n) = 2. let

### Compiler Construction Lecture 05 A Simple Stack Machine. Lent Term, Lecturer: Timothy G. Griffin. Computer Laboratory University of Cambridge

Compiler Construction Lecture 05 A Simple Stack Machine Lent Term, 2015 Lecturer: Timothy G. Griffin Computer Laboratory University of Cambridge 1 Where are we going? When we derived the stack machine

### Shell CSCE 314 TAMU. Higher Order Functions

1 CSCE 314: Programming Languages Dr. Dylan Shell Higher Order Functions 2 Higher-order Functions A function is called higher-order if it takes a function as an argument or returns a function as a result.

### Handout 2 August 25, 2008

CS 502: Compiling and Programming Systems Handout 2 August 25, 2008 Project The project you will implement will be a subset of Standard ML called Mini-ML. While Mini- ML shares strong syntactic and semantic

### Lab 7: OCaml 12:00 PM, Oct 22, 2017

CS17 Integrated Introduction to Computer Science Hughes Lab 7: OCaml 12:00 PM, Oct 22, 2017 Contents 1 Getting Started in OCaml 1 2 Pervasives Library 2 3 OCaml Basics 3 3.1 OCaml Types........................................

### Lecture #13: Type Inference and Unification. Typing In the Language ML. Type Inference. Doing Type Inference

Lecture #13: Type Inference and Unification Typing In the Language ML Examples from the language ML: fun map f [] = [] map f (a :: y) = (f a) :: (map f y) fun reduce f init [] = init reduce f init (a ::