Mutable objects in R

  title={Mutable objects in R},
  author={Hadley Wickham},
  journal={Computational Statistics},
  • H. Wickham
  • Published 1 September 2011
  • Computer Science
  • Computational Statistics
Programming paradigms help us understand the differences and similarities between fundamental choices in language design. This paper looks at R in the context of three paradigms of object oriented programming: mutable versus immutable objects, generic-function versus message-passing methods, and class-based versus prototype-based inheritance. The paper also describes a new OO package for R, mutatr, which provides mutable objects with message-passing methods and prototype-based inheritance. The… Expand


Prototypes with Multiple Dispatch: An Expressive and Dynamic Object Model
This paper introduces a novel object model, prototypes with multiple dispatch (PMD), which seamlessly unifies these two approaches to object-oriented programming, and gives formal semantics for PMD. Expand
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. Expand
The R.oo package - Object-oriented programming with references using standard R code
The package R.oo is presented, which provides a foundation for designing and implementing object-oriented applications in a robust way and extends the current exception handling mechanism in R such that exception objects can be caught based on their class. Expand
Dylan programming: an object-oriented and dynamic language
Dylan Programming gets you started quickly, with a simple but complete program that lets you experiment with the language, and leads you progressively through the development of a sample application, illustrating advanced topics such as macros, modules, libraries, inher itance, performance, and exceptions. Expand
Using a prototype-based language for user interface: the Newton project's experience
NewtonScript is developed to find that prototype inheritance has compelling advantages over classes in the domain of user interface programming, and can help overcome the memory constraints of a small machine. Expand
The Clojure programming language
This talk will focus on the motivations, mechanisms and experiences of the implementation of Clojure, a general-purpose language suitable in those areas where Java is suitable, and providing built-in concurrency support via software transactional memory and asynchronous agents. Expand
Io: a small programming language
An overview of the Io language and demos of some multi-platform desktop applications written with it are included, well suited for use as both scripting and embedding within larger projects. Expand
Programming paradigms for dummies: what every programmer should know
This chapter gives an introduction to all the main programming paradigms, their underlying concepts, and the relationships between them. We give a broad view to help programmers choose the rightExpand
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. Expand
Lexical Scope and Statistical Computing
The concept of scoping rules is discussed and how lexical scope can enhance the functionality of a language is shown. Expand