Leslie Lamport

2013 Turing Award:

The importance of formalisms

• A mathematically precise specification (no ambiguity)
• Notation: condense information, an abstraction tool, a visualization aid

Limitations

• Maintaining a specification up-to-date with the implementation takes time and effort
• Yet another thing to learn: Can everyone in the project understand the specification?
• What is the risk of a failure versus the time spent in specifying the software?

How to implement a programming language?

In this class, we will learn how to implement an interpreter. In CS451/651 you can learn how to implement a compiler.

1. The interpreter:

   1. a parser converts the source code into an abstract-syntax-tree (a logical representation of the program)
   2. an interpreter executes the abstract-syntax-tree

2. The compiler:

   1. a parser converts the source code into an abstract-syntax-tree
   2. a compiler converts the abstract-syntax-tree into assembly (through a series of steps)

What is an interpreter

An interpreter executes programs of a given language

• Usually, an interpreter executes a logical representation of the source code (known as the abstract syntax).
• An interpreter repeatedly executes (evaluates) one instruction (expression) at a time, until the program terminates.

Concrete Syntax of λ_S

• The concrete syntax dictates the syntactic structure of a program (how do we represent a number, a variable, etc). This is not the focus of our course (refer to CS451/651).

• We can easily sidestep the parsing issue by reminding ourselves that quote can serialize Racket expressions into a data structure.

Abstract Syntax

In TypedRacket

(define-type s:value (U s:number s:lambda))
(define-type s:expression (U s:value s:variable s:apply))

(struct s:number ([value : Number]) #:transparent)
(struct s:variable ([name : Symbol]) #:transparent)
(struct s:lambda ([param : s:variable] [body : s:expression]) #:transparent)
(struct s:apply ([func : s:expression] [arg : s:expression]) #:transparent)

Mathematically

The abstract syntax of λ_S

A formal notation

• An expression is represented by letter $e$
• A value is represented by letter $v$
• A variable is represented by letter $x$
• A function application is represented by notation $(e_1\ e_2)$, where $e_1$ is an expression, and $e_2$ is another expression. The subscript numbers are just a way to distinguish each expression.
• A number is represented by letter $n$
• A function declaration is represented by $\lambda x.e$

λ_S

Syntax

Semantics

Example

We show that evaluating $({(\lambda x.x)}\ {10})$ returns $10$:

1. The expression is a function application, so we must apply rule $\texttt{E-app}$
2. We evaluate function $\lambda x.x$ with rule $\texttt{E-val}$, which is a value and therefore get the same value back
3. We evaluate argument $10$ with rule $\texttt{E-val}$, which is also a value and therefore we get the same value back
4. Finally, we take the body of the function $x$ and substitute variable $x$ by the number 10 and evaluate 10, which because it is a value we get 10 back.

λ_S semantics

We will use a more familiar notation. We define the evaluation function $\mathtt{eval}(e) = v$ that takes an expression $e$ and returns a value $v$.

Mathematical notation

Code notation

λ_S semantics, informally

Our objective is to evaluate an expression.

1. If the expression $e$ is a value, then we are in the base case, and we return value $e$.

2. If the expression is a variable $x$, this is an error, report it as such.

3. Otherwise, we have a function application $(e_f\ e_a)$. Recursively evaluate function $e_f$ down to a value. Ensure that the result is a function declaration, say $(\texttt{lambda}(x)\ e_d)$.

4. Recursively evaluate the argument of the function $e_a$ down to a value $v_a$.

5. Substitute variable $x$ by value $v_a$ in $e_d$, say $e_d[x \mapsto v_a]$. Recursively evaluate $e_d[x \mapsto v_a]$.

Variable substitution, formally

Variable substitution, informally

Objective: substitute variable $x$ by value $v$ in expression $e$, notation $e[x \mapsto v]$.

1. If the expression is a number, say $n$, then return $n$.
2. If the expression is a variable $y$ and $x = y$, then return $v$. Otherwise, return $y$.
3. If the expression is a function call $(e_1\ e_2)$, then return $(e_1[x \mapsto v]\ e_2[x \mapsto v])$. That is, recursively substitute each sub-expression.
4. If the expression is a function declaration $(\lambda (y)\ e)$, then $\dots$

What should we do?

Test-case utility function

Function (check-r:eval? exp val) is given in the template to help you test your code effectively.

1. The first parameter is an S-expression that represents a valid $\lambda$ expression
2. The second parameter is an S-expression that represents a valid $\lambda$ value

Test-cases

; `a number is a value, so we just return it`
(check-r:eval? 1 1)
; `a lambda is a value, so we just return it`
(check-r:eval? '(lambda (x) x) '(lambda (x) x))
; `function application`
(check-r:eval? '((lambda (x) x) 10) 10)
; `function application that returns a lambda and replaces a variable`
(check-r:eval? '((lambda (y) (lambda (x) y)) 1) '(lambda (x) 1))

More examples

• The University of Birmingham: Principles of Programming Languages 2009
• Church encoding, Wikipedia