1,566 research outputs found
Type Inference for Bimorphic Recursion
This paper proposes bimorphic recursion, which is restricted polymorphic
recursion such that every recursive call in the body of a function definition
has the same type. Bimorphic recursion allows us to assign two different types
to a recursively defined function: one is for its recursive calls and the other
is for its calls outside its definition. Bimorphic recursion in this paper can
be nested. This paper shows bimorphic recursion has principal types and
decidable type inference. Hence bimorphic recursion gives us flexible typing
for recursion with decidable type inference. This paper also shows that its
typability becomes undecidable because of nesting of recursions when one
removes the instantiation property from the bimorphic recursion.Comment: In Proceedings GandALF 2011, arXiv:1106.081
Foundational Extensible Corecursion
This paper presents a formalized framework for defining corecursive functions
safely in a total setting, based on corecursion up-to and relational
parametricity. The end product is a general corecursor that allows corecursive
(and even recursive) calls under well-behaved operations, including
constructors. Corecursive functions that are well behaved can be registered as
such, thereby increasing the corecursor's expressiveness. The metatheory is
formalized in the Isabelle proof assistant and forms the core of a prototype
tool. The corecursor is derived from first principles, without requiring new
axioms or extensions of the logic
Data Structures and Data Types in Object-Oriented Databases
The possibility of finding a static type system for object-oriented programming languages was initiated by Cardelli [Car88, CW85] who showed that it is possible to express the polymorphic nature of functions such a
Type-Based Termination, Inflationary Fixed-Points, and Mixed Inductive-Coinductive Types
Type systems certify program properties in a compositional way. From a bigger
program one can abstract out a part and certify the properties of the resulting
abstract program by just using the type of the part that was abstracted away.
Termination and productivity are non-trivial yet desired program properties,
and several type systems have been put forward that guarantee termination,
compositionally. These type systems are intimately connected to the definition
of least and greatest fixed-points by ordinal iteration. While most type
systems use conventional iteration, we consider inflationary iteration in this
article. We demonstrate how this leads to a more principled type system, with
recursion based on well-founded induction. The type system has a prototypical
implementation, MiniAgda, and we show in particular how it certifies
productivity of corecursive and mixed recursive-corecursive functions.Comment: In Proceedings FICS 2012, arXiv:1202.317
Practical Subtyping for System F with Sized (Co-)Induction
We present a rich type system with subtyping for an extension of System F.
Our type constructors include sum and product types, universal and existential
quantifiers, inductive and coinductive types. The latter two size annotations
allowing the preservation of size invariants. For example it is possible to
derive the termination of the quicksort by showing that partitioning a list
does not increase its size. The system deals with complex programs involving
mixed induction and coinduction, or even mixed (co-)induction and polymorphism
(as for Scott-encoded datatypes). One of the key ideas is to completely
separate the induction on sizes from the notion of recursive programs. We use
the size change principle to check that the proof is well-founded, not that the
program terminates. Termination is obtained by a strong normalization proof.
Another key idea is the use symbolic witnesses to handle quantifiers of all
sorts. To demonstrate the practicality of our system, we provide an
implementation that accepts all the examples discussed in the paper and much
more
Inductive types in the Calculus of Algebraic Constructions
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 higher-order
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 non-strictly positive types and
inductive-recursive types together with non-free constructors and
pattern-matching on defined symbols.Comment: Journal version of TLCA'0
Typing Copyless Message Passing
We present a calculus that models a form of process interaction based on
copyless message passing, in the style of Singularity OS. The calculus is
equipped with a type system ensuring that well-typed processes are free from
memory faults, memory leaks, and communication errors. The type system is
essentially linear, but we show that linearity alone is inadequate, because it
leaves room for scenarios where well-typed processes leak significant amounts
of memory. We address these problems basing the type system upon an original
variant of session types.Comment: 50 page
- …