A semantics of multiple inheritance.
Proc. of the international symposium on Semantics of data types
F-bounded polymorphism for object-oriented programming
FPCA '89 Proceedings of the fourth international conference on Functional programming languages and computer architecture
PLDI '91 Proceedings of the ACM SIGPLAN 1991 conference on Programming language design and implementation
ACM Transactions on Programming Languages and Systems (TOPLAS)
Qualified types: theory and practice
Qualified types: theory and practice
Pragmatic subtyping in polymorphic languages
ICFP '98 Proceedings of the third ACM SIGPLAN international conference on Functional programming
Types and programming languages
Types and programming languages
OOPSLA '04 Companion to the 19th annual ACM SIGPLAN conference on Object-oriented programming systems, languages, and applications
Polymorphic variants in Haskell
Proceedings of the 2006 ACM SIGPLAN workshop on Haskell
TLCA'01 Proceedings of the 5th international conference on Typed lambda calculi and applications
A foundation for flow-based program matching: using temporal logic and model checking
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Proceedings of the 3rd workshop on Programming languages meets program verification
Computer Languages, Systems and Structures
| Hi-index | 0.00 |
A newtype declaration in Haskell introduces a new type renaming an existing type. The two types are viewed by the programmer as semantically different, but share the same runtime representation. When operations on the two semantic views coincide, the run-time cost of conversion between the two types is reduced to zero (in both directions) because of this common representation. We describe a new language feature called Shared Subtypes (SSubtypes), which generalizes these properties of the newtype declaration. SSubtypes allow programmers to specify subtype rules between types and sharing rules between data constructors. A value of a type T, where T is a subtype of U, can always be cast, at no cost, to value of type U. This free up-casting allows library functions that consume the supertype to be applied without cost to subtypes. Yet any semantic interpretations desired by the programmer can be enforced by the compiler. SSubtype declarations work particularly well with GADTs. GADTs use differing type indexes to make explicit semantic differences, by using a different index for each way of viewing the data. Shared subtypes allow GADTs to share the same runtime representation as a reference type, of which the GADT is a refinement.