Binding and scoping

The assignment, from Lecture 4

1. In domains.py, add "^" to the OP terminal and bind it to power in create_initial_env.
2. Check that evaluate did not need any change.

Two lines, and evaluate does not change.

The assignment, from Lecture 4

1. Bind ten to 10 in the initial environment: it is a DVal too.
2. Add an IDENTIFIER terminal, a rule for it in mono, a node Var(name) and its case in evaluate.
3. Write the equation for Var first, then the code.
4. What should + + 1 and ten(1, 2) do? Which stage reports each error?

A name is one more kind of mono: it can stand wherever a number can.

IDENTIFIER is a letter or _, followed by letters, digits and _: the same rule as for Python names.

The parse tree has a node var, which becomes a Var in the AST.

The value of a name is what the environment says it stands for.

The check is the mirror of the one for operators: a name used as a value must stand for a number.

+ + 1 and ten(1, 2) are syntax errors: the parser rejects them, before any environment is involved.

The same expression written three times is three chances to make a mistake, and three times the work.

The second line computes it once, gives the result a name, and uses the name.

It also says something to the reader: these three are the same thing.

The rules of Lecture 4 move one level down, into arith. Above them, an expression is a let or an arithmetic expression.

The definition and the body of a let are expr: they can contain other lets.

Since let is above arith, it cannot be an operand: 1 + let x = 2 in x is a syntax error. Write 1 + (let x = 2 in x).

"let", "=" and "in" are anonymous strings: they do not appear in the parse tree.

The body goes as far to the right as it can. In the first line it is x + 2, not x.

The left side of bin is an arith, so it cannot be a let: let x = 1 in x followed by + 2 is not a way to read the first line. There is one parse tree only.

A let inside arithmetic needs parentheses.

OCaml accepts 2 + let y = 3 in y. We chose a smaller grammar with no ambiguity; the price is some parentheses.

Without the first part, let and in would also match IDENTIFIER, and let in = 3 in in would be a program.

(?!...) means "not followed by": a name cannot start with the word let or the word in. \b is the end of a word, so inside and let1 are still names.

Python has 35 reserved words: if, def, lambda, ... Try lambda = 3 in Python.

One new node, with the three parts of a let.

The name is a string, not an expression: let 3 = x in ... is not a program.

The Let case is the equation, line by line.

Compute the definition in env. Build a new environment with bind. Compute the body in it.

This is the use of bind announced in Lecture 4: env is not changed, and the code after the let still sees it as it was.

The second x is outside the parentheses, so outside the body: it is not in the scope of the let.

Undefined identifier: x
      

When the let is done, evaluate goes back to the environment it had, which does not contain x. Nothing needs to be removed.

In let x = x + 1 in ..., the x of the definition is computed in \( \rho \), before x is bound.

If an outer x exists, the definition uses it: in the second line, the inner x is 1 + 10.

A let whose definition sees its own name is a recursive binding. Recursive functions need it; we will come back to it.

In let x = 1 in let x = x + 10 in x * 2 there are two bindings of x. In x * 2, the inner one wins.

The outer binding is shadowed: it still exists, but in the inner body it cannot be reached by its name.

lookup stops at the first environment that knows the name. Shadowing needs no code of its own.

An occurrence of a name is bound if it is in the scope of a let for that name; otherwise it is free.

The free names are those the expression needs from outside: its value depends on what the environment says about them.

In the third line, the first x after = is free, the last one is bound.

A function with the same structure as evaluate: one case per node, recursion on the children.

The Let case follows the scope: the definition counts in full, the body without the bound name.

It does not need an environment and does not compute anything: it only reads the text. A program with no free names is closed, and can be run in the initial environment without Undefined identifier errors.

let a = 2 in let b = a * a in let a = b + 1 in a * b
let x = 3 in (let y = x in y * x) + (let x = 1 in x)
let n = 10 in let m = n % 3 in let n = n / m in n - m
(let p = 4 in p) * (let q = p in q)
    

Today's interpreter: code/lesson-05/binding.py

Level 1 of 4

1. For each line, write the value, or the error, before running it.
2. For each occurrence of a name, say which let binds it, or that it is free.
3. Check with evaluate_string and free_variables in binding.py.

Level 2 of 4

1. Write run(text): parse, call free_variables, and evaluate only if the program is closed.
2. Give an example where the check reports an error that evaluation alone would not reach.
3. Which stage of the interpreter does this check belong to: parser, transform, or a new one?

Level 3 of 4

1. Extend the grammar, the AST and evaluate to allow several bindings in one let.
2. Two choices for the second line: each definition sees the names before it, or no definition sees any of them. Write the equation for each.
3. Can you implement it without a new AST node, by transforming into nested Lets?

Level 4 of 4 · a longer one

A new language, built from binding.py: a program computes a text.

Extra · a language of images

A new language, built from binding.py: a program computes an image.

The next slides give the Python primitives, in images.py. print calls show.

The standard library of Python has no module for images. Pillow is the one almost everybody uses.

Three of its modules are enough: Image to load, save and combine, ImageDraw to draw shapes, ImageOps for ready-made transformations.

pathlib is in the standard library: a Path is a file name that knows how to join folders, HERE / "red_circle.png". Pillow is now in requirements.txt.

(512, 512) RGBA
(220, 40, 40, 200)
(0, 0, 0, 0)
      

convert("RGBA") gives every image the same form, whatever the file was: four numbers per pixel.

with closes the file when the block ends; convert has already made a copy in memory.

save chooses the format from the extension: .png keeps transparency, .jpg does not.

Image.new makes a transparent image; ImageDraw draws on it.

The four numbers of ellipse and rectangle are the corners of a box: left, top, right, bottom. The circle and the square overlap in the middle.

The files are already in code/images/; these functions are how they were made.

def over(front: Image.Image,
         back: Image.Image) -> Image.Image:
    return Image.alpha_composite(back, front)

over(circle, square).getpixel((300, 300))
# (194, 46, 66, 235)
      

alpha_composite puts the second image on top of the first. over takes them in the order we read them: front, then back.

Where both are present, the front lets a part of the back show through. With alpha between 0 and 1:

\( \alpha = \alpha_f + \alpha_b (1 - \alpha_f) \)

The order matters: over is not commutative. The two images on the left differ only in the middle.

def over(front: Image.Image, back: Image.Image,
         x: int = 0, y: int = 0) -> Image.Image:
    result = back.copy()
    result.alpha_composite(front, dest=(x, y))
    return result

def scale(image: Image.Image, factor: float) -> Image.Image:
    width = max(1, round(image.width * factor))
    height = max(1, round(image.height * factor))
    return image.resize((width, height),
                        Image.Resampling.LANCZOS)

small = scale(circle, 0.5)          # 256 × 256
over(small, square, 256, 256)
      

With x and y, the top-left corner of front goes at that point of back. What falls outside back is cut away.

scale multiplies width and height by factor; LANCZOS is a way to compute the new pixels that keeps edges smooth.

This over is the one in the file. With x = y = 0 it gives the same result as the previous slide. Pillow does not accept a negative position.

beside makes an image wide enough for both and pastes them in. above, in the file, does the same vertically.

mirror flips left to right. fade splits the four channels, multiplies alpha by factor, and puts them back.

point applies a function to every pixel of a channel: a function passed as a value, as in Lecture 4.