A run-time representation of scheme record types

  title={A run-time representation of scheme record types},
  author={Andrew W. Keep and R. Kent Dybvig},
  journal={Journal of Functional Programming},
  pages={675 - 716}
Abstract The Revised6 Report on the Algorithmic Language Scheme added a mechanism to the Scheme programming language for creating new record types procedurally. While many programming languages support user defined, structured data types, these are usually handled syntactically, so that the compiler can make choices at compile time about the memory layout of these data types. The procedural record types in Scheme, however, can be constructed at run time, making the efficient run-time… 
Record data structures in racket: usage analysis and optimization
This paper analyzes how records are used in different applications in the Scheme dialect Racket and suggests the application of existing optimization techniques for records and devise a new one for immutable boolean fields.
Optimizing record data structures in Racket
This paper analyzes how records are used in different applications in the Scheme dialect Racket and suggests the application of existing optimization techniques for records and a new one for immutable boolean fields to apply to Pycket, an implementation of Racket.


A sufficiently smart compiler for procedural records
An efficient run-time implementation of procedural record types is described, its overhead is discussed, and a set of compiler optimizations that eliminate the overhead when record-type information can be determined statically are described.
Ftypes: Structured foreign types
This paper describes a Scheme syntactic abstraction for describing foreign data, a set of operators for interacting with that data, and an implementation that together provide a complete, well integrated, and efficient solution for handling structured data outside the Scheme heap.
Revised6 Report on the Algorithmic Language Scheme
Scheme demonstrates that a very small number of rules for forming expressions, with no restrictions on how they are composed, suffice to form a practical and efficient programming language that is flexible enough to support most of the major programming paradigms in use today.
An efficient implementation of SELF a dynamically-typed object-oriented language based on prototypes
This work has developed and implemented techniques that double the performance of dynamically-typed object-oriented languages and dynamically compiles multiple versions of a source method, each customized according to its receiver's map.
Self: The power of simplicity
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.
Smalltalk-80: The Language and Its Implementation
This book is the first detailed account of the Smalltalk-80 system and is divided into four major parts: an overview of the concepts and syntax of the programming language, a specification of the system's functionality, and an example of the design and implementation of a moderate-size application.
Effective Java (2nd Edition) (The Java Series)
Josh Bloch explores new design patterns and language idioms, showing you how to make the most of features ranging from generics to enums, annotations to autoboxing, and outstanding code examples.
The Common Lisp Object System: An Overview
The Common Lisp Object System is an object-oriented system that is based on the concepts of generic functions, multiple inheritance, and method combination that has been proposed as a standard for ANSI Common Lisp and has been tentatively endorsed by X3J13.
Programming with explicit metaclasses in Smalltalk-80
The ObjVlisp model is implemented into the standard Smalltalk-80 system and the resulting combination defines the Classtalk platform, which provides a full-size environment to experiment with class-oriented programming by combining implicit metaclasses and explicit metaclass.
Fast and Effective Procedure Inlining
A new inlining algorithm for higher-order languages that combines simple analysis techniques with demand-driven online transformation to achieve consistent and often dramatic performance gains in fast linear time is presented.