cs7120 (prasad)l13-1-lambda-opt1 typed lambda calculus adapted from lectures by profs aiken and...

CS7120 (Prasad) L13-1-Lambda-Opt 1

Typed Lambda Calculus

Adapted from Lectures byProfs Aiken and Necula of

Univ. of California at Berkeley


Lecture Outline

• Lambda Calculus – Review and examples

• Simple types

• Type checking

• Comparison with OO type systems


Lambda Calculus Review

• Grammar:

E ::= x variables | E1 E2 function application

| x. E function creation

• Evaluation:(x. e) e’ [e’/x]e


Example 1

(x.x) y.y y.y

(x.x) y.y [y.y/x] x =y.y


Example 2

(x.y.x) (z.z) e * z.z

((x.y.x) (z.z)) e ([z.z/x]y.x) e (y.z.z) e [e/y]z.z =z.z


Example 3

(x. x x) (x. x x) (x. x x) (x. x x) . . .

(x. x x) (x. x x) [( x. x x)/x](x x) =(x. x x) (x. x x)


Question

What programming errors can occur in lambda calculus?


Notes

• We can encode anything we like in lambda calculus– Booleans, integers, objects, if-then-else,

recursion, . . .

• But don’t forget that these are encodings– Akin to programming directly with 0’s and 1’s


Extension

• Grammar: E ::= x variables | E1 E2 function application

| x. E function creation | 0,1,2,… integers | + addition

• Evaluation:(x. e) e’ [e’/x]e+ i j k where k = i + j


Digression

• There is nothing magic about adding integers and + as constants to the lambda calculus

• We could add any data types and operations we like

• They can be encoded directly in lambda calculus anyway


Examples

(x. + x 1)

(x. + x x)

(x. + x 1) 3 4

(x. + x 1) (y.y) ?


What Happens?

(x. + x 1) (y.y) + (y.y) 1 ?

Answer: It depends.

A runtime error; we can’t add to a function

Or no error: If + and 1 are encoded as lambda terms, computation will continue!


Notes

• Assume 1, + are encoded as lambda terms

• Nothing guarantees the encoding of 1 is used as an integer– E.g., (1 x.x)– Evaluation doesn’t know what the encodings

are supposed to represent


Back to the Future

• We need to be able to restrict uses of values to appropriate operations

• We need a type system!

• Note that we’d like a type system whether or not + (y.y) 1 causes a runtime error– Catching these errors before program

execution is better


Typed Lambda Calculus

• Grammar: E ::= x variables | E1 E2 function application

| x:. E function creation | 0,1,2,… integers | + addition

• Evaluation:(x:. e) e’ [e’/x]e+ i j k where k = i + j


The Types

• We have only two kinds of values– Integers– Functions

• Type grammar: := int |


Examples of Types

int

int int

(int int) int

int (int int)


Type Judgments

A e : x Type environment Type

Expression

“it is provable that” “has type”


Examples

x:int.x : int int

1 2 1 1 2 1 2x: . y: .x y : ( )


More Examples

x:int. y:int.x : int int int

t:int. e:int. b:int int int.b t e :int int (int int int) int

x:int. y:int.y : int int int


Type Rule: Variables

A variable has the type assumed in the type environment.

A, x: x: x [Var]


Abstraction

A function has type 1 2 if the function body has type 2 when we assume the argument has type 1.

1 2

1 1 2

A, x: e :A x: .e :

x [Abs]


Application

Applying a function of type 1 2 to an argument of type 1 gives a result of type 2

1 1 2

2 1

1 2 2

A e : A e : A e e :

[App]


Integers

An integer has type int

A i:intx [Int]


Addition

Adding two int’s produces an int

1

2

1 2

A e :intA e :int

A + e e :int

xx

x[Add]


Example 1

x:int x:int x:int.x : int int


Example 2

x:int x:int x:int 1: intx:int + x 1: int 3:int x:int.+ x 1: int int

( x:int.+ x 1) 3: int

x


Type Checking

• One recursive descent traversal.

• Top-down: Add type declarations of formal parameters to environments

1 2

1 1 2

A, x: e :A x: .e :

x [Abs]


Type Checking (Cont.)

• Bottom-up: Check that types match in applications

1 1 2

2 1

1 2 2

A e : A e : A e e :

[App]


Structural Equality

• “Types match” means “types are equal”• Equality is recursively defined

int = inta b = c d a = c b = d


Notes

• In typed lambda calculus:– Types of all variables are declared– Types are structured (e.g., int int)– Types are checked for equality

• Many typed languages in this class– Nearly all typed languages before 1980– FORTRAN, ALGOL, Pascal, C– Captures C typing except for casts & coercions


Typed OO Languages

• In many typed object-oriented languages– Types of all variables are declared– Types are non-structural (just names)

• Declare all types and type relationships– Types are checked for subtyping relationships

• What if type declarations are omitted?– A language with type inference


Discussion

What about structural types + subtyping?– Area of current research– Currently no consensus on the right way to

combine C-like type systems with typical OO-like type systems

cs7120 (prasad)l13-1-lambda-opt1 typed lambda calculus adapted from lectures by profs aiken and...

Documents