a functional evaluation modeldpw/courses/cos326-1... · a functional evaluation model 2 in order to...
TRANSCRIPT
![Page 1: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/1.jpg)
A Functional Evaluation Model
COS 326
David Walker
Princeton University
![Page 2: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/2.jpg)
A Functional Evaluation Model
2
In order to be able to write a program, you have to have a solid grasp of how a programming language works.
We often call the definition of “how a programming language works” its semantics.
There are many kinds of programming language semantics.
In this class, we will look at O’Caml’s call-by-value evaluation: – First, informally, giving program rewrite rules by example
– Second, using code, by specifying an OCaml interpreter in OCaml
– Third, more formally, using logical inference rules
In each case, we are specifying what is known as OCaml's operational semantics
![Page 3: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/3.jpg)
O’CAML BASICS: CORE EXPRESSION EVALUATION
![Page 4: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/4.jpg)
Evaluation
• Execution of an O'Caml expression
– produces a value
– and may have some effect (eg: it may raise an exception, print a string, read a file, or store a value in an array)
• A lot of O'Caml expressions have no effect
– they are pure
– they produce a value and do nothing more
– the pure expressions are the easiest kinds of expressions to reason about
• We will focus on evaluation of pure expressions
![Page 5: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/5.jpg)
Evaluation of Pure Expressions
• Given an expression e, we write:
to state that expression e evaluates to value v
• Note that "e --> v" is not itself a program -- it is some notation that we use talk about how programs work
e --> v
![Page 6: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/6.jpg)
Evaluation of Pure Expressions
• Given an expression e, we write:
to state that expression e evaluates to value v
• Some examples:
e --> v
![Page 7: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/7.jpg)
Evaluation of Pure Expressions
• Given an expression e, we write:
to state that expression e evaluates to value v
• Some examples:
1 + 2
e --> v
![Page 8: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/8.jpg)
Evaluation of Pure Expressions
• Given an expression e, we write:
to state that expression e evaluates to value v
• Some examples:
1 + 2 --> 3
e --> v
![Page 9: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/9.jpg)
Evaluation of Pure Expressions
• Given an expression e, we write:
to state that expression e evaluates to value v
• Some examples:
1 + 2 --> 3
2
e --> v
![Page 10: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/10.jpg)
Evaluation of Pure Expressions
• Given an expression e, we write:
to state that expression e evaluates to value v
• Some examples:
1 + 2 --> 3
2 --> 2
e --> v
values step to values
![Page 11: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/11.jpg)
Evaluation of Pure Expressions
• Given an expression e, we write:
to state that expression e evaluates to value v
• Some examples:
1 + 2 --> 3
2 --> 2
int_to_string 5 --> "5"
e --> v
![Page 12: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/12.jpg)
Evaluation of Pure Expressions
More generally, we say expression e (partly) evaluates to expression e’:
e --> e’
![Page 13: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/13.jpg)
Evaluation of Pure Expressions
More generally, we say expression e (partly) evaluates to expression e’:
Evaluation is complete when e’ is a value
– In general, I’ll use the letter “v” to represent an arbitrary value
– The letter “e” represents an arbitrary expression
– Concrete numbers, strings, characters, etc. are all values, as are:
• tuples, where the fields are values
• records, where the fields are values
• datatype constructors applied to a value
• functions
e --> e’
![Page 14: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/14.jpg)
Evaluation of Pure Expressions
• Some expressions (all the interesting ones!) take many steps to evaluate them:
(2 * 3) + (7 * 5)
![Page 15: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/15.jpg)
Evaluation of Pure Expressions
• Some expressions (all the interesting ones!) take many steps to evaluate them:
(2 * 3) + (7 * 5) --> 6 + (7 * 5)
![Page 16: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/16.jpg)
Evaluation of Pure Expressions
• Some expressions (all the interesting ones!) take many steps to evaluate them:
(2 * 3) + (7 * 5) --> 6 + (7 * 5) --> 6 + 35
![Page 17: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/17.jpg)
Evaluation of Pure Expressions
• Some expressions (all the interesting ones!) take many steps to evaluate them:
(2 * 3) + (7 * 5) --> 6 + (7 * 5) --> 6 + 35 --> 41
![Page 18: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/18.jpg)
Evaluation of Pure Expressions
• Some expressions do not compute a value and it is not obvious how to proceed:
• A strongly typed language rules out a lot of nonsensical expressions that compute no value, like the one above
• Other expressions compute no value but raise an exception:
• Still others simply fail to terminate …
"hello" + 1 --> no value!
7 / 0 --> raise Divide_by_zero
![Page 19: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/19.jpg)
Let Expressions: Evaluate using Substitution
19
let x = 30 in
let y = 12 in
x+y
let y = 12 in
30+y
30+12
42
-->
-->
-->
![Page 20: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/20.jpg)
Informal Evaluation Model
20
To evaluate a function call “f a”
• first evaluate f until we get a function value (fun x -> e)
• then evaluate a until we get an argument value v
• then substitute v for x in e, the function body
• then evaluate the resulting expression.
let inc = (fun x -> x+1) in
inc 41 -->
(fun x -> x+1) 41 -->
41+1 -->
42
this is why we say O’Caml is “call by value”
![Page 21: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/21.jpg)
Informal Evaluation Model
21
Another example:
let add x y = x+y in
let inc = add 1 in
let dec = add -1 in
dec(inc 42)
![Page 22: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/22.jpg)
Informal Evaluation Model
22
Recall the syntactic sugar:
let add = fun x -> (fun y -> x+y) in
let inc = add 1 in
let dec = add -1 in
dec(inc 42)
![Page 23: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/23.jpg)
Informal Evaluation Model
23
Then we use the let rule – we substitute the value for add:
let add = fun x -> (fun y -> x+y) in
let inc = add 1 in
let dec = add -1 in
dec(inc 42)
-->
let inc = (fun x -> (fun y -> x+y)) 1 in
let dec = (fun x -> (fun y -> x+y)) -1 in
dec(inc 42)
functions are values
![Page 24: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/24.jpg)
Informal Evaluation Model
24
let inc = (fun x -> (fun y -> x+y)) 1 in
let dec = (fun x -> (fun y -> x+y)) -1 in
dec(inc 42)
-->
let inc = fun y -> 1+y in
let dec = (fun x -> (fun y -> x+y)) -1 in
dec(inc 42)
not a value; must reduce before substituting for inc
![Page 25: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/25.jpg)
Informal Evaluation Model
25
let inc = fun y -> 1+y in
let dec = (fun x -> (fun y -> x+y)) -1 in
dec(inc 42)
-->
let dec = (fun x -> (fun y -> x+y)) -1 in
dec((fun y -> 1+y) 42)
now a value
![Page 26: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/26.jpg)
Informal Evaluation Model
26
Next: simplify dec’s definition using the function-call rule.
let dec = (fun x -> (fun y -> x+y)) -1 in
dec((fun y -> 1+y) 42)
-->
let dec = fun y -> -1+y in
dec((fun y -> 1+y) 42)
now a value
![Page 27: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/27.jpg)
Informal Evaluation Model
27
And we can use the let-rule now to substitute dec:
let dec = fun y -> -1+y in
dec((fun y -> 1+y) 42) -->
(fun y -> -1+y) ((fun y -> 1+y) 42)
![Page 28: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/28.jpg)
Informal Evaluation Model
28
Now we can’t yet apply the first function because the argument is not yet a value – it’s a function call. So we need to use the function-call rule to simplify it to a value:
(fun y -> -1+y) ((fun y -> 1+y) 42) -->
(fun y -> -1+y) (1+42) -->
(fun y -> -1+y) 43 -->
-1+43 -->
42
![Page 29: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/29.jpg)
Variable Renaming
29
Consider the following Ocaml code:
let x = 30 in
let y = 12 in
x+y;;
Does this evaluate any differently than the following?
let a = 30 in
let b = 12 in
a+b;;
![Page 30: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/30.jpg)
Renaming
30
A basic principle of programs is that systematically changing the names of variables shouldn’t cause the program to behave any differently – it should evaluate to the same thing.
let x = 30 in
let y = 12 in
x+y;;
But we do have to be careful about systematic change.
let a = 30 in
let a = 12 in
a+a;;
Systematic change of variable names is called alpha-conversion.
![Page 31: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/31.jpg)
Substitution
31
Wait a minute, how do we evaluate this using the let-rule? If we substitute 30 for “a” naively, then we get:
let a = 30 in
let a = 12 in
a+a -->
let 30 = 12 in
30+30
Which makes no sense at all! Besides, Ocaml returns 24 not 60. What went wrong with our informal model?
![Page 32: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/32.jpg)
Scope and Modularity
32
• Lexically scoped (a.k.a. statically scoped) variables have a simple rule: the nearest enclosing “let” in the code defines the variable.
• So when we write:
let a = 30 in
let a = 12 in
a+a;;
• we know that the “a+a” corresponds to “12+12” as opposed to “30+30” or even weirder “30+12”.
![Page 33: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/33.jpg)
A Revised Let-Rule:
33
• To evaluate “let x = e1 in e2”: – First, evaluate e1 to a value v.
– Then substitute v for the corresponding uses of x in e2.
– Then evaluate the resulting expression.
let a = 30 in
let a = 12 in
a+a
-->
let a = 12 in
a+a
-->
12+12
-->
24
This “a” doesn’t correspond to the uses of “a” below.
So when we substitute 30 for it, it
doesn’t change anything.
![Page 34: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/34.jpg)
Scope and Modularity
34
• But what does “corresponding uses” mean?
• Consider:
let a = 30 in
let a = (let a = 3 in a*4) in
a+a;;
![Page 35: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/35.jpg)
Abstract Syntax Trees
35
• We can view a program as a tree – the parentheses and precedence rules of the language help determine the structure of the tree.
let
a 30 let
a let +
a 3 *
let a = 30 in
let a =
(let a = 3 in a*4)
in
a+a;;
==
(let a = (30) in
(let a =
(let a = (3) in (a*4))
in
(a+a)))
a a
a 4
![Page 36: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/36.jpg)
Binding Occurrences
36
• An occurrence of a variable where we are defining it via let is said to be a binding occurrence of the variable.
let
a 30 let
a let +
a 3 *
let a = 30 in
let a = (let a = 3 in a*4) in
a+a;;
a a
a 4
![Page 37: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/37.jpg)
Free Occurrences
37
• A non-binding occurrence of a variable is said to be a free variable.
• That is a use of a variable as opposed to a definition.
let
a 30 let
a let +
a 3 *
let a = 30 in
let a = (let a = 3 in a*4) in
a+a;;
a a
a 4
![Page 38: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/38.jpg)
Abstract Syntax Trees
38
• Given a free variable occurrence, we can find where it is bound by …
let
a 30 let
a let +
a 3 *
let a = 30 in
let a = (let a = 3 in a*4) in
a+a;;
a a
a 4
![Page 39: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/39.jpg)
Abstract Syntax Trees
39
• crawling up the tree to the nearest enclosing let…
let
a 30 let
a let +
a 3 *
let a = 30 in
let a = (let a = 3 in a*4) in
a+a;;
a a
a 4
![Page 40: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/40.jpg)
Abstract Syntax Trees
40
• crawling up the tree to the nearest enclosing let…
let
a 30 let
a let +
a 3 *
let a = 30 in
let a = (let a = 3 in a*4) in
a+a;;
a a
a 4
![Page 41: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/41.jpg)
Abstract Syntax Trees
41
• crawling up the tree to the nearest enclosing let…
let
a 30 let
a let +
a 3 *
let a = 30 in
let a = (let a = 3 in a*4) in
a+a;;
a a
a 4
![Page 42: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/42.jpg)
Abstract Syntax Trees
42
• and see if the “let” binds the variable – if so, we’ve found the nearest enclosing definition. If not, we keep going up.
let
a 30 let
a let +
a 3 *
let a = 30 in
let a = (let a = 3 in a*4) in
a+a;;
a a
a 4
![Page 43: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/43.jpg)
Abstract Syntax Trees
43
• Now we can also systematically rename the variables so that it’s not so confusing. Systematic renaming is called alpha-conversion
let
a 30 let
a let +
a 3 *
let a = 30 in
let a = (let a = 3 in a*4) in
a+a;;
a a
a 4
![Page 44: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/44.jpg)
Abstract Syntax Trees
44
• Start with a let, and pick a fresh variable name, say “x”
let
a 30 let
a let +
a 3 *
let a = 30 in
let a = (let a = 3 in a*4) in
a+a;;
a a
a 4
![Page 45: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/45.jpg)
Abstract Syntax Trees
45
• Rename the binding occurrence from “a” to “x”.
let
x 30 let
a let +
a 3 *
let x = 30 in
let a = (let a = 3 in a*4) in
a+a;;
a a
a 4
![Page 46: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/46.jpg)
Abstract Syntax Trees
46
• Then rename all of the free occurrences of the variables that this let binds.
let
x 30 let
a let +
a 3 *
let x = 30 in
let a = (let a = 3 in a*4) in
a+a;;
a a
a 4
![Page 47: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/47.jpg)
Abstract Syntax Trees
47
• There are none in this case!
let
x 30 let
a let +
a 3 *
let x = 30 in
let a = (let a = 3 in a*4) in
a+a;;
a a
a 4
These a’s are bound by this let.
![Page 48: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/48.jpg)
Abstract Syntax Trees
48
• There are none in this case!
let
x 30 let
a let +
a 3 *
let x = 30 in
let a = (let a = 3 in a*4) in
a+a;;
a a
a 4
This a is bound by
this let
![Page 49: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/49.jpg)
Abstract Syntax Trees
49
• Let’s do another let, renaming “a” to “y”.
let
x 30 let
a let +
a 3 *
let x = 30 in
let a = (let a = 3 in a*4) in
a+a;;
a a
a 4
![Page 50: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/50.jpg)
Abstract Syntax Trees
50
• Let’s do another let, renaming “a” to “y”.
let
x 30 let
y let +
a 3 *
let x = 30 in
let y = (let a = 3 in a*4) in
y+y;;
y y
a 4
![Page 51: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/51.jpg)
Abstract Syntax Trees
51
• And if we rename the other let to “z”:
let
x 30 let
y let +
a 3 *
let x = 30 in
let y = (let a = 3 in a*4) in
y+y;;
y y
a 4
![Page 52: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/52.jpg)
Abstract Syntax Trees
52
• And if we rename the other let to “z”:
let
x 30 let
y let +
z 3 *
let x = 30 in
let y = (let z = 3 in z*4) in
y+y;;
y y
z 4
![Page 53: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/53.jpg)
AN O’CAML DEFINITION OF O’CAML EVALUATION
![Page 54: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/54.jpg)
type variable = string ;;
type operand = 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 ;;
Making These Ideas Precise
54
• We can define a datatype for Ocaml expressions
![Page 55: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/55.jpg)
Making These Ideas Precise
55
• We can define a datatype for Ocaml expressions
type variable = string ;;
type operand = 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 ;;
let three = Int_e 3 ;;
let three_plus_one =
Op_e (Int_e 1, Plus, Int_e 3) ;;
![Page 56: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/56.jpg)
Making These Ideas Precise
56
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”)
![Page 57: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/57.jpg)
Making These Ideas Precise
57
Notice 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
![Page 58: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/58.jpg)
Free versus Bound Variables
58
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 free occurrence of a variable
![Page 59: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/59.jpg)
Free versus Bound Variables
59
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 binding occurrence of a variable
This is a free occurrence of a variable
![Page 60: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/60.jpg)
A Simple Evaluator
60
let is_value (e:exp) : bool =
match e with
| Int_e _ -> true
| (Op_e (_,_,_) | Let_e(_,_,_) | Var_e _) -> false
let eval_op v1 op v2 = …
let substitute v x e = …
let rec eval (e:exp) : exp =
match e with
| 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 e = substitute v1 x e2 in
eval e
![Page 61: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/61.jpg)
Even Simpler
61
let eval_op v1 op v2 = …
let substitute v x e = …
let rec eval (e:exp) : exp =
match e with
| 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)
![Page 62: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/62.jpg)
Oops! We Missed a Case:
62
let eval_op v1 op v2 = …
let substitute v x e = …
let rec eval (e:exp) : exp =
match e with
| 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 substituted with a value! (This is a type-error.)
![Page 63: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/63.jpg)
We Could Use Options:
63
let eval_op v1 op v2 = …
let substitute v x e = …
let rec eval (e:exp) : exp option =
match e with
| 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!
![Page 64: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/64.jpg)
Exceptions
64
exception UnboundVariable of variable ;;
let rec eval (e:exp) : exp =
match e with
| 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 exception.
![Page 65: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/65.jpg)
Exceptions
65
exception UnboundVariable of variable ;;
let rec eval (e:exp) : exp =
match e with
| 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 exception declaration is a lot like a datatype declaration. Really, we are extending one big datatype (exn) with a new constructor (UnboundVariable).
![Page 66: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/66.jpg)
Exceptions
66
exception UnboundVariable of variable ;;
let rec eval (e:exp) : exp =
match e with
| 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)
Later on, we’ll see how to catch an exception.
![Page 67: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/67.jpg)
Back to our Evaluator
67
let eval_op v1 op v2 = …
let substitute v x e = …
let rec eval (e:exp) : exp =
match e with
| 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) ;;
![Page 68: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/68.jpg)
Evaluating the Primitive Operations
68
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)
…;;
let substitute v x e = …
let rec eval (e:exp) : exp =
match e with
| 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) ;;
![Page 69: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/69.jpg)
Substitution
69
let substitute (v:exp) (x:variable) (e:exp) : exp =
let rec subst (e:exp) : exp =
match e with
| 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)
in
subst e
;;
let rec eval (e:exp) : exp =
match e with
| 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) ;;
![Page 70: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/70.jpg)
Substitution
70
let substitute (v:exp) (x:variable) (e:exp) : exp =
let rec subst (e:exp) : exp =
match e with
| 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)
in
subst e
;;
let rec eval (e:exp) : exp =
match e with
| 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) ;;
We want to replace x (and only x) with v.
![Page 71: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/71.jpg)
Substitution
71
let substitute (v:exp) (x:variable) (e:exp) : exp =
let rec subst (e:exp) : exp =
match e with
| 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) in
subst e
;;
let rec eval (e:exp) : exp =
match e with
| 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) ;;
If x and y are the same
variable, then y shadows x.
![Page 72: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/72.jpg)
Let us Scale up the Language
72
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 =
match e with
| Int_e _ -> true
| Fun_e (_,_) -> true
| (Op_e (_,_,_) | Let_e (_,_,_) |
Var_e _ | FunCall_e (_,_)) -> false ;;
![Page 73: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/73.jpg)
Let us Scale up the Language
73
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 =
match e with
| Int_e _ -> true
| Fun_e (_,_) -> true
| (Op_e (_,_,_) | Let_e (_,_,_) |
Var_e _ | FunCall_e (_,_)) -> false ;;
(fun x -> e) is represented as
Fun_e(x,e)
![Page 74: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/74.jpg)
Let us Scale up the Language
74
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 =
match e with
| Int_e _ -> true
| Fun_e (_,_) -> true
| (Op_e (_,_,_) | Let_e (_,_,_) |
Var_e _ | FunCall_e (_,_)) -> false ;;
A function call (e.g., fact 3) is represented
using a FunCall_e
![Page 75: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/75.jpg)
Let us Scale up the Language
75
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 =
match e with
| Int_e _ -> true
| Fun_e (_,_) -> true
| (Op_e (_,_,_) | Let_e (_,_,_) |
Var_e _ | FunCall_e (_,_)) -> false ;;
fact 3 is represented as: FunCall_e(Var_e “fact”, Int_e 3) append x y is the same as (append x) y and represented as: FunCall_e ( FunCall_e (Var_e “append”, Var_e “x”), Var_e “y”)
![Page 76: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/76.jpg)
Let us Scale up the Language:
76
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 =
match e with
| Int_e _ -> true
| Fun_e (_,_) -> true
| (Op_e (_,_,_) | Let_e (_,_,_) |
Var_e _ | FunCall_e (_,_)) -> false ;;
Functions are values!
![Page 77: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/77.jpg)
Let us Scale up the Language:
77
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 =
match e with
| Int_e _ -> true
| Fun_e (_,_) -> true
| (Op_e (_,_,_) | Let_e (_,_,_) |
Var_e _ | FunCall_e (_,_)) -> false ;;
Function calls are not values.
![Page 78: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/78.jpg)
Let us Scale up the Language:
78
let rec eval (e:exp) : exp =
match e with
| 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)
![Page 79: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/79.jpg)
Let us Scale up the Language:
79
let rec eval (e:exp) : exp =
match e with
| 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 functions) always
evaluate to themselves.
![Page 80: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/80.jpg)
Let us Scale up the Language:
80
let rec eval (e:exp) : exp =
match e with
| 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 function call, we
first evaluate both e1 and e2 to
values.
![Page 81: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/81.jpg)
Let us Scale up the Language
81
let rec eval (e:exp) : exp =
match e with
| 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 better evaluate to a
function value, else we have a
type error.
![Page 82: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/82.jpg)
Let us Scale up the Language
82
let rec eval (e:exp) : exp =
match e with
| 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 substitute e2’s
value (v2) for x in e and evaluate the resulting expression.
![Page 83: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/83.jpg)
Simplifying a little
83
let rec eval (e:exp) : exp =
match e with
| 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)
![Page 84: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/84.jpg)
Simplifying a little
84
let rec eval (e:exp) : exp =
match e with
| 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)
This looks like the case for let!
![Page 85: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/85.jpg)
Let and Lambda
85
let x = 1 in
x+41
-->
1+41
-->
42
(fun x -> x+41) 1
-->
1+41
-->
42
![Page 86: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/86.jpg)
So we could write:
86
let rec eval (e:exp) : exp =
match e with
| 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)
![Page 87: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/87.jpg)
Alternatively:
87
let rec eval (e:exp) : exp =
match e with
| 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_e (Fun_e(x,e2)) e1)
| 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)
Or we can turn let’s into
function calls!
![Page 88: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/88.jpg)
Recursive definitions
88
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
| LetRec_e of variable * exp * exp ;;
let rec f x = f (x+1) in f 3
let rec f = fun x -> f (x+1) in f 3
LetRec_e (“f”,
Fun_e (“x”,
FunCall_e (Var_e “f”,
Op_e (Var_e “x”, Plus, Int_e 1)
)
),
FunCall (Var_e “f”, Int_e 3)
)
(rewrite)
(implement)
Example:
let rec f = fun x -> f (x+1) in f 3
LetRec_e (“f”,
Fun_e (“x”,
FunCall_e (Var_e “f”,
Op_e (Var_e “x”, Plus, Int_e 1)
)
),
FunCall (Var_e “f”, Int_e 3)
)
![Page 89: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/89.jpg)
Recursive definitions
89
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
| LetRec_e of variable * exp * exp ;;
let is_value (e:exp) : bool =
match e with
| Int_e _ -> true
| Fun_e (_,_) -> true
| (Op_e (_,_,_) | Let_e (_,_,_) |
Var_e _ | FunCall_e (_,_) | LetRec_e of (_,_,_)) -> false ;;
![Page 90: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/90.jpg)
Evaluating Letrec
90
let rec f =
fun x -> f (x+1)
in f 3
let rec f =
fun x -> (let rec f = fun x -> f (x+1) in f) (x+1)
in f 3
let f =
fun x -> (let rec f = fun x -> f (x+1) in f) (x+1)
in f 3
Start out with a recursive let:
Unwind/unroll the recursion one time:
Replace the recursive let with a normal let:
(fun x -> (let rec f = fun x -> f (x+1) in f) (x+1)) 3 Evaluate the normal let definition:
![Page 91: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/91.jpg)
Evaluating Letrec
91
let rec eval (e:exp) : exp =
match e with
| 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) ->
let e1_unwound =
substitute (LetRec_e (x,e1,Var x)) x e1 in
eval (Let_e (x, e1_unwound, e2))
![Page 92: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/92.jpg)
Evaluating Letrec
92
let rec eval (e:exp) : exp =
match e with
| 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) ->
let e1_unwound =
substitute (LetRec_e (x,e1,Var x)) x e1 in
eval (Let_e (x, e1_unwound, e2))
We’re unrolling the recursive function once by substituting
LetRec_e (x,e1,var x) for x.
![Page 93: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/93.jpg)
Evaluating Letrec
93
Once it’s unwound, it’s no longer recursive. So we can evaluate it like a
normal let.
let rec eval (e:exp) : exp =
match e with
| 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) ->
let e1_unwound =
substitute (LetRec_e (x,e1,Var x)) x e1 in
eval (Let_e (x, e1_unwound, e2))
![Page 94: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/94.jpg)
Another Example of Unwinding Letrec
94
let rec fact n = if n < 1 then 1 else n * fact(n-1) in
fact 3
==
let rec fact =
fun n -> if n < 1 then 1 else n * fact(n-1) in
fact 3
==>
let fact =
fun n -> if n < 1 then 1 else n *
(let rec fact = fun n -> if … in fact) (n-1) in
fact 3
==>
if 3 < 1 then 1 else 3 *
(let rec fact = fun n -> if … in fact) (3-1)
![Page 95: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/95.jpg)
A MATHEMATICAL DEFINITION* OF O’CAML EVALUATION
* it’s a partial definition and this is a big topic; for more, see COS 441
![Page 96: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/96.jpg)
From Code to Abstract Specification
• the O’Caml code is one kind of specification of a language
– advantage: it can be executed, so we can try it out
– advantage: it is amazingly concise
• especially compared to what you would have written in Java
– disadvantage: it is a little ugly to operate over concrete ML datatypes like “Op_e(e1,Plus,e2)” as opposed to “e1 + e2”
• PL researchers have developed their own, relatively standard notation for writing down how programs execute
– it has a mathematical “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 notation if you want to read specifications of programming language semantics
• eg: Standard ML (of which O’Caml is a descent) has a formal definition given in this notation
![Page 97: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/97.jpg)
Notation for Substitution
• Programming languages are defined using substitution so often that PL researchers have a special notation for it
– (actually, we have like 6 notations for it; I’ll just give you one)
• To substitute, value v for free variable x in expression e:
• Examples:
e [v/x]
(x + y) [7/y] is (x + y) (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)
![Page 98: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/98.jpg)
Rules
• Our goal is to explain how an expression e evaluates to a value v.
• We are going to do so using a set of (inductive) rules
• A rule looks like this:
• You read a rule like this:
– “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”
premise 1 premise 2 ... premise 3 conclusion
![Page 99: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/99.jpg)
An example rule concerning evaluation
e1 ==> v1 e2 ==> v2 eval_op (v1, op, v2) == v’ e1 op e2 ==> v’
let rec eval (e:exp) : exp =
match e with
...
| Op_e(e1,op,e2) -> eval_op (eval e1) op (eval e2)
“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’
As a rule:
In English:
In code:
![Page 100: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/100.jpg)
An example rule concerning evaluation
i ϵ i --> i
let rec eval (e:exp) : exp =
match e with
| Int_e i -> Int_e i
...
“If the expression is an integer, it evaluates to itself.”
As a rule:
In English:
In code:
asserts i is an integer
![Page 101: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/101.jpg)
An example rule concerning evaluation
e1 --> v1 e2 [v1/x] --> v2 let x = e1 in e2 --> v2
let rec eval (e:exp) : exp =
match e with
...
| Let_e(x,e1,e2) -> eval (substitute (eval e1) x e2)
...
“If e1 evaluates to v1 and e2 with v1 substituted for x evaluates to v2 then let x=e1 in e2 evaluates to v2.”
As a rule:
In English:
In code:
![Page 102: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/102.jpg)
An example rule concerning evaluation
λx.e --> λx.e
let rec eval (e:exp) : exp =
match e with
...
| Fun_e (x,e) -> Fun_e (x,e)
...
“A function evaluates to itself.”
As a rule:
In English:
In code:
typical “lambda” notation for a function with argument x, body e
![Page 103: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/103.jpg)
An example rule concerning evaluation
e1 --> λx.e e2 --> v2 e[v2/x] --> v e1 e2 --> v
let rec eval (e:exp) : exp =
match e with
..
| FunCall_e (e1,e2) ->
(match eval e1
| Fun_e (x,e) -> eval (Let_e (x,e2,e))
| _ -> raise TypeError)
...
“if e1 evaluates to a function with argument x and body e and e2 evaluates to a value v2 and e with v2 substituted for x evaluates to v then e1 applied to e2 evaluates to v”
As a rule:
In English:
In code:
![Page 104: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/104.jpg)
An example rule concerning evaluation
eu == e1[letrec x = e1 in x / x] let x = eu in e2 --> v letrec x = e1 in e2 --> v
let rec eval (e:exp) : exp =
match e with
..
| LetRec_e (x,e1,e2) ->
let e1_unwound =
substitute (LetRec_e (x,e1,Var x)) x e1 in
eval (Let_e (x, e1_unwound, e2))
“uggh”
As a rule:
In English:
In code:
![Page 105: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/105.jpg)
Comparison: Code vs. Rules
Almost isomorphic:
– one rule per pattern-matching clause
– recursive call to eval whenever there is a --> premise in a rule
– what’s the main difference?
let rec eval (e:exp) : exp =
match e with
| 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) ->
let e1_unwound =
substitute (LetRec_e (x,e1,Var x)) x e1 in
eval (Let_e (x, e1_unwound, e2)) eu == e1[letrec x = e1 in x / x] let x = eu in e2 --> v letrec x = e1 in e2 --> v
e1 --> v1 e2 --> v2 eval_op (v1, op, v2) == v e1 op e2 --> v
i ϵ i --> i
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
complete eval code: complete set of rules:
![Page 106: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/106.jpg)
Comparison: Code vs. Rules
• There’s no rule for handling free variables
• No rule for evaluating function calls when a non-function in the caller position
• In general, no rule when further evaluation is impossible
– the rules express the legal evaluations and say nothing about what to do in error situations
– the code handles the error situations by raising exceptions
let rec eval (e:exp) : exp =
match e with
| 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) ->
let e1_unwound =
substitute (LetRec_e (x,e1,Var x)) x e1 in
eval (Let_e (x, e1_unwound, e2)) eu == e1[letrec x = e1 in x / x] let x = eu in e2 --> v letrec x = e1 in e2 --> v
e1 --> v1 e2 --> v2 eval_op (v1, op, v2) == v e1 op e2 --> v
i ϵ i --> i
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
complete eval code: complete set of rules:
![Page 107: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/107.jpg)
Summary
107
• We can reason about Ocaml programs using a substitution model. – integers, bools, strings, chars, and functions are values – value rule: values evaluate to themselves – let rule: “let x = e1 in e2” : substitute e1’s value for x into e2 – fun call rule: “(fun x -> e2) e1”: substitute e1’s value for x into e2 – let-rec rule: “let rec x = e1 in e2” : unwind e1 once, then evaluate
using the same rule as let. • To unwind: substitute (let rec x = e1 in x) for x in e1
• Substitution is tricky – follow the rule of lexical scope – substitute for only those free occurrences that correspond to the
bound variable. (i.e., respect shadowing)
• We can make the evaluation model precise by building an interpreter and using that interpreter as a specification of the language semantics.
• We can also specify the evaluation model using a set of inference rules – more on this in COS 441
![Page 108: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/108.jpg)
Some Final Words
108
• The substitution model is only a model. – it does not accurately model all of Ocaml’s features
• I/O, exceptions, mutation, concurrency, …
• we can build models of these things, but they aren’t as simple.
• even substitution was tricky to formalize!
• It’s useful for reasoning about higher-order functions, correctness of algorithms, and optimizations. – we can use it to formally prove that, for instance:
• map f (map g xs) == map (comp f g) xs
• proof: by induction on the length of the list xs, using the definitions of the substitution model.
– we often model complicated systems (e.g., protocols) using a small functional language and substitution-based evaluation.
• It is not useful for reasoning about program execution time or space
![Page 109: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/109.jpg)
Some Exercises
109
Complete the following expressions so they evaluate to 42 or explain why this is impossible, appealing to the substitution model.
let x = ??? in let x = fun x -> x*2 in
let x = 43 in let x = ??? 21 in
x ;; x ;;
let x = ??? in
let y = (let x = 21 in x+x) in
x ;;
let x = ??? in
let y = [42] in
x y ;;
![Page 110: A Functional Evaluation Modeldpw/courses/cos326-1... · A Functional Evaluation Model 2 In order to be able to write a program, you have to have a solid grasp of how a programming](https://reader034.vdocuments.net/reader034/viewer/2022051814/60363707289c62170762793b/html5/thumbnails/110.jpg)
END