Mexpression
This article needs additional citations for verification. (August 2013) (Learn how and when to remove this template message) 
In computer programming, Mexpressions (or metaexpressions) were an early proposed syntax for the Lisp programming language, inspired by contemporary languages such as Fortran and ALGOL.
Background[edit]
John McCarthy published the first paper on Lisp in 1960 while a research fellow at the Massachusetts Institute of Technology. In it he described a language of symbolic expressions (Sexpressions) that could represent complex structures as lists. Then he defined a set of primitive operations on the Sexpressions, and a language of metaexpressions (Mexpressions) that could be used to define more complex operations. Finally, he showed how the metalanguage itself could be represented with Sexpressions, resulting in a system that was potentially selfhosting.^{[1]}
Expression type  Mathematical notation  Mexpression  Modern Lisp Sexpression 

List value  [1;2;3]  (quote (1 2 3))
 
Function application  f[x;y]  (f x y)
 
Function definition  label[square;λ[[x];product[x;x]]]  (define square (lambda (x) (* x x)))
 
Conditional expression  [lessthan[x;0] → negative[x]; T → x]  (cond ((< x 0) ( x)) (t x))

McCarthy had planned to develop an automatic Lisp compiler using Mexpressions as the language syntax and Sexpressions to describe the compiler's internal processes. Stephen B. Russell read the paper and suggested to him that Sexpressions were a more convenient syntax. Although McCarthy disapproved of the idea, Russell and colleague Daniel J. Edwards handcoded an interpreter program that could execute Sexpressions.^{[2]} This program was adopted by McCarthy's research group, establishing Sexpressions as the dominant form of Lisp.
McCarthy reflected on the fate of Mexpressions in 1979:
The project of defining Mexpressions precisely and compiling them or at least translating them into Sexpressions was neither finalized nor explicitly abandoned. It just receded into the indefinite future, and a new generation of programmers appeared who preferred internal notation to any FORTRANlike or ALGOLlike notation that could be devised.^{[3]}
Iexpressions[edit]
A more recent variant is Iexpressions, which use indentation to indicate parentheses implicitly, and are thus in some ways intermediate between Sexpressions and Mexpressions. Iexpressions were introduced in Scheme Request For Implementation 49 as an auxiliary syntax for Scheme, but they have not been widely adopted.
References[edit]
 ^ McCarthy, John (April 1960) "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I"
 ^ "LISP 1.5 Programmer's Manual" (PDF). Community.computerhistory.org. Archived from the original (PDF) on 20060211. Retrieved 20130902.
 ^ "The implementation of LISP". Formal.stanford.edu. 19790212. Retrieved 20130824.