lambda calculi with polymorphism - uni koblenz-landaulaemmel/plt/slides/... · 2012. 12. 12. ·...

x = 1 let x = 1 in ...

x(1).

!x(1) x.set(1)

Lambda Calculi With Polymorphism

Ralf Lämmel

Programming Language Theory

Resources: The slides of this lecture were derived from [Järvi], with permission of the original author, by copy & paste or by selection, annotation, or rewording. [Järvi] is in turn based on [Pierce] as the underlying textbook.

[Järvi] Slides by J. Järvi: “Programming Languages”, CPSC 604 @ TAMU (2009)[Pierce] B.C. Pierce: Types and Programming Languages, MIT Press, 2002

© Ralf Lämmel, 2009-2012 unless noted otherwise

Polymorphism -- Why?

• What’s the identity function?

• In the simply typed lambda calculus, we need many!

• Examples

✦ λx:bool. x✦ λx:nat. x✦ λx:bool→bool. x✦ λx:bool→nat. x✦ ...

87

This slide is derived from Jaakko Järvi’s slides for his course ”Programming Languages”, CPSC 604 @ TAMU.

In need of polymorphic functions, i.e., functions that accept many types of arguments.


Kinds of polymorphism

✦ Parametric polymorphism (“all types”)

✦ Bounded polymorphism (“subtypes”)

✦ Ad-hoc polymorphism (“some types”)

✦ Existential types (“exists as opposed to for all”)

88


Font size correlates with

coverage in lecture.







89



System F -- Syntax

90

Introduction

System-F on one page

Syntaxt ::=x | v | t t | t[T ]v ::=λx :T .t| ΛX .tT ::=X |T �T |∀X .T

Evaluation rules

E-AppFunt1 → t1�

t1 t2 → t1� t2

E-AppArgt → t �

v t → v t �

E-AppAbs(λx :T .t) v → [v/x ]t

E-TypeAppt1 → t1�

t1[T ] → t1�[T ]

E-TypeAppAbs(ΛX .t)[T ] → [T/X ]t

Typing rules

T-Variablex : T ∈ ΓΓ � x : T

T-AbstractionΓ, x : T � u : U

Γ � λx : T .u : T → UT-ApplicationΓ � t : U → T Γ � u : U

Γ � t u : TT-TypeAbstraction

Γ,X � t : TΓ � ΛX .t : ∀X .T

T-TypeApplicationΓ � t : ∀X .T

Γ � t[T1] : [T1/X ]T

7 / 50

Type application

Type abstraction

Polymorphic type


System F [Girard72,Reynolds74] =

(simply-typed) lambda calculus

+

type abstraction & application

Type variable

Example:id : ∀X.X →Xid =ΛX.λx :X.x


System F -- Typing rules

91

Introduction



Evaluation rules


t1 t2 → t1� t2

E-AppArgt → t �

v t → v t �



t1[T ] → t1�[T ]


Typing rules





Γ,X � t : TΓ � ΛX .t : ∀X .T


Γ � t[T1] : [T1/X ]T

7 / 50


Type variables are held the

context.

Type variables are subject to

alpha conversion.



System F -- Evaluation rules

92

Introduction



Evaluation rules


t1 t2 → t1� t2

E-AppArgt → t �

v t → v t �



t1[T ] → t1�[T ]


Typing rules





Γ,X � t : TΓ � ΛX .t : ∀X .T


Γ � t[T1] : [T1/X ]T

7 / 50

Introduction



Evaluation rules


t1 t2 → t1� t2

E-AppArgt → t �

v t → v t �



t1[T ] → t1�[T ]


Typing rules





Γ,X � t : TΓ � ΛX .t : ∀X .T


Γ � t[T1] : [T1/X ]T

7 / 50




Examples

93

Term

id =ΛX.λx :X.xid[bool]

id[bool] true

id true

Type

: ∀X.X →X: bool → bool: bool

type error

In actual programming languages, type application may be implicit.



The doubling functiondouble=ΛX.λf :X →X.λx :X.f (f x)

94

• Instantiated with natdouble_nat = double [nat]

: (nat → nat) → nat → nat• Instantiated with nat → nat

double_nat_arrow_nat = double [nat → nat]: ((nat → nat) → nat → nat) → (nat → nat) → nat → nat

• Invoking double

double [nat] (λx : nat.succ (succ x)) 5 →* 9



Functions on polymorphic functions

• Consider the polymorphic identity function:id : ∀X. X→Xid = ΛX.λx : X.x

• Use id to construct a pair of Boolean and String:pairid : (Bool, String)

pairid = (id true, id “true”)

• Abstract over id:pairapply : (∀X. X→X) → (Bool, String)pairapply = λf : ∀X. X→X. (f true, f “true”)

95

Type application left implicit.

Argument must be polymorphic!



Self application

96

• Not typeable in the simply-typed lambda calculus

λx : ? . x x

• Typeable in System F

selfapp : (∀X.X → X) → (∀X.X → X)

selfapp = λx : ∀X.X → X.x [∀X.X → X] x



The fix operator (Y)

97

• Not typeable in the simply-typed lambda calculus

✦ Extension required

• Typeable in System F.

fix : ∀X.(X → X) → X

• Encodeable in System F with recursive types.

fix = ?

See [TAPL]


Aside: general recursion

The fix operator

We discussed the fix point operator (Y-combinator, fix), and showedits definition in untyped lambda calculusJust like self-application, fix cannot be typed in simply-typed lambdacalculusSimple fix: add fix as a primitive

fix (λx : T .t)→ [(fix (λx : T .t))/x ] t

t → t �

fix t → fix t �

Γ � t : T → TΓ � fix t : T

16 / 50


Meaning of “all types”

98

• Predicative polymorphism✦ X ranges over simple types.✦ Polymorphic types are “type schemes”.✦ Type inference is decidable.

• Impredicative polymorphism✦ X also ranges over polymorphic types.✦ Type inference is undecidable.

• type:type polymorphism✦ X ranges over all types, including itself.

✦ Computations on types are expressible.

✦ Type checking is undecidable.


In the type ∀X. ..., we quantify over “all types”.

Not covered by this lecture

Generality is used for selfapp.







99



• We say S is a subtype of T.

S


Why subtyping• Function in near-to-C: void foo( struct { int a; } r) { r.a = 0; }

• Function application in near-to-C: struct K { int a; int b: } K k; foo(k); // error

• Intuitively, it is safe to pass k.Subtyping allows it.

101



Subsumption(Subsititutability of supertypes by subtypes)

102

Subtype relation

Subsumption

Subsititutability is captured with the following subsumption rule:

Γ � t : U U


Structural subtyping for records

• A subtype may have additional label/type pairs.

• A subtype may permute the label/type pairs.

• A subtype may use subtypes for label/type pairs.

103



A subtype may have additional label/type pairs.

104

Subtype relation

Subtyping for records

We can always add new fields in the end

S-RecordNewFields{li : Ti i∈1...n+k}


A subtype may permute the label/type pairs.

105

Subtype relation


Order of fields does not matter

S-RecordPermutation{li : Ti i∈1...n} is a permutation of {kj : Uj j∈1...n}

{li : Ti i∈1...n}


A subtype may use subtypes for label/type pairs.

106

Subtype relation


We can subject the fields to subtyping:

S-RecordElementsfor each i Ti


General rules for subtyping

• Subsumption

• Reflexivity of subtyping

• Transitivity of subtyping

• Subtyping for function types

• Supertype of everything

• Up and down cast

107




• Reflexivity

• Transitivity

• Example which needs transitivity

108

Subtype relation


Reflexivity

T


Subtyping of functions

• Subsumption provides subtyping for function arguments and results.

• An additional rule is needed to provide subtyping for function types.

• Compare this to the need for subtyping rules for record types.

• Consider the following function application:

(λf : {a:int, b:int} → {c:int} . f {a:42, b:88}) g• Several types can be permitted for g:

✦ g : {a:int, b:int} → {c:int}✦ g : {a:int} → {c:int, d:int}✦ ...

109


The actual function may “use” less fields and “return”

more fields.


Subtyping of functions

• Function subtyping

✦ covariant on return types

✦ contravariant on parameter types

110

Subtype relation

Subtyping and functions

T2


Supertype of everything

• T ::= ... | top

✦ The most general type

✦ The supertype of all types

111

Subtype relation

Supertype of everything

Often type systems with subtyping have the most general type, which

is a supertype of all types

T


Remember type annotation?

112


• Syntax:

t ::= ... | t as T

• Typing rule:

• Evaluation rules:

Subtyping and other extensions

Ascription

Reminder. Type rules:

Γ � t : TΓ � t as T : T

Evaluation rules:

t → ut as T → u as T

v as T → v

18 / 40


Ascription


Γ � t : TΓ � t as T : T

Evaluation rules:


v as T → v

18 / 40


Ascription


Γ � t : TΓ � t as T : T

Evaluation rules:


v as T → v

18 / 40


• Illustrative type derivation:

• Example:

Annotation as up-casting

113


Ascription

Example

...Γ � t : U

...U

© Ralf Lämmel, 2009-2012 unless noted otherwise 114


• Typing rule:

• Evaluation rules:


Ascription


Γ � t : TΓ � t as T : T

Evaluation rules:


v as T → v

18 / 40


Down-casting typing and evaluation rules

Typing rule

Γ � t : UΓ � t as T : T

Remember the evaluation rules:


v as T → v

Is this right? What’s the effect on preservation?

22 / 40

Potentially too liberal


Down-casting typing and evaluation rules

Typing rule

Γ � t : UΓ � t as T : T

Remember the evaluation rules:


� v : Tv as T → v

Note, that this type condition on evaluation relation is a checkperformed at run-timeWhat is the effect on progress?

23 / 40

Runtime type check

Annotation as down-casting


Algorithmic subtyping

115

Reminder: A type system is a tractable syntactic method for proving the absence of certain program behaviors by classifying phrases according to the kinds of values they compute. [B.C. Pierce]


We violate this definition because some rules are not “syntax-driven”!


Violation of syntax direction

• Consider an application:

t u where

t of type U → V and u of type S.

• A type checker would need to figure out that S


Analysis of subsumption

117

• The term in the conclusion can be anything.

It is just a metavariable.

• Example: Which rule should you apply here?

T-Abstraction or T-Subsumption?

About subtyping

Closer look at subsumption rule

T-SubsumptionΓ � t : U U


Analysis of transitivity

118

• U does not appear in conclusion.

Thus, to show T


Analysis of transitivity

119

• What is the purpose of transitivity?

Chaining together separate subtyping rules for records!

Subtype relation


Order of fields does not matter

S-RecordPermutation{li : Ti i∈1...n} is a permutation of {kj : Uj j∈1...n}

{li : Ti i∈1...n}


Algorithmic subtyping• Replace all previous rules by a single rule.

• Correctness / completeness of new rule can be shown.

• Maintain extra rule for function types.

120

About subtyping


Transitivity was to chain together the three record subtyping rulesWe can replace all three by just one syntax directed rule

S-Record{li i∈1...n} ⊆ {kj j∈1...m} li = kj implies Ui



• The subsumption rule is still not syntax-directed.

• The rule is essentially used in function application.

• Express subsumption through an extra premise.

• Retire subsumption rule.

121

About subtyping

Algorithmic typing

Similar problems remain with the subsumption rule — it is not syntaxdirectedWhere is subsumption needed?

(λx : {b : B}. x .b) {a = someA, b = someB}

This is the only place where it is essentialSubsumption can be dropped if the function application rule ismodified

T-ApplicationΓ � t : U → T Γ � u : V V







122








123



Universal versus existential quantification

124

• Existential types serve a specific purpose:

A means for information hiding (encapsulation).

• Remember predicate logic.

• Existential types can be encoded as universal types; see [TAPL].

Existential types

Existential types

Existential types are a means for information hiding and abstractionNot a strict extension, remember from predicate logic:

∀x .P(x) ≡ ¬(∃x .¬P(x))

Indeed, existential types can be encoded as universal typesSyntax:

{∃X , T}

31 / 50


“∃” will not show up in the exam! However, it’s very healthy to know this stuff!


Overview

• Syntax of types:

T ::= ···

| {∃X, T}

• Normal forms:

v ::= ···

| { *T, v }

• Terms:

t ::= ···

| { *T, t } as T

| let {X, x} = t in t

125

Hidden type

Package with type

Unpacking

Package

Existentially quantified type


Constructing existentials

126

• A record:

r : { a : nat, b : nat → nat }

r = { a = 1, b = λ x : nat . pred x }

• A package with nat as hidden type:

p : {∃X, {a : X, b : X → nat}}

p = { *nat, r }

• The type system makes sure that nat is inaccessible from outside.


Illustration of using the record:

r. b r.a

In fact, we need to “assign” this or another type.

© Ralf Lämmel, 2009-2012 unless noted otherwise 127

• r : { a : nat, b : nat → nat }

r = { a = 1, b = λ x : nat . pred x }

• p = {*nat, r } as {∃X, {a:X, b:X → X}}

p has type: { ∃X, {a:X, b:X → X}}

• p’ = {*nat, r } as {∃X, {a:X, b:X → nat}}

p’ has type: { ∃X, {a:X, b:X → nat}}


Multiple types make sense for the package. Hence, the programmer must provide an annotation upon construction.

“preferred”


• p1 = {*nat, {a = 1, b = λx:nat. iszero x}}

as

{∃X ,

{a:X ,

b:X → bool}}

• p2 = {*bool, {a = false, b = λx:bool. if x then false else true}}

as

{∃X ,

{a:X ,

b:X → bool}}

128


We can have the same existential type with different

representation types.


Unpacking existentials(Opening package, importing module)

• Example -- apply b to a:

let {X,x} = p2 in (x.b x.a) →* true : bool

• Syntax:

let {X,x} = t in t’

✦ The value x of the existential becomes available.

✦ The representation type is not accessible (only X).

129



Typing rules

130

Existential types

Typing rules

T-PackExistentialΓ � t : [U/X ]T

Γ � {∗U, t} as {∃X , T} : {∃X , T}

The big thing of existentials is that packages with differentrepresentation types can have the same existential type

This is what gives information hidingExample

p1 = {*nat, {a = 1, b = λx:nat. iszero x}}as {∃X, {a:X, b:X → bool}}

p2 = {*bool, {a = false,b = λx:bool. if x then false else true}}

as {∃X, {a:X, b:X → bool}}

36 / 50

Existential types

Elimination rule

T-UnpackExistentialΓ � t1 : {∃X , T12} Γ, X , x : T12 � t2 : T2

Γ � let {X , x} = t1 in t2 : T2

Unpacking an existential is comparable to importing or opening a

module/package

The existential becomes available but the representation type is not

accessible

Only the capabilities of the existential type are accessible

Example

let {X,t} = p2 in (t.b t.a)

$> true : bool

37 / 50


Substitution checks that the abstracted type of t can be instantiated with the hidden type to the

actual type of t.

Only expose abstract type of existential!


Evaluation rules

131

Existential types

Evaluation rules

E-Packt → t �

{∗T , t} as U → {∗T , t �} as UE-Unpack

t1 → t �1let {X , x} = t1 in t2 → let {X , x} = t �1 in t2

E-UnpackPacklet {X , x} = ({∗T , v} as U) in t2 → [T/X ][v/x ]t2

The last rule is like module linking: symbolic names are replaced withthe concrete componentsNote: an expression can get a more exact type with evaluationEvaluation rules don’t care about typing, an ill-typed expression couldbe evaluated to a well-typed one

38 / 50


The hidden type is known to the evaluation, but the type system did not expose it; so t2 cannot exploit it.


Illustration of information hiding

• The type can be used in the scope of the unpacked package.

let {X, x} = t in (λ y:X. x.b y) x.a →* false : bool

• The representation type must remain abstract.

t = {*nat, {a = 1, b = λx:nat. iszero x} as {∃ X, {a:X, b:X → bool}}}

let {X,x} = t in pred x.a

// Type error!

• The type must not leak into the resulting type:

let {X, x} = t in x.a

// Type error!

132



• Summary: Lambdas with somewhat sexy types✦ Done: ∀,∃,

lambda calculi with polymorphism - uni koblenz-landaulaemmel/plt/slides/... · 2012. 12. 12. ·...

Documents

The Simply Typed Lambda Calculus - Uni Koblenz-Landaulaemmel/plt/slides/typed-lambda.pdf · Why is Y not typeable? •Consider again the ﬁxed-point combinator:! Y = λf .(λx.f

arXiv:cs/0610006v2 [cs.AI] 3 Apr 2007 · the untyped theory of predicate calculus with untyped logical objects (untyped terms), i.e. the logical reasoning algorithms apply pure syntactical

Lambda-Calcul Sémantique de Montague. Plan Introduction au lambda-calcul 1- Lambda Calcul non typé 2- Lambda Calcul simplement typé 3- Propriétés du lambda-calcul

PL’17 Exam Preparation: Lambda Calculus, JavaScriptmsagiv/courses/pl17/pl17_exam... · 2017-01-29 · Untyped Lambda Calculus - Syntax t ::= terms x variable x. t abstraction t

Categorical coherence in the untyped setting · 2013-06-03 · Categorical coherence in the untyped setting Peter M. Hines SamsonFest – Oxford ... is a genuine monoidal category

Logical Types for Untyped Languages

CSEP505: Programming Languages Lecture 4: Untyped lambda-calculus, inference rules, environments, … Dan Grossman Spring 2006

LAMBDA CALCULUS - George Mason University · Implementing the untyped lambda calculus Investigate implementing the untyped lambda calculus in Haskell: •datafor our terms •is_valuefunction

ISO13485 TDK-Lambda Medical Equipment 2020TDK-Lambda Products Guide for Medical Equipment 2020 ME_FL_2004J TDK-Lambda UK イルフラコム・ブリストル TDK-Lambda China TDK-Lambda

Concepts in Programming Languages Recitation 5: More ...msagiv/courses/pl17/lambda_2_recitation.pdfMore (Untyped) Lambda Calculus Oded Padon & Mooly Sagiv (original slides by Kathleen

Typed Parsing and Unparsing for Untyped Regular Expression … · 2020. 8. 23. · Typed Parsing and Unparsing for Untyped Regular Expression Engines Gabriel Radanne University of

( ( lambda (z) ( define x ( lambda (x) ( lambda (y z) (y x) ) ) )

LAMBDA MINIFOR - bioreactors · 2017. 1. 30. · LAMBDA MINIFOR Laborfermenter und Bioreaktor INNOVATIONSÜBERSICHT UND VORTEILE LAMBDA Laborgeräte LAMBDA CZ s.r.o. Dr. Pavel Lehky

An Untyped Calculus of Aspect-Oriented Programs

Chapter 5: The Untyped Lambda Calculus · Scope •An occurrence of the variable x is said to be bound when it occurs in the body t of an abstraction λx.t. –λxis a binder whose

CSEP505: Programming Languages Lecture 4: Untyped Lambda

Lambda Calculus1 The Untyped Lambda-Calculus Hossein Hojjat University of Tehran Formal Methods Laboratory

Lambda Calculus - Technische Universität München8 CHAPTER 1. UNTYPED LAMBDA CALCULUS To make the choice of zin the last rule deterministic, assume that the variables are linearly

SONDA LAMBDA SONDA LAMBDA PLANAR UNIVERSAL SONDA …

Sistemi modulari - Modular systems LAMBDA - Amazon S3 · alla prova del filo incandescente 850°C, ... LAMBDA arcluce.it lambda Code ... 4 A1708 5 Lambda LAMBDA 11 21 arcluce.it lambda

Omicron Lambda Lambda krogercommunityrewards.com

Normalisation in lambda calculus and its relation to type ... · we give an informal explanation of the untyped lambda calculus, of the concept of type and an overview of the lambda

LAMBDA TD Software, Inc. presents LAMBDA LCE Domotics

TYPED LAMBDA CALCULI - Le · The lambda-calculus originated in order to study functions more carefully. Rosser The untyped λ-calculus was originally part of a formal system proposed

UCT Algorithm Circle: Lambda CalculusIntroduction to Lambda Calculus Untyped Lambda Calculus in Action Typed Lambda Calculi History In the early 1920s, Moses Schonﬁnkel develops¨

Lambda Calculus - TUMChapter 1 Untyped Lambda Calculus 1.1 Syntax 1.1.1 Terms De nition 1.1.1. The set of lambda calculus terms is de ned as follows: t ::= c j x j (t 1 t 2) j ( x:t)

Untyped λ -Calculusrxg/cpsc509/UntypedLambdaCalculus.pdfThe calculi of lambda-conversion. (Book) Barendregt, H.P. (1984) .The Lambda Calculus Its Syntax and Semantics. (Paper)Barendregt,

The lambda calculus David Walker CS 441. the (untyped) lambda calculus a language of functions e ::= x | \x.e | e1 e2 v ::= \x.e there are several different

The Untyped Lambda Calculuslaemmel/plt/slides/lambda.pdf · (x .y )(y .y ) x .(y .xy)y Combinator —atermwithnofreevariables(alsoclosed term) 9/36 ... Apply function before reducing

A Simplifier for Untyped Lambda Expressionsi.stanford.edu/pub/cstr/reports/cs/tr/90/1337/CS-TR-90-1337.pdf · expressions, thegenerates relation xgen and the notion of a set of lambda

OTTER-LAMBDA, A THEOREM-PROVER WITH UNTYPED LAMBDA …beeson/Papers/esfor.pdf · 2004. 12. 8. · December 7, 2004 19:40 WSPC/INSTRUCTION FILE esfor Otter-lambda, a theorem-prover

Graphic Lambda Calculus - Wolfram ResearchGraphic lambda calculus, a visual language that can be used for repre-senting untyped lambda calculus, is introduced and studied. It can also

CSEP505: Programming Languages Lecture 4: Untyped lambda-calculus, Formal Operational Semantics, … Dan Grossman Winter 2009

The Root Cause of Blame:Contracts for Intersection and ... · • Extending the untyped lambda calculus with contracts for monitoring higher-order intersec-tion and union types, for

x(1). !x(1) x.set(1) - Uni Koblenz-Landaulaemmel/paradigms1011/resource… · Programming Paradigms and Formal Semantics