Implemen'ng OCaml in OCaml
|
|
|
- Albert Stevenson
- 5 years ago
- Views:
Transcription
1 1 An OCaml defini'on of OCaml evalua'on, or, Implemen'ng OCaml in OCaml COS 326 David Walker Princeton University slides copyright David Walker and Andrew W. Appel permission granted to reuse these slides for non-commercial educa'onal purposes
2 Implemen'ng an Interpreter 2 text file containing program as a sequence of characters let x = 3 in x + x Num 6 Parsing data structure represen'ng result of evalua'on PreWy Prin'ng data structure represen'ng program Let ( x, Num 3, Binop(Plus, Var x, Var x )) Evalua'on 6 the data type and evaluator tell us a lot about program seman'cs text file/stdout containing with formawed output
3 Making These Ideas Precise 3 We can define a datatype for simple OCaml expressions: type variable = string type op = Plus Minus Times type exp = Int_e of int Op_e of exp * op * exp Var_e of variable Let_e of variable * exp * exp type value = exp
4 Making These Ideas Precise 4 We can define a datatype for simple OCaml expressions: type variable = string type op = Plus Minus Times type exp = Int_e of int Op_e of exp * op * exp Var_e of variable Let_e of variable * exp * exp type value = exp let e1 = Int_e 3 let e2 = Int_e 17 let e3 = Op_e (e1, Plus, e2) represents
5 Making These Ideas Precise 5 We can represent the OCaml program: let x = 30 in let y = (let z = 3 in z*4) in y+y;; as an exp value: Let_e( x, Int_e 30, Let_e( y, Let_e( z, Int_e 3, Op_e(Var_e z, Times, Int_e 4)), Op_e(Var_e y, Plus, Var_e y )
6 Making These Ideas Precise 6 No'ce how this reflects the tree : Let_e( x,int_e 30, Let_e( y,let_e( z,int_e 3, Op_e(Var_e z, Times, Int_e 4)), Op_e(Var_e y, Plus, Var_e y ) let x 30 let y let + z 3 * y y z 4
7 Binding occurrences versus applied occurrences 7 type exp = Int_e of int Op_e of exp * op * exp Var_e of variable Let_e of variable * exp * exp This is a use of a variable This is a binding occurrence of a variable
8 Some Useful Auxiliary Func'ons 8 let is_value (e:exp) : bool = Int_e _ -> true ( Op_e _ Let_e _ Var_e _ ) -> false nested pawern (can t use variables) eval_op : value -> op -> value -> exp (* substitute v x e: replace free occurrences of x with v in e *) substitute : value -> variable -> exp -> exp
9 A Simple Evaluator 9 is_value : exp -> bool eval_op : value -> op -> value -> value substitute : value -> variable -> exp -> exp let rec eval (e:exp) : exp = Int_e i -> Op_e(e1,op,e2) -> Let_e(x,e1,e2) ->
10 A Simple Evaluator 10 is_value : exp -> bool eval_op : value -> op -> value -> value substitute : value -> variable -> exp -> exp let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> Let_e(x,e1,e2) ->
11 A Simple Evaluator 11 is_value : exp -> bool eval_op : value -> op -> value -> value substitute : value -> variable -> exp -> exp let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> let v1 = eval e1 in let v2 = eval e2 in eval_op v1 op v2 Let_e(x,e1,e2) ->
12 A Simple Evaluator 12 is_value : exp -> bool eval_op : value -> op -> value -> value substitute : value -> variable -> exp -> exp let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> let v1 = eval e1 in let v2 = eval e2 in eval_op v1 op v2 Let_e(x,e1,e2) -> let v1 = eval e1 in let e2 = substitute v1 x e2 in eval e2
13 Shorter but Dangerous 13 is_value : exp -> bool eval_op : value -> op -> value -> value substitute : value -> variable -> exp -> exp let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2) Why?
14 Simpler but Dangerous 14 is_value : exp -> bool eval_op : value -> op -> value -> value substitute : value -> variable -> exp -> exp let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2) Which gets evaluated first? Does OCaml use lei-to-right eval order or right-to-lei? Always use OCaml let if you want to specify evalua'on order.
15 Simpler but Dangerous 15 is_value : exp -> bool eval_op : value -> op -> value -> value substitute : value -> variable -> exp -> exp let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2) Since the language we are interpre'ng is pure (no effects), it won t mawer which expression gets evaluated first. We ll produce the same answer in either case.
16 Limita'ons of metacircular interpreters 16 is_value : exp -> bool eval_op : value -> op -> value -> value substitute : value -> variable -> exp -> exp let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> let v1 = eval e1 in let v2 = eval e2 in eval_op v1 op v2 Let_e(x,e1,e2) -> let v1 = eval e1 in Which gets evaluated first, (eval e1) or (eval e2)? Seems obvious, right? But that s because we assume OCaml has call-by-value evalua'on! If it were call-by-name, then this ordering of lets would not guarantee order of evalua'on. let e2 = substitute v1 x e2 in eval e2 Moral: using a language to define its own seman+cs can have limita6ons.
17 Back to the eval func'on 17 let eval_op v1 op v2 = let substitute v x e = let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2) (same as the one a couple of slides ago)
18 Oops! We Missed a Case: 18 let eval_op v1 op v2 = let substitute v x e = let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2) Var_e x ->??? We should never encounter a variable they should have been subs'tuted with a value! (This is a type-error.) We could leave out the case for variables if we type check before evalua+ng. (which we should definitely do!) But that will create a mess of Ocaml warnings bad style. (Bad for debugging.)
19 We Could Use Op'ons: 19 let eval_op v1 op v2 = let substitute v x e = let rec eval (e:exp) : exp option = Int_e i -> Some(Int_e i) Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2) Var_e x -> None But this isn t quite right we need to match on the recursive calls to eval to make sure we get Some value!
20 Excep'ons 20 exception UnboundVariable of variable let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2) Var_e x -> raise (UnboundVariable x) Instead, we can throw an excep'on.
21 Excep'ons 21 exception UnboundVariable of variable let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2) Var_e x -> raise (UnboundVariable x) Note that an excep'on declara'on is a lot like a datatype declara'on. Really, we are extending one big datatype (exn) with a new constructor (UnboundVariable). Later on, we ll see how to catch an excep'on.
22 Excep'on or op'on? In a previous lecture, I explained why to use an op'on type (or a Success/Failure datatype) instead of raising an excep'on. 22 No! I do not contradict myself! The other example was for errors that will occur (because the input might be ill formawed). This example is for errors that cannot occur (unless the program itself has a bug).
23 AUXILIARY FUNCTIONS 23
24 Evalua'ng the Primi've Opera'ons 24 let eval_op (v1:exp) (op:operand) (v2:exp) : exp = match v1, op, v2 with Int_e i, Plus, Int_e j -> Int_e (i+j) Int_e i, Minus, Int_e j -> Int_e (i-j) Int_e i, Times, Int_e j -> Int_e (i*j) _,(Plus Minus Times), _ -> if is_value v1 && is_value v2 then raise TypeError else raise NotValue let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2) Var_e x -> raise (UnboundVariable x) ;;
25 Subs'tu'on Want to replace x (and only x) with v. let substitute (v:exp) (x:variable) (e:exp) : exp =... ;; 25
26 Subs'tu'on let substitute (v:exp) (x:variable) (e:exp) : exp = let rec subst (e:exp) : exp = Int_e _ -> Op_e(e1,op,e2) -> Var_e y ->... use x... Let_e (y,e1,e2) ->... use x... ;; in subst e 26
27 Subs'tu'on let substitute (v:exp) (x:variable) (e:exp) : exp = let rec subst (e:exp) : exp = Int_e _ -> e Op_e(e1,op,e2) -> Var_e y -> Let_e (y,e1,e2) -> ;; in subst e 27
28 Subs'tu'on let substitute (v:exp) (x:variable) (e:exp) : exp = let rec subst (e:exp) : exp = Int_e _ -> e Op_e(e1,op,e2) -> Op_e(subst e1,op,subst e2) Var_e y -> Let_e (y,e1,e2) -> ;; in subst e 28
29 Subs'tu'on let substitute (v:exp) (x:variable) (e:exp) : exp = let rec subst (e:exp) : exp = Int_e _ -> e Op_e(e1,op,e2) -> Op_e(subst e1,op,subst e2) Var_e y -> if x = y then v else e Let_e (y,e1,e2) -> ;; in subst e 29
30 Subs'tu'on let substitute (v:exp) (x:variable) (e:exp) : exp = ;; let rec subst (e:exp) : exp = in subst e Int_e _ -> e Op_e(e1,op,e2) -> Op_e(subst e1,op,subst e2) Var_e y -> if x = y then v else e Let_e (y,e1,e2) -> Let_e (y, subst e1, subst e2) 30 WRONG!
31 Subs'tu'on let substitute (v:exp) (x:variable) (e:exp) : exp = ;; let rec subst (e:exp) : exp = in subst e Int_e _ -> e Op_e(e1,op,e2) -> Op_e(subst e1,op,subst e2) Var_e y -> if x = y then v else e Let_e (y,e1,e2) -> Let_e (y, if x = y then e1 else subst e1, if x = y then e2 else subst e2) 31 wrong
32 Subs'tu'on let substitute (v:exp) (x:variable) (e:exp) : exp = ;; let rec subst (e:exp) : exp = in subst e Int_e _ -> e Op_e(e1,op,e2) -> Op_e(subst e1,op,subst e2) Var_e y -> if x = y then v else e Let_e (y,e1,e2) -> Let_e (y, subst e1, if x = y then e2 else subst e2) evalua'on/subsitu'on must implement our variable scoping rules correctly 32
33 Subs'tu'on let substitute (v:exp) (x:variable) (e:exp) : exp = let rec subst (e:exp) : exp = in subst e Int_e _ -> e Op_e(e1,op,e2) -> Op_e(subst e1,op,subst e2) Var_e y -> if x = y then v else e Let_e (y,e1,e2) -> ;; If x and y are the same variable, then y shadows x. Let_e (y, subst e1, if x = y then e2 else subst e2) 33
34 SCALING UP THE LANGUAGE (MORE FEATURES, MORE FUN) 34
35 Scaling up the Language 35 type exp = Int_e of int Op_e of exp * op * exp Var_e of variable Let_e of variable * exp * exp Fun_e of variable * exp FunCall_e of exp * exp ;;
36 Scaling up the Language 36 type exp = Int_e of int Op_e of exp * op * exp Var_e of variable Let_e of variable * exp * exp Fun_e of variable * exp FunCall_e of exp * exp ;; OCaml s fun x -> e is represented as Fun_e(x,e)
37 Scaling up the Language 37 type exp = Int_e of int Op_e of exp * op * exp Var_e of variable Let_e of variable * exp * exp Fun_e of variable * exp FunCall_e of exp * exp ;; A func'on call fact 3 is implemented as FunCall_e (Var_e fact, Int_e 3)
38 Scaling up the Language 38 type exp = Int_e of int Op_e of exp * op * exp Var_e of variable Let_e of variable * exp * exp Fun_e of variable * exp FunCall_e of exp * exp;; let is_value (e:exp) : bool = Int_e _ -> true Fun_e (_,_) -> true ( Op_e (_,_,_) Let_e (_,_,_) Var_e _ FunCall_e (_,_) ) -> false ;; Func'ons are values! Easy exam ques'on: What value does the OCaml interpreter produce when you enter (fun x -> 3) in to the prompt? Answer: the value produced is (fun x -> 3)
39 Scaling up the Language: 39 type exp = Int_e of int Op_e of exp * op * exp Var_e of variable Let_e of variable * exp * exp Fun_e of variable * exp FunCall_e of exp * exp;; let is_value (e:exp) : bool = Int_e _ -> true Fun_e (_,_) -> true ( Op_e (_,_,_) Let_e (_,_,_) Var_e _ FunCall_e (_,_) ) -> false ;; Func'on calls are not values.
40 Scaling up the Language: 40 let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2) Var_e x -> raise (UnboundVariable x) Fun_e (x,e) -> Fun_e (x,e) FunCall_e (e1,e2) -> (match eval e1, eval e2 with Fun_e (x,e), v2 -> eval (substitute v2 x e) _ -> raise TypeError)
41 Scaling up the Language: 41 let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2) Var_e x -> raise (UnboundVariable x) Fun_e (x,e) -> Fun_e (x,e) FunCall_e (e1,e2) -> (match eval e1, eval e2 with Fun_e (x,e), v2 -> eval (substitute v2 x e) _ -> raise TypeError) values (including func'ons) always evaluate to themselves.
42 Scaling up the Language: 42 let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2) Var_e x -> raise (UnboundVariable x) Fun_e (x,e) -> Fun_e (x,e) FunCall_e (e1,e2) -> (match eval e1, eval e2 with Fun_e (x,e), v2 -> eval (substitute v2 x e) _ -> raise TypeError) To evaluate a func'on call, we first evaluate both e1 and e2 to values.
43 Scaling up the Language 43 let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2) Var_e x -> raise (UnboundVariable x) Fun_e (x,e) -> Fun_e (x,e) FunCall_e (e1,e2) -> (match eval e1, eval e2 with Fun_e (x,e), v2 -> eval (substitute v2 x e) _ -> raise TypeError) e1 had bewer evaluate to a func'on value, else we have a type error.
44 Scaling up the Language 44 let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2) Var_e x -> raise (UnboundVariable x) Fun_e (x,e) -> Fun_e (x,e) FunCall_e (e1,e2) -> (match eval e1, eval e2 with Fun_e (x,e), v2 -> eval (substitute v2 x e) _ -> raise TypeError) Then we subs'tute e2 s value (v2) for x in e and evaluate the resul'ng expression.
45 Simplifying a liwle 45 let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2) Var_e x -> raise (UnboundVariable x) Fun_e (x,e) -> Fun_e (x,e) FunCall_e (e1,e2) -> (match eval e1 Fun_e (x,e) -> eval (substitute (eval e2) x e) _ -> raise TypeError) We don t really need to pawern-match on e2. Just evaluate here
46 Simplifying a liwle 46 let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2) Var_e x -> raise (UnboundVariable x) Fun_e (x,e) -> Fun_e (x,e) FunCall_e (ef,e1) -> (match eval ef with Fun_e (x,e2) -> eval (substitute (eval e1) x e2) _ -> raise TypeError) This looks like the case for let!
47 Let and Lambda 47 let x = 1 in x+41 --> > 42 (fun x -> x+41) 1 --> > 42 In general: (fun x -> e2) e1 == let x = e1 in e2
48 So we could write: 48 let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (FunCall (Fun_e (x,e2), e1)) Var_e x -> raise (UnboundVariable x) Fun_e (x,e) -> Fun_e (x,e) FunCall_e (ef,e2) -> (match eval ef with Fun_e (x,e1) -> eval (substitute (eval e1) x e2) _ -> raise TypeError) In programming-languages speak: Let is syntac6c sugar for a func'on call Syntac'c sugar: A new feature defined by a simple, local transforma'on.
49 Recursive defini'ons 49 type exp = Int_e of int Op_e of exp * op * exp Var_e of variable Let_e of variable * exp * exp Fun_e of variable * exp FunCall_e of exp * exp Rec_e of variable * variable * exp ;; let rec f x = f (x+1) in f 3 (rewrite) let f = (rec f x -> f (x+1)) in f 3 let g = (rec f x -> f (x+1)) in g 3 (alpha-convert) (implement) Let_e ( g, Rec_e ( f, x, FunCall_e (Var_e f, Op_e (Var_e x, Plus, Int_e 1)) ), FunCall (Var_e g, Int_e 3) )
50 Recursive defini'ons 50 type exp = Int_e of int Op_e of exp * op * exp Var_e of variable Let_e of variable * exp * exp Fun_e of variable * exp FunCall_e of exp * exp Rec_e of variable * variable * exp ;; let is_value (e:exp) : bool = Int_e _ -> true Fun_e (_,_) -> true Rec_e of (_,_,_) -> true (Op_e (_,_,_) Let_e (_,_,_) Var_e _ FunCall_e (_,_) ) -> false ;;
51 Recursive defini'ons 51 type exp = Int_e of int Op_e of exp * op * exp Var_e of variable Let_e of variable * exp * exp Fun_e of variable * exp FunCall_e of exp * exp Rec_e of variable * variable * exp ;; let is_value (e:exp) : bool = Int_e _ -> true Fun_e (_,_) -> true Rec_e of (_,_,_) -> true (Op_e (_,_,_) Let_e (_,_,_) Var_e _ FunCall_e (_,_) ) -> false ;; Fun_e (x, body) == Rec_e("unused", x, body) A bewer IR would just delete Fun_e avoid unnecessary redundancy
52 Interlude: Nota'on for Subs'tu'on 52 Subs'tute value v for variable x in expression e: e [ v / x ] examples of subs'tu'on: (x + y) [7/y] is (x + 7) (let x =30 in let y=40 in x + y) [7/y] is (let x =30 in let y=40 in x + y) (let y = y in let y = y in y + y) [7/y] is (let y = 7 in let y = y in y + y)
53 Evalua'ng Recursive Func'ons 53 Basic evalua'on rule for recursive func'ons: (rec f x = body) arg --> body [arg/x] [rec f x = body/f] argument value subs'tuted for parameter en're func'on subs'tuted for func'on name
54 Evalua'ng Recursive Func'ons 54 Start out with a let bound to a recursive func'on: let g = rec f x -> if x <= 0 then x else x + f (x-1) in g 3 The Subs'tu'on: g 3 [rec f x -> if x <= 0 then x else x + f (x-1) / g] The Result: (rec f x -> if x <= 0 then x else x + f (x-1)) 3
55 Evalua'ng Recursive Func'ons Recursive Func'on Call: (rec f x -> if x <= 0 then x else x + f (x-1)) 3 The Subs'tu'on: (if x <= 0 then x else x + f (x-1)) [ rec f x -> if x <= 0 then x else x + f (x-1) / f ] [ 3 / x ] Subs'tute argument for parameter Subs'tute en're func'on for func'on name The Result: (if 3 <= 0 then 3 else 3 + (rec f x -> if x <= 0 then x else x + f (x-1)) (3-1)) 55
56 Evalua'ng Recursive Func'ons 56 let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2) Var_e x -> raise (UnboundVariable x) Fun_e (x,e) -> Fun_e (x,e) FunCall_e (e1,e2) -> (match eval e1 with Fun_e (x,e) -> let v = eval e2 in substitute e x v (Rec_e (f,x,e)) as f_val -> let v = eval e2 in substitute f_val f (substitute v x e) _ -> raise TypeError) pa=ern as x match the pawern and binds x to value
57 More Evalua'on 57 (rec fact n = if n <= 1 then 1 else n * fact(n-1)) 3 --> if 3 < 1 then 1 else 3 * (rec fact n = if... then... else...) (3-1) --> 3 * (rec fact n = if ) (3-1) --> 3 * (rec fact n = if ) 2 --> 3 * (if 2 <= 1 then 1 else 2 * (rec fact n =...)(2-1)) --> 3 * (2 * (rec fact n =...)(2-1)) --> 3 * (2 * (rec fact n =...)(1)) --> 3 * 2 * (if 1 <= 1 then 1 else 1 * (rec fact...)(1-1)) --> 3 * 2 * 1
58 58 A MATHEMATICAL DEFINITION* OF OCAML EVALUATION * it s a par'al defini'on and this is a big topic; for more, see COS 510
59 From Code to Abstract Specifica'on 59 OCaml code can give a language seman'cs advantage: it can be executed, so we can try it out advantage: it is amazingly concise especially compared to what you would have wriwen in Java disadvantage: it is a liwle ugly to operate over concrete ML datatypes like Op_e(e1,Plus,e2) as opposed to e1 + e2 disadvantage: defining a language in itself is a logical fallacy
60 From Code to Abstract Specifica'on 60 PL researchers have developed their own standard nota'on for wri'ng down how programs execute it has a mathema'cal feel that makes PL researchers feel special and gives us goosebumps inside it operates over abstract expression syntax like e1 + e2 it is useful to know this nota'on if you want to read specifica'ons of programming language seman'cs e.g.: Standard ML (of which OCaml is a descendent) has a formal defini'on given in this nota'on (and C, and Java; but not OCaml ) e.g.: most papers in the conference POPL (ACM Principles of Prog. Lang.)
61 Goal 61 Our goal is to explain how an expression e evaluates to a value v. In other words, we want to define a mathema'cal rela6on between pairs of expressions and values.
62 Formal Inference Rules 62 We define the evaluates to rela'on using a set of (induc've) rules that allow us to prove that a par'cular (expression, value) pair is part of the rela'on. A rule looks like this: You read a rule like this: premise 1 premise 2... premise 3 conclusion if premise 1 can be proven and premise 2 can be proven and... and premise n can be proven then conclusion can be proven Some rules have no premises this means their conclusions are always true we call such rules axioms or base cases
63 An example rule 63 As a rule: e1 --> v1 e2 --> v2 eval_op (v1, op, v2) == v e1 op e2 --> v In English: If e1 evaluates to v1 and e2 evaluates to v2 and eval_op (v1, op, v2) is equal to v then e1 op e2 evaluates to v In code: let rec eval (e:exp) : exp = Op_e(e1,op,e2) -> let v1 = eval e1 in let v2 = eval e2 in let v = eval_op v1 op v2 in v
64 An example rule 64 As a rule: In English: i ϵ Ζ i --> i asserts i is an integer If the expression is an integer value, it evaluates to itself. In code: let rec eval (e:exp) : exp = Int_e i -> Int_e i...
65 An example rule concerning evalua'on 65 As a rule: e1 --> v1 e2 [v1/x] --> v2 let x = e1 in e2 --> v2 In English: In code: If e1 evaluates to v1 (which is a value) and e2 with v1 subs'tuted for x evaluates to v2 then let x=e1 in e2 evaluates to v2. let rec eval (e:exp) : exp = Let_e(x,e1,e2) -> let v1 = eval e1 in eval (substitute v1 x e2)...
66 An example rule concerning evalua'on 66 As a rule: In English: λx.e --> λx.e typical lambda nota'on for a func'on with argument x, body e A func'on value evaluates to itself. In code: let rec eval (e:exp) : exp =... Fun_e (x,e) -> Fun_e (x,e)...
67 An example rule concerning evalua'on 67 As a rule: In English: e1 --> λx.e e2 --> v2 e[v2/x] --> v e1 e2 --> v In code: if e1 evaluates to a func'on with argument x and body e and e2 evaluates to a value v2 and e with v2 subs'tuted for x evaluates to v then e1 applied to e2 evaluates to v let rec eval (e:exp) : exp =.. FunCall_e (e1,e2) -> (match eval e1 with Fun_e (x,e) -> eval (substitute (eval e2) x e)...)...
68 An example rule concerning evalua'on 68 As a rule: e1--> rec f x = e e2 --> v e[rec f x = e/f][v/x] --> v2 e1 e2 --> v2 In English: uggh In code: let rec eval (e:exp) : exp =... (Rec_e (f,x,e)) as f_val -> let v = eval e2 in substitute f_val (substitute v x e) g
69 Comparison: Code vs. Rules 69 complete eval code: complete set of rules: let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2) Var_e x -> raise (UnboundVariable x) Fun_e (x,e) -> Fun_e (x,e) FunCall_e (e1,e2) -> (match eval e1 Fun_e (x,e) -> eval (Let_e (x,e2,e)) _ -> raise TypeError) LetRec_e (x,e1,e2) -> (Rec_e (f,x,e)) as f_val -> let v = eval e2 in substitute f_val f (substitute v x e) e1 --> rec f x = e e2 --> v2 e[rec f x = e/f][v2/x] --> v3 e1 e2 --> v3 Almost isomorphic: one rule per pawern-matching clause i ϵ Ζ i --> i e1 --> v1 e2 --> v2 eval_op (v1, op, v2) == v e1 op e2 --> v e1 --> v1 e2 [v1/x] --> v2 let x = e1 in e2 --> v2 λx.e --> λx.e e1 --> λx.e e2 --> v2 e[v2/x] --> v e1 e2 --> v recursive call to eval whenever there is a --> premise in a rule what s the main difference?
70 Comparison: Code vs. Rules 70 complete eval code: let rec eval (e:exp) : exp = Int_e i -> Int_e i Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2) Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2) Var_e x -> raise (UnboundVariable x) Fun_e (x,e) -> Fun_e (x,e) FunCall_e (e1,e2) -> (match eval e1 Fun_e (x,e) -> eval (Let_e (x,e2,e)) _ -> raise TypeError) LetRec_e (x,e1,e2) -> (Rec_e (f,x,e)) as f_val -> let v = eval e2 in substitute f_val f (substitute v x e) There s no formal rule for handling free variables No rule for evalua'ng func'on calls when a non-func'on in the caller posi'on In general, no rule when further evalua6on is impossible the rules express the legal evalua6ons and say nothing about what to do in error situa'ons the code handles the error situa'ons by raising excep'ons complete set of rules: i ϵ Ζ i --> i e1 --> v1 e2 --> v2 eval_op (v1, op, v2) == v e1 op e2 --> v e1 --> v1 e2 [v1/x] --> v2 let x = e1 in e2 --> v2 λx.e --> λx.e e1 --> λx.e e2 --> v2 e[v2/x] --> v e1 e2 --> v e1 --> rec f x = e e2 --> v2 e[rec f x = e/f][v2/x] --> v3 e1 e2 --> v3 type theorists prove that well-typed programs don t run into undefined cases
71 Summary 71 We can reason about OCaml programs using a subs6tu6on model. integers, bools, strings, chars, and func6ons are values value rule: values evaluate to themselves let rule: let x = e1 in e2 : subs'tute e1 s value for x into e2 fun call rule: (fun x -> e2) e1 : subs'tute e1 s value for x into e2 rec call rule: (rec x = e1) e2 : like fun call rule, but also subs'tute recursive func'on for name of func'on To unwind: subs'tute (rec x = e1) for x in e1 We can make the evalua'on model precise by building an interpreter and using that interpreter as a specifica'on of the language seman'cs. We can also specify the evalua'on model using a set of inference rules more on this in COS 510
72 Some Final Words 72 The subs'tu'on model is only a model. it does not accurately model all of OCaml s features I/O, excep'ons, muta'on, concurrency, we can build models of these things, but they aren t as simple. even subs'tu'on is tricky to formalize! It s useful for reasoning about higher-order func'ons, correctness of algorithms, and op'miza'ons. we can use it to formally prove that, for instance: map f (map g xs) == map (comp f g) xs proof: by induc'on on the length of the list xs, using the defini'ons of the subs'tu'on model. we oien model complicated systems (e.g., protocols) using a small func'onal language and subs'tu'on-based evalua'on. It is not useful for reasoning about execu'on 'me or space more complex models needed there
73 Some Final Words 73 The subs'tu'on model is only a model. it does not accurately model all of OCaml s features I/O, excep'ons, muta'on, concurrency, we can build models of these things, but they aren t as simple. even subs'tu'on was tricky to formalize! It s useful for reasoning about higher-order func'ons, correctness of algorithms, and op'miza'ons. we can use it to formally prove that, for instance: map You f (map can g say xs) that == map again! (comp f g) xs I got it wrong the first proof: by induc'on on the length of the list xs, using the defini'ons 'me I of tried, the in subs'tu'on model. Fixed the bug by 1934, we oien model complicated systems (e.g., protocols) using a though. small func'onal language and subs'tu'on-based evalua'on. It is not useful for reasoning about execu'on Alonzo 'me Church, or space more complex models needed there Princeton Professor,
74 Church's mistake 74 subs'tute: fun xs -> map (+) xs for f in: fun ys -> let map xs = 0::xs in f (map ys) and if you don't watch out, you will get: fun ys -> let map xs = 0::xs in (fun xs -> map (+) xs) (map ys)
75 Church's mistake 75 subs'tute: fun xs -> map (+) xs for f in: fun ys -> let map xs = 0::xs in f (map ys) the problem was that the value you subs'tuted in had a free variable (map) in it that was captured. and if you don't watch out, you will get: fun ys -> let map xs = 0::xs in (fun xs -> map (+) xs) (map ys)
76 Church's mistake 76 subs'tute: fun xs -> map (+) xs for f in: fun ys -> let map xs = 0::xs in f (map ys) to do it right, you need to rename some variables: fun ys -> let z xs = 0::xs in (fun xs -> map (+) xs) (z ys)
77 NOW WE ARE REALLY DONE! 77
A Functional Evaluation Model
A Functional Evaluation Model COS 326 Andrew W. Appel Princeton University slides copyright 2013-2015 David Walker and Andrew W. Appel A Functional Evaluation Model In order to be able to write a program,
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Operational Semantics CMSC 330 Summer 2018 1 Formal Semantics of a Prog. Lang. Mathematical description of the meaning of programs written in that language
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
A Func'onal Introduc'on. COS 326 David Walker Princeton University
A Func'onal Introduc'on COS 326 David Walker Princeton University Thinking Func'onally In Java or C, you get (most) work done by changing something temp = pair.x; pair.x = pair.y; pair.y = temp; commands
Lecture 2: Big-Step Semantics
Lecture 2: Big-Step Semantics 1 Representing Abstract Syntax These are examples of arithmetic expressions: 2 * 4 1 + 2 + 3 5 * 4 * 2 1 + 2 * 3 We all know how to evaluate these expressions in our heads.
CS251 Programming Languages Spring 2016, Lyn Turbak Department of Computer Science Wellesley College
Functions in Racket CS251 Programming Languages Spring 2016, Lyn Turbak Department of Computer Science Wellesley College Racket Func+ons Functions: most important building block in Racket (and 251) Functions/procedures/methods/subroutines
Lecture 13 CIS 341: COMPILERS
Lecture 13 CIS 341: COMPILERS Announcements HW4: OAT v. 1.0 Parsing & basic code generation Due: March 28 th START EARLY! Midterm Exam Grades Available on Gradescope Zdancewic CIS 341: Compilers 2 Midterm
Func+on applica+ons (calls, invoca+ons)
Func%ons in Racket Racket Functions: most important building block in Racket (and 25) Functions/procedures/methods/subroutines abstract over computations Like Java methods, Python functions have arguments
Thinking Induc,vely. COS 326 David Walker Princeton University
Thinking Induc,vely COS 326 David Walker Princeton University slides copyright 2013-2015 David Walker and Andrew W. Appel permission granted to reuse these slides for non-commercial educa,onal purposes
CS152: Programming Languages. Lecture 11 STLC Extensions and Related Topics. Dan Grossman Spring 2011
CS152: Programming Languages Lecture 11 STLC Extensions and Related Topics Dan Grossman Spring 2011 Review e ::= λx. e x e e c v ::= λx. e c τ ::= int τ τ Γ ::= Γ, x : τ (λx. e) v e[v/x] e 1 e 1 e 1 e
Programming Language Features. CMSC 330: Organization of Programming Languages. Turing Completeness. Turing Machine.
CMSC 330: Organization of Programming Languages Lambda Calculus Programming Language Features Many features exist simply for convenience Multi-argument functions foo ( a, b, c ) Ø Use currying or tuples
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Lambda Calculus CMSC 330 1 Programming Language Features Many features exist simply for convenience Multi-argument functions foo ( a, b, c ) Ø Use currying
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Lambda Calculus CMSC 330 Summer 2017 1 100 years ago Albert Einstein proposed special theory of relativity in 1905 In the paper On the Electrodynamics of
Modules and Representa/on Invariants
Modules and Representa/on Invariants COS 326 David Walker Princeton University slides copyright 2017 David Walker permission granted to reuse these slides for non-commercial educa/onal purposes LAST TIME
02-13-actual.ml Fri Feb 14 11:50: (* Lecture 6: 02/13/2014 *) (* Substitution example:
02-13-actual.ml Fri Feb 14 11:50:37 2014 1 Lecture 6: 02/13/2014 Substitution example: let x = 5 in (let y = 12 in x + y) * (let x = x + 1 in x - 3) (let y = 12 in 5 + y) * (let x = 5 + 1 in x - 3) (5
CMSC 330: Organization of Programming Languages. Lambda Calculus
CMSC 330: Organization of Programming Languages Lambda Calculus 1 Turing Completeness Turing machines are the most powerful description of computation possible They define the Turing-computable functions
The Substitution Model
The Substitution Model Prof. Clarkson Fall 2017 Today s music: Substitute by The Who Review Previously in 3110: simple interpreter for expression language abstract syntax tree (AST) evaluation based on
LISP: LISt Processing
Introduc)on to Racket, a dialect of LISP: Expressions and Declara)ons LISP: designed by John McCarthy, 1958 published 1960 CS251 Programming Languages Spring 2017, Lyn Turbak Department of Computer Science
CSE341: Programming Languages Lecture 17 Implementing Languages Including Closures. Dan Grossman Autumn 2018
CSE341: Programming Languages Lecture 17 Implementing Languages Including Closures Dan Grossman Autumn 2018 Typical workflow concrete syntax (string) "(fn x => x + x) 4" Parsing Possible errors / warnings
CMSC 330: Organization of Programming Languages. Lambda Calculus
CMSC 330: Organization of Programming Languages Lambda Calculus 1 100 years ago Albert Einstein proposed special theory of relativity in 1905 In the paper On the Electrodynamics of Moving Bodies 2 Prioritätsstreit,
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
Modules and Representation Invariants
Modules and Representation Invariants COS 326 Andrew W. Appel Princeton University slides copyright 2013-2015 David Walker and Andrew W. Appel In previous classes: Reasoning about individual OCaml expressions.
Functions & First Class Function Values
Functions & First Class Function Values PLAI 1st ed Chapter 4, PLAI 2ed Chapter 5 The concept of a function is itself very close to substitution, and to our with form. Consider the following morph 1 {
Environments
Environments PLAI Chapter 6 Evaluating using substitutions is very inefficient To work around this, we want to use a cache of substitutions. We begin evaluating with no cached substitutions, then collect
Lecture 2: SML Basics
15-150 Lecture 2: SML Basics Lecture by Dan Licata January 19, 2012 I d like to start off by talking about someone named Alfred North Whitehead. With someone named Bertrand Russell, Whitehead wrote Principia
CMSC 330: Organization of Programming Languages. OCaml Imperative Programming
CMSC 330: Organization of Programming Languages OCaml Imperative Programming CMSC330 Spring 2018 1 So Far, Only Functional Programming We haven t given you any way so far to change something in memory
CSE413: Programming Languages and Implementation Racket structs Implementing languages with interpreters Implementing closures
CSE413: Programming Languages and Implementation Racket structs Implementing languages with interpreters Implementing closures Dan Grossman Fall 2014 Hi! I m not Hal J I love this stuff and have taught
The Substitution Model. Nate Foster Spring 2018
The Substitution Model Nate Foster Spring 2018 Review Previously in 3110: simple interpreter for expression language abstract syntax tree (AST) evaluation based on single steps parser and lexer (in lab)
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
CMSC 330: Organization of Programming Languages. Operational Semantics
CMSC 330: Organization of Programming Languages Operational Semantics Notes about Project 4, Parts 1 & 2 Still due today (7/2) Will not be graded until 7/11 (along with Part 3) You are strongly encouraged
COMP 1130 Lambda Calculus. based on slides by Jeff Foster, U Maryland
COMP 1130 Lambda Calculus based on slides by Jeff Foster, U Maryland Motivation Commonly-used programming languages are large and complex ANSI C99 standard: 538 pages ANSI C++ standard: 714 pages Java
(Func&onal (Programming (in (Scheme)))) Jianguo Lu
(Func&onal (Programming (in (Scheme)))) Jianguo Lu 1 Programming paradigms Func&onal No assignment statement No side effect Use recursion Logic OOP AOP 2 What is func&onal programming It is NOT what you
Bindings & Substitution
Bindings & Substitution Even in our simple language, we encounter repeated expressions. 1 {* {+ 4 2} {+ 4 2}} There are several reasons to eliminate duplicated code. It introduces a redundant computation.
CVO103: Programming Languages. Lecture 5 Design and Implementation of PLs (1) Expressions
CVO103: Programming Languages Lecture 5 Design and Implementation of PLs (1) Expressions Hakjoo Oh 2018 Spring Hakjoo Oh CVO103 2018 Spring, Lecture 5 April 3, 2018 1 / 23 Plan Part 1 (Preliminaries):
CMSC 330: Organization of Programming Languages. OCaml Imperative Programming
CMSC 330: Organization of Programming Languages OCaml Imperative Programming CMSC330 Fall 2017 1 So Far, Only Functional Programming We haven t given you any way so far to change something in memory All
Review. CS152: Programming Languages. Lecture 11 STLC Extensions and Related Topics. Let bindings (CBV) Adding Stuff. Booleans and Conditionals
Review CS152: Programming Languages Lecture 11 STLC Extensions and Related Topics e ::= λx. e x ee c v ::= λx. e c (λx. e) v e[v/x] e 1 e 2 e 1 e 2 τ ::= int τ τ Γ ::= Γ,x : τ e 2 e 2 ve 2 ve 2 e[e /x]:
CSE 505: Concepts of Programming Languages
CSE 505: Concepts of Programming Languages Dan Grossman Fall 2003 Lecture 6 Lambda Calculus Dan Grossman CSE505 Fall 2003, Lecture 6 1 Where we are Done: Modeling mutation and local control-flow Proving
M. Snyder, George Mason University LAMBDA CALCULUS. (untyped)
1 LAMBDA CALCULUS (untyped) 2 The Untyped Lambda Calculus (λ) Designed by Alonzo Church (1930s) Turing Complete (Turing was his doctoral student!) Models functions, always as 1-input Definition: terms,
COMP 105 Homework: Type Systems
Due Tuesday, March 29, at 11:59 PM (updated) The purpose of this assignment is to help you learn about type systems. Setup Make a clone of the book code: git clone linux.cs.tufts.edu:/comp/105/build-prove-compare
Ways to implement a language
Interpreters Implemen+ng PLs Most of the course is learning fundamental concepts for using PLs Syntax vs. seman+cs vs. idioms Powerful constructs like closures, first- class objects, iterators (streams),
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
Lecture 3: Recursion; Structural Induction
15-150 Lecture 3: Recursion; Structural Induction Lecture by Dan Licata January 24, 2012 Today, we are going to talk about one of the most important ideas in functional programming, structural recursion
CSE 341 Section 7. Ethan Shea Autumn Adapted from slides by Nicholas Shahan, Dan Grossman, Tam Dang, and Eric Mullen
CSE 341 Section 7 Ethan Shea Autumn 2018 Adapted from slides by Nicholas Shahan, Dan Grossman, Tam Dang, and Eric Mullen Outline Interpreting MUPL Assume Correct Syntax Check for Correct Semantics Evaluating
Principles of Programming Languages
Principles of Programming Languages h"p://www.di.unipi.it/~andrea/dida2ca/plp- 14/ Prof. Andrea Corradini Department of Computer Science, Pisa Lesson 11! Syntax- Directed Transla>on The Structure of the
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
Behavioral Equivalence
Behavioral Equivalence Prof. Clarkson Fall 2015 Today s music: Soul Bossa Nova by Quincy Jones Review Previously in 3110: Functional programming Modular programming Interpreters Imperative and concurrent
Formal Semantics. Prof. Clarkson Fall Today s music: Down to Earth by Peter Gabriel from the WALL-E soundtrack
Formal Semantics Prof. Clarkson Fall 2015 Today s music: Down to Earth by Peter Gabriel from the WALL-E soundtrack Review Previously in 3110: simple interpreter for expression language: abstract syntax
Announcements. Working on requirements this week Work on design, implementation. Types. Lecture 17 CS 169. Outline. Java Types
Announcements Types Working on requirements this week Work on design, implementation Lecture 17 CS 169 Prof. Brewer CS 169 Lecture 16 1 Prof. Brewer CS 169 Lecture 16 2 Outline Type concepts Where do types
Principles of Programming Languages
Principles of Programming Languages h"p://www.di.unipi.it/~andrea/dida2ca/plp- 14/ Prof. Andrea Corradini Department of Computer Science, Pisa Introduc;on to Hakell Lesson 27! 1 The origins: ML programming
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 Expressions and Functions
CMSC 330: Organization of Programming Languages OCaml Expressions and Functions CMSC330 Spring 2018 1 Lecture Presentation Style Our focus: semantics and idioms for OCaml Semantics is what the language
CMSC330. Objects, Functional Programming, and lambda calculus
CMSC330 Objects, Functional Programming, and lambda calculus 1 OOP vs. FP Object-oriented programming (OOP) Computation as interactions between objects Objects encapsulate mutable data (state) Accessed
A Func'onal Space Model
A Func'onal Space Model COS 26 David Walker Princeton University slides copyright 2017 David Walker permission granted to reuse these slides for non-commercial educa'onal purposes 2 Because Halloween draws
CSE 413 Languages & Implementation. Hal Perkins Winter 2019 Structs, Implementing Languages (credits: Dan Grossman, CSE 341)
CSE 413 Languages & Implementation Hal Perkins Winter 2019 Structs, Implementing Languages (credits: Dan Grossman, CSE 341) 1 Goals Representing programs as data Racket structs as a better way to represent
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 *)
Functional Languages. Hwansoo Han
Functional Languages Hwansoo Han Historical Origins Imperative and functional models Alan Turing, Alonzo Church, Stephen Kleene, Emil Post, etc. ~1930s Different formalizations of the notion of an algorithm
Behavioral Equivalence
Behavioral Equivalence Prof. Clarkson Fall 2016 Today s music: Soul Bossa Nova by Quincy Jones Review Previously in 3110: Functional programming Modular programming & software engineering Interpreters
Formal Semantics. Chapter Twenty-Three Modern Programming Languages, 2nd ed. 1
Formal Semantics Chapter Twenty-Three Modern Programming Languages, 2nd ed. 1 Formal Semantics At the beginning of the book we saw formal definitions of syntax with BNF And how to make a BNF that generates
CSE505, Fall 2012, Midterm Examination October 30, 2012
CSE505, Fall 2012, Midterm Examination October 30, 2012 Rules: The exam is closed-book, closed-notes, except for one side of one 8.5x11in piece of paper. Please stop promptly at Noon. You can rip apart
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
The Eval/Apply Cycle Eval. Evaluation and universal machines. Examining the role of Eval. Eval from perspective of language designer
Evaluation and universal machines What is the role of evaluation in defining a language? How can we use evaluation to design a language? The Eval/Apply Cycle Eval Exp & env Apply Proc & args Eval and Apply
Comp 411 Principles of Programming Languages Lecture 7 Meta-interpreters. Corky Cartwright January 26, 2018
Comp 411 Principles of Programming Languages Lecture 7 Meta-interpreters Corky Cartwright January 26, 2018 Denotational Semantics The primary alternative to syntactic semantics is denotational semantics.
CS422 - Programming Language Design
1 CS422 - Programming Language Design Elements of Functional Programming Grigore Roşu Department of Computer Science University of Illinois at Urbana-Champaign 2 The two languages that we defined so far
Lambda Calculus: Implementation Techniques and a Proof. COS 441 Slides 15
Lambda Calculus: Implementation Techniques and a Proof COS 441 Slides 15 Last Time: The Lambda Calculus A language of pure functions: values e ::= x \x.e e e v ::= \x.e With a call-by-value operational
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
Typical workflow. CSE341: Programming Languages. Lecture 17 Implementing Languages Including Closures. Reality more complicated
Typical workflow concrete synta (string) "(fn => + ) 4" Parsing CSE341: Programming Languages abstract synta (tree) Lecture 17 Implementing Languages Including Closures Function Constant + 4 Var Var Type
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: =,
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
> module Lambda where > import Data.List -- I need some standard list functions
Lecture 9 Lambda Calculus We now look at lambda calculus, the theoretical stuff that underlies functional programming. It was introduced by Alonzo Church to formalise two key concepts when dealing with
CS152: Programming Languages. Lecture 7 Lambda Calculus. Dan Grossman Spring 2011
CS152: Programming Languages Lecture 7 Lambda Calculus Dan Grossman Spring 2011 Where we are Done: Syntax, semantics, and equivalence For a language with little more than loops and global variables Now:
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Lambda Calculus CMSC 330 1 Programming Language Features Many features exist simply for convenience Multi-argument functions foo ( a, b, c ) Use currying
A Functional Space Model. COS 326 David Walker Princeton University
A Functional Space Model COS 326 David Walker Princeton University Data type representations: Last Time type tree = Leaf Node of int * tree * tree Leaf: Node(i, left, right): 0 Node 3 left right This Time
CSE 341 Section 7. Eric Mullen Spring Adapted from slides by Nicholas Shahan, Dan Grossman, and Tam Dang
CSE 341 Section 7 Eric Mullen Spring 2017 Adapted from slides by Nicholas Shahan, Dan Grossman, and Tam Dang Outline Interpreting LBI (Language Being Implemented) Assume Correct Syntax Check for Correct
CSE 341, Autumn 2005, Assignment 3 ML - MiniML Interpreter
Due: Thurs October 27, 10:00pm CSE 341, Autumn 2005, Assignment 3 ML - MiniML Interpreter Note: This is a much longer assignment than anything we ve seen up until now. You are given two weeks to complete
Functional Languages. CSE 307 Principles of Programming Languages Stony Brook University
Functional Languages CSE 307 Principles of Programming Languages Stony Brook University http://www.cs.stonybrook.edu/~cse307 1 Historical Origins 2 The imperative and functional models grew out of work
Chapter 11 :: Functional Languages
Chapter 11 :: Functional Languages Programming Language Pragmatics Michael L. Scott Copyright 2016 Elsevier 1 Chapter11_Functional_Languages_4e - Tue November 21, 2017 Historical Origins The imperative
To figure this out we need a more precise understanding of how ML works
Announcements: What are the following numbers: 52/37/19/6 (2:30,3:35,11:15,7:30) PS2 due Thursday 9/22 11:59PM Quiz #1 back in section Monday Quiz #2 at start of class on Thursday 9/22 o HOP s, and lots
CS153: Compilers Lecture 16: Local Optimization II
CS153: Compilers Lecture 16: Local Optimization II Stephen Chong https://www.seas.harvard.edu/courses/cs153 Announcements Project 4 out Due today! Project 5 out Due Tuesday Nov 13 (19 days) Project 6 out
(Refer Slide Time: 01:01)
Principles of Programming Languages Dr. S. Arun Kumar Department of Computer Science & Engineering Indian Institute of Technology, Delhi Lecture - 32 Monomorphism Welcome to lecture 32. So today I will
Intro. Scheme Basics. scm> 5 5. scm>
Intro Let s take some time to talk about LISP. It stands for LISt Processing a way of coding using only lists! It sounds pretty radical, and it is. There are lots of cool things to know about LISP; if
CSE 413 Midterm, May 6, 2011 Sample Solution Page 1 of 8
Question 1. (12 points) For each of the following, what value is printed? (Assume that each group of statements is executed independently in a newly reset Scheme environment.) (a) (define x 1) (define
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
Compilers. Type checking. Yannis Smaragdakis, U. Athens (original slides by Sam
Compilers Type checking Yannis Smaragdakis, U. Athens (original slides by Sam Guyer@Tufts) Summary of parsing Parsing A solid foundation: context-free grammars A simple parser: LL(1) A more powerful parser:
Programming Languages Fall 2013
Programming Languages Fall 2013 Lecture 3: Induction Prof. Liang Huang huang@qc.cs.cuny.edu Recursive Data Types (trees) data Ast = ANum Integer APlus Ast Ast ATimes Ast Ast eval (ANum x) = x eval (ATimes
(Today's lecture is not on the midterm)
Midterm on Wednesday of this week in class 3-4:20pm Tenta=ve loca=on: Friend 101 (we are s.ll checking... will no.fy on Piazza... will direct you on the day) Topics: Possibly revisi.ng ques.ons similar
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
5. Introduction to the Lambda Calculus. Oscar Nierstrasz
5. Introduction to the Lambda Calculus Oscar Nierstrasz Roadmap > What is Computability? Church s Thesis > Lambda Calculus operational semantics > The Church-Rosser Property > Modelling basic programming
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
CS-XXX: Graduate Programming Languages. Lecture 22 Class-Based Object-Oriented Programming. Dan Grossman 2012
CS-XXX: Graduate Programming Languages Lecture 22 Class-Based Object-Oriented Programming Dan Grossman 2012 PL Issues for OOP? OOP lets you: 1. Build some extensible software concisely 2. Exploit an intuitive
CSE341, Spring 2013, Final Examination June 13, 2013
CSE341, Spring 2013, Final Examination June 13, 2013 Please do not turn the page until 8:30. Rules: The exam is closed-book, closed-note, except for both sides of one 8.5x11in piece of paper. Please stop
Lambda Calculus.
Lambda Calculus Oded Padon & Mooly Sagiv (original slides by Kathleen Fisher, John Mitchell, Shachar Itzhaky, S. Tanimoto, Stephen A. Edwards) Benjamin Pierce Types and Programming Languages http://www.cs.cornell.edu/courses/cs3110/2008fa/recitations/rec26.html
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
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
CS 242. Fundamentals. Reading: See last slide
CS 242 Fundamentals Reading: See last slide Syntax and Semantics of Programs Syntax The symbols used to write a program Semantics The actions that occur when a program is executed Programming language
7. Introduction to Denotational Semantics. Oscar Nierstrasz
7. Introduction to Denotational Semantics Oscar Nierstrasz Roadmap > Syntax and Semantics > Semantics of Expressions > Semantics of Assignment > Other Issues References > D. A. Schmidt, Denotational Semantics,
Goal. CS152: Programming Languages. Lecture 15 Parametric Polymorphism. What the Library Likes. What The Client Likes. Start simpler.
Goal Understand what this interface means and why it matters: CS152: Programming Languages Lecture 15 Parametric Polymorphism Dan Grossman Spring 2011 type a mylist; val mt_list : a mylist val cons : a
CSE 505: Programming Languages. Lecture 10 Types. Zach Tatlock Winter 2015
CSE 505: Programming Languages Lecture 10 Types Zach Tatlock Winter 2015 What Are We Doing? Covered a lot of ground! Easy to lose sight of the big picture. Zach Tatlock CSE 505 Winter 2015, Lecture 10
(Refer Slide Time: 00:51)
Programming, Data Structures and Algorithms Prof. Shankar Balachandran Department of Computer Science and Engineering Indian Institute Technology, Madras Module 10 E Lecture 24 Content Example: factorial
Higher-Order Functions
Higher-Order Functions 1 Why Functions as Values Abstraction is easier with functions as values abstract over add and sub cases filter, map, etc. What are objects? Callbacks? Separate deffun form becomes
Verified compilers. Guest lecture for Compiler Construction, Spring Magnus Myréen. Chalmers University of Technology
Guest lecture for Compiler Construction, Spring 2015 Verified compilers Magnus Myréen Chalmers University of Technology Mentions joint work with Ramana Kumar, Michael Norrish, Scott Owens and many more