John Reppy's Publications

Object-oriented Languages


Metaprogramming with Traits.
John Reppy and Aaron Turon. In Proceedings of the European Conference on Object Oriented Programming (ECOOP 2007), pages 373--398, July-August 2007.
bib | .pdf ]

In many domains, classes have highly regular internal structure. For example, so-called business objects often contain boilerplate code for mapping database fields to class members. The boilerplate code must be repeated per-field for every class, because existing mechanisms for constructing classes do not provide a way to capture and reuse such member-level structure. As a result, programmers often resort to ad hoc code generation. This paper presents a lightweight mechanism for specifying and reusing member-level structure in Java programs. The proposal is based on a modest extension to traits that we have termed trait-based metaprogramming. Although the semantics of the mechanism are straightforward, its type theory is difficult to reconcile with nominal subtyping. We achieve reconciliation by introducing a hybrid structural/nominal type system that extends Java's type system. The paper includes a formal calculus defined by translation to Featherweight Generic Java.

A Foundation for Trait-based Metaprogramming.
John Reppy and Aaron Turon. In 2006 International Workshop on Foundations and Developments of Object-Oriented Languages, January 2006.
bib | .pdf ]

Scharli et al. introduced traits as reusable units of behavior independent of the inheritance hierarchy. Despite their relative simplicity, traits offer a surprisingly rich calculus. Trait calculi typically include operations for resolving conflicts when composing two traits. In the existing work on traits, these operations (method exclusion and aliasing) are shallow, i.e., they have no effect on the body of the other methods in the trait. In this paper, we present a new trait system, based on the Fisher-Reppy trait calculus, that adds deep operations (method hiding and renaming) to support conflict resolution. The proposed operations are deep in the sense that they preserve any existing connections between the affected method and the other methods of the trait. Our system uses Riecke-Stone dictionaries to support these features. In addition, we define a more fine-grained mechanism for tracking trait types than in previous systems. The resulting calculus is more flexible and expressive, and can serve as the foundation for trait-based metaprogramming, an idiom we introduce. A companion technical report proves type soundness for our system; we state the key results in this paper.

A Typed Calculus of Traits.
Kathleen Fisher and John Reppy. In Proceedings of the 11th Workshop on Foundations of Object-oriented Programming, January 2004.
bib | .pdf ]

Object-oriented aspects of Moby.
Kathleen Fisher and John Reppy. Technical Report TR-2003-10, Department of Computer Science, University of Chicago, Chicago, IL, September 2003.
bib ]

Statically Typed Traits.
Kathleen Fisher and John Reppy. Technical Report TR-2003-13, Department of Computer Science, University of Chicago, Chicago, IL, December 2003.
bib ]

Inheritance-based subtyping.
Kathleen Fisher and John Reppy. Information and Computation, 177(1):28--55, August 2002.
bib | .pdf ]

Classes play a dual role in mainstream statically-typed object-oriented languages, serving as both object generators and object types. In such languages, inheritance implies subtyping. In contrast, the theoretical language community has viewed this linkage as a mistake and has focused on subtyping relationships determined by the structure of object types, without regard to their underlying implementations. In this paper, we explore why inheritance-based subtyping relations are useful, and we describe two different approaches to extending the Moby programming language with inheritance-based subtyping relations. In addition, we present a typed object calculus that supports both structural and inheritance-based subtyping, and which provides a formal accounting of our extensions to Moby.

Extending Moby with inheritance-based subtyping.
Kathleen Fisher and John Reppy. In Proceedings of the European Conference on Object Oriented Programming, Volume 1850 of Lecture Notes in Computer Science, pages 83--107, New York, NY, June 2000. Springer-Verlag.
bib | .pdf ]

A Calculus for Compiling and Linking Classes.
Kathleen Fisher, John Reppy, and Jon Riecke. In Proceedings of the European Symposium on Programming, Volume 1782 of Lecture Notes in Computer Science, pages 134--149, New York, NY, March/April 2000. Springer-Verlag.
bib | .pdf ]

Inheritance-based subtyping.
Kathleen Fisher and John Reppy. In Proceedings of the 7th Workshop on Foundations of Object-oriented Programming, January 2000.
bib | .pdf ]

The design of a class mechanism for Moby.
Kathleen Fisher and John Reppy. In Proceedings of the SIGPLAN 1999 Conference on Programming Language Design and Implementation, pages 37--49, New York, NY, May 1999. ACM.
bib ]

Foundations for Moby classes.
Kathleen Fisher and John Reppy. Technical Memorandum, Bell Labs, Lucent Technologies, Murray Hill, NJ, February 1999.
bib ]

Classes in Object ML via modules.
John H. Reppy and Jon G. Riecke. In Proceedings of the Third Workshop on Foundations of Object-oriented Programming, July 1996.
bib ]

Simple objects for SML.
John H. Reppy and Jon G. Riecke. In Proceedings of the SIGPLAN 1996 Conference on Programming Language Design and Implementation, pages 171--180, New York, NY, May 1996. ACM.
bib ]


This file was generated by bibtex2html 1.98.


Last updated on August 31, 2018
Comments to John Reppy.