The power of Pi

@inproceedings{Oury2008ThePO,
  title={The power of Pi},
  author={Nicolas Oury and Wouter Swierstra},
  booktitle={ICFP},
  year={2008}
}
This paper exhibits the power of programming with dependent types by dint of embedding three domain-specific languages: Cryptol, a language for cryptographic protocols; a small data description language; and relational algebra. Each example demonstrates particular design patterns inherent to dependently-typed programming. Documenting these techniques paves the way for further research in domain-specific embedded type systems. 
A library for polymorphic dynamic typing
TLDR
The resulting library allows dynamically typed values with a polymorphic type to be instantiated to a less general (possibly monomorphic) type without compromising type soundness.
Resource typing in Guru
TLDR
A resource typing framework for the Guru verified-programming language, in which abstractions for various kinds of program resources can be defined, that enables efficient, type-safe programming with mutable and aliased data structures, with explicit deallocation.
IDRIS ---: systems programming meets full dependent types
TLDR
An overview of the distinctive features of Idris which allow it to interact with external systems code, with precise types, are given, and how to integrate tactic scripts and plugin decision procedures to reduce the burden of proof on application developers is shown.
Π-Ware : Hardware Description and Verification in Agda
TLDR
This paper demonstrates that by employing dependently typed programming languages, it becomes possible to define circuit descriptions that may be simulated, tested, verified and synthesized using a single language, Π-Ware, which makes it Possible to define and verify entire families of circuits at once.
The gentle art of levitation
TLDR
A closed dependent type theory whose inductive types are given not by a scheme for generative declarations, but by encoding in a universe, so datatype-generic programming thus becomes ordinary programming.
Type-safe diff for families of datatypes
TLDR
A functional, datatype-generic implementation of diff (and the associated program patch) is described and it is shown that its efficiency can be improved with memoization and that it can also be defined in Haskell.
Reflect on Your Mistakes ! Lightweight Domain-Specific Error Messages
TLDR
This paper presents a language feature, called error reflection, that allows EDSL and library authors to customize the display of compiler errors based on reflected representations of these errors.
A sequent-calculus presentation of type-theory
TLDR
This work thinks that “natural deduction” style is the source of efficiency issues in the presence of inference, and proposes to use a core language in sequent calculus style to solve those issues.
From algebra to abstract machine: a verified generic construction
TLDR
This paper defines a datatype generic, tail-recursive higher-order function that is guaranteed to produce the same result as the fold, and combines the compositional nature of folds and the performance benefits of a hand-written tail- Recursion function in a single setting.
Engineering Proof by Reflection in Agda
TLDR
A library that can be used for automatically quoting a class of concrete Agda terms to a non-dependent, user-defined inductive data type, alleviating some of the burden a programmer faces when using reflection in a practical setting is presented.
...
...

References

SHOWING 1-10 OF 46 REFERENCES
Towards a practical programming language based on dependent type theory
TLDR
This thesis is concerned with bridging the gap between the theoretical presentations of type theory and the requirements on a practical programming language.
Lava: hardware design in Haskell
TLDR
The system design exploits functional programming language features, such as monads and type classes, to provide multiple interpretations of circuit descriptions that implement standard circuit analyses such as simulation, formal verification and the generation of code for the production of real circuits.
Subset Coercions in Coq
TLDR
A new language for writing programs with dependent types on top of the COQ proof assistant allowing to write algorithms as easily as in a practical functional programming language whilst giving them as rich a specification as desired and proving that the code meets the specification using the whole COQProof apparatus.
Dependent Types for Distributed Arrays
TLDR
It is shown how a dependently-typed programming language can help develop locality-aware algorithms over distributed arrays by hosting a domain-specific embedded type system that ensures every well-typing program will only ever access local data.
Views: a way for pattern matching to cohabit with data abstraction
TLDR
The views mechanism is proposed, which allows any type to be viewed as a free data type, thus combining the clarity of pattern matching with the efficiency of data abstraction.
Domain specific embedded compilers
TLDR
This work sketches a general design pattern/or embedding client-server style services into Haskell using a domain specific embedded compiler for the server's source language, and applies this idea to implement Haskell/DB, adomain specific embdedded compiler that dynamically generates of SQL queries from monad comprehensions, which are then executed on an arbitrary ODBC database server.
Functional reactive programming, continued
TLDR
Of particular interest are the AFRP combinators that support dynamic collections and continuation-based switching and it is shown how these combinators can be used to express systems with an evolving structure that are difficult to model in more traditional dataflow languages.
Refinement types for ML
TLDR
A type system called refinement types is described, which is an example of a new way to make this tradeoff, as well as a potentially useful system in itself.
Putting Curry-Howard to work
TLDR
A program is described, Djinn, which takes a Haskell type and produces a program of that type, using the Curry-Howard correspondence, and for the subset of Haskell types that Djinn can handle (no recursive types) it does quite well.
The next 700 data description languages
TLDR
A calculus of dependent types to serve as the semantic foundation for a family of languages called data description languages, designed to facilitate programming with ad hoc data, that is, data not in well-behaved relational or xml formats.
...
...