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

Size: px
Start display at page:

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

## Transcription

1 Booleans (aka Truth Values) Programming Languages and Compilers (CS 421) Sasa Misailovic 4110 SC, UIUC # true;; - : bool = true # false;; - : bool = false // 7 = {c 4, test 3.7, a 1, b 5} # if b > a then 25 else 0;; - : int = 25 Based in part on slides by Mattox Beckman, as updated by Vikram Adve, Gul Agha, and Elsa L Gunter 9/10/ /10/ Booleans and Short-Circuit Evaluation Tuples as Values # 3 > 1 && 4 > 6;; - : bool = false # 3 > 1 4 > 6;; - : bool = true # not (4 > 6);; - : bool = true // 0 = {c 4, a 1, b 5} # let s = (5,"hi",3.2);; val s : int * string * float = (5, "hi", 3.2) // = {s (5, "hi", 3.2), c 4, a 1, b 5} # (print_string "Hi\n"; 3 > 1) 4 > 6;; Hi - : bool = true # 3 > 1 (print_string "Bye\n"; 4 > 6);; - : bool = true 9/10/ /10/ Pattern Matching with Tuples Nested Tuples // = {s (5, "hi", 3.2), a 1, b 5, c 4} # let (a,b,c) = s;; (* (a,b,c) is a pattern *) val a : int = 5 val b : string = "hi" val c : float = 3.2 # let (a, _, _) = s;; val a : int = 5 # (*Tuples can be nested *) # let d = ((1,4,62),("bye",15),73.95);; val d : (int * int * int) * (string * int) * float = ((1, 4, 62), ("bye", 15), 73.95) # (*Patterns can be nested *) # let (p, (st,_), _) = d;; (* _ matches all, binds nothing *) val p : int * int * int = (1, 4, 62) val st : string = "bye" # let x = 2, 9.3;; (* tuples don't require parens in Ocaml *) val x : int * float = (2, 9.3) 9/10/ /10/

3 Partial application of functions Recall: let plus_x = fun x => y + x let add_three x y z = x + y + z;; # let h = add_three 5 4;; val h : int -> int = <fun> let x = 12 X 12 let plus_x = fun y => y + x X 12 plus_x y y + x X 12 # h 3;; - : int = 12 # h 7;; - : int = 16 Partial application also called sectioning 9/10/ let x = 7 plus_x y y + x x 7 X 12 9/10/ Closure for plus_x Evaluation When plus_x was defined, had environment: plus_x = {, x 12, } Recall: let plus_x y = y + x is really let plus_x = fun y -> y + x Closure for fun y -> y + x: <y y + x, plus_x > Environment just after plus_x defined: {plus_x <y y + x, plus_x >} + plus_x 9/10/ Running Ocaml source: Parse the program to detect each expression Keep an internal environment at each time step For each expression, interpret the program using the function Eval Nice property of Ocaml: everything is a declaration or an expression! How does Eval (expression, environment) work: Evaluation uses a starting environment Define the rules for evaluating declarations, constants, arithmetic expressions, function applications 9/10/ Evaluating Declarations Evaluation uses a starting environment To evaluate a (simple) declaration let x = e Evaluate expression e in to value v Update with the mapping from x to v: {x v} + Evaluating Declarations Evaluation uses a starting environment To evaluate a (simple) declaration let x = e Evaluate expression e in to value v Update with the mapping from x to v: {x v} + Definition of + on environments! Update: has all the bindings in 1 and all those in 2 that are not rebound in 1 {x 2, y 3, a hi } + {y 100, b 6} = {x 2, y 3, a hi, b 6} It is not commutative! 9/10/ Warm-up: we evaluate this case: = { x 2 } let y = 2*x+1;; = { x 2; y 5 } 9/10/

4 Evaluating Expressions Evaluation of Application with Closures Evaluation uses an environment A constant evaluates to itself To evaluate an variable, look it up in i.e., use (v) To evaluate uses of +, _, etc, first eval the arguments, then do operation To evaluate a local declaration: let x = e1 in e2 Evaluate e1 to v, evaluate e2 using {x v} + Function application (f x) -- see next slide Function defined as: let f (x 1, x n )= body Function application: f (e 1,, e n ) Evaluation uses the function App(Closure, Value): In environment, evaluate the left term to closure, c = <(x 1,,x n ) body, > Evaluate the arguments in the application e 1 e n to their values v 1,,v n in the environment Update the environment to = {x 1 v 1,, x n v n } + Evaluate the function body (body) in environment 9/10/ /10/ Evaluation of Application of plus_x;; Have environment: = {plus_x <y y + x, plus_x >,, y 3, } where plus_x = {x 12,, y 24, } Eval (plus_x y, ) rewrites to App (Eval(plus_x, ), Eval(y, )) rewrites to App (<y y + x, plus_x >, 3) rewrites to Eval (y + x, {y 3} + plus_x ) rewrites to Eval (3 + 12, plus_x ) = 15 Evaluation of Application of plus_pair Assume environment = {x 3,, plus_pair <(n,m) n + m, plus_pair >} + plus_pair Eval (plus_pair (4,x), )= App (Eval (plus_pair, ), Eval ((4,x), )) = App (<(n,m) n + m, plus_pair >, (4,3)) = Eval (n + m, {n -> 4, m -> 3} + plus_pair ) = Eval (4 + 3, {n -> 4, m -> 3} + plus_pair ) = 7 9/10/ /10/ Closure question If we start in an empty environment, and we execute: let f = fun n -> n + 5;; (* 0 *) let pair_map g (n,m) = (g n, g m);; let a = f (4,6);; What is the environment at (* 0 *)? Answer start = {} let f = fun n -> n + 5;; 0 = {f <n n + 5, { }>} 9/10/ /10/

5 Closure question If we start in an empty environment, and we execute: let f = fun => n + 5;; let pair_map g (n,m) = (g n, g m);; (* 1 *) let a = f (4,6);; What is the environment at (* 1 *)? Answer 0 = {f <n n + 5, { }>} let pair_map g (n,m) = (g n, g m);; 1 = { f <n n + 5, { }>, pair_map <g (fun (n,m) -> (g n, g m)), {f <n n + 5, { }>} > } 9/10/ /10/ Closure question If we start in an empty environment, and we execute: let f = fun => n + 5;; let pair_map g (n,m) = (g n, g m);; (* 2 *) let a = f (4,6);; What is the environment at (* 2 *)? Evaluate pair_map f 0 = {f <n n + 5, { }>} 1 = {f <n n + 5, { }>, pair_map <g (fun (n,m) -> (g n, g m)), {f <n n + 5, { }>}>} 9/10/ /10/ Evaluate pair_map f Evaluate pair_map f 0 = {f <n n + 5, { }>} 1 = {f <n n + 5, { }>, pair_map <g (fun (n,m) -> (g n, g m)), {f <n n + 5, { }>}>} Eval(pair_map f, 1 ) = 0 = {f <n n + 5, { }>} 1 = {f <n n + 5, { }>, pair_map <g (fun (n,m) -> (g n, g m)), {f <n n + 5, { }>}>} Eval(pair_map f, 1 ) = App (<g fun (n,m) -> (g n, g m), 0 >, <n n + 5, { }>) = 9/10/ /10/

6 Evaluate pair_map f Answer 0 = {f <n n + 5, { }>} 1 = {f <n n + 5, { }>, pair_map <g (fun (n,m) -> (g n, g m)), {f <n n + 5, { }>}>} Eval(pair_map f, 1 ) = App (<g fun (n,m) -> (g n, g m), 0 >, <n n + 5, { }>) = Eval(fun (n,m)->(g n, g m), {g <n n + 5, { }>}+ 0 ) = <(n,m) (g n, g m), {g <n n + 5, { }>}+ 0 > = <(n,m) (g n, g m), {g <n n + 5, { }>, f <n n + 5, { }>} 9/10/ = {f <n n + 5, { }>} 1 = {f <n n + 5, { }>, pair_map <g (fun (n,m) -> (g n, g m)), {f <n n + 5, { }>}>} 2 = {f <(n,m) (g n, g m), {g <n n + 5, { }>, f <n n + 5, { }>}>, pair_map <g fun (n,m) -> (g n, g m), {f <n n + 5, { }>} > } 9/10/ Closure question If we start in an empty environment, and we execute: let f = fun => n + 5;; let pair_map g (n,m) = (g n, g m);; let a = f (4,6);; (* 3 *) What is the environment at (* 3 *)? Final Evalution? 2 = {f <(n,m) (g n, g m), {g <n n + 5, { }>, f <n n + 5, { }>}>, pair_map <g fun (n,m) -> (g n, g m), {f <n n + 5, { }>} > } let a = f (4,6);; 9/10/ /10/ Evaluate f (4,6);; Evaluate f (4,6);; 2 = { f <(n,m) (g n, g m), {g <n n + 5, { }>, f <n n + 5, { }>}>, pair_map <g fun (n,m) -> (g n, g m), {f <n n + 5, { }>} > } let a = f (4,6);; 2 = { f <(n,m) (g n, g m), {g <n n + 5, { }>, f <n n + 5, { }>}>, pair_map <g fun (n,m) -> (g n, g m), {f <n n + 5, { }>} > } let a = f (4,6);; Eval(f (4,6), 2 ) = 9/10/ Eval(f (4,6), 2 ) = App(<(n,m) (g n, g m), {g <n n + 5, { }>, f <n n + 5, { }>}>, (4,6)) = 9/10/

7 Evaluate f (4,6);; Evaluate f (4,6);; App(<(n,m) (g n, g m), {g <n n + 5, { }>, f <n n + 5, { }>}>, (4,6)) = Eval((g n, g m), {n 4, m 6} + {g <n n + 5, { }>, f <n n + 5, { }>}) = (App(<n n + 5, { }>, 4), App (<n n + 5, { }>, 6)) = (App(<n n + 5, { }>, 4), App (<n n + 5, { }>, 6)) = (Eval(n + 5, {n 4} + { }), Eval(n + 5, {n 6} + { })) = (Eval(4 + 5, {n 4} + { }), Eval(6 + 5, {n 6} + { })) = (9, 11) 9/10/ /10/ Functions as arguments # let thrice f x = f (f (f x));; val thrice : ('a -> 'a) -> 'a -> 'a = <fun> # let g = thrice plus_two;; (* plus_two x is x+2 *) val g : int -> int = <fun> # g 4;; - : int = 10 # thrice (fun s -> "Hi! " ^ s) "Good-bye!";; - : string = "Hi! Hi! Hi! Good-bye!" 9/10/ Higher Order Functions A function is higher-order if it takes a function as an argument or returns one as a result Example: # let compose f g = fun x -> f (g x);; val compose : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b = <fun> The type ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b is a higher order type because of ('a -> 'b) and ('c -> 'a) and -> 'c -> 'b 9/10/ Thrice Recall: # let thrice f x = f (f (f x));; val thrice : ('a -> 'a) -> 'a -> 'a = <fun> How do you write thrice with compose? # let thrice f = compose f (compose f f);; val thrice : ('a -> 'a) -> 'a -> 'a = <fun> Lambda Lifting You must remember the rules for evaluation when you use partial application # let add_two = (+) (print_string "test\n"; 2);; test val add_two : int -> int = <fun> # let add2 = (* lambda lifted *) fun x -> (+) (print_string "test\n"; 2) x;; val add2 : int -> int = <fun> 9/10/ /10/

8 Lambda Lifting Match Expressions # thrice add_two 5;; - : int = 11 # thrice add2 5;; test test test - : int = 11 Lambda lifting delayed the evaluation of the argument to (+) until the second argument was supplied # let triple_to_pair triple = match triple with (0, x, y) -> (x, y) (x, 0, y) -> (x, y) (x, y, _) -> (x, y);; Each clause: pattern on left, expression on right Each x, y has scope of only its clause Use first matching clause val triple_to_pair : int * int * int -> int * int = <fun> 9/10/ /10/ Recursive Functions Recursion Example # let rec factorial n = if n = 0 then 1 else n * factorial (n - 1);; val factorial : int -> int = <fun> # factorial 5;; - : int = 120 # (* rec is needed for recursive function declarations *) Compute n 2 recursively using: n 2 = (2 * n - 1) + (n - 1) 2 # let rec nthsq n = (* rec for recursion *) match n with (* pattern matching for cases *) 0 -> 0 (* base case *) n -> (2 * n -1) (* recursive case *) + nthsq (n -1);; (* recursive call *) val nthsq : int -> int = <fun> # nthsq 3;; - : int = 9 Structure of recursion similar to inductive proof 9/10/ /10/ Recursion and Induction Lists # let rec nthsq n = match n with 0 -> 0 (*Base case!*) n -> (2 * n - 1) + nthsq (n - 1) ;; Base case is the last case; it stops the computation Recursive call must be to arguments that are somehow smaller - must progress to base case if or match must contain base case (!!!) Failure of selecting base case will cause non-termination But the program will crash because it exhausts the stack! 9/10/ First example of a recursive datatype (aka algebraic datatype) Unlike tuples, lists are homogeneous in type (all elements same type) 9/10/

9 Lists List can take one of two forms: Empty list, written [ ] Non-empty list, written x :: xs x is head element, xs is tail list, :: called cons How we typically write them (syntactic sugar): [x] == x :: [ ] [ x1; x2; ; xn ] == x1 :: x2 :: :: xn :: [ ] Lists # let fib5 = [8;5;3;2;1;1];; val fib5 : int list = [8; 5; 3; 2; 1; 1] # let fib6 = 13 :: fib5;; val fib6 : int list = [13; 8; 5; 3; 2; 1; 1] # (8::5::3::2::1::1::[ ]) = fib5;; - : bool = true # fib6;; - : int list = [8; 5; 3; 2; 1; 1; 13; 8; 5; 3; 2; 1; 1] 9/10/ /10/ Lists are Homogeneous Question # let bad_list = [1; 3.2; 7];; Characters 19-22: let bad_list = [1; 3.2; 7];; ^^^ This expression has type float but is here used with type int Which one of these lists is invalid? 1. [2; 3; 4; 6] 2. [2,3; 4,5; 6,7] 3. [(2.3,4); (3.2,5); (6,7.2)] 3 is invalid because of last pair 4. [[ hi ; there ]; [ wahcha ]; [ ]; [ doin ]] 9/10/ /10/ 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> (* fib5 = [8;5;3;2;1;1] *) # let fib5_2 = double_up fib5;; val fib5_2 : int list = [8; 8; 5; 5; 3; 3; 2; 2; 1; 1; 1; 1] 9/10/ 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/10/

10 Question: Length of list Problem: write code for the length of the list How to start? let length l = Question: Length of list Problem: write code for the length of the list How to start? let rec length l = match l with 9/10/ /10/ Question: Length of list Problem: write code for the length of the list What patterns should we match against? let rec length l = match l with Question: Length of list Problem: write code for the length of the list What patterns should we match against? let rec length l = match l with [] -> (a :: bs) -> 9/10/ /10/ Question: Length of list Problem: write code for the length of the list What result do we give when l is empty? let rec length l = match l with [] -> 0 (a :: bs) -> Question: Length of list Problem: write code for the length of the list What result do we give when l is not empty? let rec length l = match l with [] -> 0 (a :: bs) -> 9/10/ /10/

11 Question: Length of list Problem: write code for the length of the list What result do we give when l is not empty? let rec length l = match l with [] -> 0 (a :: bs) -> 1 + length bs Same Length How can we efficiently answer if two lists have the same length? 9/10/ /10/ Same Length How can we efficiently answer if two lists have the same length? let rec same_length list1 list2 = match list1 with [] -> ( match list2 with [] -> true (y::ys) -> false ) (x::xs) -> ( match list2 with [] -> false (y::ys) -> same_length xs ys ) 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/10/ /10/ 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 = () Iterating over lists # 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 (fun s -> fun () -> print_string s) ["hi"; "there"] ();; therehi- : unit = () 9/10/ /10/

12 Structural Recursion Functions on recursive datatypes (eg lists) tend to be recursive Recursion over recursive datatypes generally by structural recursion Recursive calls made to components of structure of the same recursive type Base cases of recursive types stop the recursion of the function 9/10/ 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 Nil case [ ] is base case Cons case recurses on component list xs 9/10/ Forward Recursion In Structural Recursion, split input into components and (eventually) recurse Forward Recursion is a form of Structural Recursion In forward recursion, first call the function recursively on all recursive components, and then build final result from partial results Wait until whole structure has been traversed to start building answer 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) -> poor_rev [x];; val poor_rev : 'a list -> 'a list = <fun> 9/10/ /10/ Encoding Recursion with Fold Mapping Recursion # let rec append list1 list2 = match list1 with [ ] -> list2 x::xs -> x :: append xs 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] # let append_alt list1 list2 = fold_right (fun x y -> x :: y) list1 list2;; val append_alt : 'a list -> 'a list -> 'a list = <fun> 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/10/ /10/

13 Mapping Recursion 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] Same function, but no recursion Folding Recursion 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 Computes (2 * (4 * (6 * 1))) 9/10/ /10/ Folding Recursion multlist folds to the right 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 How long will it take? Common big-o times: Constant time O (1) input size doesn t matter Linear time O (n) 2x input size 2x time Quadratic time O (n 2 ) 3x input size 9x time Exponential time O (2 n ) Input size n+1 2x time 9/10/ /10/ Linear Time Expect most list operations to take linear time O (n) Each step of the recursion can be done in constant time Each step makes only one recursive call List example: multlist, append Integer example: factorial Quadratic Time Each step of the recursion takes time proportional to input Each step of the recursion makes only one recursive call. List example: # let rec poor_rev list = match list with [] -> [] (x::xs) -> poor_rev [x];; val poor_rev : 'a list -> 'a list = <fun> 9/10/ /10/

14 Exponential running time Hideous running times on input of any size Each step of recursion takes constant time Each recursion makes two recursive calls Exponential running time # let rec naivefib n = match n with 0 -> 0 1 -> 1 _ -> naivefib (n-1) + naivefib (n-2);; val naivefib : int -> int = <fun> Easy to write naïve code that is exponential for functions that can be linear 9/10/ /10/ An Important Optimization An Important Optimization Normal call h g f 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 What if f calls g and g calls h, but calling h is the last thing g does (a tail call)? Tail call h f 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 What if f calls g and g calls h, but calling h is the last thing g does (a tail call)? Then h can return directly to f instead of g 9/10/ /10/ Tail Recursion A recursive program is tail recursive if all recursive calls are tail calls Tail recursive programs may be optimized to be implemented as loops, thus removing the function call overhead for the recursive calls Tail recursion generally requires extra accumulator arguments to pass partial results May require an auxiliary function 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> What is its running time? 9/10/ /10/

15 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/10/ 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/10/ Folding - Forward Recursion # let sumlist list = fold_right (+) list 0;; val sumlist : int list -> int = <fun> # sumlist [2;3;4];; - : int = 9 Folding - Tail Recursion - # let rev list = - fold_left - (fun l -> fun x -> x :: l) //comb op [] //accumulator cell list # let prodlist list = fold_right ( * ) list 1;; val prodlist : int list -> int = <fun> # prodlist [2;3;4];; - : int = 24 9/10/ /10/ Folding Can replace recursion by fold_right in any forward primitive recursive definition Primitive recursive means it only recurses on immediate subcomponents of recursive data structure Can replace recursion by fold_left in any tail primitive recursive definition 9/10/

### 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) #3: Closures, evaluation of function applications, order of evaluation #4: Evaluation and Application rules using symbolic rewriting Madhusudan Parthasarathy

### 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/11/17

### 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

### 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

### 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

### 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

### 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 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

### 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,

### 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

### 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

### 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,

### 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

### 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

### 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.

### 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

### CSE 341 Section 5. Winter 2018

CSE 341 Section 5 Winter 2018 Midterm Review! Variable Bindings, Shadowing, Let Expressions Boolean, Comparison and Arithmetic Operations Equality Types Types, Datatypes, Type synonyms Tuples, Records

### 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

### 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

### 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

### Summer 2017 Discussion 10: July 25, Introduction. 2 Primitives and Define

CS 6A Scheme Summer 207 Discussion 0: July 25, 207 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,

### 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

### 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

### 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

### 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

### 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

### CMSC 330, Fall 2013, Practice Problems 3

CMSC 330, Fall 2013, Practice Problems 3 1. OCaml and Functional Programming a. Define functional programming b. Define imperative programming c. Define higher-order functions d. Describe the relationship

### 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

### 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

### 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

### 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

### 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

### 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

### 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

### Project 2: Scheme Interpreter

Project 2: Scheme Interpreter CSC 4101, Fall 2017 Due: 12 November 2017 For this project, you will implement a simple Scheme interpreter in C++ or Java. Your interpreter should be able to handle the same

### 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

### LECTURE 16. Functional Programming

LECTURE 16 Functional Programming WHAT IS FUNCTIONAL PROGRAMMING? Functional programming defines the outputs of a program as a mathematical function of the inputs. Functional programming is a declarative

### Programming Languages

CSE 130 : Winter 2009 Programming Languages News PA 2 out, and due Mon 1/26 5pm Lecture 5: Functions and Datatypes t UC San Diego Recap: Environments Phone book Variables = names Values = phone number

### Lecture 15 CIS 341: COMPILERS

Lecture 15 CIS 341: COMPILERS Announcements HW4: OAT v. 1.0 Parsing & basic code generation Due: March 28 th No lecture on Thursday, March 22 Dr. Z will be away Zdancewic CIS 341: Compilers 2 Adding Integers

### 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,

### Tail Calls. CMSC 330: Organization of Programming Languages. Tail Recursion. Tail Recursion (cont d) Names and Binding. Tail Recursion (cont d)

CMSC 330: Organization of Programming Languages Tail Calls A tail call is a function call that is the last thing a function does before it returns let add x y = x + y let f z = add z z (* tail call *)

### Programming Languages

CSE 130: Fall 2009 Programming Languages Lecture 2: A Crash Course in ML News On webpage: Suggested HW #1 PA #1 (due next Fri 10/9) Technical issues installing Ocaml - should be resolved soon! Ranjit Jhala

### 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

### Overview. A normal-order language. Strictness. Recursion. Infinite data structures. Direct denotational semantics. Transition semantics

Overview A normal-order language Strictness Recursion Infinite data structures Direct denotational semantics Transition semantics Lazy (call-by-need) evaluation and its semantics A Normal-Order Language

### 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

### 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

### Introduction to Scheme

How do you describe them Introduction to Scheme Gul Agha CS 421 Fall 2006 A language is described by specifying its syntax and semantics Syntax: The rules for writing programs. We will use Context Free

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

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

### A Second Look At ML. Chapter Seven Modern Programming Languages, 2nd ed. 1

A Second Look At ML Chapter Seven Modern Programming Languages, 2nd ed. 1 Outline Patterns Local variable definitions A sorting example Chapter Seven Modern Programming Languages, 2nd ed. 2 Two Patterns

### SCHEME 7. 1 Introduction. 2 Primitives COMPUTER SCIENCE 61A. October 29, 2015

SCHEME 7 COMPUTER SCIENCE 61A October 29, 2015 1 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,

### Encodings. Using the minimal λ-calculus language we get. functions. local binding. booleans. numbers... and recursive functions?

Part Encodings Using the minimal λ-calculus language we get functions local binding booleans numbers... and recursive functions? Factorial in Plait (local [(define fac (lambda (n) (if (zero? n) (* n (fac

### SCHEME 8. 1 Introduction. 2 Primitives COMPUTER SCIENCE 61A. March 23, 2017

SCHEME 8 COMPUTER SCIENCE 61A March 2, 2017 1 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,

Advanced Type System Features Tom Schrijvers Leuven Haskell User Group Data Recursion Genericity Schemes Expression Problem Monads GADTs DSLs Type Type Families Classes Lists and Effect Free Other Handlers

### CMSC 330: Organization of Programming Languages. Formal Semantics of a Prog. Lang. Specifying Syntax, Semantics

Recall Architecture of Compilers, Interpreters CMSC 330: Organization of Programming Languages Source Scanner Parser Static Analyzer Operational Semantics Intermediate Representation Front End Back End

### Programming Languages

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

### CSE341: Programming Languages Lecture 9 Function-Closure Idioms. Dan Grossman Winter 2013

CSE341: Programming Languages Lecture 9 Function-Closure Idioms Dan Grossman Winter 2013 More idioms We know the rule for lexical scope and function closures Now what is it good for A partial but wide-ranging

### Racket. CSE341: Programming Languages Lecture 14 Introduction to Racket. Getting started. Racket vs. Scheme. Example.

Racket Next 2+ weeks will use the Racket language (not ML) and the DrRacket programming environment (not emacs) Installation / basic usage instructions on course website CSE34: Programming Languages Lecture

### 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

### To figure this out we need a more precise understanding of how ML works

Announcements: What are the following numbers: 74/2/70/17 (2:30,2:30,3:35,7:30) PS2 due Thursday 9/20 11:59PM Guest lecture on Tuesday 9/25 o No RDZ office hours next Friday, I am on travel A brief comment

### 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

### Introduction to OCaml

Introduction to OCaml Jed Liu Department of Computer Science Cornell University CS 6110 Lecture 26 January 2009 Based on CS 3110 course notes and an SML tutorial by Mike George Jed Liu Introduction to

### 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

### 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

### The type checker will complain that the two branches have different types, one is string and the other is int

1 Intro to ML 1.1 Basic types Need ; after expression - 42 = ; val it = 42 : int - 7+1; val it = 8 : int Can reference it - it+2; val it = 10 : int - if it > 100 then "big" else "small"; val it = "small"

### CS 457/557: Functional Languages

CS 457/557: Functional Languages Lists and Algebraic Datatypes Mark P Jones Portland State University 1 Why Lists? Lists are a heavily used data structure in many functional programs Special syntax is

### CMSC 330, Fall 2013, Practice Problem 3 Solutions

CMSC 330, Fall 2013, Practice Problem 3 Solutions 1. OCaml and Functional Programming a. Define functional programming Programs are expression evaluations b. Define imperative programming Programs change

### Datatype declarations

Datatype declarations datatype suit = HEARTS DIAMONDS CLUBS SPADES datatype a list = nil (* copy me NOT! *) op :: of a * a list datatype a heap = EHEAP HEAP of a * a heap * a heap type suit val HEARTS

### A Third Look At ML. Chapter Nine Modern Programming Languages, 2nd ed. 1

A Third Look At ML Chapter Nine Modern Programming Languages, 2nd ed. 1 Outline More pattern matching Function values and anonymous functions Higher-order functions and currying Predefined higher-order

### Spring 2018 Discussion 7: March 21, Introduction. 2 Primitives

CS 61A Scheme Spring 2018 Discussion 7: March 21, 2018 1 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme

### 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

### Fall 2018 Discussion 8: October 24, 2018 Solutions. 1 Introduction. 2 Primitives

CS 6A Scheme Fall 208 Discussion 8: October 24, 208 Solutions Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write

### 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

### Denotational Semantics. Domain Theory

Denotational Semantics and Domain Theory 1 / 51 Outline Denotational Semantics Basic Domain Theory Introduction and history Primitive and lifted domains Sum and product domains Function domains Meaning

### Programming Languages and Techniques (CIS120)

Programming Languages and Techniques (CIS120) Lecture 10 February 5 th, 2016 Abstract types: sets Lecture notes: Chapter 10 What is the value of this expresssion? let f (x:bool) (y:int) : int = if x then

### Programming Languages

CSE 130 : Fall 2008 Programming Languages Lecture 2: A Crash Course in ML Ranjit Jhala UC San Diego News On webpage: Suggested HW #1, sample for Quiz #1 on Thu PA #1 (due next Fri 10/10) No make-up quizzes

### Thinking Induc,vely. COS 326 David Walker Princeton University

Thinking Induc,vely COS 326 David Walker Princeton University slides copyright 2017 David Walker permission granted to reuse these slides for non-commercial educa,onal purposes Administra,on 2 Assignment

### n n Try tutorial on front page to get started! n spring13/ n Stack Overflow!

Announcements n Rainbow grades: HW1-6, Quiz1-5, Exam1 n Still grading: HW7, Quiz6, Exam2 Intro to Haskell n HW8 due today n HW9, Haskell, out tonight, due Nov. 16 th n Individual assignment n Start early!

### 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

### COSE212: Programming Languages. Lecture 3 Functional Programming in OCaml

COSE212: Programming Languages Lecture 3 Functional Programming in OCaml Hakjoo Oh 2017 Fall Hakjoo Oh COSE212 2017 Fall, Lecture 3 September 18, 2017 1 / 44 Why learn ML? Learning ML is a good way of

### Fall 2017 Discussion 7: October 25, 2017 Solutions. 1 Introduction. 2 Primitives

CS 6A Scheme Fall 207 Discussion 7: October 25, 207 Solutions Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write

### CS 360: Programming Languages Lecture 10: Introduction to Haskell

CS 360: Programming Languages Lecture 10: Introduction to Haskell Geoffrey Mainland Drexel University Thursday, February 5, 2015 Adapted from Brent Yorgey s course Introduction to Haskell. Section 1 Administrivia

### 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).

### COP4020 Programming Languages. Functional Programming Prof. Robert van Engelen

COP4020 Programming Languages Functional Programming Prof. Robert van Engelen Overview What is functional programming? Historical origins of functional programming Functional programming today Concepts

### 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

### Tail Recursion: Factorial. Begin at the beginning. How does it execute? Tail recursion. Tail recursive factorial. Tail recursive factorial

Begin at the beginning Epressions (Synta) Compile-time Static Eec-time Dynamic Types Values (Semantics) 1. Programmer enters epression 2. ML checks if epression is well-typed Using a precise set of rules,

### Introduction to ML. Mooly Sagiv. Cornell CS 3110 Data Structures and Functional Programming

Introduction to ML Mooly Sagiv Cornell CS 3110 Data Structures and Functional Programming Typed Lambda Calculus Chapter 9 Benjamin Pierce Types and Programming Languages Call-by-value Operational Semantics

### CMSC 330: Organization of Programming Languages. OCaml Higher Order Functions

CMSC 330: Organization of Programming Languages OCaml Higher Order Functions CMSC330 Fall 2017 1 Anonymous Functions Recall code blocks in Ruby (1..10).each { x print x } Here, we can think of { x print

### CSE 130 [Winter 2014] Programming Languages

CSE 130 [Winter 2014] Programming Languages Introduction to OCaml (Continued) Ravi Chugh! Jan 14 Announcements HW #1 due Mon Jan 20 Post questions/discussion to Piazza Check Piazza for TA/Tutor lab hours

### CS 11 Haskell track: lecture 1

CS 11 Haskell track: lecture 1 This week: Introduction/motivation/pep talk Basics of Haskell Prerequisite Knowledge of basic functional programming e.g. Scheme, Ocaml, Erlang CS 1, CS 4 "permission of

### CMSC 330: Organization of Programming Languages. OCaml Higher Order Functions

CMSC 330: Organization of Programming Languages OCaml Higher Order Functions CMSC 330 - Spring 2017 1 Anonymous Functions Recall code blocks in Ruby (1..10).each { x print x } Here, we can think of { x

### Recap. Recap. If-then-else expressions. If-then-else expressions. If-then-else expressions. If-then-else expressions

Recap Epressions (Synta) Compile-time Static Eec-time Dynamic Types (Semantics) Recap Integers: +,-,* floats: +,-,* Booleans: =,

### CSE341: Programming Languages Lecture 9 Function-Closure Idioms. Dan Grossman Fall 2011

CSE341: Programming Languages Lecture 9 Function-Closure Idioms Dan Grossman Fall 2011 More idioms We know the rule for lexical scope and function closures Now what is it good for A partial but wide-ranging

### CS 320: Concepts of Programming Languages

CS 320: Concepts of Programming Languages Wayne Snyder Computer Science Department Boston University Lecture 04: Basic Haskell Continued o Polymorphic Types o Type Inference with Polymorphism o Standard

### CMSC 330: Organization of Programming Languages. OCaml Higher Order Functions

CMSC 330: Organization of Programming Languages OCaml Higher Order Functions CMSC 330 - Summer 2017 1 Anonymous Functions Recall code blocks in Ruby (1..10).each { x print x } Here, we can think of { x

### 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