Module System in Standard ML

Module System of Standard ML
Jiten, Keheliya, Tobias
Tuesday 21st April, 2015
Jiten, Keheliya, Tobias Module System of Standard ML Tuesday 21st
April, 2015 1 / 39

Outline
1 Modularity
2 Introduction to Standard ML
3 Modules in Standard ML
April, 2015 2 / 39

Outline
1 Modularity
April, 2015 3 / 39

Why Modularity?
Writing large programs is difﬁcult!
Lots of interdependencies
Changing code breaks other code
Concurrent development difﬁcult
Maintenance is a nightmare.
April, 2015 4 / 39

Why Modularity?
Writing large programs is difﬁcult!
Lots of interdependencies
Changing code breaks other code
Concurrent development difﬁcult
Maintenance is a nightmare.
The solution: Modularity
Implement program as independent modules
Hide information between modules to obscure implementation
details (abstraction)
Sharing: Interaction of program modules
April, 2015 4 / 39

How do programmers use modularity in C?
Write .h file (Header) and .c file (Source)
Header specifies variables and functions
Source is the full implementation
Compile library from both files and provide Header file as
interface.
April, 2015 5 / 39

Outline
1 Modularity
April, 2015 6 / 39

History of Standard ML
ML (stands for metalanguage)
Developed in Edinburgh in late ’70s
Designed by Michael J.C. Gordon, Robin Milner, and Christopher
P. Wadsworth
Standard ML (originated from ML)
Has a formal speciﬁcation, given as typing rules and operational
semantics
The Deﬁnition of Standard ML (Revised) in 1997
Other siblings of the family: CAML, Caml Light, OCaml
April, 2015 7 / 39

Features of Standard ML
Higher-order functions
Interactive
Strongly Typed
Call-by-value
Polymorphism
Algebraic datatypes and pattern matching
Statically scoped
Type-safe exceptions
Modularity
April, 2015 8 / 39

Language Basics
Primitive Data Types: unit,bool,int,real,string
Function Expressions
val inc = fn x => x + 1
fun inc x = x + 1
April, 2015 9 / 39

Tuples, Records, Lists
Tuples
> val x = ("Prius", 1.0 / 2.0, false)
: string * real * bool
Records
> val dob = {day=21,month="July",year="1815"}
: {day:int, month:string, year:string}
Lists
> val price = [1.0,2.0,3.0];
> val price = 1.0 :: 2.0 :: 3.0 :: nil
val price = [1.0,2.0,3.0] : real list
April, 2015 10 / 39

Higher-order Functions
Functions can consume functions as arguments
fun applyTwice f x = f(f(x));
Functions can return functions
val add = fn x => fn y => x + y
April, 2015 11 / 39

Static Scoping
What is the output of this program?
val x = 2
fun f y = x+y
val x = 3
val z = f 4
Refers to the nearest lexically enclosing declaration!
April, 2015 12 / 39

Type Inference
Examples of type inference
fun ident (x) = x;
val ident = fn : ’a -> ’a
fun plus (x,y) = x+y;
val plus = fn : int * int -> int
fun new_if(A,B,C) = if A then B else C;
val new_if = fn : bool * ’a * ’a -> ’a
fun first (x,y) = x;
val first = fn : ’a * ’b -> ’a
’a standing for any type at all.
Function body makes no commitment to type of x at all.
Type inference produces the most general type, which may be
polymorphic.
April, 2015 13 / 39

Pattern Matching
Wildcard Patterns
val (x,y,_) = (4,"May",1987);
val x = 4 : int
val y = "May" : string
Nested Patterns
val (a,b)::c::_ = [(3,true),(5,false),(9,false)];
val a = 3 : int
val b = true : bool
val c = (5,false) : int * bool
Function deﬁnition by cases
fun is_nil( nil ) = true
| is_nil(_::_) = false;
April, 2015 14 / 39

Recursive Types
datatype ’a tree = empty
| leaf of ’a
| node of ’a tree * ’a tree;
datatype ’a list = nil | :: of ’a * ’a list;
fun append(nil,l) = l
| append(hd::tl,l) = hd :: append(tl,l);
April, 2015 15 / 39

Recursive Typing
To type inﬁnte data-structures (Lists, queues, trees, streams etc.)
April, 2015 16 / 39

Recursive Typing
Without Recursive typing:-
t ::“ nilT | consT t t | headT t | tailT t
v ::“ nilT | consT v v
T ::“ List T
Γ $ t1 : T1 Γ $ t2 : List T1
Γ $ consT1 t1 t2 : List T1
(T-cons)
Γ $ t1 : List T1
Γ $ headT1 t1 : T1
(T-head)
April, 2015 16 / 39

Recursive Typing
T ::“ List T
Γ $ t1 : T1 Γ $ t2 : List T1
(T-cons)
Γ $ t1 : List T1
Γ $ headT1 t1 : T1
(T-head)
Recursive typing:-
T ::“ X | rec X.T
April, 2015 16 / 39

Recursive Typing
T ::“ List T
Γ $ t1 : T1 Γ $ t2 : List T1
(T-cons)
Γ $ t1 : List T1
Γ $ headT1 t1 : T1
(T-head)
Recursive typing:-
T ::“ X | rec X.T
IntList “ rec X. xnil : Unit, cons : tInt, Xuy
Nat “ rec X. xZero : Unit, succ : Xy
April, 2015 16 / 39

Recursive Typing...
t ::“ foldT t | unfoldT t
v ::“ foldT v
unfoldS pfoldT vq ÝÑ v(E-unfldfld)
U “ rec X.T1 Γ $ t1 : rU{XsT1
Γ $ foldU t1 : U
(T-fld)
U “ rec X.T1 Γ $ t1 : U
Γ $ unfoldU t1 : rU{XsT1
(T-unfld)
April, 2015 17 / 39

Recursive Typing...
t ::“ foldT t | unfoldT t
v ::“ foldT v
unfoldS pfoldT vq ÝÑ v(E-unfldfld)
U “ rec X.T1 Γ $ t1 : rU{XsT1
Γ $ foldU t1 : U
(T-fld)
U “ rec X.T1 Γ $ t1 : U
Γ $ unfoldU t1 : rU{XsT1
(T-unfld)
nil “ foldrIntLists xnil “ unity
cons = λn : Int.λl : IntList.foldrIntLists xcons “ tn, luy
April, 2015 17 / 39

v ::“ λx : T.t | λX.t
T ::“ X | T Ñ T | @X.T
Γ ::“ Φ | Γ, x : T | Γ, X
pλx : T11.t12q v2 rv2{xst12
pλX.t12q rT2s rT2{Xst12
April, 2015 18 / 39

v ::“ λx : T.t | λX.t
T ::“ X | T Ñ T | @X.T
Γ ::“ Φ | Γ, x : T | Γ, X
Γ, X $ t2 : T2
Γ $ λX.t2 : @X.T2
(T-Tabs)
Γ $ t1 : @X.T12
Γ $ t1 rT2s : rT2{XsT12
T-Tapp)
April, 2015 18 / 39

v ::“ λx : T.t | λX.t
T ::“ X | T Ñ T | @X.T
Γ ::“ Φ | Γ, x : T | Γ, X
Γ, X $ t2 : T2
Γ $ λX.t2 : @X.T2
(T-Tabs)
Γ $ t1 : @X.T12
T-Tapp)
Example:-
Polymorphism in ML:-
Self-Application: Type of λx.x x?
λx : @X.X Ñ X. x r@X.X Ñ Xs x : p@X.X Ñ Xq Ñ p@X.X Ñ Xq
April, 2015 18 / 39

Example: Stack
exception EmptyStack;
val empty = [];
fun push x r = x::r;
fun pop r = case r of
x::s => (x,s)
| [] => raise EmptyStack;
Type of push:
’a -> ’a list -> ’a list
April, 2015 19 / 39

Example: Stack
Type of push:
’a -> ’a list -> ’a list
This exposes the implementation datastructure (list)!
We want the view of the type to be abstract:
’a -> ’a stack -> ’a stack
ñ Need Standard ML’s abstract types in modules.
April, 2015 20 / 39

Outline
1 Modularity
April, 2015 21 / 39

Signatures
Signatures encode structural information
Specify a module’s value and function types
Provided explicitly by the programmer or discovered by type
inference
signature EQ =
sig
type elem
val eq: elem * elem -> bool
end;
April, 2015 22 / 39

Structures
structure is Standard ML’s Module
structure IntEq : EQ =
struct
type elem = int
val eq = (op =)
end;
Here, the signature is speciﬁed explicitly.
April, 2015 23 / 39

All put together: Signature, Module and Access
signature EQ =
sig
type elem
end;
struct
type elem = int
val eq = (op =)
end;
IntEq.eq(3,4);
IntEq.eq(4,4);
April, 2015 24 / 39

Structures with explicit Signatures (1)
structure IntEq : EQ means that the structure’s inferred
signature is checked against the signature EQ
IntEq must provide at least what’s in EQ.
signature EQ =
sig
type elem
end;
struct
type elem = int
end;
> Error: unmatched value specification: eq
April, 2015 25 / 39

Structures with explicit Signatures (2)
We can make structure IntEq more powerful than EQ. But the
view is still restricted by the explicit signature EQ.
signature EQ =
sig
type elem
end;
struct
type elem = int
val eq = (op =)
val internalvalue = 1337
end;
IntEq.internalvalue;
> Error: unbound variable or constructor: internalvalue in
path IntEq.internalvalue
April, 2015 26 / 39

Opaque vs. Transparent Signatures (1)
Remember we could evaluate IntEq.eq(3,4);?
IntEq has signature EQ, which means IntEq.eq takes elem
variables as parameter – not integers!
April, 2015 27 / 39

Remember we could evaluate IntEq.eq(3,4);?
IntEq has signature EQ, which means IntEq.eq takes elem
variables as parameter – not integers!
Well duh, calling with integers works, since IntEq.elem = int.
Signatures are transparent. We can make them opaque to strictly
restrict the view of IntEq to EQ.
April, 2015 27 / 39

structure IntEq :> EQ =
struct
type elem = int
val eq = (op =)
end;
IntEq.eq(3,4);
> Error: operator and operand don’t agree [literal]
operator domain: IntEq.elem * IntEq.elem
operand: int * int
in expression:
IntEq.eq (3,4)
April, 2015 28 / 39

Stack Module
signature STACK =
sig
type ’a stack
val empty: ’a stack
val push: ’a -> ’a stack -> ’a stack
val pop: ’a stack -> ’a * ’a stack
end;
structure stack :> STACK =
struct
exception EmptyStack;
type ’a stack = ’a list;
val empty = [];
fun push x r = x::r;
fun pop r = case r of
x::s => (x,s)
| [] => raise EmptyStack;
end;
April, 2015 29 / 39

Stack Module
stack.push now has type:
’a -> ’a stack.stack -> ’a stack.stack.
Thanks to opaqueness, stack.push 3 [5]; is illegal.
Implementation protected. Yay!
April, 2015 30 / 39

Functors
A Functor takes a Structure as an argument and returns a
Structure.
They are deﬁned using functor bindings at the top level (like
function deﬁnitions)
Limited to a single argument (Workaround: Several structures can
be packaged into one as substructures and then passed to a
functor)
April, 2015 31 / 39

Functors: Example
functor F( P: EQ ) : EQ =
struct
type t = P.t * P.t
fun eq((x,y),(u,v)) = P.eq(x,u) andalso P.eq(y,v)
end;
struct
type t = int
val eq = (op =)
end;
structure IntTupleEq = F(IntEq);
IntTupleEq.eq((3,4),(3,4));
April, 2015 32 / 39

Functors with Submodules: Example
What if we want tuples of two different datatypes?
For instance tuples of Integers and Strings: eq((3,"a"),(3,"c"))
First, we introduce StringEq, similarly to IntEq:
structure StringEq : EQ =
struct
type t = string
val eq = (op =)
end;
Problem: functors only take a single structure as an argument. We
need to pass IntEq and StringEq!
Solution: Create a module containing both.
April, 2015 33 / 39

Functors with Submodules: Example
signature TupleOfEQ =
sig
structure first : EQ
structure second : EQ
end;
functor F( P: TupleOfEQ ) : EQ =
struct
type t = P.first.t * P.second.t
fun eq((x,y),(u,v)) = P.first.eq(x,u) andalso P.second.eq(y,v)
end;
structure IntStringTuple : TupleOfEQ =
struct
structure first = IntEq
structure second = StringEq
end;
structure IntStringTupleCombined = F(IntStringTuple);
IntStringTupleCombined.eq((3,"a"),(3,"c"));
April, 2015 34 / 39

Sums and Products :-
Πx : A.B “
ą
t Bpxq | x P A u
Σx : A.B “ t Bpxq | x P A u
Elements of Πx : A.B fpaq “ ra{xsB.
Elements of Σx : A.B xa, by , a P A, b “ ra{xsB.
Strong sums:
sndppq : Bpfstppqq fstppq “ a.
Corresponds to the transparent signatures.
Weak sums:
Corresponds to the opaque ascription.
A form of existential type.
Transclucent sums:-
Optionally contain information about the representation of type.
April, 2015 35 / 39

Module system Calculus..
Introduction and elimination rules:-
$ Γvalid @i P r1.ns. Γ, D1, .., Di´1 $ Bi : Di
Γ $ B1, .., Bn : D1, .., Dn
(TSUM)
Γ $ V : b Ź α :: K
Γ $ V.b :: K
(C-EXT-O)
Γ $ M : y Ź x : A
Γ $ M.y : A
(EXT-V)
Translucency:-
Γ $ V : b Ź α :: K “ A
Γ $ V.b “ A :: K
(ABBREV)
April, 2015 37 / 39

Module system Calculus..
Value Rules:-
Γ $ V : b Ź α :: K, D1, .., Dn
Γ $ V : b Ź α :: K “ V.b, D1, .., Dn
(VALUE-O)
Γ $ V.y : A1 Γ $ V : y Ź x : A, D1, .., Dn
Γ $ V : y Ź x : A1, D1, .., Dn
(VALUE-V)
April, 2015 38 / 39

Summary and Outlook
ML has a powerful module system, using signatures, structures
and functors
Modules in ML are not part of the core language
Beyond ML Modules: Recursive modules, higher-order functors,
applicative functors
April, 2015 39 / 39

Module System in Standard ML

Recommended

Recommended

More Related Content

Viewers also liked

Viewers also liked (13)

Similar to Module System in Standard ML

Similar to Module System in Standard ML (20)

Recently uploaded

Recently uploaded (20)

Module System in Standard ML