Results 11  20
of
49
Foundations for the Implementation of HigherOrder Subtyping
, 1997
"... We show how to implement a calculus with higherorder subtyping and subkinding by replacing uses of implicit subsumption with explicit coercions. To ensure this can be done, a polymorphic function is adjusted to take, as an additional argument, a proof that its type constructor argument has the desi ..."
Abstract

Cited by 13 (6 self)
 Add to MetaCart
We show how to implement a calculus with higherorder subtyping and subkinding by replacing uses of implicit subsumption with explicit coercions. To ensure this can be done, a polymorphic function is adjusted to take, as an additional argument, a proof that its type constructor argument has the desired kind. Such a proof is extracted from the derivation of a kinding judgement and may in turn require proof coercions, which are extracted from subkinding judgements. This technique is formalized as a typedirected translation from a calculus of higherorder subtyping to a subtypingfree calculus. This translation generalizes an existing result for secondorder subtyping calculi (such as F ). We also discuss two interpretations of subtyping, one that views it as type inclusion and another that views it as the existence of a wellbehaved coercion, and we show, by a typetheoretic construction, that our translation is the minimum consequence of shifting from the inclusion interpretation to th...
Parametric and TypeDependent Polymorphism
, 1995
"... Data Types, though, as Reynolds stresses, is not perfectly suited for higher type or higher order systems and, thus, he proposes a "relational" treatment of invariance: computations do not depend on types in the sense that they are "invariant" w.r.t. arbitrary relations on types ..."
Abstract

Cited by 10 (5 self)
 Add to MetaCart
Data Types, though, as Reynolds stresses, is not perfectly suited for higher type or higher order systems and, thus, he proposes a "relational" treatment of invariance: computations do not depend on types in the sense that they are "invariant" w.r.t. arbitrary relations on types and between types. Reynolds's approach set the basis for most of the current work on parametricity, as we will review below (.3). Some twelve years earlier, Girard had given just a simple hint towards another understanding of the properties of "computing with types". In [Gir71], it is shown, as a side remark, that, given a type A, if one defines a term J A such that, for any type B, J A B reduces to 1, if A = B, and reduces to 0, if A ¹ B, then F + J A does not normalize. In particular, then, J A is not definable in F. This remark on how terms may depend on types is inspired by a view of types which is quite different from Reynolds's. System F was born as the theory of proofs of second order intuitionis...
The Meaning of Types  From Intrinsic to Extrinsic Semantics
 Department of Computer Science, University of Aarhus
, 2000
"... A definition of a typed language is said to be "intrinsic" if it assigns meanings to typings rather than arbitrary phrases, so that illtyped phrases are meaningless. In contrast, a definition is said to be "extrinsic " if all phrases have meanings that are independent of their t ..."
Abstract

Cited by 10 (1 self)
 Add to MetaCart
A definition of a typed language is said to be "intrinsic" if it assigns meanings to typings rather than arbitrary phrases, so that illtyped phrases are meaningless. In contrast, a definition is said to be "extrinsic " if all phrases have meanings that are independent of their typings, while typings represent properties of these meanings. For a simply typed lambda calculus, extended with recursion, subtypes, and named products, we give an intrinsic denotational semantics and a denotational semantics of the underlying untyped language. We then establish a logical relations theorem between these two semantics, and show that the logical relations can be "bracketed" by retractions between the domains of the two semantics. From these results, we derive an extrinsic semantics that uses partial equivalence relations.
The BehaviorRealization Adjunction and Generalized Homomorphic Relations
 COMP. SCI
, 1996
"... A model theory for proving correctness of abstract data types is developed within the framework of the behaviorrealization adjunction. To allow for incomplete specifications, proofofcorrectness ... ..."
Abstract

Cited by 9 (5 self)
 Add to MetaCart
A model theory for proving correctness of abstract data types is developed within the framework of the behaviorrealization adjunction. To allow for incomplete specifications, proofofcorrectness ...
Semantics of architectural specifications in Casl
 Proc. 4th Intl. Conf. Fundamental Approaches to Software Engineering FASE’01, Springer LNCS 2029
, 2001
"... Abstract. We present a semantics for architectural specifications in Casl, including an extended static analysis compatible with modeltheoretic requirements. The main obstacle here is the lack of amalgamation for Casl models. To circumvent this problem, we extend the Casl logic by introducing enrich ..."
Abstract

Cited by 8 (6 self)
 Add to MetaCart
Abstract. We present a semantics for architectural specifications in Casl, including an extended static analysis compatible with modeltheoretic requirements. The main obstacle here is the lack of amalgamation for Casl models. To circumvent this problem, we extend the Casl logic by introducing enriched signatures, where subsort embeddings form a category rather than just a preorder. The extended model functor has amalgamation, which makes it possible to express the amalgamability conditions in the semantic rules in static terms. Using these concepts, we develop the semantics at various levels in an institutionindependent fashion.
Preliminary Design of Larch/C++
 PROCEEDINGS OF THE FIRST INTERNATIONAL WORKSHOP ON LARCH, JULY, 1992, WORKSHOPS IN COMPUTING
, 1992
"... We describe the problems encountered in the design of Larch/C++, especially its objectoriented features. We discuss a range of possible solutions to these problems, and give the rationale for our particular solutions. We also present examples of Larch/C++ specifications and discuss differences fr ..."
Abstract

Cited by 7 (2 self)
 Add to MetaCart
We describe the problems encountered in the design of Larch/C++, especially its objectoriented features. We discuss a range of possible solutions to these problems, and give the rationale for our particular solutions. We also present examples of Larch/C++ specifications and discuss differences from Larch/C.
Subject reduction and minimal types for higher order subtyping
 In Proceedings of the Second Chinese Language Processing Workshop
, 1997
"... We define the typed lambda calculus F ω ∧ , a natural generalization of Girard’s system F ω with intersection types and bounded polymorphism. A novel aspect of our presentation is the use of term rewriting techniques to present intersection types, which clearly splits the computational semantics (re ..."
Abstract

Cited by 6 (3 self)
 Add to MetaCart
We define the typed lambda calculus F ω ∧ , a natural generalization of Girard’s system F ω with intersection types and bounded polymorphism. A novel aspect of our presentation is the use of term rewriting techniques to present intersection types, which clearly splits the computational semantics (reduction rules) from the syntax (inference rules) of the system. We establish properties such as ChurchRosser for the reduction relation on types and terms, and Strong Normalization for the reduction on types. We prove that types are preserved by computation (Subject Reduction property), and that the system satisfies the Minimal Types property. On the way to establishing these results, we define algorithms for type inference and subtype checking. 1
On complete completion using types and weights
, 2012
"... Developing modern software typically involves composing functionality from existing libraries. This task is difficult because libraries may expose many methods to the developer. To help developers in such scenarios, we present a technique that synthesizes and suggests valid expressions of a given ty ..."
Abstract

Cited by 5 (5 self)
 Add to MetaCart
Developing modern software typically involves composing functionality from existing libraries. This task is difficult because libraries may expose many methods to the developer. To help developers in such scenarios, we present a technique that synthesizes and suggests valid expressions of a given type at a given program point. As the basis of our technique we use type inhabitation for lambda calculus terms in long normal form. We introduce a succinct representation for type judgements that merges types into equivalence classes to reduce the search space, then reconstructs any desired number of solutions on demand. Furthermore, we introduce a method to rank solutions based on weights derived from a corpus of code. We implemented the algorithm and deployed it as a plugin for the Eclipse IDE for Scala. We show that the techniques we incorporated greatly increase the effectiveness of the approach. Our evaluation benchmarks are code examples from programming practice; we make them available for future comparisons.