Meta-circular evaluator

A meta-circular evaluator is a special case of a self-interpreter in which the existing facilities of the parent interpreter are directly applied to the source code being interpreted, without any need for additional implementation. Meta-circular evaluation is most common in the context of homoiconic languages.

The idea goes back at least to the definition of Lisp 1.5 (1961) by John McCarthy.^[1] He describes the evaluation rules of Lisp as a Lisp program.

A translator or interpreter (evaluator) is just a special kind of program, which can be processed like any other; and can therefore certainly be translated or interpreted by another translator or interpreter.^[2]

The difference between self-interpreters and meta-circular interpreters is that the latter restate language features in terms of the features themselves, instead of actually implementing them. (Circular definitions, in other words; hence the name). They depend on their host environment to give the features meaning.

— Reginald Braithwaite, "The significance of the meta-circular interpreter". 2006-11-22. http://weblog.raganwald.com/2006/11/significance-of-meta-circular_22.html. Retrieved 2011-01-22. 

Meta-circular evaluation is discussed at length in section 4.1, titled The Metacircular Evaluator, of the MIT university textbook Structure and Interpretation of Computer Programs (SICP). The core idea they present is two functions:

• Eval which takes as arguments an expression and an environment (bindings for variables) and produces either a primitive or a procedure and a list of arguments
• Apply which takes two arguments, a procedure and a list of arguments to which the procedure should be applied and produces an expression and an environment

The two functions then call each other in circular fashion to fully evaluate a program.

Ramifications

Meta-circular implementations are suited to extending the language they are written in. They are also useful for writing tools that are tightly integrated with the programming language, such as sophisticated debuggers. A language designed with a meta-circular implementation in mind is often more suited for building languages in general, even ones completely different from the host language.

Examples

Many languages have one or more meta-circular implementation.

Languages with a meta-circular implementation designed from the bottom up, in grouped chronological order:

• Lisp, 1958
  • Scheme, 1975
    • Pico, 1997^[3]
    • ActorScript, 2009?
• Forth, 1968
  • PostScript, 1982
• Prolog, 1972
• Smalltalk, 1980
• REBOL, 1997
• Factor, 2003

Languages with a meta-circular implementation via third-parties:

• Java via Jikes RVM, Squawk or Maxine
• JavaScript via Narcissus
• Oz via Glinda
• Python via PyPy
• Ruby via Rubinius

Languages with a meta-circular implementation via other means:

• Perl via eval()

See also

• M-expression

References

1. ^ Definition of EVALQUOTE in Lisp 1.5 Programmer's Manual
2. ^ Gilbert, Philip (1977). Notes on Program Design Techniques. Reseda, CA: Ridgeview Publishing Company. p. 7.7. 
3. ^ Meta-circular implementation of the Pico programming language

External links

Structure and Interpretation of Computer Programs (SICP), online version of full book, accessed 2009-01-18.