Context Navigation

Disciplined Disciple Compiler 0.3.1

22/12/2012

DDC is a research compiler used to investigate program transformation in the
presence of computational effects. This is a development release. There is
enough implemented to experiment with the language, but not enough to solve
actual problems... (unless you're looking for a compiler to hack on).

DDC compiles several related languages:

Disciple Core Lite

Explicitly typed System-F2 style core language with region, effect and
closure typing. Evaluation is left-to-right call-by-value by default,
but explicit lazy evaluation is also supported. There is also a capability
system to track whether objects are mutable or constant, and to ensure that
computations that perform visible side effects are not suspended with lazy
evaluation. The Lite language supports higher order functions, algebraic
data types and unboxed primitive types.
(* not all features are supported by the code generators yet, see below *)

Disciple Core Salt

A cut-down version of Disciple Core Lite that can be easily mapped onto
C or LLVM code. The Salt language is first-order and does not support
partial application. DDC transforms Lite code to Salt code and uses Salt as
an intermediate representation. You can also write programs in it directly.

Disciple Core Eval

Similar to Disciple Core Lite, except without unboxed primitive types.
This language is accepted by the interpreter.

All three languages share the same abstract syntax tree (AST), type checker,
and are amenable to the same program transformations. They differ only in the
set of allowable language features, and which primitive types and operators
are included.

Immediate Plans

Finish the Coq proof for the core language. We have a hand-done proof for an earlier version of the language, and a Coq formalization for a System-F2 language with a mutable heap. We need to add regions, effects and the capability system to the Coq formalization.

Implement a local type inferencer. The type inferencer will fill in type applications as well as effect and closure annotations, but will not perform let-generalisation. This is similar the local type inference used to support implicits in Coq/Gallina.