From Rosetta Code
Jump to: navigation, search
You are encouraged to solve this task according to the task description, using any language you may know.

Name and briefly demonstrate any support your language has for metaprogramming. Your demonstration may take the form of cross-references to other tasks on Rosetta Code. When possible, provide links to relevant documentation.

For the purposes of this task, "support for metaprogramming" means any way the user can effectively modify the language's syntax that's built into the language (like Lisp macros) or that's conventionally used with the language (like the C preprocessor). Such facilities need not be very powerful: even user-defined infix operators count. On the other hand, in general, neither operator overloading nor eval count. The task author acknowledges that what qualifies as metaprogramming is largely a judgment call.


[edit] ALGOL 68

Works with: ALGOL 68G version Any - tested with release 2.8.win32

ALGOL 68 allows the definition of new unary and binary operators, as well at the overloading of existing operators. This sample adds a COBOL-like INSPECT "statement" by defining suitable operators.

# This example uses ALGOL 68 user defined operators to add a COBOL-style     #
# "INSPECT statement" to ALGOL 68 #
# #
# The (partial) syntax of the COBOL INSPECT is: #
# INSPECT string-variable REPLACING ALL string BY string #
# or INSPECT string-variable REPLACING LEADING string BY string #
# or INSPECT string-variable REPLACING FIRST string BY string #
# #
# Because "BY" is a reserved bold word in ALGOL 68, we use "WITH" instead #
# #
# We define unary operators INSPECT, ALL, LEADING and FIRST #
# and binary operators REPLACING and WITH #
# We choose the priorities of REPLACING and WITH so that parenthesis is not #
# needed to ensure the correct interpretation of the "statement" #
# #
# We also provide a unary DISPLAY operator for a partial COBOL DISPLAY #
# statement #
# INSPECTEE is returned by the INSPECT unary operator #
# INSPECTTOREPLACE is returned by the binary REPLACING operator #
= STRUCT( REF STRING item, INT option, STRING to replace );
# REPLACEMENT is returned by the unary ALL, LEADING and FIRST operators #
# REPLACING option codes, these are the option values for a REPLACEMENT #
INT replace all = 1;
INT replace leading = 2;
INT replace first = 3;
OP ALL = ( STRING replace )REPLACEMENT: ( replace all, replace );
OP LEADING = ( STRING replace )REPLACEMENT: ( replace leading, replace );
OP FIRST = ( STRING replace )REPLACEMENT: ( replace first, replace );
OP ALL = ( CHAR replace )REPLACEMENT: ( replace all, replace );
OP LEADING = ( CHAR replace )REPLACEMENT: ( replace leading, replace );
OP FIRST = ( CHAR replace )REPLACEMENT: ( replace first, replace );
( item OF inspected
, option OF replace
, replace OF replace
OP WITH = ( INSPECTTOREPLACE inspected, CHAR replace with )REF STRING:
STRING with := replace with;
inspected WITH with
STRING to replace = to replace OF inspected;
INT pos := 0;
STRING rest := item OF inspected;
STRING result := "";
IF option OF inspected = replace all
# replace all occurances of "to replace" with "replace with" #
WHILE string in string( to replace, pos, rest )
result +:= rest[ 1 : pos - 1 ] + replace with;
rest := rest[ pos + UPB to replace : ]
ELIF option OF inspected = replace leading
# replace leading occurances of "to replace" with "replace with" #
WHILE IF string in string( to replace, pos, rest )
pos = 1
result +:= replace with;
rest := rest[ UPB to replace : ]
ELIF option OF inspected = replace first
# replace first occurance of "to replace" with "replace with" #
IF string in string( to replace, pos, rest )
result +:= rest[ 1 : pos - 1 ] + replace with;
rest := rest[ pos + UPB to replace : ]
# unsupported replace option #
write( ( newline, "*** unsupported INSPECT REPLACING...", newline ) );
result +:= rest;
item OF inspected := result
OP DISPLAY = ( STRING s )VOID: write( ( s, newline ) );
main: (
# test the INSPECT and DISPLAY "verbs" #
STRING text := "some text";
INSPECT text REPLACING ALL "text" WITH "some";


some text
sombbc text
somXXc text
somXXc some
kmXXc some

[edit] C

C preprocessor can be used to extend language to some extent.

It's possible to create static assertions

#define STATIC_ASSERT(COND,MSG) typedef char static_assertion_##MSG[(!!(COND))*2-1]
// token pasting madness:
#define COMPILE_TIME_ASSERT3(X,L) STATIC_ASSERT(X,static_assertion_at_line_##L)
int main()

Another common usage is to create custom loops

//requires C99
#define ITERATE_LIST(n, list) \
for(Node *n = (list)->head; n; n = n->next)

printf("node value: %s\n", n->value);

For examples in real world, look FreeCiv, and OpenTTD macros(city_map_iterate for FreeCiv, FOR_ALL_ENGINES for OpenTTD).

Also, C does not support functions overloading, but becaus macro calls do not require type it's possible to emulate overloading to some extent

#define my_min(x, y) ((x) < (y) ? (x) : (y))
printf("%f %d %ll\n", my_min(0.0f, 1.0f), my_min(1,2), my_min(1ll, 2ll));

The Order programming language is implemented entirely using the C preprocessor, providing a portable, high-level, functional programming language that can be used to metaprogram any C99 project, in a fashion loosely similar to Lisp's macro system.

[edit] Common Lisp

[edit] Built-In Fruits of Metaprogramming

Common Lisp is based on decades of metaprogramming, so programmers don't have to roll their own to benefit from it. For instance, the LOOP syntax is just a macro. Prior to becoming a standard language feature, it was just a library that users shared. The object system originated in the same way.

Calculate mean, and sample variance and sample standard deviation of some numbers:

(loop for count from 1
for x in '(1 2 3 4 5)
summing x into sum
summing (* x x) into sum-of-squares
(let* ((mean (/ sum count))
(spl-var (- (* count sum-of-squares) (* sum sum)))
(spl-dev (sqrt (/ spl-var (1- count)))))
(values mean spl-var spl-dev))))
5/2 ;
105 ;

Being a macro, if LOOP were removed from Lisp, it could be supplied by the application program. In fact, sometimes programs have included their own LOOP to work around bugs in some implementations.

Here is what CLISP makes of the above, by investigating the macro expansion using the ANSI standard macroexpand function:

(loop for count from 1
for x in '(1 2 3 4 5)
summing x into sum
summing (* x x) into sum-of-squares
(let* ((mean (/ sum count))
(spl-var (- (* count sum-of-squares) (* sum sum)))
(spl-dev (sqrt (/ spl-var (1- count)))))
(values mean spl-var spl-dev)))))
(LET ((COUNT 1))
(LET ((#:LIST-3047 '(1 2 3 4 5)))
(LET ((X NIL))
(SETQ X (CAR #:LIST-3047))
(PSETQ COUNT (+ COUNT 1)) (PSETQ #:LIST-3047 (CDR #:LIST-3047))
(VALUES MEAN SPL-VAR SPL-DEV)))))))))))))) ; T

Next, we can leave ANSI behind and call CLISP's internal code walker to expand the entire form, removing all traces of the definitions of local macros, leaving behind only pure code based on special forms and function calls:

'(loop for count from 1
for x in '(1 2 3 4 5)
summing x into sum
summing (* x x) into sum-of-squares
(let* ((mean (/ sum count))
(spl-var (- (* count sum-of-squares) (* sum sum)))
(spl-dev (sqrt (/ spl-var (1- count)))))
(values mean spl-var spl-dev))))))
(LET ((COUNT 1))
(LET ((#:LIST-3230 '(1 2 3 4 5)))
(LET ((X NIL))
(SETQ X (CAR #:LIST-3230))
(PSETQ COUNT (+ COUNT 1)) (PSETQ #:LIST-3230 (CDR #:LIST-3230))

[edit] Implement monadic comprehensions

We can use Lisp macros, and other features, to add support to Lisp for monads, which come from functional languages. The following module of code provides a new macro form called COMPREHEND which works with monads. If we use the LIST monad, we get list comprehensions. For instance:

;; The -> notation is not part of Lisp, it is used in examples indicate the output of a form.
(comprehend 'list-monad (cons x y) (x '(1 2 3)) (y '(A B C)))
-> ((1 . A) (1 . B) (1 . C)
(2 . A) (2 . B) (2 . C)
(3 . A) (3 . B) (3 . C))

As you can see, the comprehension processes all combinations of X and Y from both sets, and collects the application of (CONS X Y) to these elements.

In other words {∀x∀y:(cons x y) | x ∈ { 1, 2 ,3 } ∧ y ∈ { A, B, C }}

Other monads are possible: idenitity, state transfomer, etc. Some of these are provided in the code below.

Furthermore, a form called DEFINE-MONAD is provided to define new kinds of monads. It is used to define the basic monads. DEFINE-MONAD also optionally generates a (trivial) short-hand comprehension macro for your monad type. So instead of (comprehend 'list ...) it is possible to write is also (list-comp ...).

Note how the state transformer monad uses the identity monad comprehension in its definition.

Also, a monad is a class, and there is a way in the DEFINE-MONAD syntax to declare what the base classes are (multiple inheritance) as well as any additional custom slots.

Another example, using the identity monad. With the identity monad, the comprehension becomes a sequence of successive variable bindings, and a form evaluated in the scope of those bindings. It is basically like a "Lispified" Haskell DO syntax:

(identity-comp (list x y z) (x 1) (y (* 3 x)) (z (+ x y)))
-> (1 3 4)

I.e. combine the values X, Y and Z into a triplet list, were X is 1, Y is 3X, and Z is X + Y.

To see the original version of this code with lengthy comments, have a look in the Lisp Pastebin.

(defgeneric monadic-map (monad-class function))
(defgeneric monadic-join (monad-class container-of-containers &rest additional))
(defgeneric monadic-instance (monad-class-name))
(defmacro comprehend (monad-instance expr &rest clauses)
(let ((monad-var (gensym "CLASS-")))
((null clauses) `(multiple-value-call #'monadic-unit
,monad-instance ,expr))
((rest clauses) `(let ((,monad-var ,monad-instance))
(multiple-value-call #'monadic-join ,monad-var
(comprehend ,monad-var
(comprehend ,monad-var ,expr ,@(rest clauses))
,(first clauses)))))
(t (destructuring-bind (var &rest container-exprs) (first clauses)
((and var (symbolp var))
`(funcall (monadic-map ,monad-instance (lambda (,var) ,expr))
,(first container-exprs)))
((and (consp var) (every #'symbolp var))
`(multiple-value-call (monadic-map ,monad-instance
(lambda (,@var) ,expr))
(t (error "COMPREHEND: bad variable specification: ~s" vars))))))))
(defmacro define-monad (class-name
&key comprehension
(monad-param (gensym "MONAD-"))
bases slots initargs
((:map ((map-param)
&body map-body)))
((:join ((join-param
(j-rest-kw '&rest)
(j-rest (gensym "JOIN-REST-")))
&body join-body)))
((:unit ((unit-param
(u-rest-kw '&rest)
(u-rest (gensym "UNIT-REST-")))
&body unit-body))))
(defclass ,class-name ,bases ,slots)
(defmethod monadic-instance ((monad (eql ',class-name)))
(load-time-value (make-instance ',class-name ,@initargs)))
(defmethod monadic-map ((,monad-param ,class-name) ,map-param)
(declare (ignorable ,monad-param))
(defmethod monadic-join ((,monad-param ,class-name)
,join-param &rest ,j-rest)
(declare (ignorable ,monad-param ,j-rest))
(defmethod monadic-unit ((,monad-param ,class-name)
,unit-param &rest ,u-rest)
(declare (ignorable ,monad-param ,u-rest))
,@(if comprehension
`((defmacro ,comprehension (expr &rest clauses)
`(comprehend (monadic-instance ',',class-name)
,expr ,@clauses))))))
(defmethod monadic-map ((monad symbol) function)
(monadic-map (monadic-instance monad) function))
(defmethod monadic-join ((monad symbol) container-of-containers &rest rest)
(apply #'monadic-join (monadic-instance monad) container-of-containers rest))
(defmethod monadic-unit ((monad symbol) element &rest rest)
(apply #'monadic-unit (monadic-instance monad) element rest))
(define-monad list-monad
:comprehension list-comp
:map ((function) (lambda (container) (mapcar function container)))
:join ((list-of-lists) (reduce #'append list-of-lists))
:unit ((element) (list element)))
(define-monad identity-monad
:comprehension identity-comp
:map ((f) f)
:join ((x &rest rest) (apply #'values x rest))
:unit ((x &rest rest) (apply #'values x rest)))
(define-monad state-xform-monad
:comprehension state-xform-comp
:map ((f)
(lambda (xformer)
(lambda (s)
(identity-comp (values (funcall f x) new-state)
((x new-state) (funcall xformer s))))))
:join ((nested-xformer)
(lambda (s)
(identity-comp (values x new-state)
((embedded-xformer intermediate-state)
(funcall nested-xformer s))
((x new-state)
(funcall embedded-xformer intermediate-state)))))
:unit ((x) (lambda (s) (values x s))))

[edit] Python in Lisp

The CLPython project ( provides a Python implementation embedded in Common Lisp. Python modules can be included in Lisp programs and interoperate with Lisp code. There is even a mixed-mode interactive loop ("REPL") where one can use a dialect which mixes Python and Lisp:

From the project documentation:

CLPython is able to turn a regular Lisp listener (REPL) into a "mixed-mode" listener that supports both Lisp and Python source as input:
clpython(213): (clpython:enter-mixed-lisp-python-syntax)
; The mixed Lisp/Python syntax mode is now enabled;
; Lispy *readtable* is now set.
clpython(214): print 123 * 2
clpython(215): range(100)[98:2:-2]
#(98 96 94 92 90 88 86 84 82 80 ...)
clpython(216): (+ 1 2)

It supports multi-line Python statements as long as the next lines are properly indented:

clpython(70): for i in range(4):
  print i,
  print i*2
0 0
1 2
2 4
3 6

Unfortunately, further metaprogramming within the Python is evidently discouraged (see Python section below).

[edit] D

Mixins enable string constants to be compiled as regular D code and inserted into the program. Combining this with compile time manipulation of strings enables the creation of domain-specific languages.

enum GenStruct(string name, string fieldName) =
"struct " ~ name ~ "{ int " ~ fieldName ~ "; }";
// Equivalent to: struct Foo { int bar; }
mixin(GenStruct!("Foo", "bar"));
void main() {
Foo f; = 10;

[edit] E

Forms of metaprogramming existant in E:

  • Quasi-literals provide convenient notation for data structures and values for which there is not literal syntax, as discussed in String#E.
  • E program fragments may be quoted, manipulated as an AST, and evaluated, similarly to Lisp; lexical environments are first-class objects (though static with respect to the evaluated code). Demonstrated in Runtime evaluation#E and Eval in environment#E.
  • Control structures may be defined, as demonstrated in Extend your language#E.

[edit] Erlang

Metaprogramming, as understood for this task, is done with parse transformations in Erlang. This is what the documentation says: "Programmers are strongly advised not to engage in parse transformations".

[edit] Haskell

Metaprogramming is implemented using Template Haskell.

[edit] J

J names have one of four different grammatic types: noun, verb, adverb, conjunction. Nouns and verbs are nothing special from a metaprogramming point of view. However, adverbs and conjunctions are evaluated at "parse time" and can be used to introduce expression variants. (The result of an adverb, or of a conjunction may be either a noun, a verb, an adverb or a conjunction.)

Additionally, J script blocks (a block of text terminated by a right parenthesis on a single line) can and are used with differing interpreters (which may be built into the language or user written).

The J implementation of the Y combinator could be considered an example of metaprogramming.

J's explicit definitions might also be considered an example of metaprogramming, since explicit definitions have data dependent syntactic types.

[edit] Lua

Due to the way Lua's syntactic sugar is designed, metatables can make some Lua code look like a Domain-Specific Language, despite technically being (mostly) just specialized operator overloading.

For example:

class "foo" : inherits "bar"

is perfectly valid syntax. (Lua does not having a built in concept of classes or inheritance.)

[edit] Mathematica

Mathematica can overload all symbols, though sometimes Unprotect has to be invoked. You can also introduce your own infix operators:

CircleTimes[x_, y_] := Mod[x, 10] Mod[y, 10]

For more info see: Operators in Mathematica

[edit] Nemerle

Nemerle provides support for macros, which range from defining new infix operators (in fact many 'built-in' operators are macros) to new keywords or control structures.

See here, here, and here on the Nemerle wiki for more information.

[edit] Nim

[edit] Infix Operators

You can define your own infix operators:

proc `^`*[T: SomeInteger](base: T, exp: T): T =
var (base, exp) = (base, exp)
result = 1
while exp != 0:
if (exp and 1) != 0:
result *= base
exp = exp shr 1
base *= base
echo 2 ^ 10 # 1024

[edit] Compile Time evaluation

when is a compile time if and can be used to prevent code from even being parsed at compile time, for example to write platform specific code:

when defined windows:
echo "Call some Windows specific functions here"
elif defined linux:
echo "Call some Linux specific functions here"
echo "Code for the other platforms"

Normal code can be executed at compile time if it is in a static block:

echo "Hello Compile time world: ", 2 ^ 10

As well as stored in compile time constants:

const x = 2 ^ 10

[edit] Templates

The expensive procedure has to be evaluated even when debug is false:

import os
const debug = false
proc expensive: string =
sleep(milsecs = 100)
result = "That was difficult"
proc log(msg: string) =
if debug:
echo msg
for i in 1..10:
log expensive()

This can be prevented using templates, as template calls are replaced with the template body at compile time:

template log(msg: string) =
if debug:
echo msg
for i in 1..10:
log expensive()

Templates can use block syntax with statement parameters:

template times(x: expr, y: stmt): stmt =
for i in 1..x:
10.times: # or times 10:
echo "hi"
echo "bye"

[edit] Term Rewriting Templates

Term Rewriting Templates can be used to write your own optimizations:

template optLog1{a and a}(a): auto = a
template optLog2{a and (b or (not b))}(a,b): auto = a
template optLog3{a and not a}(a: int): auto = 0
x = 12
s = x and x
# Hint: optLog1(x) --> ’x’ [Pattern]
r = (x and x) and ((s or s) or (not (s or s)))
# Hint: optLog2(x and x, s or s) --> ’x and x’ [Pattern]
# Hint: optLog1(x) --> ’x’ [Pattern]
q = (s and not x) and not (s and not x)
# Hint: optLog3(s and not x) --> ’0’ [Pattern]

[edit] Macros

The most powerful metaprogramming capabilities are offered by macros. They can generate source code or even an AST directly.

dumpTree can be useful when creating an AST, as it show you the AST of any code:

import macros
if x:
if y:
if y:

This prints:

      Ident !"x"
            Ident !"y"
              Ident !"p0"
              Ident !"p1"
            Ident !"y"
              Ident !"p2"
              Ident !"p3"

Using this information we can create an if2 macro for two conditions, as is done in the "Extend your language" task.

[edit] PARI/GP

The primary means of metaprogramming for GP is to extend it with PARI. As an example, defining an infix @ operator could work like

In src/functions/symbolic_operators/min0:

Function: _@_
Help: x@y: compute the lesser of x and y, or 0, whichever is larger.
Section: symbolic_operators
C-Name: gmin0
Prototype: GG
 (small, small):small	 smin0ss($1, $2)
 (mp, mp):mp            gmin0($1, $2)
 (gen, gen):gen     	 gmin0($1, $2)

In (e.g.) basemath/somefile.c:

smin0ss(long a, long b)
long c = a < b ? a : b;
return c > 0 ? c : 0;
gmin0(GEN a, GEN b)
GEN c = gcmp(a, b) < 1 ? a : b; /* copy pointer */
return signe(c) > 0 ? gcopy(c) : gen_0;

[edit] Perl

You can textually transform code with a source filter, a module that when used modifies the following lines of source. Filter::Util::Call provides a general means of writing source filters. Filter::Simple is an interface to Filter::Util::Call that lets you elide a lot of boilerplate code. More important, Filter::Simple can hide the contents of quoting constructs from your filter, obviating the biggest dangers of textual metaprogramming. For example, given the following module:

package UnicodeEllipsis;
use Filter::Simple;
FILTER_ONLY code => sub { s/…/../g };

this program:

use UnicodeEllipsis;
print join(' … ', 15), "\n";


 1 … 2 … 3 … 4 … 5

Devel::Declare lets you define a new keyword by setting up a hook to be run whenever the parser encounters a bareword of your choice. Devel::Declare is powerful, but it has a reputation for being difficult to understand. See this blog post for a relatively simple usage example.

[edit] Perl 6

Perl 6 makes it very easy to do metaprogramming. It is a basic goal of the language.

It is trivial to add a new operator. Most Perl 6 operators are written as normal multiple-dispatch functions in the setting (known as a "prelude" in other languages, but in Perl 6 the setting is a lexical scope notionally surrounding your compilation unit).

There is no a built in factorial operator Perl 6. It was purposely left out to use as a demonstration of how easy it is to add it. :-)

sub postfix:<!> { [*] 1..$^n }
say 5!; # prints 120

You may augment a base class with a new method, as long as you declare that you are going to cheat.

Here we add a new method to do natural sorting to the base class Any. (List and Array are both subclasses of Any)

use MONKEY-TYPING; # Needed to do runtime augmentation of a base class.
augment class List {
method nsort { self.list.sort: {$^\d+)/, -> $/ {0 ~ $0.chars.chr ~ $0 }, :g) ~ "\x0" ~ $^a} }
say ~<a201st a32nd a3rd a144th a17th a2 a95>.nsort;
say ~<a201st a32nd a3rd a144th a17th a2 a95>.sort;


a2 a3rd a17th a32nd a95 a144th a201st
a144th a17th a2 a201st a32nd a3rd a95

Grammar mixins work in Perl 6 because grammar rules are just methods in grammar classes, and Perl 6 automatically writes a JIT lexer for you whenever you derive a new language. This functionality already works internally in the standard parser—what is not yet implemented is the augment slang hook to allow user code to do this mixin. Perl 6 itself is already parsed using such grammar mixins to provide extensible quoting and regex syntax. For example, every time you pick your own quote characters, you're actually deriving a new Perl 6 dialect that supports those start and stop characters. Likewise any switches to impose single or double-quote semantics, or heredoc semantics, is merely a grammar mixin on the basic Q language.

say "Foo = $foo\n";  # normal double quotes
say Q:qq 【Foo = $foo\n】; # a more explicit derivation, new quotes

[edit] PicoLisp

As in any Lisp, metaprogramming is an essential aspect of PicoLisp. In most cases normal functions are used to extend the language (see Extend your language#PicoLisp), read-macros operate on the source level, and also runtime macros are used occasionally.

[edit] PostScript

PostScript allows the reification of stack, scoping (dynamic scoping is default, but lexical scoping can be implemented using immediate loading), bindings using dictionaries, and even control flow. Here is an example of implementation of if statement

Library: initlib
/ift {
4 dict begin
[/.if /.then] let*
count array astore /.stack exch def
/_restore {clear .stack aload pop}.
.stack aload pop .if {
_restore .then
} {
} ifelse

The standard if expression in PostScript does not take a predicate. Instead it acts on the boolean value on top of the stack. This newly created word allows us to do

>| 2 {1 gt} {=} ift

Instead of

>| 2 dup 1 gt {=} ift

Note that even the let expression was implemented using meta programming

/let* {reverse {exch def} forall}.

[edit] Python

Metaprogramming is frowned on in Python and considered un-pythonic. The only widely known example of metaprogramming in Python was an implementation of a goto (and comefrom) keyword done as an April-fools joke.

Another more recent library that shows it can be done in Python is MacroPy.

Works with: [MacroPy]

This is example is taken from MacroPy's GitHub page. It creates a macro called expand that, when invoked, generates the AST for a function in place of the original expression.

from macropy.core.macros import *
from macropy.core.quotes import macros, q, ast, u
macros = Macros()
def expand(tree, **kw):
addition = 10
return q[lambda x: x * ast[tree] + u[addition]]

It is then invoked like this:

func = expand[1 + 2]
print func(5)

[edit] Racket

Racket has an extremely rich set of metaprogramming tools, taking the Lisp and Scheme traditions way ahead. In fact, the main goal of Racket is in providing support for user-defined languages. There is no good & short way to describe all of this here, since this has been the focus of the group behind Racket for many years.

[edit] Rascal

Rascal has been developed for metaprogramming. Rascal modules already have functionality to analyse Java code (see documentation).

[edit] Syntax Definition

In Rascal, grammars can be easily defined. The example below shows the syntax definition for the easy languages C and E1. ViewParseTree visualises the parse tree and lets the user interactively check whether sentences belong to the grammar. The greater than symbol in language E1 means that multiplication has a higher priority than addition.

extend ViewParseTree;
layout Whitespace = [\ \t\n]*;
syntax A = "a";
syntax B = "b";
start syntax C = "c" | A C B;
layout Whitespace = [\ \t\n]*;
lexical Integer = [0-9]+;
start syntax E1 = Integer
| E "*" E
> E "+" E
| "(" E ")"

An example of the parse viewer for E1


[edit] Syntax Tree Traversal

Furthermore, Rascal has built-in functions to traverse trees. This can be used to visit all the nodes in the abstract syntax trees that are automatically generated by Rascal. This provides a powerful tool to analyse code. The following example counts for each operator how many of these the programme contains.

map[str, int] operatorUsage(PROGRAM P) {
m = ();
case add(_,_): m["add"] ? 0 += 1;
case sub(_,_): m["sub"] ? 0 += 1;
case conc(_,_): m["conc"] ? 0 += 1;
return m;

Where the abstract syntax is defined as follows

public data TYPE =
natural() | string();
public alias PicoId = str;
public data PROGRAM =
program(list[DECL] decls, list[STATEMENT] stats);
public data DECL =
decl(PicoId name, TYPE tp);
public data EXP =
id(PicoId name)
| natCon(int iVal)
| strCon(str sVal)
| add(EXP left, EXP right)
| sub(EXP left, EXP right)
| conc(EXP left, EXP right)
public data STATEMENT =
asgStat(PicoId name, EXP exp)
| ifElseStat(EXP exp, list[STATEMENT] thenpart, list[STATEMENT] elsepart)
| ifThenStat(EXP exp, list[STATEMENT] thenpart)
| whileStat(EXP exp, list[STATEMENT] body)
| doUntilStat(EXP exp, list[STATEMENT] body)
| unlessStat(EXP exp, list[STATEMENT] body)

[edit] Pico in Rascal

This is part of the Pico syntax expressed in Rascal.

module lang::pico::Syntax
import Prelude;
lexical Id = [a-z][a-z0-9]* !>> [a-z0-9];
lexical Natural = [0-9]+ ;
lexical String = "\"" ![\"]* "\"";
layout Layout = WhitespaceAndComment* !>> [\ \t\n\r%];
lexical WhitespaceAndComment
= [\ \t\n\r]
| @category="Comment" "%" ![%]+ "%"
| @category="Comment" "%%" ![\n]* $
start syntax Program
= program: "begin" Declarations decls {Statement ";"}* body "end" ;
syntax Declarations
= "declare" {Declaration ","}* decls ";" ;
syntax Declaration = decl: Id id ":" Type tp;
syntax Type
= natural:"natural"
| string :"string"
syntax Statement
= asgStat: Id var ":=" Expression val
| ifElseStat: "if" Expression cond "then" {Statement ";"}* thenPart "else" {Statement ";"}* elsePart "fi"
| ifThenStat: "if" Expression cond "then" {Statement ";"}* thenPart "fi"
| whileStat: "while" Expression cond "do" {Statement ";"}* body "od"
| doUntilStat: "do" {Statement ";"}* body "until" Expression cond "od"
| unlessStat: Statement "unless" Expression cond
syntax Expression
= id: Id name
| strCon: String string
| natCon: Natural natcon
| bracket "(" Expression e ")"
> left conc: Expression lhs "||" Expression rhs
> left ( add: Expression lhs "+" Expression rhs
| sub: Expression lhs "-" Expression rhs
public start[Program] program(str s) {
return parse(#start[Program], s);
public start[Program] program(str s, loc l) {
return parse(#start[Program], s, l);

[edit] REXX

│ The REXX language doesn't allow for the changing or overriding of │
│ syntax per se, but any of the built-in-functions (BIFs) can be │
│ overridden by just specifying your own. │
│ │
│ To use the REXX's version of a built-in-function, you simply just │
│ enclose the BIF in quotation marks (and uppercase the name). │
│ │
│ The intent is two-fold: the REXX language doesn't have any │
│ reserved words, nor reserved BIFs (Built-In-Functions). │
│ │
│ So, if you don't know that VERIFY is a BIF, you can just code │
│ a subroutine (or function) with that name (or any name), and not │
│ worry about your subroutine being pre-empted. │
│ │
│ Second: if you're not satisfied how a BIF works, you can code │
│ your own. This also allows you to front-end a BIF for debugging │
│ or modifying the BIF's behavior. │
└───────────────────────────────────────────────────────────────────┘ */

rrr = substr(yyy,5) /*returns efghi */
mmm = 'SUBSTR'(yyy,5) /*returns 56789abcdefgji */
sss = "SUBSTR"(yyy,5) /* (same as above) */
exit /*stick a fork in it, we're done.*/
/*──────────────────────────────────SUBSTR subroutine───────────────────*/
substr: return right(arg(1),arg(2))
│ Also, some REXX interpreters treat whitespace(s) as blanks when │
│ performing comparisons. Some of the whitespace characters are: │
│ │
│ NL (newLine) │
│ FF (formFeed) │
│ VT (vertical tab) │
│ HT (horizontal tab or TAB) │
│ LF (lineFeed) │
│ CR (carriage return) │
│ EOF (end-of-file) │
│ and/or others. │
│ │
│ Note that some of the above are ASCII or EBCDIC specific. │
│ │
│ Some REXX interpreters use the OPTIONS statement to force │
│ REXX to only treat blanks as spaces. │
│ │
│ (Both the verb and option may be in lower/upper/mixed case.) │
│ │
│ REXX interpreters which don't recognize any option won't treat │
│ the (below) statement as an error. │
└───────────────────────────────────────────────────────────────────┘ */

options strict_white_space_comparisons /*can be in lower/upper/mixed.*/

[edit] Ruby

An rudimentary example of metaprogramming is presented in this simple identification system template:

class IDVictim
# Create elements of this man, woman, or child's identification.
attr_accessor :name, :birthday, :gender, :hometown
# Allows you to put in a space for anything which is not covered by the
# preexisting elements.
def self.new_element(element)
attr_accessor element

The "self.new_element" class method allows one to (later) specify a new attribute to be added to the defaults of "name", "birthday", "gender", and "hometown".

[edit] Run BASIC

(This is not really metaprogramming, at least not under any useful meaning...)

' ---------------------------------------------------
' create a file to be run
' RB can run the entire program
' or execute a function withing the RUNNED program
' ---------------------------------------------------
open "runned.bas" for output as #f ' open runned.bas as output
print #f, "text$ = ""I'm rinning the complete program. ' print this program to the output
Or you can run a function.
The program or function within the RUNNED program
can execute all Run BASIC commands."""
print #f, "
x = displayText(text$)"
print #f, " ' besides RUNNING the entireprogram
Function displayText(text$) ' we will execute this function only
print text$ '
end function"
' ----------------------------------------
' Execute the entire RUNNED program
' ----------------------------------------
RUN "runned.bas",#handle ' setup run command to execute runned.bas and give it a handle
render #handle ' render the handle will execute the program
' ----------------------------------------
' Execute a function in the RUNNED program
' ----------------------------------------
RUN "runned.bas",#handle ' setup run command to execute runned.bas and give it a handle
#handle displayText("Welcome!") ' only execute the function withing the runned program
render #handle ' render the handle will execute the program

[edit] SNOBOL4

There are several features of SNOBOL4 which could be considered meta-programming. The first of these is the ability to define synonyms for existing operators or functions, a feature which can help in creating DSLs of sorts in SNOBOL4 programs. For example the following code will alias the built-in function IDENT to SAME and the unary operator * to $:


This is a simplistic use of OPSYN, however. More interesting is the aliasing of a function to an operator:


In this setup, calling F(X) is the same as using the sequence *X which, in more complicated expressions, could result in better readability.

Other metaprogramming features supported would include the use of unevaluated expressions. If, in code, E is an expression it has a value as soon as it is defined and/or assigned to. *E, on the other hand, has a value only when it is evaluated either in the context of a pattern or in the context of an EVAL. The following example shows the motivation for unevaluated expressions in pattern matching contexts:

&ANCHOR = 0 ; &TRIM = 1
WORD = BREAK(' .,') . W SPAN(' .,')
STRING2 ' ' W ANY(' .,')  :F(LOOP)
LIST = LIST W ', '  :(LOOP)

In this code, two strings are input and a list of words appearing in both strings is generated. The problem with this code is that the pattern structure ' ' W ANY(' .,') is built on each iteration. Since pattern building is expensive, putting it in a loop like this is bad form. It cannot be moved outside of the loop, however, since the value of W changes for each iteration. The solution to this is to defer the evaluation of the variable W until it is needed while keeping the rest of the pattern intact:

&ANCHOR = 0 ; &TRIM = 1
WORD = BREAK(' .,') . W SPAN(' .,')
FINDW = ' ' *W ANY(' .,')
LIST = LIST W ', '  :(LOOP)

In this code, the pattern is constructed only once in the line FINDW = ' ' *W ANY(' .,'). The value of the variable W, however, is only provided when FINDW is used in a pattern match. In this case it is given its value from the line before when STRING1 is matched against the pattern WORD. In this way the expense of building the pattern is paid only once, but the flexibility of matching a sequence of values is retained.

The final example of metaprogramming that's available lies in the idiosyncratic way that user-defined functions work in SNOBOL4. The fact that the DEFINE function can be recalled at any point to redefine any function is a powerful feature that can lead to very efficient code. (It can also lead to very unreadable code, of course, if not properly used.)

Consider this hand-waving example for the motivation:

* This example provides a bizarrely-expensive addition operation.
* It assumes the existence of an expensive procedure—say a database
* lookup—to extract the value to be added. This version uses the
* typical initialize-on-definition approach to implementation.

In normal operation the interpreter will execute the DEFINE function and then execute the ADDVALUE = ... line, branching *past* the actual body of the function to the label XADD.END. If, however, there are many such functions, and especially if there's the possibility that these functions are never actually called, this could render program startup very slow. For purposes of amortizing initialization time, or for purposes of saving unnecessary initialization, the following code is better:


The code now defines the XADD function and immediately, without doing initialization, jumps to the XADD.END label, bypassing both initialization and the function body. The trick here is that it defines the entry point of the function to be the XADD.INIT label. Now the first time XADD is called, control is transferred to XADD.INIT, the expensive initialization is performed, then the XADD function is *redefined* to point to the XADD label as the entry point. From this point onward all calls to XADD only perform the calculation, not the expensive initialization while the expensive initialization isn't paid at all unless the function is used at least once.

There are, of course, many other uses for function redefinition in this style which are suitable for metaprogramming efforts. Indeed such features are used prominently in the debugging subsystems of SNOBOL4 implementations.

[edit] Shen

Being a Lisp, metaprogramming is easily achievable in Shen through macros. However, defining macros is only possible when the typechecker is off.

(define make-list
[A|D] -> [cons (make-list A) (make-list D)]
X -> X)
(defmacro info-macro
[info Exp] -> [output "~A: ~A~%" (make-list Exp) Exp])
(info (* 5 6)) \\ outputs [* 5 6]: 30

Like most macro systems, defmacro looks like a function that takes a sexp and returns one. However, Shen's defmacro is special in that it allows arbitrary activation of sexps.

(0-) (defmacro +-macro
[A + B] -> [+ A B])
(1-) (1 + (* 2 3))

It's important to be careful when using macros like this; this example would be bad because + is sometimes used as an argument to a function (e.g. (fold-left + 0) would compile to (+ fold-left 0)). However, the fact that a symbol can at once match a macro and denote a function can give the illusion of optional arguments or polyadicity. This is how many mathematical operators and functions like append work while retaining their type signature:

(2-) (tc +)
(3+) (+ 1 2 3)
6 : number
(4+) +
+ : (number --> (number --> number))
(5-) (tc -)
(6-) (macroexpand [+ 1 2 3])
[+ 1 [+ 2 3]]

[edit] Sidef

Sidef recognizes all mathematical operators in Unicode and allows the user to define methods that behave like infix operators, even for built-in types.

class Number {
method ⊕(arg) {
self + arg
say (2142)

Another example of metaprogramming, is the definition of methods at run-time:

var colors = Hash(
'black' => "000",
'red' => "f00",
'green' => "0f0",
'yellow' => "ff0",
'blue' => "00f",
'magenta' => "f0f",
'cyan' => "0ff",
'white' => "fff",
colors.each { |color, code|
String.def_method("in_#{color}", func (self) {
'<span style="color: #' + code + '">' + self + '</span>'
say "blue".in_blue;
say "red".in_red;
say "white".in_white;
<span style="color: #00f">blue</span>
<span style="color: #f00">red</span>
<span style="color: #fff">white</span>

[edit] Tcl

Metaprogramming is considered to be normal in Tcl; the whole language was designed to support new operations that work with a similar level of integration to existing commands (and indeed, the standard commands are not syntactically special in any way), and the upvar and uplevel commands are specifically for this sort of use. Moreover, there are no language keywords that need to be worked around; words/tokens can be used to mean anything necessary. For example:

proc loopVar {var from lower to upper script} {
if {$from ne "from" || $to ne "to"} {error "syntax error"}
upvar 1 $var v
if {$lower <= $upper} {
for {set v $lower} {$v <= $upper} {incr v} {
uplevel 1 $script
} else {
# $upper and $lower really the other way round here
for {set v $lower} {$v >= $upper} {incr v -1} {
uplevel 1 $script

The above creates a new loopVar command that might be used like this:

loopVar x from 1 to 4 {
loopVar y from $x to 6 {
puts "pair is ($x,$y)"
if {$y >= 4} break

Which prints this:

pair is (1,1)
pair is (1,2)
pair is (1,3)
pair is (1,4)
pair is (2,2)
pair is (2,3)
pair is (2,4)
pair is (3,3)
pair is (3,4)
pair is (4,4)

As you can see, the new looping command is wholly integrated with the rest of the Tcl language.

Code generation is also possible. The easiest approach is to use the list command to generate substitution-free command, leaving all substitutions to places that are written by the programmer directly.

Finally, the total lack of keywords is exemplified by this classic fragment of Tcl:

set set set

In this, the first set is a command (that updates a variable), the second is the name of a variable in the current namespace, and the third is a string that will be placed in a variable.

[edit] TXR

TXR has a built-in Lisp dialect called TXR Lisp, which supports meta-programming, some of which is patterned after ANSI Common Lisp. TXR provides:

  • run-time access to its parser for Lisp expressions: (read "(+ a b c)");
  • a parser for regular exprssions: (regex-parse "a.*b") which produces abstract syntax;
  • a run-time compiler for converting regular expression abstract syntax to compiled regular expression object;
  • a eval function which expands and evaluates Lisp abstract syntax;
  • global as well as lexically scoped macros, for both compound forms (with automatically destructured parameter lists) and symbols (symbol macros): the operators defmacro, defsymacro, macrolet and symacrolet;
  • structural quasiquote for convenient macro writing.

Example define a while loop which supports break and continue. Two forms of break are supported break which causes the loop to terminate with the return value nil and (break <form>) which returns the specified value.

(defmacro whil ((condition : result) . body)
(let ((cblk (gensym "cnt-blk-"))
(bblk (gensym "brk-blk-")))
^(macrolet ((break (value) ^(return-from ,',bblk ,value)))
(symacrolet ((break (return-from ,bblk))
(continue (return-from ,cblk)))
(block ,bblk
(for () (,condition ,result) ()
(block ,cblk ,*body)))))))
(let ((i 0))
(whil ((< i 100))
(if (< (inc i) 20)
(if (> i 30)
(prinl i)))
'(whil ((< i 100))
(if (< (inc i) 20)
(if (> i 30)
(prinl i))))
(block #:brk-blk-0062
  (for () ((< i 100) ())
    () (block #:cnt-blk-0061
         (if (< (sys:setq i (succ i))
                20) (return-from
         (if (> i 30)
         (prinl i))))

[edit] zkl

Meta programming is quite limited unless you hack the compiler (which is written in zkl) or you write a DSL. Otherwise, there is a "kinda like" C pre-processor support.

#define name [0|1]
#if [0|1|name]
#else, #endif
#ifdef name
#fcn name {code}
Full zkl functionality but limited access to the parse stream; only #defines
#text name text
#tokenize name, #tokenize f, #tokenize f(a)
Shove text into the parse stream
Personal tools