A run-time representation of scheme record types

@article{Keep2014ARR,
  title={A run-time representation of scheme record types},
  author={Andrew W. Keep and R. Kent Dybvig},
  journal={Journal of Functional Programming},
  year={2014},
  volume={24},
  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
TLDR
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
TLDR
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.

References

SHOWING 1-10 OF 20 REFERENCES
A sufficiently smart compiler for procedural records
TLDR
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
TLDR
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
TLDR
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
TLDR
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
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.
Smalltalk-80: The Language and Its Implementation
TLDR
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)
TLDR
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
TLDR
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
TLDR
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
TLDR
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.
...
1
2
...