University of Pennsylvania ScholarlyCommons Departmental Papers (CIS) Department of Computer & Information Science 9-2006 On Decidability of Nominal Subtyping with Variance Andrew J. Kennedy Microsoft Research Cambridge Benjamin C. Pierce University of Pennsylvania, [email protected] Follow this and additional works at: https://repository.upenn.edu/cis_papers Part of the Computer Sciences Commons Recommended Citation Andrew J. Kennedy and Benjamin C. Pierce, "On Decidability of Nominal Subtyping with Variance", . September 2006. Andrew J. Kennedy and Benjamin C. Pierce. On Decidability of Nominal Subtyping with Variance, September 2006. FOOL-WOOD '07. ACM COPYRIGHT NOTICE. Copyright © 2006 by the Association for Computing Machinery, Inc. Permission to make digital or hard copies of part or all of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, to republish, to post on servers, or to redistribute to lists, requires prior specific permission and/or a ee.f Request permissions from Publications Dept., ACM, Inc., fax +1 (212) 869-0481, or [email protected]. This paper is posted at ScholarlyCommons. https://repository.upenn.edu/cis_papers/671 For more information, please contact [email protected]. On Decidability of Nominal Subtyping with Variance Abstract We investigate the algorithmics of subtyping in the presence of nominal inheritance and variance for generic types, as found in Java 5, Scala 2.0, and the .NET 2.0 Intermediate Language. We prove that the general problem is undecidable and characterize three different decidable fragments. From the latter, we conjecture that undecidability critically depends on the combination of three features that are not found together in any of these languages: contravariant type constructors, class hierarchies in which the set of types reachable from a given type by inheritance and decomposition is not always finite, and class hierarchies in which a type may have multiple supertypes with the same head constructor. These results settle one case of practical interest: subtyping between ground types in the .NET intermediate language is decidable; we conjecture that our proof can also be extended to show full decidability of subtyping in .NET. For Java and Scala, the decidability questions remain open; however, the proofs of our preliminary results introduce a number of novel techniques that we hope may be useful in further attacks on these questions. Disciplines Computer Sciences Comments Andrew J. Kennedy and Benjamin C. Pierce. On Decidability of Nominal Subtyping with Variance, September 2006. FOOL-WOOD '07. ACM COPYRIGHT NOTICE. Copyright © 2006 by the Association for Computing Machinery, Inc. Permission to make digital or hard copies of part or all of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, to republish, to post on servers, or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from Publications Dept., ACM, Inc., fax +1 (212) 869-0481, or [email protected]. This conference paper is available at ScholarlyCommons: https://repository.upenn.edu/cis_papers/671 On Decidability of Nominal Subtyping with Variance Andrew J. Kennedy Benjamin C. Pierce Microsoft Research Cambridge University of Pennsylvania Abstract 22], and the declaration-site variance of Scala [18], algorithmic subtyping rules have never been presented, and decidability is still We investigate the algorithmics of subtyping in the presence of 1 nominal inheritance and variance for generic types, as found in an open problem. This is the starting point for our investigation. Java 5, Scala 2.0, and the .NET 2.0 Intermediate Language. We Language features Each of these languages supports generic in- prove that the general problem is undecidable and characterize heritance, in which a named class is declared with type parameters three different decidable fragments. From the latter, we conjecture and (multiple) supertypes referencing the type parameters. Here are that undecidability critically depends on the combination of three equivalent definitions in .NET 2.0 IL, C] 2.0, Java 5 and Scala 2.0: features that are not found together in any of these languages: con- .class C<X,Y> extends class D<class E<!X>> // .NET IL travariant type constructors, class hierarchies in which the set of implements class I<!Y> types reachable from a given type by inheritance and decomposi- class C<X,Y> : D<E<X>>, I<Y> // C# tion is not always finite, and class hierarchies in which a type may class C<X,Y> extends D<E<X>> implements I<Y> // Java have multiple supertypes with the same head constructor. class C[X,Y] extends D[E[X]] with I[Y] // Scala These results settle one case of practical interest: subtyping be- A second feature shared by these languages is covariant and tween ground types in the .NET intermediate language is decidable; contravariant subtyping of generic types. Scala 2.0 and .NET 2.0 IL we conjecture that our proof can also be extended to show full de- support declaration-site variance, where the variance behaviour of cidability of subtyping in .NET. For Java and Scala, the decidability type parameters is declared up-front on the declaration of the class; questions remain open; however, the proofs of our preliminary re- this feature is also a strong candidate for a future version of C]. sults introduce a number of novel techniques that we hope may be For example, here are equivalent headers for a contra/co-variant useful in further attacks on these questions. function type in .NET IL, an imaginary future version of C], and Scala: 1. Introduction .class interface Func<-A,+B> // .NET IL The core of the subtype relation in most object-oriented program- interface Func<-A,+B> // C# ?.0 trait Func[-A,+B] // Scala ming languages is nominal, in the sense that basic inclusions be- tween type constructors are explicitly declared by the program- In contrast, Java 5 supports use-site variance, where annotations on mer. However, most languages also support a modicum of struc- the use of a generic type determine its variance behaviour, as in the tural subtyping; for example, array types in Java and C] behave co- cast function below: variantly. More recent designs feature richer structural features—in interface Func<A,B> { B apply(A a); } particular, covariant and contravariant subtyping of constructor pa- class C { } rameters, such as the variance annotations of Scala’s generic types class D extends C { and the wildcard types supported by Java 5. static Func<? super D, ? extends C> Formally, subtyping is typically presented in a declarative cast(Func<? super C, ? extends D> f) { return f; } } style. For many systems, an equivalent syntax-directed presenta- tion is easily derived, and termination of the corresponding sub- Here, the ? extends annotation induces covariant subtyping on type checker is easy to demonstrate. For example, in the case of the type argument, and ? super annotation induces contravariant C] 2.0 and the original “GJ” design for generics in Java [3, 13], subtyping. (In an earlier variance design for Java [14] the annota- it is straightforward to derive an algorithm by building transitivity tions were the more concise + and -.) into the subtyping rules for superclasses and upper bounds and to For all of these languages, decidability of subtyping is an open then prove termination by constructing a measure on subtype judg- problem. The Java 5 design [12, 22] is based on an earlier extension ments that strictly decreases from conclusion to premises in the to Java generics whose decidability is not known [14, §4.1]. A algorithmic rules. core calculus for Scala has been studied recently and type-checking For more sophisticated systems, such as the original use-site and subtyping proved decidable [8], but variance is not supported. variance proposal for Java [14], the wildcard design of Java 5 [12, Finally, an extension to C] 2.0 modeled on variance in .NET IL 2.0 has been studied by the first author and others [10], but without considering generic inheritance in its full generality (in particular, support for multiple instantiation inheritance). Permission to make digital or hard copies of all or part of this work for personal or Contributions We present here a collection of results regard- classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation ing the algorithmics of nominal subtyping in the presence of on the first page. To copy otherwise, to republish, to post on servers or to redistribute (declaration-site) variance. First, we show that a general form of to lists, requires prior specific permission and/or a fee. 1 Readers may enjoy attempting to compile the examples in Appendix A Copyright c ACM [to be supplied]. $5.00 using their favorite Java compiler! the problem, where the subtype hierarchy may involve multiple We require that inheritance be acyclic, in the following sense: inheritance from arbitrary supertypes (in particular, from multiple if C <T > <::+ D<U > then C 6= D. In the presence of mixins instances of the same type constructor) is undecidable. Second, we it is not immediately apparent how to check acyclicity for a given show various restricted fragments of the system are decidable: (1) class table: consider, for example, the definitions CX <:: X and a system with only covariant and invariant constructors (no con- D <:: CD.