Why dependent types matter

@inproceedings{McKinna2006WhyDT,
  title={Why dependent types matter},
  author={J. McKinna},
  booktitle={POPL '06},
  year={2006}
}
  • J. McKinna
  • Published in POPL '06 2006
  • Computer Science
Language designers have in recent years proposed a wealth of richer type systems for programming which seek to extend the range of statically enforced guarantees on data and code. Most such proposals have been evolutionary extensions of ML or Haskell, offering programmers a balanced compromise between expressive strength and existing well-understood technology. Typically they revolve around type- or kind-indexed types such as GADTs, supported by limited equality reasoning at the type-checking… Expand
PiSigma: Dependent Types without the Sugar
TLDR
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. Expand
Towards a Prelude for Agda
TLDR
This thesis aims to improve the situation by implementing type classes which resolve many of the name clashes in Agda by implementing a “Prelude”, which provides all the necessary data types and functions for day-to-day Agda programming. Expand
A multivalued language with a dependent type system
TLDR
A new dependently-typed functional programming language based on two key ideas, which makes no distinction between expressions, types, kinds, and sorts-everything is a term, and is considered a good tradeoff to get an expressive language without the pain of some dependent type systems. Expand
Advances in Type Systems for Functional Logic Programming
TLDR
This work proposes a Damas & Milner-like type system where certain uses of HO patterns (even opaque) are permitted while preserving type safety, as proved by a subject reduction result that uses a HO-let-rewriting, a recently proposed operational semantics for HO functional logic programs. Expand
In Search of Effectful Dependent Types
TLDR
This thesis develops a game semantics for dependent type theory, which had so far been missing altogether and explores a generalisation of Levy’s call-by-push-value to encompass dependent types. Expand
Combining Proofs and Programs
TLDR
A work-in-progress overview of the Trellys project, which is new core language, designed to provide a smooth path from functional programming to dependently-typed programming, and allows programmers to work with total and partial functions uniformly. Expand
Dependently typed programming in Agda
TLDR
This talk gives an overview of the Agda programming language (Norell 2007), whose main focus is on dependently typed programming, and a number of examples of interesting dependency typed programs chosen from the domain of programming language implementation are presented as they are implemented in Agda. Expand
Dependent Types : Easy as P IE Work-In-Progress
Dependent type systems allow for a rich set of program properties to be expressed and mechanically verified via type checking. However, despite their significant expressive power, dependent typesExpand
Constrained types for object-oriented languages
TLDR
The design and implementation of constrained types are presented, a natural, simple, clean, and expressive extension to object-oriented programming that supports extension with new constraint systems using compiler plugins. Expand
Introducing Type Properties
TLDR
This paper presents a concept that allows a programmer to express these attributions while fulfilling the requirement of being fully on the static level, and proposes type properties, which would allow one to express linear types as functionality in a separate program module, without the need to refine the whole type system. Expand
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 71 REFERENCES
Dynamic optimization for functional reactive programming using generalized algebraic data types
TLDR
This paper is a case study on the applications of GADTs in the context of Yampa, a domain-specific language for Functional Reactive Programming in the form of a self-optimizing, arrow-based Haskell combinator library. Expand
Dependent types in practical programming
We present an approach to enriching the type system of ML with a restricted form of dependent types, where type index objects are drawn from a constraint domain C, leading to the DML(C) languageExpand
Dependently typed functional programs and their proofs
TLDR
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. Expand
Practical implementation of a dependently typed functional programming language
TLDR
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. Expand
Typing dynamic typing
TLDR
It is shown how, by a careful use of existentially and universally quantified types, one may achieve the same effect, without extending the language with new or unsafe features. Expand
First-Class Phantom Types
TLDR
This work proves type soundness and decidability for a Haskell-like language extended by first-class phantom types, which make type constraints explicit via type equations in the datatype cases themselves. Expand
Applied Type System: Extended Abstract
  • H. Xi
  • Computer Science
  • TYPES
  • 2003
TLDR
This paper presents not only a formal development of ATS but also mention some examples in support of using ATS as a framework to form type systems for practical programming. Expand
Programmable Type Systems for Domain Specific Languages
TLDR
It is shown that a component that ensures the generation of correct HTML documents can take good advantage of type-level functions, as implemented using functional logic overloading, and that a function that ensuring the consistency of data submitted to a Web script with the data expected by the script is less awkward to use in the presence of lambda expressions in the type language. Expand
Scrap your boilerplate: a practical design pattern for generic programming
TLDR
This work describes a design pattern for writing programs that traverse data structures built from rich mutually-recursive data types that makes essential use of rank-2 polymorphism, an extension found in some implementations of Haskell. Expand
Epigram: Practical Programming with Dependent Types
TLDR
A static language capable of expressing the significance of particular values in legitimizing some computations rather than others is needed, and Haskell should not give up on programming. Expand
...
1
2
3
4
5
...