Tutorial 3

Embedded Domain-speciﬁc Language Implementation using Dependent Types

Abstract

Domain-speciﬁc languages (DSLs) are programming languages
designed for solving problems in a particular domain. By providing
suitable abstractions, they allow experts to focus on solving high-level problems without being concerned with low-level programming details. Embedded domain-speciﬁc languages (EDSLs) are
an emerging implementation technique, in which features of a host
language, for example parsing or code generation, are exploited by
the DSL implementation. In this way, EDSLs can be implemented
much more rapidly than their standalone equivalents and can take
advantage of compiler optimisations and other implementation effort in the host.

Dependent types allow types to be predicated on values. Using
dependent types, a programmer can ascribe a precise type to a
program, for example that concatenating lists of length n and m
yields a list of length n + m, or that sorting a list of length n yields
a list of length n which is a permutation of its input satisfying
a given ordering. In this way, types can be viewed as a form of
speciﬁcation, veriﬁed by the type checker.

Using a dependently typed language as the host for an EDSL
brings additional beneﬁts. Not only can we reuse the host language’s parser and code generator, we can exploit its type system to
express properties of the EDSL and guarantee their correctness. In
this tutorial I will introduce I DRIS, a dependently typed functional
programming language. I will give practical examples of dependently type programs, culminating in the construction of an EDSL
for network protocol implementation.

Author biography

Edwin Brady is a SICSA Advanced Research Fellow in Computer
Science at the University of St Andrews, where he has worked since
receiving his PhD from the University of Durham in 2005. His research interests include functional programming with dependent
types, type theory, program generation and programming language
design and implementation. His previous work has included compilation and optimisation techniques for dependently typed functional
programming languages. This has important applications in the veriﬁcation of safety-critical systems; he has also been closely involved with the Hume project (http://www.hume-lang.org/),
applying dependent type systems to the correct implementation of
safety-critical embedded systems with limited memory.
He is the main developer of I DRIS (http://www.idris-lang.org/), a functional language with dependent types intended for
systems programming, and contributes to the development of Epigram (http://www.e-pig.org/). His recent work has focused
on the practical applications of dependently typed programming,
using I DRIS to implement domain-speciﬁc languages for veriﬁed
network protocols, data formats, and resource aware systems in
general.