So far, you've seen the basic intuition 
behind local expressions and you've seen 
how the concepts of lexical scoping and 
scope contours allow us to know exactly 
which definition provides the value for a 
constant reference or a function call But 
we don't yet have a precise model for how 
Local is evaluated. 
And without that model, we can't know the 
exact value of locally defined constants, 
When they appear inside of function 
definitions. 
So what I'm going to do in this video is 
show you the exact evaluation rules for 
Local. 
And we'll just work through that step by 
step. 
And this is going to be really important 
for the way that we use locals, when we 
get to function abstraction. 
In this video, I'm going to talk about 
the actual evaluation rules for local 
expressions. 
And I'm going to do that because it'll 
help you understand some of the ways that 
we're going to be making use of local in. 
Function abstraction a little bit later 
in the course. 
So here we go. 
I've got another example here. 
This one is slightly simpler than the 
super complicated one we saw last time. 
but it's complicated enough to talk about 
what we need to talk about here. 
So, you know, intuitively, we could see 
what's going on here; that b and that b B 
are the outer b. 
And both of those inner b's are the inner 
b. 
So that's plus 1 times 2 2 is 4. 
So plus 1 4 and 1. 
Pretty sure that's 6. 
It is. 
Well let's talk about how, ISL actually 
evaluates the local expression. 
So the first thing to remember is that 
Local is an expression. 
It doesn't affect the evaulation of 
expressions outside of it. 
All expressions are like that. 
So let's start by evaluating this whole 
expression, open paren plus. 
Plus is the name of a primative 
operation. 
So this is a call to a primative 
operation. 
We need to reduce the three operands: 
this b, this local expression, and that b 
to values. 
We start with the first one? 
Is it a value? 
No it's not. 
It's a reference to a defined constant. 
We happen to be using lower-case names 
here, but that's a style guide issue, not 
a language issue. 
So B is going to be replaced by ones, so 
the first evaluation step is just that b 
gets replaced by one. 
Nothing's happened with the local yet. 
We haven't seen it yet. 
Okay now let's do this local. 
Now the way local evaluation works is 
that three things are going to happen in 
one step. 
See? 
There's going to be a thing called 
renaming. 
There's going to be a thing called 
lifting. 
And then we're going to replace the 
entire local expression with its renamed 
body. 
Let's first talk about the renaming. 
The first thing we do is we take every 
definition in the local. 
In this case there's just one, define b. 
And we find all the references to that 
definition, in this case there's these 
two. 
We can either do that ourselves or we can 
use check syntax to help us. 
There's those two definitions. 
And now we come up with a new, globally 
unique name for b. 
What I'll do is I'll make a copy to work 
in. 
Just to keep it simple, what I'm going to 
do is, I'm going to rename b to b 
underscore 0. 
And at the time I do that I'm going to 
rename all the references to be, to be 
_0. 
Now, if the _0 already existed I would 
use something else. 
The key thing is it has to be a unique 
name. 
There can be no other definition in the 
world that has this name. 
Okay. 
Technically there could be no other 
definition in the top level scope that 
has this name. 
And, technically, the actually, the 
renaming works in a more subtle way, but 
this explanation is good enough to 
understand the valuation of any program 
we're going to write. 
Now that I've done the renaming, I do 
another thing, which is that I take the 
renamed definition and I lift it out of 
the local, so that it's now in the top 
level scope. 
And notice I don't lift it just out of 
the local. 
I didn't put it here. 
I did not put it there. 
I have to lift it all the way to top 
level. 
I lifted it all the way to top level. 
If you want you could go put it all the 
way up here with the other definitions. 
You don't have to do that. 
It really just has to go to top level. 
So I did the renaming. 
I did the lifting. 
Now the third step is I replace the local 
with the body in which the renaming has 
happened. 
And now notice something important. 
There's no local anymore. 
The local is gone. 
That's the same kind of thing we saw with 
if and cod. 
If tried to put itself out of the way. 
It evaluated the question, and then it 
replaced itself with either the true 
answer expression or the false answer 
expression. 
That's what's happening here. 
The rules for evaluating local or trying 
to make the local go away, so that it 
will have a program in BSL. 
This is now a BSL program, it's not an 
ISL program anymore. 
Local is gone. 
And so now we just keep evaluating and of 
course, since it's a BSL program it's 
quite straight forward, let's see which 
B0 is this. 
This. 
Well, it's that b0, so this will become 
in the next step, that b0 will become 
two. 
In the step after that, the next b0 will 
become two. 
In the step after that The times 2 2 will 
become 4. 
And the step after that, this b, well 
which b is that? 
That's this one way up at the top here. 
That's going to become 1. 
Whoops, I need to actually do the step. 
Yeah, that's going to become 1. 
And in the final step, that whole thing 
is going to become six. 
The key thing about the step by step 
evaluation or about the evaluation rules 
for local expression is, when you get to 
the local, first you rename Each 
definition and all of the references to a 
globally unique name. 
So if there were multiple definitions 
here, you would do this for all the 
definitions. 
For this case, we renamed B to B zero. 
We renamed the references also to B zero. 
Then you lift the definition to top 
level. 
There it is. 
And then you replace the local by it's 
body. 
So that's the rules for evaluating a 
local. 
Rename, lift, replace the local with it's 
body. 
You should practice that because 
understanding how we're going to use 
local in abstract functions. 
Is going to require having this 
understanding of local. 
You need to understand how to form a 
local. 
You need to understand the rules of 
lexical scoping, the contour rules, and 
you need to understand the rules for 
evaluating a local. 
Just practice it and do these exercises 
coming up.