A lambda calculus of objects and method specialization

@article{Fisher1993ALC,
  title={A lambda calculus of objects and method specialization},
  author={Kathleen Fisher and Furio Honsell and John C. Mitchell},
  journal={[1993] Proceedings Eighth Annual IEEE Symposium on Logic in Computer Science},
  year={1993},
  pages={26-38}
}
An untyped lambda calculus, extended with object primitives that reflect the capabilities of so-called delegation-based object-oriented languages, is presented. A type inference system allows static detection of errors, such as message not understood, while at the same time allowing the type of an inherited method to be specialized to the type of the inheriting object. Type soundness, in the form of a subject-reduction theorem, is proved, and examples illustrating the expressiveness of the pure… 

Tables from this paper

A Typed Lambda Calculus of Objects (Extended Abstract)

In this paper, we present an explicitly typed version of the Lambda Calculus of Objects of [7], which is a development of the object-calculi defined in [10, 2]. This calculus supports object

Encodings of Extensible Objects and Types

TLDR
A type preserving and computationally adequate interpretation of a full-fledged object calculus that supports message passing and primitives for object update and extension is described.

A Subtyping for the Fisher-Honsell-Mitchell Lambda Calculus of Objects

TLDR
Labeled types and a new relation between types are added to the lambda calculus of objects as described in [6], and type soundness follows from the subject reduction property.

A protoype-based approach to object evolution

TLDR
A sound type system is presented for this calculus of objects which guarantees that evaluating a well-typed expression will never yield a message-not-found runtime error, an attempt towards the definition of a language combining the safety advantage of static type checking with the flexibility found in dynamically typed languages.

A Core Calculus of Classes and Objects

Typed interpretations of extensible objects

TLDR
A type preserving and computationally adequate interpretation of a full-fledged object calculus that supports message passing and constructs for object update and extension is described.

Matching Constraints for the Lambda Calculus of Objects

TLDR
A new type system for the Lambda Calculus of Objects, based on matching is presented, that retains the property of type safety of the original system, while using implicit match-bounded quantification over type variables instead of implicit quantifying over row schemes to capture Mytype polymorphic types for methods.

An Imperative, First-Order Calculus with Object Extension

TLDR
This paper presents an imperative object calculus designed to support class-based programming via a combination of extensible objects and encapsulation, and shows how Java-style classes and mixins may be coded in this calculus.

A prototype-based approach to object reclassification

TLDR
A sound type system is presented for this calculus of objects which might extend themselves upon receiving a message, which guarantees that evaluating a well-typed expression will never yield a message-not-found runtime error.

Interpretations of Extensible Objects and Types

TLDR
This work gives a type preserving and computationally adequate translation of a full-fledged object calculus that includes object extension and override, and validates the expected subtyping relationships.
...

References

SHOWING 1-10 OF 22 REFERENCES

Toward a typed foundation for method specialization and inheritance

TLDR
A typed function calculus of objects and classes is presented, featuring method specialization when methods are added or redefined, and the soundness of the typing rules is suggested by a translation into a more traditional calculus with recursively-defined record types.

Operations on records

TLDR
This work defines a simple collection of operations for creating and manipulating record structures, where records are intended as finite associations of values to labels, and develops a second-order type system over these operations that supports both subtyping and polymorphism.

A Proposal for Making Eiffel Type-Safe

  • W. Cook
  • Computer Science
    Comput. J.
  • 1989
TLDR
Type attributes, or generic parameters with default values, are suggested as a replacement for most cases of declaration by association, and the special association type used to express type recursion cannot be explained using type attributes, and appears to be a truly novel construct for typing object-oriented programs.

A Proposal for Making Eiel Type-safe

TLDR
Type attributes, or generic parameters with default values, are suggested as a replacement for most cases of declaration by association, and the special association type used to ex-press type recursion cannot be explained using type attributes.

SELF: The power of simplicity

TLDR
Because SELF does not distinguish state from behavior, it narrows the gaps between ordinary objects, procedures, and closures, and offers new insights into object-oriented computation.

Customization: optimizing compiler technology for SELF, a dynamically-typed object-oriented programming language

TLDR
Coupling these new techniques with compile-time message lookup, aggressive procedure inlining, and traditional optimizations has doubled the performance of dynamically-typed object-oriented languages.

Baby Modula-3 and a theory of objects

  • M. Abadi
  • Computer Science
    Journal of Functional Programming
  • 1994
TLDR
To the theoretician, Baby Modula-3 provides a tractable, concrete example of an object-oriented language, and it is used to study the formal semantics of objects to guarantee the soundness of this definition.

Eiffel: The Language

Object-oriented programming in scheme

TLDR
A small set of additions to Scheme to support object-oriented programming, including a form of multiple inheritance, are proposed, in keeping with the spirit of the Scheme language and consequently differ from Lisp-based object systems such as Flavors and the Common Lisp Object System.

T: a dialect of Lisp or LAMBDA: The ultimate software tool

TLDR
The T project is an experiment in language design and implementation that tests the thesis developed by Steele and Sussman that Scheme may be used as the basis for a practical programming language of exceptional expressive power and that implementations of Scheme could perform better than other Lisp systems, and competitively with implementations of programming languages.