Idris, a general-purpose dependently typed programming language: Design and implementation

  title={Idris, a general-purpose dependently typed programming language: Design and implementation},
  author={Edwin C. Brady},
  journal={Journal of Functional Programming},
  pages={552 - 593}
  • Edwin C. Brady
  • Published 1 September 2013
  • Computer Science
  • Journal of Functional Programming
Many components of a dependently-typed programming language are by now well understood, for example the underlying type theory, type checking, unification and evaluation. [] Key Method I describe the high-level language and the underlying type theory, and present a tactic-based method for elaborating concrete high-level syntax with implicit arguments and type classes into a fully explicit type theory. Furthermore, I show how this method facilitates the implementation of new high-level language constructs.

The Idris Programming Language - Implementing Embedded Domain Specific Languages with Dependent Types

In this tutorial, Idris is described, a pure functional programming language with dependent types, and it is shown how it may be used to develop verified embedded domain specific languages (EDSLs).

Dependent Types for Class-based Mutable Objects

This is the first dependently-typed language with mutable objects that the authors know of to bring classes and index refinements into play, enabling types (classes) to be refined by indices drawn from some constraint domain.

Practical Reflection and Metaprogramming for Dependent Types

This dissertation introduces elaborator reflection, in which the core operators of the elaborator are realized as a type of computations that are executed during the elaboration process of Idris itself, along with a rich API for reflection.

Intrinsically-typed definitional interpreters for imperative languages

This paper describes and demonstrates techniques and libraries in Agda that successfully scale up intrinsically-typed definitional interpreters to handle rich object languages with non-trivial binding structures and mutable state, and claims that they still meet the goals of being concise, comprehensible, and executable while guaranteeing type safety for more elaborate object languages.

Practical Erasure in Dependently Typed Languages

This paper presents a new erasure mechanism based on whole-program analysis, currently implemented in the Idris programming language, and shows that with it, erasure can lead to asymptotically faster code thanks to the ability to erase not only proofs but also indices.

Logic Programming and Type Inference with the Calculus of Constructions

Because every result of execution is a term in the consistent calculus of constructions, Caledon can be considered an interactive theorem prover with a less orthogonal combination of proof search and proof checking than has previously been designed or implemented.

A Framework for Resource Dependent EDSLs in a Dependently Typed Language (Artifact)

Resources is a framework for realising Embedded Domain Specific Languages (EDSLs) with type systems that contain domain specific substructural properties and several exemplar EDSLs are presented that illustrates the framework’s operation and how dependent types provide correctness-by-construction guarantees that substructureural properties of written programs hold.

A specification for dependent types in Haskell

A core semantics for Dependent Haskell, an extension of Haskell with full-spectrum dependent types, which consists of two related languages, a Curry-style dependently-typed language with nontermination, irrelevant arguments, and equality abstraction, and its explicitly-typing analogue, suitable for implementation in GHC.

Dependent Types for Safe and Secure Web Programming

Using the dependently typed programming language Idris, this paper shows how to use EDSLs to enforce resource usage protocols associated with common web operations such as CGI, database access and session handling, and introduces an E DSL which uses dependent types to facilitate the creation and handling of web forms.

A framework for improving error messages in dependently-typed languages

This work modify a higher-order unification algorithm that is used to resolve and type-check implicit arguments, and augment this algorithm with replay graphs, allowing for a global heuristic analysis of a unification problem-set, error-tolerant typing, and counter-factual unification, which makes error messages less affected by the order in which types are checked.



Practical implementation of a dependently typed functional programming language

This thesis considers the practical implementation of a dependently typed programming language using the Epigram notation, and sees that a dependent type theory is an effective base on which to build a feasible programming language.

PiSigma: Dependent Types without the Sugar

It is shown, by translating several high-level constructions, that ΠΣ is suitable as a core language for dependently typed programming, and structural equality is used consistently for values and types.

Equational reasoning about programs with general recursion and call-by-value semantics

This paper outlines one core language design for Trellys, and demonstrates the use of the key language constructs to facilitate sound reasoning about potentially unsound programs.

IDRIS ---: systems programming meets full dependent types

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.

Interactive Programs in Dependent Type Theory

A bisimulation relation between interactive programs is introduced, with respect to which the monad laws and defining equations of while are proved and most definitions in this article make essential use of the expressive strength of dependent typing.

Towards a practical programming language based on dependent type theory

This thesis is concerned with bridging the gap between the theoretical presentations of type theory and the requirements on a practical programming language.

Dependently typed functional programs and their proofs

This thesis shows that the adoption of this uniqueness as axiomatic is sufficient to make pattern matching admissible, and develops technology for programming with dependent inductive families of datatypes and proving those programs correct.

A Tutorial Implementation of a Dependently Typed Lambda Calculus

The type rules for a dependently typed core calculus are presented together with a straight-forward implementation in Haskell and the changes necessary to shift from a simply-typed lambda calculus to the dependent typed lambda calculus are highlighted.

Epigram reloaded: a standalone typechecker for ETT

A standalone typechecker for ETT in Haskell is implemented, allowing us to reload existing libraries into the system safely without re-elaboration, and using a glued representation of values, pairing first-order syntax with a functional representation of its semantics, computed lazily.

Epic - A Library for Generating Compilers

Epic is a compiled functional language which exposes functional compilation techniques to a language implementor, with a Haskell API, and outline how it may be used to implement a high level language compiler.