Topic
Dependent ML
About: Dependent ML is a research topic. Over the lifetime, 6 publications have been published within this topic receiving 246 citations. The topic is also known as: DML.
Papers
16 Jun 2001
TL;DR: In this article, the authors present a type system for verifying program termination using dependent types developed in Dependent ML (DML), and prove that every well-typed program in this type system is terminating.
Abstract: Program termination verification is a challenging research subject of significant practical importance. While there is already a rich body of literature on this subject, it is still undeniably a difficult task to design a termination checker for a realistic programming language that supports general recursion. In this paper, we present an approach to program termination verification that makes use of a form of dependent types developed in Dependent ML (DML), demonstrating a novel application of such dependent types to establishing a liveness property. We design a type system that enables the programmer to supply metrics for verifying program termination and prove that every well-typed program in this type system is terminating. We also provide realistic examples, which are all verified in a prototype implementation, to support the effectiveness of our approach to program termination verification as well as its unobtrusiveness to programming. The main contribution of the paper lies in the design of an approach to program termination verification that smoothly combines types with metrics, yielding a type system capable of guaranteeing program termination that supports a general form of recursion (including mutual recursion), higher-order functions, algebraic data types and polymorphism.
114 citations
1 Jan 2005
TL;DR: A calculus that supports dependent programming in the style of Xi and Pfenning’s Dependent ML is studied and type safety and decidability of type checking are proved and a detailed comparison is presented with other dependently typed languages.
Abstract: We study a calculus that supports dependent programming in the style of Xi and Pfenning’s Dependent ML. Xi and Pfenning’s language determines equality of static data using a built-in decision procedure; ours permits explicit, programmer-written proofs of equality. In this report, we define our calculus’ semantics and prove type safety and decidability of type checking; we have mechanized much of these proofs using the Twelf proof assistant. Additionally, we illustrate programming in our calculus through a series of examples. Finally, we present a detailed comparison with other dependently typed languages, including Dependent ML, Epigram, Cayenne, ATS, Ωmega, and RSP1. This material is based on work supported in part by the National Science Foundation under grants CCR-0204248: Type Refinements and 0121633: ITR/SY+SI: Language Technology for Trustless Software Dissemination. Any opinions, findings, conclusions and recommendations in this publication are the authors’ and do not reflect the views of this agency.
25 citations
TL;DR: This article systematically extracts cost recurrences from first-order DML programs, guiding the abstraction from data to data size with information contained in DML type derivations.
Abstract: A cost recurrence describes an upper bound for the running time of a program in terms of the size of its input. Finding cost recurrences is a frequent intermediate step in complexity analysis, and this step requires an abstraction from data to data size. In this article, we use information contained in dependent types to achieve such an abstraction: Dependent ML (DML), a conservative extension of ML, provides dependent types that can be used to associate data with size information, thus describing a possible abstraction. We systematically extract cost recurrences from first-order DML programs, guiding the abstraction from data to data size with information contained in DML type derivations.
11 citations
TL;DR: The quantitative realizability model aims at a better understanding of d l PCF type decorations and at giving an abstract semantic proof of intensional soundness.
1 citations
14 Apr 2008
TL;DR: A novel approach to applications of dependent types to practical programming languages is proposed, which mine the output specification of a dependent function from the function's call sites, and then propagate that specification backward to infer the input specification.
Abstract: Dependent types are useful for statically checking detailed specifications of programs and detecting pattern match or array bounds errors. We propose a novel approach to applications of dependent types to practical programming languages: Instead of requiring programmers' declaration of dependent function types (as in Dependent ML) or trying to infer them from function definitions only (as in size inference), we mine the output specification of a dependent function from the function's call sites, and then propagate that specification backward to infer the input specification. We have implemented a prototype type inference system which supports higher-order functions, parametric polymorphism, and algebraic data types based on our approach, and obtained promising experimental results.
Related Topics (5)
Performance Metrics
| Year | Papers |
|---|---|
| 2015 | 1 |
| 2008 | 1 |
| 2007 | 1 |
| 2005 | 1 |
| 2001 | 2 |