Principal type inference with subtyping Stephen Dolan and Alan - - PowerPoint PPT Presentation

Principal type inference with subtyping

Stephen Dolan and Alan Mycroft April 21, 2016

Computer Laboratory University of Cambridge

select

select p v d = if (p v) then v else d

2

select

select p v d = if (p v) then v else d ML : ∀α.(α → bool) → α → α → α

2

select

select p v d = if (p v) then v else d ML : ∀α.(α → bool) → α → α → α v argument to p result d

2

select

select p v d = if (p v) then v else d ML : ∀α.(α → bool) → α → α → α v argument to p result d MLsub : ∀α.(α → bool) → α → β → (α ⊔ β)

2

Defining types

Extensibility

When I add more types, no programs should break.

4

Constructing types syntactically

Types: τ ::= bool | τ1 → τ2 | {ℓ1 : τ1, . . . , ℓn : τn}

5

Constructing types syntactically

Types with subtyping: τ ::= bool | τ1 → τ2 | {ℓ1 : τ1, . . . , ℓn : τn} bool ≤ bool τ ′

1 ≤ τ1

τ2 ≤ τ ′

2

τ1 → τ2 ≤ τ ′

1 → τ ′ 2

{ℓ1 : τ1, . . . , ℓn : τn, . . . } ≤ {ℓ1 : τ1, . . . ℓn : τn} τ1 ≤ τ ′

1

. . . τn ≤ τ ′

n

{ℓ1 : τ1, . . . , ℓn : τn} ≤ {ℓ1 : τ ′

1, . . . , ℓn : τ ′ n}

5

Constructing types syntactically

Types with subtyping, least and greatest types: τ ::= bool | τ1 → τ2 | {ℓ1 : τ1, . . . , ℓn : τn} | ⊥ | ⊤ bool ≤ bool τ ′

1 ≤ τ1

τ2 ≤ τ ′

2

τ1 → τ2 ≤ τ ′

1 → τ ′ 2

{ℓ1 : τ1, . . . , ℓn : τn, . . . } ≤ {ℓ1 : τ1, . . . ℓn : τn} τ1 ≤ τ ′

1

. . . τn ≤ τ ′

n

{ℓ1 : τ1, . . . , ℓn : τn} ≤ {ℓ1 : τ ′

1, . . . , ℓn : τ ′ n}

⊤ ≤ τ τ ≤ ⊤

5

Constructing types syntactically

Types with lattice subtyping: τ ::= bool | τ1 → τ2 | {ℓ1 : τ1, . . . , ℓn : τn} | ⊥ | ⊤ bool ≤ bool τ ′

1 ≤ τ1

τ2 ≤ τ ′

2

τ1 → τ2 ≤ τ ′

1 → τ ′ 2

{ℓ1 : τ1, . . . , ℓn : τn, . . . } ≤ {ℓ1 : τ1, . . . ℓn : τn} τ1 ≤ τ ′

1

. . . τn ≤ τ ′

n

{ℓ1 : τ1, . . . , ℓn : τn} ≤ {ℓ1 : τ ′

1, . . . , ℓn : τ ′ n}

⊤ ≤ τ τ ≤ ⊤

5

What’s going on here?

F(A) = Bool(A) + Func(A) + Rec(A) Bool(A) = bool Func(A) = A × A Rec(A) = L ⇀ A Take the initial algebra of F : Set → Set

6

What’s going on here?

F(A) = Bool(A) + Func(A) + Rec(A) Bool(A) = bool Func(A) = A− × A Rec(A) = L ⇀ A Take the initial algebra of F : Pos → Pos.

6

What’s going on here?

F(A) = Bool(A) + Func(A) + Rec(A) Bool(A) = (bool)⊤

⊥

Func(A) = (A− × A)⊤

⊥

Rec(A) = (L ⇀ A)⊤

⊥

Take the initial algebra of F : Pos⊤

⊥ → Pos⊤ ⊥.

6

What’s going on here?

F(A) = Bool(A) + Func(A) + Rec(A) Bool(A) = (bool)⊤

⊥

Func(A) = (A− × A)⊤

⊥

Rec(A) = (L ⇀ A)⊤

⊥

Take a lattice of types, forget that it’s a lattice, apply F : Pos⊤

⊥ →

Pos⊤

⊥, and notice that the result happens to be a lattice.

6

What’s going on here?

F(A) = Bool(A) + Func(A) + Rec(A) Bool(A) = (bool)⊤

⊥

Func(A) = (A− × A)⊤

⊥

Rec(A) = (L ⇀ A)⊤

⊥

Take the initial algebra of F : Lat → Lat.

6

Coproducts

τ ::= bool | τ1 → τ2 | {ℓ1 : τ1, . . . , ℓn : τn} The | should be the coproduct. Not always union!

7

Coproducts

τ ::= bool | τ1 → τ2 | {ℓ1 : τ1, . . . , ℓn : τn} The | should be the coproduct. Not always union! We get some new types: (τ → τ) ⊓ {foo : τ}

7

Coproducts

τ ::= bool | τ1 → τ2 | {ℓ1 : τ1, . . . , ℓn : τn} The | should be the coproduct. Not always union! We get some new types: (τ → τ) ⊓ {foo : τ} ≤ bool

7

Type variables

How about type variables as metavariables?

8

Type variables

How about type variables as metavariables? Pottier’s tricky example: τ = ⊥ | τ → τ | ⊤ (⊥ → ⊤) → ⊥ ≤ (α → ⊥) ⊔ α This is true, by case analysis. . .

8

Type variables

How about type variables as metavariables? Pottier’s tricky example: τ = ⊥ | τ → τ | ⊤ (⊥ → ⊤) → ⊥ ≤ (α → ⊥) ⊔ α This is true, by case analysis. . . until we extend the type system α = (⊤ ◦ → ⊥)

• → ⊥

8

Type variables

How about type variables as metavariables? Pottier’s tricky example: τ = ⊥ | τ → τ | ⊤ (⊥ → ⊤) → ⊥ ≤ (α → ⊥) ⊔ α This is true, by case analysis. . . until we extend the type system α = (⊤ ◦ → ⊥)

• → ⊥

We need type variables as a free algebra. Syntactically, add them as opaque indeterminates: τ ::= bool | τ1 → τ2 | {ℓ1 : τ1, . . . , ℓn : τn} | α

8

Inferring types

Polarity

We have lots of types, but they’re not all useful all the time. τ1 ⊔ τ2 describes an output that may be τ1 or may be τ2. τ1 ⊓ τ2 describes an input that must be τ1 and must be τ2

10

Polarity

We have lots of types, but they’re not all useful all the time. τ1 ⊔ τ2 describes an output that may be τ1 or may be τ2. τ1 ⊓ τ2 describes an input that must be τ1 and must be τ2 Use positive types τ + for outputs, and negative types τ − for inputs: τ + ::= α | τ + ⊔ τ + | ⊥ | unit | τ − → τ + τ − ::= α | τ − ⊓ τ − | ⊤ | unit | τ + → τ −

10

When does ML unify?

Two inputs: introduce ⊓ Two outputs: introduce ⊔ Output used as an input: constraint τ + ≤ τ −

11

When does ML unify?

Two inputs: introduce ⊓ Two outputs: introduce ⊔ Output used as an input: constraint τ + ≤ τ − Handling ⊔ and ⊓ is easy, thanks to polarity: τ1 ⊔ τ2 ≤ τ3 iff τ1 ≤ τ3, τ2 ≤ τ3 τ1 ≤ τ2 ⊓ τ3 iff τ1 ≤ τ2, τ1 ≤ τ3

11

Atomic constraints

How do we get rid of α ≤ τ − or τ + ≤ α? Not substitution!

12

Atomic constraints

How do we get rid of α ≤ τ − or τ + ≤ α? Not substitution!

∀ = Λ

12

Atomic constraints

How do we get rid of α ≤ τ − or τ + ≤ α? Not substitution!

∀ = Λ

ML’s ∀ is more like a set comprehension. These are the same: ∀α∀β. α → β → α ∀β∀α. α → β → α because these are the same {α → β → α | α, β types} {α → β → α | β, α types}

12

Preserving the set of instances

It’s easy to remove constraints from set comprehensions:

13

Preserving the set of instances

It’s easy to remove constraints from set comprehensions: {n2 + 17 | n ∈ N, n ≥ 5}

13

Preserving the set of instances

It’s easy to remove constraints from set comprehensions: {n2 + 17 | n ∈ N, n ≥ 5} = {max(n, 5)2 + 17 | n ∈ N}

13

Preserving the set of instances

It’s easy to remove constraints from set comprehensions: {n2 + 17 | n ∈ N, n ≥ 5} = {max(n, 5)2 + 17 | n ∈ N} Thinking of type schemes as set comprehensions, we can do the same: α → α | α ≤ {isgood : bool}

13

Preserving the set of instances

It’s easy to remove constraints from set comprehensions: {n2 + 17 | n ∈ N, n ≥ 5} = {max(n, 5)2 + 17 | n ∈ N} Thinking of type schemes as set comprehensions, we can do the same: α → α | α ≤ {isgood : bool} = (α ⊓ {isgood : bool}) → (α ⊓ {isgood : bool})

13

Preserving the set of instances

It’s easy to remove constraints from set comprehensions: {n2 + 17 | n ∈ N, n ≥ 5} = {max(n, 5)2 + 17 | n ∈ N} Thinking of type schemes as set comprehensions, we can do the same: α → α | α ≤ {isgood : bool} = (α ⊓ {isgood : bool}) → (α ⊓ {isgood : bool}) = (α ⊓ {isgood : bool}) → α

13

Example

filter good : list[{isgood : bool} ⊓ α] → list[α] things : list[{isgood : bool, x : int}]

14

Example

filter good : list[{isgood : bool} ⊓ α] → list[α] things : list[{isgood : bool, x : int}] list[{isgood : bool}⊓α] → list[α] ≤ list[{isgood : bool, x : int}] → β

14

Example

filter good : list[{isgood : bool} ⊓ α] → list[α] things : list[{isgood : bool, x : int}] list[α] ≤ β list[{isgood : bool, x : int}] ≤ list[{isgood : bool} ⊓ α]

14

Example

filter good : list[{isgood : bool} ⊓ α] → list[α] things : list[{isgood : bool, x : int}] list[α] ≤ β {isgood : bool, x : int} ≤ {isgood : bool} ⊓ α

14

Example

filter good : list[{isgood : bool} ⊓ α] → list[α] things : list[{isgood : bool, x : int}] list[α] ≤ β {isgood : bool, x : int} ≤ {isgood : bool} {isgood : bool, x : int} ≤ α

14

Example

filter good : list[{isgood : bool} ⊓ α] → list[α] things : list[{isgood : bool, x : int}] list[α] ≤ β {isgood : bool, x : int} ≤ α

14

Example

filter good : list[{isgood : bool} ⊓ α] → list[α] things : list[{isgood : bool, x : int}] β+ → β ⊔ list[α] α+ → α ⊔ {isgood : bool, x : int}

14

Example

filter good : list[{isgood : bool} ⊓ α] → list[α] things : list[{isgood : bool, x : int}] β ⊔ list[α ⊔ {isgood : bool, x : int}]

14

Example

filter good : list[{isgood : bool} ⊓ α] → list[α] things : list[{isgood : bool, x : int}] list[{isgood : bool, x : int}]

14

Questions? http://www.cl.cam.ac.uk/~sd601/mlsub stephen.dolan@cl.cam.ac.uk

15