Results 1  10
of
54
Polymorphism and separation in Hoare type theory
 In icfp
, 2006
"... In previous work we have proposed a Dependent Hoare Type Theory (HTT) as a framework for development and reasoning about higherorder functional programs with effects of state, aliasing and nontermination. The main feature of HTT is the type of Hoare triples {P}x:A{Q} specifying computations with pr ..."
Abstract

Cited by 65 (14 self)
 Add to MetaCart
In previous work we have proposed a Dependent Hoare Type Theory (HTT) as a framework for development and reasoning about higherorder functional programs with effects of state, aliasing and nontermination. The main feature of HTT is the type of Hoare triples {P}x:A{Q} specifying computations with precondition P and postcondition Q, that return a result of type A. Here we extend HTT with predicative type polymorphism. Type quantification is possible in both types and assertions, and we can also quantify over Hoare triples. We show that as a consequence it becomes possible to reason about disjointness of heaps in the assertion logic of HTT. We use this expressiveness to interpret the Hoare triples in the “small footprint ” manner advocated by Separation Logic, whereby a precondition tightly describes the heap fragment required by the computation. We support stateful commands of allocation, lookup, strong update, deallocation, and pointer arithmetic. 1
Generic programming within dependently typed programming
 In Generic Programming, 2003. Proceedings of the IFIP TC2 Working Conference on Generic Programming, Schloss Dagstuhl
, 2003
"... Abstract We show how higher kinded generic programming can be represented faithfully within a dependently typed programming system. This development has been implemented using the Oleg system. The present work can be seen as evidence for our thesis that extensions of type systems can be done by prog ..."
Abstract

Cited by 52 (7 self)
 Add to MetaCart
Abstract We show how higher kinded generic programming can be represented faithfully within a dependently typed programming system. This development has been implemented using the Oleg system. The present work can be seen as evidence for our thesis that extensions of type systems can be done by programming within a dependently typed language, using data as codes for types. 1.
Abstract predicates and mutable ADTs in Hoare type theory
 In Proc. ESOP’07, volume 4421 of LNCS
, 2007
"... Hoare Type Theory (HTT) combines a dependently typed, higherorder language with monadicallyencapsulated, stateful computations. The type system incorporates pre and postconditions, in a fashion similar to Hoare and Separation Logic, so that programmers can modularly specify the requirements and e ..."
Abstract

Cited by 42 (19 self)
 Add to MetaCart
Hoare Type Theory (HTT) combines a dependently typed, higherorder language with monadicallyencapsulated, stateful computations. The type system incorporates pre and postconditions, in a fashion similar to Hoare and Separation Logic, so that programmers can modularly specify the requirements and effects of computations within types. This paper extends HTT with quantification over abstract predicates (i.e., higherorder logic), thus embedding into HTT the Extended Calculus of Constructions. When combined with the Hoarelike specifications, abstract predicates provide a powerful way to define and encapsulate the invariants of private state; that is, state which may be shared by several functions, but is not accessible to their clients. We demonstrate this power by sketching a number of abstract data types and functions that demand ownership of mutable memory, including an idealized custom memory manager. 1
TypeBased Termination of Recursive Definitions
, 2002
"... This article The purpose of this paper is to introduce b, a simply typed calculus that supports typebased recursive definitions. Although heavily inspired from previous work by Giménez (Giménez 1998) and closely related to recent work by Amadio and Coupet (Amadio and CoupetGrimal 1998), the techn ..."
Abstract

Cited by 39 (3 self)
 Add to MetaCart
This article The purpose of this paper is to introduce b, a simply typed calculus that supports typebased recursive definitions. Although heavily inspired from previous work by Giménez (Giménez 1998) and closely related to recent work by Amadio and Coupet (Amadio and CoupetGrimal 1998), the technical machinery behind our system puts a slightly different emphasis on the interpretation of types. More precisely, we formalize the notion of typebased termination using a restricted form of type dependency (a.k.a. indexed types), as popularized by (Xi and Pfenning 1998; Xi and Pfenning 1999). This leads to a simple and intuitive system which is robust under several extensions, such as mutually inductive datatypes and mutually recursive function definitions; however, such extensions are not treated in the paper
A Coverage Checking Algorithm for LF
, 2003
"... Coverage checking is the problem of deciding whether any closed term of a given type is an instance of at least one of a given set of patterns. It can be used to verify if a function defined by pattern matching covers all possible cases. This problem has a straightforward solution for the first ..."
Abstract

Cited by 39 (12 self)
 Add to MetaCart
Coverage checking is the problem of deciding whether any closed term of a given type is an instance of at least one of a given set of patterns. It can be used to verify if a function defined by pattern matching covers all possible cases. This problem has a straightforward solution for the firstorder, simplytyped case, but is in general undecidable in the presence of dependent types. In this paper we present a terminating algorithm for verifying coverage of higherorder, dependently typed patterns.
Elimination with a Motive
 Types for Proofs and Programs (Proceedings of the International Workshop, TYPES’00), volume 2277 of LNCS
, 2002
"... I present a tactic, BasicElim, for Type Theory based proof systems to apply elimination rules in a refinement setting. Applicable rules are parametric in their conclusion, expressing the leverage hypotheses ~x yield on any \Phi ~x we choose. \Phi represents the motive for an elimination: BasicElim' ..."
Abstract

Cited by 37 (12 self)
 Add to MetaCart
I present a tactic, BasicElim, for Type Theory based proof systems to apply elimination rules in a refinement setting. Applicable rules are parametric in their conclusion, expressing the leverage hypotheses ~x yield on any \Phi ~x we choose. \Phi represents the motive for an elimination: BasicElim's job is to construct a \Phi suited to the goal at hand. If these ~x inhabit an instance of \Phi's domain, I adopt a technique standard in `folklore', generalizing the ~x and expressing the restriction by equation. A novel notion of = readily permits dependent equations, and a second tactic, Unify, simpifies the equational hypotheses thus appearing in subgoals. Given such technology, it becomes effective to express properties of datatypes, relations and functions in this style. A small extension couples BasicElim with rewriting, allowing complex techniques to be packaged in a single rule. 1
The derivative of a regular type is its type of onehole contexts (extended abstract), 2001. Unpublished manuscript, available via http://strictlypositive.org/diff.pdf. Conor McBride and Ross Paterson. Applicative programming with effects
"... Polymorphic regular types are treelike datatypes generated by polynomial type expressions over a set of free variables and closed under least fixed point. The ‘equality types ’ of Core ML can be expressed in this form. Given such a type expression with free, this paper shows a way to represent the ..."
Abstract

Cited by 36 (6 self)
 Add to MetaCart
Polymorphic regular types are treelike datatypes generated by polynomial type expressions over a set of free variables and closed under least fixed point. The ‘equality types ’ of Core ML can be expressed in this form. Given such a type expression with free, this paper shows a way to represent the onehole contexts for elements of within elements of, together with an operation which will plug an element of into the hole of such a context. Onehole contexts are given as inhabitants of a regular type, computed generically from the syntactic structure of by a mechanism better known as partial differentiation. The relevant notion of containment is shown to be appropriately characterized in terms of derivatives and plugging in. The technology is then exploited to give the onehole contexts for subelements of recursive types in a manner similar to Huet’s ‘zippers’[Hue97]. 1
Termination Checking with Types
, 1999
"... The paradigm of typebased termination is explored for functional programming with recursive data types. The article introduces , a lambdacalculus with recursion, inductive types, subtyping and bounded quanti cation. Decorated type variables representing approximations of inductive types ..."
Abstract

Cited by 28 (6 self)
 Add to MetaCart
The paradigm of typebased termination is explored for functional programming with recursive data types. The article introduces , a lambdacalculus with recursion, inductive types, subtyping and bounded quanti cation. Decorated type variables representing approximations of inductive types are used to track the size of function arguments and return values. The system is shown to be type safe and strongly normalizing. The main novelty is a bidirectional type checking algorithm whose soundness is established formally.
Faking It: Simulating Dependent Types in Haskell
, 2001
"... Dependent types reflect the fact that validity of data is often a relative notion by allowing prior data to affect the types of subsequent data. Not only does this make for a precise type system, but also a highly generic one: both the type and the program for each instance of a family of operations ..."
Abstract

Cited by 27 (6 self)
 Add to MetaCart
Dependent types reflect the fact that validity of data is often a relative notion by allowing prior data to affect the types of subsequent data. Not only does this make for a precise type system, but also a highly generic one: both the type and the program for each instance of a family of operations can be computed from the data which codes for that instance. Recent experimental extensions to the Haskell type class mechanism give us strong tools to relativize types to other types. We may simulate some aspects of dependent typing by making counterfeit typelevel copies of data, with type constructors simulating data constructors and type classes simulating datatypes. This paper gives examples of the technique and discusses its potential. 1
The Calculus of Algebraic Constructions
 In Proc. of the 10th Int. Conf. on Rewriting Techniques and Applications, LNCS 1631
, 1999
"... Abstract. In a previous work, we proved that an important part of the Calculus of Inductive Constructions (CIC), the basis of the Coq proof assistant, can be seen as a Calculus of Algebraic Constructions (CAC), an extension of the Calculus of Constructions with functions and predicates defined by hi ..."
Abstract

Cited by 27 (10 self)
 Add to MetaCart
Abstract. In a previous work, we proved that an important part of the Calculus of Inductive Constructions (CIC), the basis of the Coq proof assistant, can be seen as a Calculus of Algebraic Constructions (CAC), an extension of the Calculus of Constructions with functions and predicates defined by higherorder rewrite rules. In this paper, we prove that almost all CIC can be seen as a CAC, and that it can be further extended with nonstrictly positive types and inductiverecursive types together with nonfree constructors and patternmatching on defined symbols. 1.