Results 1 
6 of
6
A Calculus for Overload Functions with Subtyping

, 1992
"... We present a simple extension of typed calculus where functions can be overloaded by putting different "branches of code" together. When the function is applied, the branch to execute is chosen according to a particular selection rule which depends on the type of the argument. The cru ..."
Abstract

Cited by 139 (28 self)
 Add to MetaCart
We present a simple extension of typed calculus where functions can be overloaded by putting different "branches of code" together. When the function is applied, the branch to execute is chosen according to a particular selection rule which depends on the type of the argument. The crucial feature of the present approach is that the branch selection depends on the "runtime type" of the argument, which may differ from its compiletime type, because of the existence of a subtyping relation among types. Hence overloading cannot be eliminated by a static analysis of code, but is an essential feature to be dealt with during computation. We obtain in this way a typedependent calculus, which differs from the various calculi where types do not play any role during computation. We prove Confluence and a generalized SubjectReduction theorem for this calculus. We prove Strong Normalization for a "stratified" subcalculus. The definition of this calculus is guided by the understand...
Positive Subtyping
 Information and Computation
, 1994
"... The statement S T in a calculus with subtyping is traditionally interpreted as a semantic coercion function of type [[S]]![[T ]] that extracts the "T part" of an element of S. If the subtyping relation is restricted to covariant positions, this interpretation may be enriched to includ ..."
Abstract

Cited by 51 (8 self)
 Add to MetaCart
The statement S T in a calculus with subtyping is traditionally interpreted as a semantic coercion function of type [[S]]![[T ]] that extracts the "T part" of an element of S. If the subtyping relation is restricted to covariant positions, this interpretation may be enriched to include both the coercion and an overwriting function put[S; T ] 2 [[S]]![[T ]]![[S]] that updates the T part of an element of S.
Equational reasoning with subtypes
 Iowa State University
, 2002
"... Abstract. Using equational logic as a specification language, we investigate the proof theory of behavioral subtyping for objectoriented abstract data types with immutable objects and deterministic methods that can use multiple dispatch. In particular, we investigate a proof technique for correct b ..."
Abstract

Cited by 5 (1 self)
 Add to MetaCart
Abstract. Using equational logic as a specification language, we investigate the proof theory of behavioral subtyping for objectoriented abstract data types with immutable objects and deterministic methods that can use multiple dispatch. In particular, we investigate a proof technique for correct behavioral subtyping in which each subtypeâ€™s specification includes terms that can be used to coerce its objects to objects of each of its supertypes. We show that this technique is sound, using our previous work on the model theory of such abstract data types. We also give an example to show that the technique is not complete, even if the methods do not use multiple dispatch, and even if types specified are termgenerated. In preparation for the results on equational subtyping we develop the proof theory of a richer form of equational logic that is suitable for dealing with subtyping and behavioral equivalence. This gives some insight into question of when our proof techniques can be make effectively computable, but in general behavioral consequence is not effectively computable. 1.
Extending AlgBench with a Type System
 IN DESIGN AND IMPLEMENTATION OF SYMBOLIC COMPUTATION SYSTEMS (PROCEEDINGS OF DISCO '93), VOLUME 722 OF LNCS
, 1993
"... This paper presents some design decisions taken in the ongoing project of extending the symbolic computation system AlgBench with a type system. The only mechanism for structuring values in AlgBench are classes which are firstclass values and anonymous, hence type constructors are simple functio ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
This paper presents some design decisions taken in the ongoing project of extending the symbolic computation system AlgBench with a type system. The only mechanism for structuring values in AlgBench are classes which are firstclass values and anonymous, hence type constructors are simple functions. We show how within this approach abstract datatypes and categories can be modelled. Subtyping by means of embeddings (inclusions) is distinguished from subtyping by coercions to avoid some deficiencies which arise in a coercionbased mechanism. Furthermore, we allow to compute with "declaredonly" identifiers to retain the symbolic capabilities of the original AlgBench.
ClassBased and Algebraic Models of Objects
 BRAZIL JOINT WORKSHOPS ON THE FORMAL FOUNDATIONS OF SOFTWARE SYSTEMS, VOLUME 14 OF ELECTRONIC NOTES IN THEORETICAL COMPUTER SCIENCE. ELSEVIER SCIENCE
, 1998
"... We compare different kinds of firstorder models of objects and message passing, as found in objectoriented programming languages. We show that generic function models can easily simulate record models for static, classbased languages. We explore type systems for such languages, and show tha ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
We compare different kinds of firstorder models of objects and message passing, as found in objectoriented programming languages. We show that generic function models can easily simulate record models for static, classbased languages. We explore type systems for such languages, and show that our ...
Coviarance and Contravariance: Conflict without a Cause
, 1994
"... In type theoretic research on objectoriented programming the "covariance versus contravariance issue" is a topic of continuing debate. In this short note we argue that covariance and contravariance appropriately characterize two distinct and independent mechanisms. The socalled contravar ..."
Abstract
 Add to MetaCart
In type theoretic research on objectoriented programming the "covariance versus contravariance issue" is a topic of continuing debate. In this short note we argue that covariance and contravariance appropriately characterize two distinct and independent mechanisms. The socalled contravariance rule correctly captures the substitutivity, or subtyping relation (that establishes which sets of codes can replace in every context another given set). A covariant relation, instead, characterizes the specialization of code (i.e. the definition of new code that replaces the old one in some particular cases). Therefore, covariance and contravariance are not opposing views, but distinct concepts that each have their place in objectoriented systems and that both can (and should) be type safely integrated in an objectoriented language. We also show that the independence of the two mechanisms is not characteristic of a particular model but is valid in general, since covariant specialization is pre...