Separate Compilation for Standard ML - CiteSeerX

Separate Andrew

Compilation

W.

Princeton

for Standard

Appel*

David

University

appel@princeton

AT&T

.edu

Bell

terface ever,

Languages

that

structure,

such

(more

or

less)

dency

hierarchies

support

abstraction

as Standard

ML,

C++,

may

among

is particularly

source

severe

rametrized

module

cies

implementation

among

have

deeply

modular

In ML

ML’s

facility

Ada,

nested

files.

because

(functor)

and

Modula,

the

just

modules the

att .com

that

it imports

examination

When

depen-

it’s

prob-

powerful

not

Laboratories

or exports,

of another

but

rarely,

implementation

if

mod-

ule.

and

ent ails depend

modules,

MacQueen

macqueen@research.

Abstract

lem

B.

ML

the

dependency

reasonable

by each

is modified;

en-

make[7]. There

graph

re-parse

compilation

paamong

to

unit

this

some

the any

C

compilers

problems,

is shallow,

interfaces

when

is what

are still

of interfaces

all

imported

imported

interface

do

with

Unix

however:

interfaces. To efficiently guages, and

it is useful

cache

the

compilation Our

system

This

in the form that

necessary)

environment

a simple

from

to infer,

resulting

from

dependent

ules

digest,

can

available

“visible

with

compiler

IRM

incremental

●

modules,

a fea-

The

client

chief

tion

recompilation

●

guish

between In

a weaker

mentation

in

as Ada modules

sense

even

by organizing

Compilers

compilation

such

interface

a distinction

.C files.

in about

Implementa-

for these which

module

the

requires

and

Modula,

and

Languages

C and

languages

that

support

compilation the examination

can

3 [20,

may,

mod-

in

the

for

01

building

20,000

lines

be time-consuming

for

of those

in

in-

in part by NSF grant &XL9200790.

powerful nient

that

Another cies

SIGPIAN 94-6/94 Orlando, Florida USA @ 1994 ACM 0-89791 -662-xKWO006..$3.5O

13

is

2).

also

avoid

it is heavily source

in-line

As have

problem, module

ML

we

Modula-

will

explain inter-

generics

have

yield

a less

but system.

The and

so a heavy-duty

of

functions

in

of parame-

funcconve-

approach

is justified.

of inter-implementation

expansion

—

nontrivial

is so powerful

used;

compilation

[4] and forms

Modula-3

this

language

(parameterized

Ada

generics.

dependencies.

algorithms

dependencies

functor

other

recompilation.

of a modular

limited

generics

on

dependency

make

ation

more

of Standard

to its separate

deeper

of unnecessary

and less convenient

t or facility

a

a powerful

depenHaving

dependent

to

timestamp-based

called

that

allow

modules.

module

(see section

2, Ada ation

reasons,

is an example

modules,

section

restrictions

Permission to co y without fee all or part of this material is “J that the copies are not made or distributed for granted provrd direct commercial advantage, the ACM copyright notice and the title of the publication and its date appear, and notice is given that copying is by permission of the Association of Computing Machinery. To copy otherwise, or to republish, requires a fee ancf/or specific permission.

various

leads

much

mod-

recompila-

is changed.

inter-implement

facility

on a particular

unnecessary

implementation

amounts

ML

9] have

trized

imple-

depend avoid

module

case, to support

module)

.h and

separate

of each

that

causing

allows

this

support in

files to

between

Standard

distin-

C++ code

which

implementation

DAG,

implementation

source

[13],

many

when

implement *Supp.rted

bring

files

to do large

languages,

modules. such

user interfaces,

implementations

t ions Modular

library

so we want

dencies

and

interface files

C++

Sometimes ule,

CMU.

Interfaces

the

some

type-safe

one

1

of just

deep:

to process.

(a

to user programs

compiler.”

quite

a well-known

of header

of compilation

y DAG

be

library[5],

the

recompilation

compilation)

is made

is the

model

incremental

of a set of internal

interface

Q The

in such lan-

X-based

of separate model

modules

module.

supports

we call the

manager

ML,

provides

form

linkage.

of this

static

that

restricted

individual

(in

of each

and linkage

ture

compile

dependenacross

module

boundaries—whether line

pragma

performed

(as in

timizing

compiler

describe

here

sort,

Some

al.

for

does

though

ated

of

the

[1] review

hashed

into

source

code

sions

(and

of interface

ysis

both

making face

it

are just ports

too

not

files.

big

be

ics cannot

to

guments.)

for

In this

paper

we give

to be used by a “make” ation

an overview crement analyzer,

of those of a major

al

client

and

Our

new

source

module face,

view”

and we describe In section

of these

manager a full

compilation

implemented

in

of the

IRM.

recompilation at ion

in

interfaces,

a uniform

ronment

so that

a language

commands piled

are

compilation

and

linkage

with

separately

bles)

and

similar and

dynamic

(analogous

environments

to linkage

tables)

can be composed

that

to symbol

the

exact

module,

stamp

for

export and

precise

interface

hashes

this

recompilation

“link-time

provides ternal own

type-safe type

dynamic

an

2

intrinsic

components clients

for

without

type-safe

of an interactive

(see section

{Hj

text

} of

of the

compilation with

inter-

Mj, on the

without

(in

the

again.

is altered—in

a way

interface—and use Adams’s

compiled

that

recompiled,

M;

terminology (dependent

on

recompilation. allows

examination

must

then

be made

about

of Mi.

But

demonstrated

Mi

of Mj

Hj

and

smartest

to (or

be any

smarter Mj

so

made

recompila-

feasible

for

higher-

ors. paper

not

we will

a classical

describe or smartest

a cutofl

recompilation

system.

usage system

Standard

ML

modules

5); requir-

checking;”

an architecture

Mj

hypotheses

yet been

mod-

of an implemeninto

(see section linkage

compiled

Mj

the

compilation

funct

In this

side-effect-free

The

ing

the

sepa-

(dependent

recompilation[23]

linker

verify

has not

order

values

can

system,

tation

enforces

Hj !); the it

the

language

Mi

the

[21] (we

without

corre-

1

be

previously

smartest even

inter-

any

subset

separate

any

exported

to be used without

during tion

manner; infers

the

if any

a set of implementations

modules

recompilation

vacuo,

and

of

of some

a module

Mj ) to

its

in But

classical

compilation

or

an

modules.

lln

examining

) compiling

affect

allows

of the

a role

are first-class

in an elegant,

ar-

pos-

its export

. . . . Mn,

Classical ML,

compiled

of the

Finally,

ta-

the

dependence.

ations

compiled com-

(playing

do

termed

a module

111,..., Ml,

without

allows

“session”

that

environments

to

gener-

always

of the dependent

interfaces

for

once

envi-

modules;

uses static

at all

their

it imports.

changing

examination

but

Having

cutofl

compile-and-execute

compatible

of

the

ation

[1])

without

allows

implement

same

compile

recompilation

possible

implement

Stanof New

to

all of the modules

recompilation

dependencies;

interactive

is better

implementations.

Mj ) provides

from

It is not

set

M~ with

If one

incremental

the

separately

implementations

does not allows

first

system.

system,

a

ule

compiler,

wit h inter-implement

are

however,

we avoid

other

utility.

ML

the

systems,

achieved,

is recompiled

is not

an in-

for

Standard

we

with

is not

recompilation our

the

A compan-

of this mechanism

the

the im8 we give

primitives,

called

modules

or Modula-3

compiled

rat e compilation

source-dependence

description

to inter-

in a language

order

we believe

Ada

seeing

Given

im-

as a set of primitives

manager,

separate

ML,

Jersey

in

inter-

that

system,

client

library gives

s-eye

and

we have

sible,

modules

primitives.

recompilation

paper[15]

dard

a “compiler’

mechanism

opti-

leads

Recompilation

incremental without

digested

each

descriptions higher

be fully

sponding

compilation

plement

(In

What

anal-

modules,

the

interface

for

process.

implementation

to re-elaborate

cross-module

language)

ver-

by semantic

re-elaborate

support

any

dependencies.

compiled

Cutoff

use

to (in

un-

“digested”

importing

to

full

thing,

them.

separate

ion

the

just

ation

existing

can

implementation

The

implement

a trivial

modifications

is derived

necessary

and

which

this.

et

the hash-and

[8, 12] create

to speed

especially

of imported

enumerAdams

interface

trivial

and

be generalized

mization,

separately

are avoided.

interface

descriptions,

code

we

replacements

change

interface

can

●

of this

issues

an

so that

files

an export

system

before:

several

necessarily

compilers

In ML,

in-

To infer

compilation

measure)

a stamp, don’t

The

an

an op-

dependencies

recompilation:

Modula

of

with

addressed

recompilation

Some

language.

by

in principle.

been

timestamp-based

to

automatically

deal

separate

have

in response

or

any

not

it could

above

necessary

Ada),

module

system

Ada,

distinguishes

tures

in

ML)

and

of ML, between

like

those

interfaces

implementations

of Modula (called

(called

and signa-

structures

1In ML the user can always decouple implementations from each other using functors. This is helpful to the user, when true separate compilation is desire~ for example, when a client module must be compiled independently of the modules it imports.

of inby its

7);

14

and ~unctors). ture

is

However,

often

only

in ML

partially

the interface

described

of a struc-

by

an

More

explicit

generally,

ule it maybe

signature2.

of

all

the

modules

todetermine signature

PARTIAL.

not

ORDER =

type val

less

:

elem

*

elem

->

bool

end SORT =

type

imported

modules.

sort

: t

list

->

t

end functor

TopSort(P

: PARTIAL_OmER)

utility

struct type

t

fun

=

. . . P.less(x,y)

. . .

~

structure

Factors

: PARTIAL-ORDER

that

=

type

elem

fun

= int =

(j

mod

i

= O)

end

different

dard

ML.

: SORT = TopSort(Factors)

are

signatures

A signature

in

a structure like

will

opaque.

ML’s

that

structure known not

FSort that

thenit

partial

in the

orders

inspect

structure and

not

1 will

the

merely

be of use only

SORT to

However, nor apply

rectly

on

that

is subject they

applying

to arise

in Stan-

Modula-3

is to view

of source-language

only

their

a functor code

ex-

compilation”

of

instances

is type-checked

independently

of its

is a very it

significant

does

come

dependence. module

avoid

weaken so our

the

These

original

separate

with

inter-implementation

ML

compilation

styles

for

alternatives

Standard

compilation

of inter-

10 we discuss

and programming

dependence.

of the

cost

In section

systems

this

advantage at the

ML

system

can module

deals

di-

dependence.

is

3

be,

model

TopSortto original

single

of FSotionelmust

module interface,

generic

a package

depend also

those

since

ML,

the

of

as

a de-

thisis

The

a client

and

“separate

machine

system,

significantly

the

shouldit

: SORT = TopSort(Factors (partial)

that

system,

must

types.3

implementation the

ML

param-

ifit

this

module

alternative

interface

Forexample,

In

into

implementation

(func-

which

really

themselves,

compiled.

compiled

Though ML

matching

actual types,

asint.

to compile

FSort

unele-

is a partial

bepossible

other

but

is not

the

causes

though

and

limit

applications.

of

these

structures

functor.

signature

not

over

Consequently, first

the

of figure

would

signature

different

FSort.tisthesame

specified

for

render

be instantiatedby

through

elements

structures, not

signature

containing

be propagated

type

parameterized

will

structures

does

“transparent”

parameter

description eter

it

to support

whose

what

to client

interface,

is designed tors),

specifies

be visible

aModula

merits

ML

in Ada

in-

can occur

this

also

So Ada

as a kind

modules

truly

and

used

This

generic 1: Transparent

body

from

can its

of these

does

Importers

dependencies,

instantiation

pansion.

Figure

package

mechanisms

solution

generic

chain

package and

procedures

on

generics.

body,

implementation.

from

The FSort

of a generic

inter-implementation

less(i,j)

structure

inline

(only

restriction

of Modula-3

that

of a generic module

of A

instantiates.

because So an im-

inter-implementation

a nontrivial

in a package

exports

package’s

Struct

implementation

this

(the of the

modules

level.

is an instance an

2 and

much,

no other

an instance

it

are

only

and

situation

of

However,

Modula

at the top

A that

convenience

that

that

specifications

example

between

package

indirectly)

inspect

interfaces

this

is never

pendency

end

generic

change

so there

a submodule

in to

inter face

implementation

In Ada,

= P.elem

sort(1)

but

and

or

types

situation

the

dependencies.

: SORT .

The

is an

on

terface),

the

module

G

depend

the

be inst antiated

dependency;

list

(directly ofexported

is necessary

of)

do not

can only

module

t

val

it

closure

plementation

s ig

with

3, where

of Modula3

signature

imports

mod-

the implementations

in signatures.

contrasts

transitive

they

it

described

Modula

elem

one implementation

to inspect

thedefinitions

fully This

s ig

to compile

necessary

)

tion

(having

For

various

(though

SORT.

so for z~fact, the~iaatweis optional, and can beinferredifitis not specified. 30nec~exP=d theresdt constraint SORT of Top%rt

tion which

include asharingconstraint equatingt to P.elem; but this breaks down with higher-order functom. Seealso section 10.2.

a “top

15

of

an

ML

signature, no free

reasons

many

years

first

ML

successive level

compilation

structure,

references this

there

been

waa

a

defini-

structures).

proved

as we describe was

unit

or functor

to external

approach

it can be patched,

of separate

The

and

idea

“closed”

inadequate in section

no agreed-upon

10), no-

compilation. compilers

were

declarations

environment

interactive

were ,“

systems,

in

relative

to

evaluated

augmenting

that

environ-

ment

with

new

(signatures, this

way.

Hence,

requirement mainly

bindings,

addressed then,

proach

that

tures,

ML

unit

is a single

functors,

same

that

Thus,

all

“upward

ML

many

which

values,

the

up

compatible”

types,

file

The

units: in

The

the

are

new

link-editor

we

produced

Defi-

automatically

separate

table

of a module

that

modules

ping

names

bindings

is evaluated

to

types

of names

in

and

to

an environment

values,

types

and

and

values—a

new

evaluate

name

*

:

source

type

To

distinguish

same

between

evaluate

time

into

breaks

map-

ignating

the

new

of pids

we factor

We use persistent mediate

and

With

env into

static

identifiers,

and

execution,

execute, and

or pids

and

name

dynenv

pid

compile

source

+

code Unit

x

+

Thus

evaluate and

phases, and

is the

execute.

But

appropriate note

x code Unit

dynenv

we can perform

the

much

corresponding

chain

of compiles of

of com-

decoupled

at one time,

executes

values

exported

construct

ed dat a—n ot merely

is necessary its export

linking exist of any

(in

Ada,

as static module,

such

from

values, to

execute

fields.

can

modules closures

static

an ML

In a more

Modula, addresses The

ML

as function

be

C), even

conventional

are

imports

prior

to

It

has all

model

another

list

values. x code Unit

of in

exports

x

external

section

references

4),

the

(by the Incremental

in

compiled-

Recompilation

file.

done

and

of

i cat ed than were

their

exports that

were

ing

4We recommend (and the IRM compilation manager requires) that separately compiled units contain structures, fnnctors, and signaturca, but not top-level values and types.

a vector

16

list

previous

pids

it applies of export

to the

to form

refer-

ML

did

process

ML

dynenv,

loop

dynenv

re-

another,

maintains

of a statenv

loop

looks

producing Then

a and

a

unit—yielding

code to this

values.

to

,)’

not

compilation).

a compilation

corresponding an new

run-

use of “lvar-numbers

comprised

the

con-

these

external

(lvar-numbers

interactive

in the

functions

use of pids is more

read-eval-print compiling

ma-

case in Standard

separate

( env)

the

the

ciosures

and

imported

one

for

be

current

ent”

from

Unit—the

Then

are bound pid

our

“persist

interactive

Individual

the

our

useless

After

the

been

vallink-

from to

phase,

though

environment

imports

values.

hold

meaning

thus

a compiled the

not

obtained

generally

execution

always

sophist

are

mapping

require

as arguments

will

closures has

a compila-

of export

that

is executed.

the

which

dynenv.

execution

requires

during

a vector

references

code

of

function

references

passed

it

the

code

closed) to

external

when

Jersey[3],

global

values

are

of New

The

a (fully

external

This

The

to promodel

no

ences.

addresses. even

execution:

which ed by

and

the

processing described

of import

code

tain

conventional

all

des-

exports,

code x imports

chine

dynamic

linkage

code, the of pids

=

export

and run-time

module

The

a list

code Unit

time-created

these

later.

The

duce

having

a chain

run-time It

composition

that

and

and

Untt.

components:

statenv

and

structed pile

code.

of a statenv

=

implements

imports,

dynenv

exist

among

a compiled

imports,

values;

to a binary

editing;

ezecute

a pair

three

unit;

imported

(as

unit

ues.

--+ statenv

do not machine

dependencies

we call

into

the

further

a vector

x pid

statenv

is

of inter-

--+ value x

and

it

exported

parts.

as a form

dgnenv

type

cyclic

returns

down for

can be written

tion

statenv

by,

But

the

module’s

Unit

Linkage

x

as the

model.

exported

Manager)

name. env = statenv

be

to runtime

purpose

the

siatenv

Unit

at the

dynamic

cannot

(pids)

execute:

of the

together

designating

x ualue

compilation

no

envi-

X env --+ env

compile

so they

same

produced

function

which

code

the we factor

have

Furthermore,

in ML.)

compiled :

the

precludes

compile

ronment: env

vary,

modules

are

this

code Unit

produces

ion.

conventional

execution

machine

interface code

as the

to,

The

source

where created

functions)

“names”

serves

of the

only the

internal it

prior (Note

compila-

maps

Thus,

a code Unit,

ML

really

in ML,

closures

init ializat

do not

(though

by the start-

work

of higher-order

in ML

values

as function

stat ic “default”

fields

system.

Evaluation

cannot

(such

application

dynenv

is

There

This

of values

addresses.

signa-

etc.4

described

programs

with

the

constant

re-initialized.

ap-

source

to

be “re-initialized”

of a module).

“variables”

into

liberal

compilation

language ML

be initialized subsequently

kinds

from

ML[19].

existing

may

UP code

a critical

declarations:

delineates

module

of Standard

tion

to be broken

of

variables

reasonable

taken

structures,

nition

in

program

have

sequence

use the

all they

system,

We

a compilation

syntax

was not

of the module

programs

any

no special

system used

module has been

spaces.

units?”

containing

ML

of parameterization,

name

are

the

functors)

compilation

design issues

and

“compilation

and

separate

for the

composition, How,

Even

structures,

vector,

the

elements matching

up

each

a vector

of of

pro duc-

export

values

of the

exports

the

exported

statenv.

This

coordinated

environments the

compilation

ronment

unit.

is then

stead,

This

the

use, retaining

global

just

the

But of

envi-

(for

not

be

compiled tem,

the

Unit

interface

separately

The

in a “bin”

fine for

eral

variants—there

as input

types,

for further

and

instead

loop

uses

modules

the

compilation

can

into

{same

simple

of module

the

example

process,

illustrates

using

the

value

file,

com-

and

Even

declarations

declarations:

static out

fields.

etc.)

have

of 115 variants

of 193 record

over

sev-

of these

It is not

structure

we use a “pickier,”

garbage

“pickled”

linkage

tables,

of which

a triv-

these

types

a file.

with

into

[17]

signatures,

symbol

many

a linked

aa bit

functor

fixities,

are a total

a total

pointer

environments

signatures,

dat atypes,

to write

Therefore

sys-

be loaded

with

matter

complex

representation

of static

values,

Unit

system.

following

datatypes,

are

“easy”

functors,

36 different

aa the separate

compiled

an interactive

pilation

interactive

structures,

types,

no

representation

uses

ial

since

Our

it,. In-

statenv

environments with

compiling

compilations. But

static

structures

strings.

environment.

we should

our

data

after

right

compiled

dynamic

al exported

system,

a unit

and

environment

increment

onto

save the

of static exported

compilation

to execute

we will

later

the

layered

In a separate so eager

pair

constitutes

collector

version

of an

can read

it back

so, we found

some

that

data

structure

in again our

[20, page

internal

was not

integrated

system

arbitrary

that

environments

a program

of our

writes

a

to

a

80].

representation

suitable

for

of

pickling

with-

modifications:

Source: .

val

a = x+y

val

b = x+2*z;

Static

environments

portable. pointers they

Compilation

This

environment:

(SC, dc)

should

means

into

global

contain

they

data

function

complicate

be self-contained

that

should

structures,

closures

nor

because

cross-compilation

for

and

not

have should

this

would

a different

archi-

be affected

by in-

tecture. static

:

SC=

dynamic

{

z w

(int,

z I+

(int,

pidc

+3,

pidr),

y +

pidz)

(int,

.

pidv),

}

Export

environments

ternal,

unexported

scribe

the

{

pidy

~

4, pidz

●

*5}

The

static

contain Compilation

other

results:

statenv code imports exports

=

{a++

(int,

=

A(z,

=

[pid~,

pidy,

=

~ida,

pid~]

pida),

b #

y,z).(z+Y,

(int,

~+2

pid,)}

The pi%]

= {pida

w

v=,

the

units.

pid~

*

code((dc(pid$))

v~}

dc(pidg),

binary

compilation Unit:

unit,

a tuple

and

(increment

rate

compilation

be written

al)

our

static (or

compiler

file

produces

(import,

environment.

from

do

It is easy to write instructions 128-bit

a well

machine defined

both

as sequences

integers

which

code

of bits

are also

of

pointers

external reading

This

com-

by

is the

There

to write

pids

and

linkage problems

worst

the

exponential

the that

exported

is, we iden-

them

by stubs.

will

“rehydrate”

we stubs

of the

memory.

we “dehydrate”

file,

copy

case,

components to

of core

it to a file:

copy

environment a new

the

leading

and replace

turning

static

include In

point-

back

into

Later, the

pointers.

process. to solve

in designing

the

de-

algorithm:

each 1. How

of machine For

the

such a private

environment

files

binary

static

are two

other

it will

writing

the

right

of

traverse

a tree,

problem,

tify after

must

file;

this

points

contain

entity.

between

before

parts

to a binary

easy

may

a unit

will

when

file,

into

environment

use in another

[25].

unit

environment

environments

happily file

shared)

of binary

for

static

Later,

converted

environment

representation

the

binary

of references be

hydration has

5.

it depends.

would

the

(previously

sepa-

these

for later

a

export),

TO

recompilation)

to a binary

pickier

then

To solve

pids

static

environment

of

the binary

files

of code,

static

middle

is read

DAG

dc(pidz)))

pilation. machine

de-

in section

sharing

The

blowup

Making

the

on which

entity.

will

each

solution

of a compilation

into

of a shared

the

(va, v,)==

units

exported

into

where

compiled

its

environment pointers

Managing

Execution:

For

and

structures—we

x ~)

ers, but

4

problem

not

and

:

dc =

dynenv

should types

can the

ternal”

we use

bin

to files.

17

files,

dehydrate

pointers since

into

tell

which

structures

all pointers

things

shared

in core

look

are with

the

“exother

same?

2. Given real

a “stub,” in-core

how

pointer

can

with

the

rehydrater

which

find

to replace

tremely

the

it?

come Every

“significant”

object

(module

(structure

structor)

has its own

identifier

(pid)

a small

ever

The

exported

a stamped

another can

is the

But read

from

the

with

the

real

pointer?

source

file

is compiled

made of

object

“stamp

symbols

all

environment We each

this

Each

pings:

from

jects.

compiler, lookup,

and

same

stamp. by

needed; plies

constructing

it

might

this

static

in

context

an

unit. units;

equivalent

are layered,

For

both are

cient

layering

the

are

by stamp

is simply

be given

to

and

of the

day,

the

compiler

with

a

context

produces

the

for

use in

the

copy

is

code Unit)

for

tomorrow.

is read

context back

context

loading

in;

environment and

the

statenv

environment. will

environments

for

file,

a dehydrated

environment

source

types.

source

is saved

the

exported

re-

sharing

Unit

file

using

interbecause

preserve

one

(along

of

a set of mutually

an equivalent

binary

preserving is in part

and

and

compilations

dehydrated

other

and

compiled file

another

part on identify-

static-environment

to the binary

contexts

but

The

written

form

is

better,

earlier. now,

then

be combined

of other

other

binary

modules

files,

to

or compil-

files.

the

compilation,

IRM

in

constructs

it just

mappings mappings

stat envs reproduces the

then

Once

the

modules

they

must

be

solves

names

global

data

tion,

stamp

is more and

Type-safe

A classical

environments and

this

version compila-

the exported

indexed

5

dehydration

processes

linkage

unit.

indexed used

separately;

a con-

effire-

are

that

(typically linked

modules

.h/ .C file

A

(or

code

part

any

a C programmer to

are

informa-

programming to ensure

that

compatible. may

neglect

y in the makefile. change

reand

allocation). type

of the

the programmer)

linker

addresses

static

maintain

other

recompiled)

classical

link-time

not

together

dependent

is altered

compiled

to machine

(with

does

so it is up to some

a .h file

18

refer

environment

been

together.

addresses linker

For example,

ex-

have

linked

the

some dehydration

and

described

part

the

tempo-

structure

work

This

in 36 data

compile

compilations

with

into

time-consuming

to traverse,

is built,

the

of

“significant”

even

detailed

stubs)

further

ing

indexing. The

115 variants

The

ap-

had

all the

is dehydrated

stamps

compilation

originally

symbol

and

(with

Summary: Unit

the

cases to handle:

functions

is built;

are not

external

current

symbol

the

of a

was

are so many

On

index

elaboration

the

dehydration,

combined

the

environments

it must all

When

(DA G structure).

use in other

can-

stamps

e points.

by layering for

layering.

mappings than

the

sharing

sharing

by

of environ-

environments

to work,

cent ext environments of imported

indexed

environment

this

lookups

cent aining

be found

Fortunately,

the

appropriate

rehydrater

that

of

only

at the

environment

Within

kind

non-indexed

because

uses

text

tion

away. unit,

matches lookups

either

IRM

of the

supports

the

by

external

(statenv)

the

layering,

environment

also

to ob-

within

work

and

nal

compiled

pointers the

objects

of

language

that. troublesome

environment

map-

stamps

construction,

static

but

efficiency)

the

for

two

type

either

coercions

For

and from

to coerce

throwing (for

comprises

to

no notion

of pointer

would

ing

cursive

structures

in any But

sharing

implementation

for

stamps

have

has

where

those

allo-

problem

one is care-

can serve as indices

that

the

in,

from

to ensure

most

there

context

constructing,

is an abstract

so on; Indexed

compilation

used

now

the object the

e.

by

mapping

operations

other,

exhaustive

find

is possible

into

single

An

would

to objects,

specification

It

ment

index

indexed

source-language

to rehydrat

environment with

from

The

which

indices. for

tree

unless

matter,

Copy-

of fast one

into

collection,

(at least

a nondestruc-

but

use)

that

Ha.sh-consing

we don’t

ex-

for

to have st amps)

tables

in

is copied.

turn

in ML,

nor,

as hash-table

preserved.

context

not

so in principle

environment

symbols

Static

Any

are

rary

en-

can

trivial

objects

both

collection)

garbage

be used

internal

export-

the

is not

accomplishes

(because

in memory

identity;

with

done

SML/NJ

garbage

blowup

copying

not

replace

of the

stamps.

efficient

the

has been

within

environment

more

This

pointer

in

structures

a big

ful.

stamp.

modules.

mappings

cent aining

environment,

objects.

imported

is sufficient

make

DAG

(with

and

the

fast

is

be-

program,

the environment

efficient

and

is that

to

‘(context”

combination

stamp,

when-

belongs

is quite

enough

environments

any given

cation

rehydrater

some

the

of the context

en-

only

with

But

are

the static

is “external”

the

somewhere

;“ they

containing

the

the

ing

single

e parameter,

style:

environment,

(external-pointers

A

dration

functional

with

live

to objects

search

can

the

dif-

environment

must

environment. by

from

but

pid

1.

the dehydrated how

environments

object

to problem

tive,

a static

nodes

versa).

Dehydration/rehy

created

pid

containing

file,

vironment ternal

this

vice

a dehydrate/rehydrat

con-

unit;

whose

or

tasks.

same

compilation

is found

stubs,

traverse

leaf-like

or type objects

by current

bin

stub Each

the

certain

environment of a persistent

All

traverses

unit,

after the

composed

have

a stub

solution

later,

”

dehydrate

compilation by

a static signature,

integer.

will

object

be replaced

This

or

unit

integers.

vironment

“stamp,

and

in one compilation ferent

in

or functor),

both

similar:

replacing

the

parameters

to include Then

when

of some

procedure

~,

arguments

might

not

a client

be detected

the

be

by the

A type-safe

linker,

compiled

have

module

not

view

rally,

we have

implemented

implemented

an

output

is used

alyzer

is not

detect

any

Recall

it

this

is

linking

to

control

order

[15].

or if it

linker.

is not

by names,

but

by

ported/exported

values.

An

exported

in several

1. The

pid

mented

with

uniqueness).

be

our

host

and

This

will

“pids”

lead

when

a module its

will

pids

The

dynamic

which

label

could

iim-

aspects

The

The

pid

is edited

clusive

and

of the imported

taken

changes for

in the

the

will

mod-

code

we

This

approach Trivial

code

(editing

the

the

to change,

pid

will

emit

the

not

to the

all

recom-

pid

can

12].

module

port

will

interface and

causing Either intrinsic context.

The

use

commodate

last

tion.

Cutoff comparing

the

export

use of intrinsic the hash

There ferent cause

pid.

its

Bugs

“new”

can

without

will

can

of (time,

the it

system

place)

would

ac-

compiled not

the

could

we use a good

full

possibility hash

hash

to

output

they

function

or imported

of integers,

which

to produce The

the

static

the

we

export

this

we then

export

static

pids

unit

are

of the derived

k respectively

these

these

must

be

yet

these

entities

the

contains

entities

pids

and

cent ain

derived

from

the

are traversed

hash. by

phase pids.

are replaced

environment

exported;

is resolved

the

course

types

are

having

of the

These by

the

elaboration

compiler

are grist

“real”

pids

~21]

one;

the provisional

hash

value

version

but

with (or

because

we

of collision: same (a CRC

two

value.

with

give for

after

and keeps

seen, pid

pids

The

all enti-

the

hasherl

the

CRC

is

directly,

it

a record uses

seen thus

used

tion

before

the

for this

will

of which hssh

not the

internal of the

them:

the

pids

have

provisional value

only

make

of hidden

“alpha-convert”

of n for

the

nth

far.

Hashing,andreplacement done

but should

in the implementation

must the

substructures pids,

hasher

on the number

types

and

many

provisional

exported.

dependent

Instead,

distinct

to save

are

hash

been

(describing

of a compilation, created

of these

hasher

environments. the

to

a DAG.

re-exported)

1 through

analysis)

module.

recompila-

be implemented

previous

values

being

n decare

is actually

by

to compute

and

some

use cutofl

is unnecessary

previously

appropriate

produced

be

hash;

“provisional”

and

preferable.

unnecessary can

with

1 and

internal

here

ex-

traver-

pid.

to

ties

In

be called

naturally

compiler

take

unit.

that

paradox

(semantic

the

datatype

between

by adding

static

of the

This

ex-

pid

pids;

structures pids

with

and

objects

in order

hashing

of some

(either

and

on

computed.

of pid

our

many

pids,

is always statenvs

in-

amps.

interface)

compare)

affect

is obviously

though

intrinsic

the

compare

kinds

recompilation

the

same

are independent

recompilation—avoiding

by

the

not

can be changed,

two

pids,

using

does

alternative

timest

A system

that

static

of the im-

of recompilation.

they

intrinsic

modification

algorithms

latter

because

exported

any

yield

a cascade

of the

of the

Then

plementation

be fixed,

We

be a hash

[22,

a pid

a sequence

static

own

by

of what

algorithm

entities

result

We

the

the fewer

We do a prefix-order

traversal

however,

the

only

be done.

computed

compilation

export

Note,

and

express

are dependent

as an integer.

this

the

their

terface

development,

modules,

an integer

else

produces

k dynamic

comments,

need

pid

for

pids

For each node,

to

by a CRC

from

pilation. 3. The

IRM

for pre-production

less they

will

are

variant.

come

somewhere

pid

with

cause modules

of

enough,

software

intrinsic the

“emit”

a tree

from

hash

(ex-

system[14].

we

doing

When

almp

together

interfaces.

not

dependent

source

module

Cedar/Mesa

to the source

example)

then

of the

of

have

probability

good

pids

environment.

on the

avoid

recompiled timest

pids

static

pending

recom-

dependent

by hashing

of comments)

the pids was

be made

for

recompilation

n variants,

to ensure

a new

the and

sal of the stat env.

be recompiled.

could

would

so the

is not

of the implementation

intrinsic

This 2

precisely interface,

unnecessary

(aug-

identifiers

the

212s pairs

pids

more

other

be con-

to unnecessary

and

226 pairs,

to timestamp-bssed

Intrinsic

an-

linker

of

pid

interface,

be generated, then

(hash)

verification.

“timestamp”

process

changing

ules must

linkage

a simple

without will

if this

ported

pilation; (pid)

or But

Rolllins

every system

analyzer

ways:

could

213 pids, is 2-102.

and switch

for

software

collision

exported the

once

large

perhaps

Natu-

dependency

fail,

3 that

only

very

of evaluation,

If the

should

happen A

can use intrinsic

together

dependency

should

statenvs.

inconsistency.

from

structed

old will

that

interfaces[14].

section

values

the error

ensures

a type-safe

bugs”

used,

hand,

automatic

“makefile

This

other

of their

has

preventing

~ with

linker. on the

implementations

a consistent

whose

calling

recompiled.

dehydration

of

provisional

phase

pids,

are

in

sec-

described

4.

clifPerformance

Be-

over

of 128 bits)

10

the

export

Look

how

environments!

many

passes

we are

taking

e Hash

the

environment

Dehydrate:

●

to compute

replace

external

intrinsic

references

with

pids;

6

-Compilation

stubs;

Previous

“make”

compiler Later,

●

rehydrate:

replace

stubs

with

external

ref-

We

measured

sured

the

time

time

for

clock-tick

of

hashing

resolution

tion/rehydration this

by

20 seconds

O.0

previously

seconds

the

searches

The

we

one

code

pids imports

pid

dependence quired

for

pletely unit

list

of the

unit:

what

imported

It

would

be nice

completely

summarized

environment.

no dynamic compilation,

IRM

it is sufficient

system

needs

the

to hash

exported

for

Then, st atic-pid

It

is not

units

and

pids.

To

units

list. by

t ains

these

The

the

pids

inconsistency on dynamic

tion

to go wrong.

~xmple,

~M

t = int

2. local

type

u=t

compilation:

analysis)

and

hashing,

Also

provided primitives:

dehydration/rehy

does not

know

takes

and

the

dration,

the format compiled

writes/reads

the

import-static-pids, files

in its

keep

list track lookup

does produce be

own

of a bi-

Unit,

dehy-

statenv,

code,

export-static-pid

format.

development

was

for

command).

compilation

use

itives

compiled

dynamic

to

do:

explicitly

not

the pro-

Of

this

provided

course,

the the

SML/NJ loop

from

with

files

(the

no separate

IRM

static

are

there

(Of

for

is only

with course,

of source be easy

in the

units

code

comcannot

typed

(though

full

one units

IRM

the interactive

dragging

(and prim-

Consequently,

compatible

it should

loop

compilation

Thus,

loop.

it)

the

proper.

dependence

without

management

read-eval-print

upon

paper.

top-level And

files

the

compiler

yet implemented

tion

the

read-eval-print

to call

the

under

in

binary

mechanisms

to

units

in this

into

analyze

the

some

re-engineered

described

piled

and

interface

compiling

command)

interface

static-

the

whatsoever.

We have the

of IRM

paper,

an interactive

interactively.)

the

easy

compiler

file

top-level

in this

provision

use

functions

representation)

of the

the

of imported

compiler.

to

of a be dif-

of

the

compiler

of imported

the

out

and

static-pids.

list

interactive

described

in

we have

loop IRM

to load compila-

system.

con-

variables. for

type-safe

imports/exports

linkage. that

cannot

Any

7

has no ef-

cause

execu-

The

6

The Lisp

internal

5000/240 shotid recompile

using unit

2, below, if tit

1

changes to type t=real. But even if unit 2 were not recompile@ execution would not go wrong. 1. type

statenv,

binary

Before

IRM

anywhere.

manage the

imports/exports

5on a DECstation

a

an interface

of

manipulation

IRM

exports,

The

it imports

exported to

suffice

of static

itself

Instead,

the

to/from

binary

that

the

as free pids

fect

6 For

a dependent

(intermediate

dynamic

the

will

complicate

end

li-

re-

units

throughout

turns

phase

execution.

mapping,

compiler file.

only

exports

corresponding

compiler

and

8, is such

so on.

imports,

a single

Al,

static

to detect

compiler

the

front

into

unit

static-pid

calculates

This

lambda-expression duced

new

be able

the

the

values

In contrast, imports

the

is no longer

greatly

and

statenv each

examining

assembles make

would

its

compiler,

code

static-environment

drates

information,

of all imported

responsibility

the

types

for

When

will

that

IRM’s

IRM,

for

when IRM

that

directo-

makefiles,

available

each

(semantic and

index

have

cutoff

static

exported file

change,

dates,

information.

st atic-pids

unit

currency,

some

the

have

are intended manager

in section

makes

layering,

nary

of the

proper

bindings.

paper

version,

for

elaboration

The

com-

compiler

component

are several

are relist

signatures

exported

static-pid.

compilation ferent.

more

binary

the

and

values if this

envi-

files,

summarized

generation,

and

dynamic

dependence

implement

a unit’s

In the writes

to

the

dependence

some

type

Thus,

To characterize

the

But

component:

effect.

st atic-pid.

expresses

execution.

on its

a static

of a unit

binary

DAGs,

SML/NJ

with

DAG

parsing,

Static

the global

compilation

files,

[10],

a file

system.

structure).

The

IRM

in this

the

takes

static/dynamic

a separate

source

accessed

which

and side-effects

described

with

SML/NJ

procedure,

it with

file-dependency

braries.

overhead).

preserve

primitives

be used

ries,

substantially

(to

the file,

understands

dehydra-

lyo

linear

seen nodes

to

for

use

by extending

The

in

mea-

(modulo

for

be very

of

phases The

and (i.e.,

could

some

these lines.5

second)

20 seconds

replacing

use to identify

by

65,000

was

0.01 was

We believe reduced

taken

compilation

the

compiles

ronment

a 32-minute

systems

through

name,

erences.

interface

in val

i=5

20

community functions

the

“big cleanly

based

the

on

Compiler has

long

enjoyed

of an interactive ball

to do this vironments

end

Visible

of mud”

paradigm.

in a strongly

model

described

of

typed,

compilation,

here.

We

access

system

can

to some

(e.g.

We

eval)

show

how

modular

system,

linkage,

and

selectively

en-

expose

internal

modules

static

of the compiler

interfaces

Standard machine ecute the

ML code

these

of New

and

by

a dynamic

to the

the

and

interactive

cutes

in the

is the

usual

way

environment

process would

the

rate

compiler

values

user’s

with

system

compiler

machine

link

the

code,

compiler,

“bootstrap

loader”

stands

only

the

of the

binary

the static

files.

unit

chine

code

Once

Gene

ML

shared

library

perhaps ML

modules

in

function

that

interactive time

loading

the

machine

ments

an argument ing

combined

modules provide by the Most

only

a limited

compiler of these

built-in

types

provide

access

compiler

user

shared

and and

“window”

the

file”

system

flags such

compilation the

and

but

It

supports

String, ●

The

1/0,

shared

others

trees,

of the

compilation

compiler.

implement

its

For own

manager

but

calls

example, file

runs

upon

computed list

cascading at

files

to de-

is up to date.

the

levels.

The

is a simple

“make-

and the names

the name

makefile This

to

performs

recompilation.

several

dependencies

names.

used

IRM

(by file name)

by IRM,

file

dependency

timestamps—are

Because

of file

files

each

of the li-

are automatcontains

system

only

is simple

an and

interface

special

needs

(for

are not

manager) been

is via of the

example, kept

can

customize in

to support

structures system.

a theorem

in files;

implemented

specifically

ML IRM

prover

or a different the

IRM

a pleasingly

such

and Users

sigwith

whose

style

of li-

system,

which

modular

style

users.

I,ist,

The

as an or-

certain

it uses the

dependent

file).

of components

9

user program,

make

to scan

of the

(by mentioning

natures

has

applica-

libraries:

libraries

calls

uses timestamps

level—interface

the source

it

For

be recompiled.

interfaces

be-

files,

y information

not

provides

“sources”

etc.

separate

dinary

fundamental

must

recompilation,

listing

and

pidsnot

files

A lower-level

tions: ●

intrinsic which

brary

has many

. d. foo. sml,

source

version

the dependent

or

which

SML/NJ.

names).

a cached

etc.)

compiler

(imported

which files

dependencies

ML

SML/NJ

groups

of

convenient.

phases.

compiler

in

unordered

to internal

as syntax

of the

the

For

of

groups

be ML

Yacc,

than

analyzes

keeps

that

ically

to

providing

interfaces,

control

IRM

brary’s

to be shabred

are libraries

parser

capabilities

may

(Lex,

upon

interface.

to other files

pro-

calling

specifies

other

units.

variables

of imported

internal

filtered

refer

source

by compilers

simplest—highest

result-

of the

of modules

operations,

into

all

it is normally

the free

IRM

as

may

in

“application

the

of IRM

(IRM)

described

Compiler

user

automatically

cutoff

con-

The

other

compilation

However

a static

is passed

in

has imple-

tools

summarize

A

languages

ensure

environ-

environment

function.

modules

to compiler

types

the

programs.

or operating

environments, This

selection

and

of and

Manager

system,

Visible

programs

termine

this

briefly

A group

information

and ignoring

which

contains but

for

only

University

interactive the

system.

foo.sml,

the

files,

to build

dynamic

startup

compiler,

forms

synthesis

programs.

aa an ordinary

The

for

and

runs

SML/NJ

files.

upon

make

this,

static

composed

loader,

ML

will

IRM

IRM

to the user

binary

environments

environment

of the

the

incremental

the

of the

various the

of the low-level

it uses as libraries.

ma-

etc.),

environment

bootstrap

module

Recompilation

through

are processed

up val-

to

String,

the re-reads

and

to the

wants

accomplish

These

matching

it

accessible

the static

in the

compiler

source

reads

applies

IRM

paper.

tween

as List,

initializes

code.

the

and

this

We

For each

looks

To

only

by

loader

is a client

the

lpids

of the files. the

modules,

loop

environment

To

under-

never

way.

top-level

are dehydrated

structed

etc.

that

loader

running,

(such

a type-safe

for

by user

of Carnegie-Mellon

[15], which

the

to them. is

code

an Incremental

gram”

each

a primitive

C)

environment

its own internal

program

The

files,

import/export

component

compiler

basis including

of ML

Rollins

mented

sepa-

paper.

has

in and

bootstrap

dynamic

every

a running

IRM

This

the

pids,

system

code

The

functions

the

this

environment,

in succession,

ues in a simple

using

in

(implemented

environment

compilation

compiled

runtime

machine

testbed:

to

usable.

a convenient

evaluation

compilation

of a set of binary

static the

and

“metaprogramming”,

exe-

itself.

of stand-alone

described

consists

hacker’s

modules

in which

is visible

It provides in

as ar-

program

compiler

be true

is, of course,

compilation

compiled

a compiler

replacement

compiler

compiler

applications). Our

add

(in

values

an interactive

not

can

interactive

ex-

is achieved,

these

easy to implement

function.

as the

of building

(and

It’s

into

in memory

imported

passing

code

code

can then

Linkage up

system,

same

them

looking

machine

their

one

ML

process

to them. by

environment

guments

compiles ML

putting

jumping above,

by adding

environment.

Jersey The

segments

heap)

simply

user-level

segments.

as explained

In

to the

Visible

compiler

phases parser

Cross-compilation

to

environments

y analysis.

IRM

71 -.

Compiler

requires

to use the same

system

as the calls

compiler

upon

the

compiled

representation

the

that same

for produced

functions

code

of the

dehydrated it.

The

to compile

top-level make,

interactive

restrictions

code

architecture

port

same

for

the

compiler

“Visible

loads

as a user

all the binary

1/0

to IRM

signature

takes

can

be

the

applied

calls

(Of

course,

to

upon

the

compiler such

Another as

types

these

IRM

but

generate

sys-

in the faces.

to

IRM

compilation

files. not

makes

at-

But

it

If

the

interfaces

in Modula ML,

were

2) this

information

through” tures

the

do not

“fully

would about

in the

definition

of higher-order

Many in our

The

ML

A similar

tive

other

introductory

are

can

11

“leak

the

stem

ation

from

a single

this

as

to support

which

dependencies

Here

we describe

modules.

solutions

that

we have

these

avoid

these

had

paper,

Rollins

the

The

notion

bined

to address

between some

first

called

solution

“the

nal references modules

into

the existing

fully

is

to

alterna-

rely

The

are made funct Standard

opaque

by making

or parameters. ML

language;

This but

style all

in Standard

this

ML

and using instead

proposals

by “ab-

of “strucBut

this

mentioned

IRM

system

in

used

by at

compile

described

students

the

an

The

is robust

uncom-

enough

SML/NJ

over

by

in

Princeton.

comprising

in

implemented

system

to

system

for in

separate

22

express

remarkably

compiler

200 compilation

by function

ML

module ~but

only

compilation/linkage

style

that

and

easy

to

of environment

executable-

code

use. ma-

linkage

is

application. language

this

work

software

has long

shows

systems.

incremental

compilation

this simple

functional

and the fact

organizing

support

to ab-

that

are

as powerful

the external in order

mechanism

course

it

is due to the

The

exter-

can be done

the

interfaces

nipulation,

in which

higher

framework[6].)

interfaces).

the

regularly

on

large

architecture

a programming

style”

at

debating

units.

style

adopt

functorized

with

compiler

expressed The

can be ex-

expressed

interfaces)

IRM/Visible-Compiler we

itself—a

im-

dependencies.

fully-functorized

be

higher-order

that

to signatures,

compilation

~15]: are

dergraduate

This 10.1

true

with

[11, 16].

paragraph.

separate

that

of the difficulties

system

Conclusion

The

signa-

is necessary,

with

are on inter-

is currently

than

export

Standard

of types

sections,

not

transparent

less powerful

to

be explicit

module

proposed

opaque

partially

previous-

should

can be achieved

(with

(with

be a way

want

been proposed

are

abbreviations

are

must

we

dependencies

cannot

of

ed types

one

they

in

words,

they

identity

directly.

(as but

This

modules

from

ML

CardeHi’s

effect

type

(export there

have

community

(See also

matching

the

dependencies

Standard

order

much

mat thing.

work

plement

identity

abstraction.

explained of signature

the

matter;

signatures—in enforce

arise

expressive”

not

and

module.

signature

overriding all

at

issue.

another

the

pressed

the mentioning

au-

be explicitly

about

when

matching

first

all

practical,

because

is even implementations

this

that

under-

Alternatives

module

the deeply

be handled

signature

the interface

systems,

to

make

information

appears

adding

bet ween

is very

in each implementation

module orders.

[2].

implementation

must

abstraction

of the

stractions”

Dependencies

DAGs

so that

signature

tures”

10

The

t ype—but

opaque

“new”

things

this

signature,

and

difficult

axiomatization

it

or parame-

to express should

is to no

To make

Versions

it-

binary should

“old”

enough that

through

override

so it

commands

system

between

cross

a simple

The

“leaks”

a concrete

files!)

constraints

manageable

to

interactive

and

thing

so that

abstract).

New-

parameter; Now

is that

transparent

approach

opaque,

Compiler

compiler;

necessary

by Tofte

the funct

DAGs

Eliminate mat

phases

as a structure

old

complex

expressed

“old”

“new”

signature.

approach

programmer:

anyway.

10.2

libraries

structure

NewCompiler.

“old”

make

but

more

The

compiler’s

aa a functor

New Compiler

many

stand,

same

become

we do

to

using

the

compilers

“old”

is loaded

the

to execute

The

of the

as a standard

compiler

are compiled

self

files

this

the

dependency

redundantly

gen-

it’s

as described

or for

(etc.)

paradox.

The

In

parameter-passing

interface

fundamental

compiler

matching

tem

ways.

with for

tomatically

We do sup-

COMPILER.

“new”

Compiler

only

are shared.

are accessible

tempt

different

nested

as structures,

18].

problem

cumbersome

cross-

architecture,

as well functors,

[24,

ters must of

end.

following

target

Compiler”

program;

buffered

IRM

dead

in the with

The

version,

forms

functors

MacQueen

A to generate

these

or garbage-collector

use

an old

over

to use higher-order

These

be impossible.

do

a different

architecture

conventions

The

should to

compilation,

code

with

using

is at an evolutionary

cross

not

l?)

stract

to perform files.

(production

on architecture

unable

compilation erating

compiler

compiler

compiler

IRM binary

cross-compilation

of the

the

for

A

that

version

or running

(telling

as for generating

mean

of a new

the

commands

for example)

been

it is also practical

The

fact

recompilation

is unfortunate,

recognized

that

that instead

but

ML

can

of true

we would

not

want

to

“solve”

rametrized perhaps

problem

by limiting

as is done

research

summarized

the

eventually

this

modules,

provide

a better

power

in Modula-3, in

of pa-

[16]

section

10.2

Xavier

Leroy.

Manifest

compilation.

Instead,

In

Principles

will

York,

solution. [17]

References

of Prog.

and separate ACM

pages

Symp.

109–122,

The implementation

In ACM

Programming,

modules, Annual

on New

Press.

B. MacQueen.

modules.

First

Languages,

Jan 1994. ACM

David ML

types,

Twenty

pages

Conf.

on Lisp

212-23,

New

of Standard and Functional

York,

1988.

ACM

Press. [1] Rolf

Adams,

cost

Walter

of selective

cessing.

ACM

[2] Andrew

Tichy,

W. Appel.

for the compiler

and

Axiomatic

hacker.

W. Appel

and David

dard

compiler.

In Gilles

(LNCS

Report

March

[3] Andrew ML

The

[18]

pro-

Languages

274), pages 301-24,

CS-TR-451-

editor,

[19]

Robin

New York,

MA,

A $HanFunctional

Computer

[20]

Architecture

[5] Amber

Programming

Manual.

1987. Springer-

Benson

Guide,

June

in Ada plus

Addison-Wesley,

[21]

and

Gary

Aitken.

1991.

[22]

1993.

[6] Luca Cardelli. ularization,

Program April

fragments,

linking,

Nelson,

Mark

Rain.

puter

Make

[23]

enth Edition,

[8] Jurg

Separate

to efficient

pages 29-38,

November

Robert

NJ,

[12]

Robert

of

Harper to

Twenty

First Press.

Kalsow

[13] Andrew [14]

Butler ing

W.

SIGPLAN Issues

[15] Peter

modules ACM

[25]

Engle-

Muller.

February

1991.

Personal

Lampson

Symp.

and

Eric

’83 Symposium

A type-theoretic sharing.

In

on Principles

of

Lee,

Rollins,

(in preparation),

Jan 1994.

Modula-3

E. Schmidt.

and for

Robert

Standard

Carnegie-Mellon

Version

1993. Organiz-

environment. pages 1-13,

with

NJ,

1991.

recompilation

in and

1984.

October

PARC

Zhong

1993. Personal

done on the Cedar

in 1979-83

Shao and Andrew In Proc.

In

ACM

Language

June

1983.

Harper. ML.

In-

Technical Univexsit

Symp.

Mads

Tofte.

gram

modules.

comsystem

by Butler

Lampson,

but

published.

never

y,

1993.

23

W. Appel.

Twentieth

Principal

ACM

Eric

of Prog.

Jan 1992. ACM von

First

In William

Aspray

of John Theory,

for higher-order

Annual

pro-

A CM Symp.

pages

draft

189–199,

of a report

and Arthur

on New

won Neumann 1945.

on the

Burks,

edi-

on Computing

and

pages 17–82. The MIT

Massachusetts,

Lan-

1993.

Press.

Neumann.

Papers

of Programming

Languagq

John

recom-

A CM SIGPLAN-

Press,

signatures

In Nineteenth

Smartest

Annual

on Principles

York,

bridge,

16,

Carnegie-Mellon

on Programming

Systems,

recompilation

SRC

Cliffs,

Soflware-Practice

work

and Satterthwaite,

Computer

for standard

with

e-mail,

describing

at Xerox

tors,

Eu-

CMU-CS-94-1

communication,

in a distributed

Gene

and

pages 123-137, New York,

in Software

cremental Report

Lillibridge.

and Eric

Koenig.

soft ware

Science,

The

Cambridge,

Programming

trickle-down

14(12):1149-1157,

Principles

1994.

Annual

ACM

Pfenning,

Report

Computer

and Mark

Languages,

[24]

Software,

Hall,

recompilation

higher-order

Prog.

1.6 manual,

Frank

Technical

February

approach

Bill

Lee,

April

Harper.

Press,

Englewood

Schmidt,

EDVAC.

Incremental

Department

1979.

IEEE

Prentice

MIT

Systems

Hall,

guages, pages 439–45o.

in moduJa-2:

files.

Modula-3.

Peter

ml of new jersey. University,

compilation

appear),

and Robert

ML.

implementation.

Ed Satterthwaite.

SIGA CT

Sev-

1992.

Harper,

gene Rollins.

Laboratories,

symbol

com-

Manual,

1986.

P. Harbison. Cliffs,

for maintaining

Programmer’s

2A. Bell

An approach

wood

[11]

Unit

Volume

Gutknecht.

[9] Samuel

[10]

– a program

In

(to

for

Symposium

and lmod-

1993.

programs,

Tofte,

Avoiding

Mary2

pilation. [7] S. 1. Feldman.

‘94), page

editor.

Prentice

munication

01 Programmer’s

Mads

of Standard

Experience,

Language

New York,

A semantics

European

1990.

Greg

the

Reference

Tofte.

In Proc.

(ESOP

Milner,

Modula-3.

Verlag.

[4] J. G. P. Barnes.

and Mads

functors.

Definition

B. MacQueen. Kahn,

B. MacQueen

1994.

A guide

1994.

and

David

higher-order

on Programming

bootstrapping:

Technical

University,

Programming

Weiner.

environment

1994. to appear.

TOSEM,

94, Princeton

and Annette

recompilation

Press, Cam-