modules in uhc a proposal by: tom hofte & eric eijkelenboom

Modules in UHC

A proposal by: Tom Hofte & Eric Eijkelenboom

Contents

Our exercise What are modules Modules in ML First-class modules as records Our syntax Well kinded and well-typed records Conclusion

Our goal

Design a module system for the UHC Based on existing work No implementation; just design

What are modules?

Packaging code Orderly organization of types and values Modules can be combined List module in Haskell Java package

What are modules?

Core language and module language Good example: ML Haskell module language is weaker

Modules in ML

Separate types and values that belong together Structures and signatures Structure contains values and types Signature classifies them

Modules in ML - Signatures

Signature examplesignature INTMAP = sig

type ‘a intmapval empty: ‘a intmapval find: ‘a intmap -> int -> ‘aval insert: int*’a -> ‘a intmap

-> ‘a intmap

end;

Modules in ML - Structures

Structure example 1: Structure Intfn : INTMAP =

struct

type ‘a intmap = int -> ‘a

fun empty i = “error”

fun find f x = f x

fun insert (a,b) f i =

if i==a then b else f i

end;

Modules in ML - Structures

Structure example 2: Structure IntList : INTMAP = structtype ‘a intmap = [(Int, a)]fun empty i = []fun find f x = …

fun insert (a,b) f i = …end;

Modules in ML - Matching

Implementation independent Signature can be seen as Java interface Structure should match signature Notation: structure : signature Or: structure :> signature

Modules in ML - Matching

Transparent matching (‘:’) vs. opaque matching (‘:>’) Expression: IntFn.empty 5 Legal with transparent matching Illegal with opaque matching Correct: IntFn.insert IntFn.empty 5

Modules in ML - Functors

Parameterized modules Function maps a structure to structure Functors

Modules in ML - Functors

A signature:signature NewSig = sig

newVal : `a intmap end;

Create new structure using parameter:Functor NewStruct(IM : INTMAP) : NewSig

struct

val newVal = IM.extend IM.empty 5

end;

Modules in ML - Conclusion

Structures can use each others types and values! This is exactly what modules are all about Idea: modules are implemented by using signatures, structures Functors are ordinary functions

How to do this in UHC?

Use the ideas from ML UHC is written in Haskell Problem: Haskell has no signatures etc. Solution: implement modules as first-class objects

First-class modules as records

We introduce record types (signatures) and records (structures) These record types are first-class citizens and can thus be used in functions We implement modules as records

Record types

We would like to define a record type:

record Set a f =

empty :: f a

add :: a -> f a -> f a

asList:: f a -> [a]

Records

And implement this record type with a record:

intSet :: Set Int []

intSet = Set

empty = []

add = \(x::Int) xs -> …

asList= id

Our Syntax

We have created a syntax that realizes modules in Haskell First, we introduce some additional syntax.

Record types and constructors

Record type body declarationsS ::= record A ∆ = S’;S |

l :: σ; S | ε

Record constructor body declarations ::= l = t | ε

Addition to terms t ::= record A ∆ = S in t |

Ps |

t.l|

Type classes

Not in our syntax You can make more restrictionEg. Elements of a List module should be of the class EG You can do it with records. It works like functors in ML..

Types and type schemes

Types: τ, ν ::= ν -> τ | A τ | a τ | τ ν Type schemes:

σ ::=forall Δ. σ | exists Δ. σ

| σ -> σ| τ

Δ ::= a : κ, Δ | ε

More general types

Types: quantifiers only on outer level:

forall c. [c] -> Int Schemes: quantifiers also inside:

f (g : forall c. [c] -> Int)= g[“hello”] + g[1, 2]

Well-kinded records

k ::= * | k ->k Ω ::= a: k, Ω | A: k, Ω | record A, Ω |

ε Ω τ : k Three different check rules kind, term and record type rules

Kind rules

Record type body rules

Term kind-check rules

What still to be done

Nested records Abstract modules and existentials Kind and type inferencing Implement it for Atze in UHC

Conclusion

Modules can be implemented as first-class citizens Using records Kind and type checking rules for records Still a lot of design work to do for a well working implementation for UHC