Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and...

32
Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc., can be found at: www.csc.liv.ac.uk/~grant/Teaching/COMP205/
  • date post

    21-Dec-2015
  • Category

    Documents

  • view

    218
  • download

    3

Transcript of Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and...

Page 1: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Comp 205:Comparative Programming

Languages

Semantics of Functional Languages

• Term- and Graph-Rewriting• The λ-calculus

Lecture notes, exercises, etc., can be found at:

www.csc.liv.ac.uk/~grant/Teaching/COMP205/

Page 2: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Term Rewriting

A straightforward way of implementing afunctional programming language is to implement term-rewriting.

The Haskell interpreter evaluates expressions(terms) by "substituting equals for equals".

Page 3: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

For example, given the following definitions:

fib 0 = 1fib 1 = 1fib n = fib (n-1) + fib (n-2), if n>1

An evaluation might proceed as follows:

fib 3 (fib 2) + (fib 1) (fib 1) + (fib 0) + (fib 1) 1 + (fib 0) + (fib 1) 1 + 1 + (fib 1) 1 + 1 + 1 3

Page 4: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Terms and Trees

A standard way of representing terms is as trees:

+

Fn.Appl. +

fib 1 Fn.Appl. Fn.Appl.

fib fib 10

Page 5: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Term Rewriting

Term rewriting replaces (sub)trees:

Fn.Appl.

fib 1

1

(rewrites to)

Page 6: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Rewriting Trees

... giving the new tree:

+

+1

Fn.Appl. Fn.Appl.

fib fib 10

Page 7: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Side-Effects

In the imperative paradigm, all evaluation canchange the current state (e.g., by side-effects).

int funnyCount=0;

int funny(int i){ return funnyCount++ * i;}

funny(2) + funny(2) // might be 0+2

Page 8: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Functional Expressions

In the functional paradigm there is no state,so an expression always denotes the same

value,and evaluation simply converts an expressionto its value.This important property of functional languagesis referred to as "referential transparency".

Page 9: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Referential Transparency

Referential Transparency: any expression denotes

a single value, irrespective of its context.

Consequently, (sub)expressions can be replacedby their values without changing the behaviourof a program.

(Referential transparency = no side-effects)

Page 10: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Graphs

Expressions can also be represented by graphs:

+

+

Fn.Appl. Fn.Appl.

fib fib 10

Page 11: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Graph Rewriting

This allows identical subexpressions to be rewritten "in one go":

+

+

Fn.Appl. Fn.Appl.

fib fib 10

+

+

Fn.Appl.

fib

1

0

(rewrites to)

Page 12: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

The λ-Calculus

The λ-calculus was developed by themathematician Alonzo Church as a tool tostudy functions and computability.

The λ-calculus provides a very simple modelof computable function, and inspired thedesigners of the first functional programminglanguage, LISP.

The λ-calculus also provides an operationalsemantics for functional languages.

Page 13: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Computability

Alan Turing developed an abstract machine(the Turing Machine) and showed that it provideda universal model of computation. He showed

thatthe Turing-computable functions were

exactlythe general recursive functions.

Church showed that the Turing-computablefunctions were exactly those that could be represented in the λ-calculus (the λ-computable functions).

Page 14: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Church-Turing Hypothesis

Both Turing and Church conjectured that theirmodel of computability formalised the intuitivenotion of mathematical computability.

The Church-Turing Hypothesis states that theequivalent notions of Turing- and λ-computabilitycapture precisely "every function that wouldnaturally be regarded as computable".

Page 15: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

λ-Terms

Church designed the λ-calculus as a tool tostudy the fundamental notion of computablefunction. He therefore sought to strip away allbut the bare essentials.

The syntax for λ-terms is accordingly very simple.

λ-terms are built from:

• variables

• function application

• λ-abstraction (declaring formal parameters)

• (and brackets)

Page 16: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Syntax of λ-Terms

The set Λ of λ-terms is defined by:

Λ ::= Var | Λ Λ | λVar. Λ | (Λ)

where Var is a set of variables.

Looking at each clause in turn:

• variablesTypically, we use a, b, c, ..., x, y, z for variables;if we run out of variable names, we can use x', x'', x''', etc.

Page 17: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Syntax of λ-Terms

• function application

If M and N are λ-terms, so too is M N ,which represents the application of M to N.(All λ-terms can be considered functions.)

• λ-abstraction

If M is a λ-term, so too is λx.M,which can be thought of as a functionwith formal parameter x,and with body M.

Page 18: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Some Examples

•x

•x y

•λy.(x y)

•λx.λy.x y

• bracketsλ-abstraction binds less tightly than functionapplication, so the last example above shouldbe read as λx.(λy.(x y)) not (λx.(λy.x)) y .Also, x y z should be read as (x y) z .

Page 19: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Evaluation of λ-Terms

A λ-term λx.M represents a function whoseformal parameter is x and whose body is M.When this function is applied to another λ-term

N,as in the λ-term

(λx.M) N ,

evaluation proceeds by replacing x with N in thebody M. For example,

(λx.λy.x) (λz.z) λy.λz.z

In order to make this precise, we need the notions

of free and bound variables.

Page 20: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Free and Bound Variables

Given a λ-term λx.M, we say that λ binds ocurrences of x in M.

We also say that x is bound in (λx.M) .

A free variable is one that is not boundby a λ-abstraction.

A λ-term is closed if it has no free variables.

Page 21: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Free Variables

Given a λ-term M, we write FV(M) for the set offree variables in M. This set is defined as follows:

• FV( x ) = { x }In a λ-term consisting of just a variable,that variable is free.

• FV( M N ) = FV(M) FV(N)Function application doesn't bind variables.

• FV( λx.M ) = FV(M) - { x }If x is a bound variable, then x is not free.

Page 22: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Evaluation of λ-Terms

Given a function application of the form

(λx.M) N ,

evaluation proceeds by replacing all freeoccurrences of x in the body M with N.

For example,

(λx.λy.x) λz.z λy.λz.z

Here, the argument λz.z replaces the variable x,which is free in the body λy.x of the function being applied.

Page 23: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Evaluation of λ-Terms

However,

(λx.(λx.x)) λz.z λx.x

Here, there is no substitution,since x is not free in the body λx.x.

Page 24: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

β-Conversion

In general, we write

(λx.M) N β M[x N] ,

where M[x N] denotes the result of replacing allfree occurrences of x in M with N.

This form of evaluation is referred to asβ-conversion, for which we use the symbol β .

Page 25: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Example

((λx. λy. y x) (λz.z)) (λu. λv. u) β ( (λy. y x)[x (λz.z)] ) (λu. λv. u) = (λy. y (λz.z)) (λu. λv. u) β ( (y (λz.z))[x (λu. λv. u)] ) = (λu. λv. u) (λz.z) β λv. λz. z

Page 26: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

α-Conversion

Just as with functions, formal parameters simplyserve as place-holders, representing possiblearguments.

In the λ-calculus, formal parameters (i.e., bound variables) can be renamed.This is referred to as α-Conversion (written α).

For example,

λx. λy. y α λx. λv. v α λu. λv. v

Page 27: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

β-Conversion Again

In general, we write

(λx.M) N β M[x N] ,

where M[x N] denotes the result of replacing allfree occurrences of x in M with N,provided that no free variables in N become

boundas a result of this substitution.

For example,

(λx. λy. y x) (λz.y) β λy. y (λz.y)

is not allowed.

Page 28: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

α- and β-Conversion

Sometimes it is necessary to apply α-conversion before β-conversion can be applied.

For example,

(λx. λy. y x) (λz.y) α

(λx. λu. u x) (λz.y)

β

(λu. u x)[x (λz.y)] =

λu. u (λz.y)

Page 29: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

η-Conversion

A final reduction relation on λ-terms is η-conversion. This applies to λ-termsof the form λx. M x, where x is not free in M.Such a function takes an argument and appliesM to that argument; it is therefore equal toM itself.

This is the idea behind η-conversion (η):

λx. M x η M

provided that x is not free in M.

Page 30: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Example

• λy. (λx. y x) η λy. y

But η-conversion is not applicable to

• λx. (λy. y x)

• λy. (λx. (x y) x)

Page 31: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Computing with λ-Terms

How does the λ-calculus relate to realprogramming languages such as Haskell?

Page 32: Comp 205: Comparative Programming Languages Semantics of Functional Languages Term- and Graph-Rewriting The λ-calculus Lecture notes, exercises, etc.,

Summary

Key points:

• λ-terms• β-conversion• α-conversion• η-conversion

Next: Computing with λ-terms