Results 1  10
of
25
Simple TypeTheoretic Foundations for ObjectOriented Programming
, 1993
"... We develop a formal, typetheoretic account of the basic mechanisms of objectoriented programming: encapsulation, message passing, subtyping, and inheritance. By modeling object encapsulation in terms of existential types instead of the recursive records used in other recent studies, we obtain a s ..."
Abstract

Cited by 159 (17 self)
 Add to MetaCart
We develop a formal, typetheoretic account of the basic mechanisms of objectoriented programming: encapsulation, message passing, subtyping, and inheritance. By modeling object encapsulation in terms of existential types instead of the recursive records used in other recent studies, we obtain a substantial simplification both in the model of objects and in the underlying typed calculus.
PolyTOIL: A typesafe polymorphic objectoriented language
, 1995
"... PolyTOIL is a new staticallytyped polymorphic objectoriented programming language that is provably typesafe. By separating the de nitions of subtyping and inheritance, providing a name for the type of self, and carefully de ning the typechecking rules, we have obtained a language that is ve ..."
Abstract

Cited by 137 (10 self)
 Add to MetaCart
PolyTOIL is a new staticallytyped polymorphic objectoriented programming language that is provably typesafe. By separating the de nitions of subtyping and inheritance, providing a name for the type of self, and carefully de ning the typechecking rules, we have obtained a language that is very expressive while supporting modular typechecking of classes. The matching relation on types, which is related to Fbounded quanti cation, is used both in stating typechecking rules and expressing the bounds on type parameters for polymorphism. The design of PolyTOIL is based on a careful formal de nition of typechecking rules and semantics.
Subtyping is not a good "match" for objectoriented languages
 PROC. ECOOP '97
, 1997
"... We present the design and rationale of a new staticallytyped objectoriented language, LOOM. LOOM retains most of the features of the earlier language PolyTOIL. However the subtyping relation is dropped from LOOM in favor of the matching relation. "Hash types", which are defined in terms of matchi ..."
Abstract

Cited by 46 (4 self)
 Add to MetaCart
We present the design and rationale of a new staticallytyped objectoriented language, LOOM. LOOM retains most of the features of the earlier language PolyTOIL. However the subtyping relation is dropped from LOOM in favor of the matching relation. "Hash types", which are defined in terms of matching, are introduced to provide some of the bene ts of subtyping. These types can be used to provide support for heterogeneous data stuctures in LOOM. LOOM is considerably simpler than PolyTOIL, yet is just as expressive. The type system for the language is decidable and provably type safe. The addition of modules to the language provides better control over information hiding and allows the provision of access like that of C++'s friends.
Intersection Types and Bounded Polymorphism
, 1996
"... this paper (Compagnoni, Intersection Types and Bounded Polymorphism 3 1994; Compagnoni, 1995) has been used in a typetheoretic model of objectoriented multiple inheritance (Compagnoni & Pierce, 1996). Related calculi combining restricted forms of intersection types with higherorder polymorphism ..."
Abstract

Cited by 37 (0 self)
 Add to MetaCart
this paper (Compagnoni, Intersection Types and Bounded Polymorphism 3 1994; Compagnoni, 1995) has been used in a typetheoretic model of objectoriented multiple inheritance (Compagnoni & Pierce, 1996). Related calculi combining restricted forms of intersection types with higherorder polymorphism and dependent types have been studied by Pfenning (Pfenning, 1993). Following a more detailed discussion of the pure systems of intersections and bounded quantification (Section 2), we describe, in Section 3, a typed calculus called F ("Fmeet ") integrating the features of both. Section 4 gives some examples illustrating this system's expressive power. Section 5 presents the main results of the paper: a prooftheoretic analysis of F 's subtyping and typechecking relations leading to algorithms for checking subtyping and for synthesizing minimal types for terms. Section 6 discusses semantic aspects of the calculus, obtaining a simple soundness proof for the typing rules by interpreting types as partial equivalence relations; however, another prooftheoretic result, the nonexistence of least upper bounds for arbitrary pairs of types, implies that typed models may be more difficult to construct. Section 7 offers concluding remarks. 2. Background
Safe and decidable type checking in an objectoriented language
 In OOPSLA '93 Conference Proceedings
, 1993
"... Over the last several years, much interesting work has been done in modelling objectoriented programming languages in terms of extensions of the bounded secondorder lambda calculus, F . Unfortunately, it has recently been shown by Pierce ([Pie92]) that type checking F is undecidable. Moreover, he ..."
Abstract

Cited by 35 (2 self)
 Add to MetaCart
Over the last several years, much interesting work has been done in modelling objectoriented programming languages in terms of extensions of the bounded secondorder lambda calculus, F . Unfortunately, it has recently been shown by Pierce ([Pie92]) that type checking F is undecidable. Moreover, he showed that the undecidability arises in the seemingly simpler problem of determining whether one type is a subtype of another. In [Bru93a, Bru93b], the first author introduced a staticallytyped, functional, objectoriented programming language, TOOPL, which supports classes, objects, methods, instance variables, subtypes, and inheritance. The semantics of TOOPL is based on F , so the question arises whether type checking in this language is decidable. In this paper we show that type checking for TOOPLE, a minor variant of TOOPL (Typed ObjectOriented Programming Language), is decidable. The proof proceeds by showing that subtyping is decidable, that all terms of TOOPLE have minimum types...
Polarized HigherOrder Subtyping
, 1997
"... The calculus of higher order subtyping, known as F ω ≤ , a higherorder polymorphic λcalculus with subtyping, is expressive enough to serve as core calculus for typed objectoriented languages. The versions considered in the literature usually support only pointwise subtyping of type operators, whe ..."
Abstract

Cited by 32 (1 self)
 Add to MetaCart
The calculus of higher order subtyping, known as F ω ≤ , a higherorder polymorphic λcalculus with subtyping, is expressive enough to serve as core calculus for typed objectoriented languages. The versions considered in the literature usually support only pointwise subtyping of type operators, where two types S U and T U are in subtype relation, if S and T are. In the widely cited, unpublished note [Car90], Cardelli presents F ω ≤ in a more general form going beyond pointwise subtyping of type applications in distinguishing between monotone and antimonotone operators. Thus, for instance, T U1 is a subtype of T U2, if U1 ≤ U2 and T is a monotone operator. My thesis extends F ω ≤ by polarized application, it explores its proof theory, establishing decidability of polarized F ω ≤. The inclusion of polarized application rules leads to an interdependence of the subtyping and the kinding system. This contrasts with pure F ω ≤ , where subtyping depends on kinding but not vice versa. To retain decidability of the system, the equalbounds subtyping rule for alltypes is rephrased in the polarized setting as a mutualsubtype requirement of the upper bounds.
Subtyping is not a good "Match" for objectoriented languages
, 1997
"... . We present the design and rationale of a new staticallytyped objectoriented language, LOOM. LOOM retains most of the features of the earlier language PolyTOIL. However the subtyping relation is dropped from LOOM in favor of the matching relation. "Hash types", which are defined in terms of match ..."
Abstract

Cited by 30 (9 self)
 Add to MetaCart
. We present the design and rationale of a new staticallytyped objectoriented language, LOOM. LOOM retains most of the features of the earlier language PolyTOIL. However the subtyping relation is dropped from LOOM in favor of the matching relation. "Hash types", which are defined in terms of matching, are introduced to provide some of the benefits of subtyping. These types can be used to provide support for heterogeneous data stuctures in LOOM. LOOM is considerably simpler than PolyTOIL, yet is just as expressive. The type system for the language is decidable and provably type safe. The addition of modules to the language provides better control over information hiding and allows the provision of access like that of C++'s friends. 1 Introduction Most staticallytyped objectoriented programming languages, including C++ [ES90], Java [AG96], Object Pascal [Tes85], and Modula 3 [CDG + 88], suffer from very rigid type systems which can block the easy expression of programmers ' ideas,...
Statically Typed Friendly Functions via Partially Abstract Types
, 1993
"... A wellknown shortcoming of the object model of Simula and Smalltalk is the inability to deal cleanly with methods that require access to the internal state of more than one object at a time. Recent language designs have therefore extended the basic object model with notions such as friends' me ..."
Abstract

Cited by 26 (1 self)
 Add to MetaCart
A wellknown shortcoming of the object model of Simula and Smalltalk is the inability to deal cleanly with methods that require access to the internal state of more than one object at a time. Recent language designs have therefore extended the basic object model with notions such as friends' methods and protected features, which allow external access to the internal state of objects but limit the scope in which such access can be used. We show that a variant of this idea can be added to any typetheoretic model of the basic objectoriented mechanisms (encapsulation, message passing, and inheritance), using a construction based on Cardelli and Wegner's partially abstract types, a refinement of Mitchell and Plotkin's typetheoretic treatment of abstract types.
A MetaLanguage for Typed ObjectOriented Languages
, 1993
"... In [12] we defined the &calculus, a simple extension of the typed calculus to model typed objectoriented languages. This paper is the continuation or, rather, the companion of [12] since it analyzes the practical counterpart of the theoretical issues introduced there. Indeed, to develop a formal ..."
Abstract

Cited by 18 (5 self)
 Add to MetaCart
In [12] we defined the &calculus, a simple extension of the typed calculus to model typed objectoriented languages. This paper is the continuation or, rather, the companion of [12] since it analyzes the practical counterpart of the theoretical issues introduced there. Indeed, to develop a formal study of type systems for objectoriented languages we define a metalanguage based on & and we show, by a practical example, how it can be used it to prove properties of a language. To this purpose, we define a toy objectoriented language and its typechecking algorithm; then we translate this toy language into our metalanguage. The translation gives the semantics of the toy language and a theorem on the translation of welltyped programs proves the correctness of the typechecker of the toy language. As an aside we also illustrate the expressivity of the &based model by showing how to translate existing features like multiple inheritance and multiple dispatch, but also by integrating in ...
Divergence of F≤ Type Checking
"... System F≤ is an extension of secondorder typed lambda calculus, where a subtype hierarchy among types is defined, and bounded secondorder lambda abstraction is allowed. This language is a basis for much of the current research on integration of typed functional languages with subtypes and inherita ..."
Abstract

Cited by 14 (4 self)
 Add to MetaCart
System F≤ is an extension of secondorder typed lambda calculus, where a subtype hierarchy among types is defined, and bounded secondorder lambda abstraction is allowed. This language is a basis for much of the current research on integration of typed functional languages with subtypes and inheritance. An algorithm to perform type checking for F≤ expressions has been known since the language Fun was defined. The algorithm has been proved complete, by the author and P.L. Curien, which means that it is a semidecision procedure for the typechecking problem. In this paper we show that this algorithm is not a decision procedure, by exhibiting a term which makes it diverge. This result was the basis of Pierce's proof of undecidability of typing for F≤. We study the behavior of the algorithm to show that our diverging judgement is in some sense contained in any judgement which makes the algorithm diverge. On the basis of this result, and of other results in the paper, we claim that the c...