Results 11  20
of
43
Modeling Abstract Types in Modules with Open Existential Types
"... We propose F � , a calculus of open existential types that is an extension of System F obtained by decomposing the introduction and elimination of existential types into more atomic constructs. Open existential types model modular type abstraction as done in module systems. The static semantics of F ..."
Abstract

Cited by 15 (1 self)
 Add to MetaCart
We propose F � , a calculus of open existential types that is an extension of System F obtained by decomposing the introduction and elimination of existential types into more atomic constructs. Open existential types model modular type abstraction as done in module systems. The static semantics of F � adapts standard techniques to deal with linearity of typing contexts, its dynamic semantics is a smallstep reduction semantics that performs extrusion of type abstraction as needed during reduction, and the two are related by subject reduction and progress lemmas. Applying the CurryHoward isomorphism, F � can be also read back as a logic with the same expressive power as secondorder logic but with more modular ways of assembling partial proofs. We also extend the core calculus to handle the double vision problem as well as typelevel and termlevel recursion. The resulting language turns out to be a new formalization of (a minor variant of) Dreyer’s internal language for recursive and mixin modules.
Typelevel Computation Using Narrowing in Ωmega
 PLPV 2006
, 2006
"... Ωmega is an experimental system that combines features of both a programming language and a logical reasoning system. Ωmega is a language with an infinite hierarchy of computational levels. Terms at one level are classified (or typed) by terms at the next higher level. In this paper we report on usi ..."
Abstract

Cited by 15 (0 self)
 Add to MetaCart
Ωmega is an experimental system that combines features of both a programming language and a logical reasoning system. Ωmega is a language with an infinite hierarchy of computational levels. Terms at one level are classified (or typed) by terms at the next higher level. In this paper we report on using two different computational mechanisms. At the value level, computation is performed by reduction, and is largely unconstrained. At all higher levels, computation is performed by narrowing.
Certifying Compilation for Standard ML in a Type Analysis Framework
, 2005
"... or implied, of any sponsoring institution, the U.S. government or any other entity. ..."
Abstract

Cited by 11 (0 self)
 Add to MetaCart
(Show Context)
or implied, of any sponsoring institution, the U.S. government or any other entity.
HigherOrder Intensional Type Analysis in TypeErasure Semantics
 In Proc. 11th ESOP, LNCS 2305
, 2003
"... Higherorder intensional type analysis is a way of defining typeindexed operations, such as map, fold and zip, based on runtime type information. However, languages supporting this facility are naturally defined with a typepassing semantics, which su#ers from a number of drawbacks. This paper, de ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
Higherorder intensional type analysis is a way of defining typeindexed operations, such as map, fold and zip, based on runtime type information. However, languages supporting this facility are naturally defined with a typepassing semantics, which su#ers from a number of drawbacks. This paper, describes how to recast higherorder intensional type analysis in a typeerasure semantics. The resulting language is simple and easy to implementwe present a prototype implementation of the necessary machinery as a small Haskell library.
Strict Bidirectional Type Checking
"... Completely annotated lambda terms (such as are arrived at via the straightforward encodings of various types from System F) contain much redundant type information. Consequently, the completely annotated forms are almost never used in practice, since partially annotated forms can be defined which st ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
Completely annotated lambda terms (such as are arrived at via the straightforward encodings of various types from System F) contain much redundant type information. Consequently, the completely annotated forms are almost never used in practice, since partially annotated forms can be defined which still allow syntax directed type checking. An additional optimization that is used in some proof and type systems is to take advantage of the context of occurrence of terms to further elide type information using bidirectional type checking rules. While this technique is generally effective, we show that there exist bidirectional terms which exhibit asymptotic increases in the size of their type decorations when sequentialized into a namedform calculus (a common first step in compilation). In this paper, we introduce a refinement of the bidirectional type system based on strict logic which allows additional type decorations to be eliminated, and show that it is wellbehaved under sequentialization. Categories and Subject Descriptors D.3.1 [Programming Languages]: Formal Definitions and Theory; D.3.3 [Programming Languages]: Language Constructs and Features; D.3.4 [Programming Languages]: ProcessorsCom pilers This research was supported in part by an NDSEG fellowship, and in part by the National Science Foundation under grant ITR/SY+SI 0121633: "Language Technology for Trustless Software Dissemination ".
A Syntactic Type System for Recursive Modules
"... A practical type system for MLstyle recursive modules should address at least two technical challenges. First, it needs to solve the double vision problem, which refers to an inconsistency between external and internal views of recursive modules. Second, it needs to overcome the tension between pra ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
(Show Context)
A practical type system for MLstyle recursive modules should address at least two technical challenges. First, it needs to solve the double vision problem, which refers to an inconsistency between external and internal views of recursive modules. Second, it needs to overcome the tension between practical decidability and expressivity which arises from the potential presence of cyclic type definitions caused by recursion between modules. Although type systems in previous proposals solve the double vision problem and are also decidable, they fail to typecheck common patterns of recursive modules, such as functor fixpoints, that are essential to the expressivity of the module system and the modular development of recursive modules. This paper proposes a novel type system for recursive
LowLevel Type Systems for Modularity and ObjectOriented Constructs
, 2000
"... Typed Assembly Language (Tal) is a formal language for an idealised machine augmented with type annotations, typing rules, and a memory allocation primitive. Tal’s type system is sound; that is, well typed Tal programs do not commit runtime type errors during execution. This guarantee can be used t ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
Typed Assembly Language (Tal) is a formal language for an idealised machine augmented with type annotations, typing rules, and a memory allocation primitive. Tal’s type system is sound; that is, well typed Tal programs do not commit runtime type errors during execution. This guarantee can be used to debug typedirected compilers and to build more general security properties in an extensible system. This dissertation presents a basic version of Tal and extensions to support the compilation of modules and objectoriented languages. First, it describes a modular version of Tal that consists of typed object files, linking operations, and link compatibility conditions. Together these features provide for typesound separate compilation and substantially extend previous work on linking. Second, it shows how to use a new formulation of self quantifiers to compile an efficient implementation of a singleinheritance classbased objectoriented language into Tal. Third, it presents a new type constructor called a tag type, and shows how to use them to compile downcasting and exceptions into Tal.
Dependent types and program equivalence
 In Proceedings of the 37th ACM SIGACTSIGPLAN Symposium on Principles of Programming Languages (POPL). ACM
, 2009
"... The definition of type equivalence is one of the most important design issues for any typed language. In dependentlytyped languages, because terms appear in types, this definition must rely on a definition of term equivalence. In that case, decidability of type checking requires decidability for the ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
(Show Context)
The definition of type equivalence is one of the most important design issues for any typed language. In dependentlytyped languages, because terms appear in types, this definition must rely on a definition of term equivalence. In that case, decidability of type checking requires decidability for the term equivalence relation. Almost all dependentlytyped languages require this relation to be decidable. Some, such as Coq, Epigram or Agda, do so by employing analyses to force all programs to terminate. Conversely, others, such as DML, ATS, Ωmega, or Haskell, allow nonterminating computation, but do not allow those terms to appear in types. Instead, they identify a terminating index language and use singleton types to connect indices to computation. In both cases, decidable type checking comes at a cost, in terms of complexity and expressiveness. Conversely, the benefits to be gained by decidable type checking are modest. Termination analyses allow dependently typed programs to verify total correctness properties. However, decidable type checking is not a prerequisite for type safety. Furthermore, decidability does not imply tractability. A decidable approximation of program equivalence may not be useful in practice. Therefore, we take a different approach: instead of a fixed notion for term equivalence, we parameterize our type system with an abstract relation that is not necessarily decidable. We then design a novel set of typing rules that require only weak properties of this abstract relation in the proof of the preservation and progress lemmas. This design provides flexibility: we compare valid instantiations of term equivalence which range from betaequivalence, to contextual equivalence, to some exotic equivalences.
A syntactic account of singleton types via hereditary substitution
, 2009
"... We give a syntactic proof of decidability and consistency of equivalence for the singleton type calculus, which lies at the foundation of modern module systems such as that of ML. Unlike existing proofs, which work by constructing a model, our syntactic proof makes few demands on the underlying proo ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
We give a syntactic proof of decidability and consistency of equivalence for the singleton type calculus, which lies at the foundation of modern module systems such as that of ML. Unlike existing proofs, which work by constructing a model, our syntactic proof makes few demands on the underlying proof theory and mathematical foundation. Consequently, it can be — and has been — entirely formulated in the Twelf metalogic, and provides an important piece of a Twelfformalized typesafety proof for Standard ML. The proof works by translation of the singleton type calculus into a canonical presentation, adapted from work on logical frameworks, in which equivalent terms are written identically. Canonical forms are not preserved under standard substitution, so we employ an alternative definition of substitution called hereditary substitution, which contracts redices that arise during substitution. 1