Metaprogramming: Difference between revisions

m
→‎{{header|Wren}}: Changed to Wren S/H
m (→‎{{header|Wren}}: Changed to Wren S/H)
 
(138 intermediate revisions by 59 users not shown)
Line 1:
{{task}}{{omit from|BBC BASIC}}
 
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 <code>eval</code> count. The task author acknowledges that what qualifies as metaprogramming is largely a judgment call.
 
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|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.
 
<syntaxhighlight lang="algol68"># 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 #
MODE INSPECTEE = STRUCT( REF STRING item, INT option );
 
# INSPECTTOREPLACE is returned by the binary REPLACING operator #
MODE INSPECTTOREPLACE
= STRUCT( REF STRING item, INT option, STRING to replace );
# REPLACEMENT is returned by the unary ALL, LEADING and FIRST operators #
MODE REPLACEMENT = STRUCT( INT option, STRING replace );
 
# REPLACING option codes, these are the option values for a REPLACEMENT #
INT replace all = 1;
INT replace leading = 2;
INT replace first = 3;
 
OP INSPECT = ( REF STRING s )INSPECTEE: ( s, 0 );
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 );
 
OP REPLACING = ( INSPECTEE inspected, REPLACEMENT replace )INSPECTTOREPLACE:
( item OF inspected
, option OF replace
, replace OF replace
);
 
OP WITH = ( INSPECTTOREPLACE inspected, CHAR replace with )REF STRING:
BEGIN
STRING with := replace with;
inspected WITH with
END; # WITH #
 
OP WITH = ( INSPECTTOREPLACE inspected, STRING replace with )REF STRING:
BEGIN
 
STRING to replace = to replace OF inspected;
INT pos := 0;
STRING rest := item OF inspected;
STRING result := "";
 
IF option OF inspected = replace all
THEN
# replace all occurances of "to replace" with "replace with" #
WHILE string in string( to replace, pos, rest )
DO
result +:= rest[ 1 : pos - 1 ] + replace with;
rest := rest[ pos + UPB to replace : ]
OD
 
ELIF option OF inspected = replace leading
THEN
# replace leading occurances of "to replace" with "replace with" #
WHILE IF string in string( to replace, pos, rest )
THEN
pos = 1
ELSE
FALSE
FI
DO
result +:= replace with;
rest := rest[ 1 + UPB to replace : ]
OD
 
ELIF option OF inspected = replace first
THEN
# replace first occurance of "to replace" with "replace with" #
IF string in string( to replace, pos, rest )
THEN
result +:= rest[ 1 : pos - 1 ] + replace with;
rest := rest[ pos + UPB to replace : ]
FI
 
ELSE
# unsupported replace option #
write( ( newline, "*** unsupported INSPECT REPLACING...", newline ) );
stop
FI;
 
result +:= rest;
item OF inspected := result
END; # WITH #
 
OP DISPLAY = ( STRING s )VOID: write( ( s, newline ) );
 
 
PRIO REPLACING = 2, WITH = 1;
 
 
 
 
main: (
 
# test the INSPECT and DISPLAY "verbs" #
 
STRING text := "some text";
DISPLAY text;
 
INSPECT text REPLACING FIRST "e" WITH "bbc";
DISPLAY text;
 
INSPECT text REPLACING ALL "b" WITH "X";
DISPLAY text;
 
INSPECT text REPLACING ALL "text" WITH "some";
DISPLAY text;
 
INSPECT text REPLACING LEADING "som" WITH "k";
DISPLAY text
 
 
)</syntaxhighlight>
Output:
<pre>some text
sombbc text
somXXc text
somXXc some
kXXc some
</pre>
 
=={{header|Arturo}}==
 
Arturo has been designed with flexibility in mind (see: DSL creation) and as different languages of the same heritage (e.g. REBOL, Red, etc) has meta-programming capabilities as part of the language itself.
 
Let's see some examples:
 
===Infix Operators===
 
<syntaxhighlight lang="rebol">sumThemUp: function [x,y][
x+y
]
 
alias.infix '--> 'sumThemUp
 
do [
print 3 --> 4
]</syntaxhighlight>
 
{{out}}
 
<pre>7</pre>
 
===Runtime Code Evaluation===
 
<syntaxhighlight lang="rebol">code: "print 123"
do code</syntaxhighlight>
 
{{out}}
 
<pre>123</pre>
 
===Symbol Creation & Access at Runtime===
 
<syntaxhighlight lang="rebol">myvar: "iAmAVariable"
 
let myvar 2
 
print myvar ; print the name of the variable
 
print var myvar ; print the value of the variable
print iAmAVariable ; the same</syntaxhighlight>
 
{{out}}
 
<pre>iAmAVariable
2
2</pre>
 
===Data as Code & Code as Data===
 
<syntaxhighlight lang="rebol">block: [print]
block: block ++ to :integer "34"
 
print "Here is our code:"
print as.code block
 
print ""
print "And here's its result:"
do block</syntaxhighlight>
 
{{out}}
 
<pre>Here is our code:
[print 34]
 
And here's its result:
34</pre>
 
=={{header|C}}==
 
C preprocessor can be used to extend language to some extent.
 
It's possible to create [http://stackoverflow.com/questions/3385515/static-assert-in-c static assertions]
 
<syntaxhighlight lang="c">
// http://stackoverflow.com/questions/3385515/static-assert-in-c
#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)
#define COMPILE_TIME_ASSERT2(X,L) COMPILE_TIME_ASSERT3(X,L)
#define COMPILE_TIME_ASSERT(X) COMPILE_TIME_ASSERT2(X,__LINE__)
 
COMPILE_TIME_ASSERT(sizeof(long)==8);
int main()
{
COMPILE_TIME_ASSERT(sizeof(int)==4);
}
</syntaxhighlight>
 
Another common usage is to create custom loops
 
<syntaxhighlight lang="c">
//requires C99
#define ITERATE_LIST(n, list) \
for(Node *n = (list)->head; n; n = n->next)
 
...
ITERATE_LIST(n, list)
{
printf("node value: %s\n", n->value);
}
</syntaxhighlight>
 
For examples in real world, look [http://svn.gna.org/viewcvs/freeciv/trunk/common/city.h?view=markup FreeCiv], and [http://mz.openttdcoop.org/is2/openttd-is2-h1f270887-docs/engine__base_8h-source.html OpenTTD] macros(city_map_iterate for FreeCiv, FOR_ALL_ENGINES for OpenTTD).
 
Also, C does not support functions overloading, but because macro calls do not require type it's possible to emulate overloading to some extent
 
<syntaxhighlight lang="c">
#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));
</syntaxhighlight>
 
The [[Order|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.
 
[https://github.com/Hirrolot/metalang99 Metalang99] is also a functional language aimed at full-blown preprocessor metaprogramming in pure C99. With the aid of Metalang99, such things as [https://github.com/Hirrolot/datatype99 Datatype99] and [https://github.com/Hirrolot/interface99 Interface99] became possible.
 
==={{libheader|Gadget}}===
<p>Gadget is a basic library that combines the use of macros and functions to facilitate programming in pure C.</p>
<p>Some useful macros that you can find in this library are the following:</p>
 
<syntaxhighlight lang="c">
 
#define Str_init(_V_) char * _V_=NULL;
 
#define Free_secure(_X_) if(_X_) { free(_X_); _X_=NULL; }
 
#define Let(_X_,_Y_) \
do{\
if(_X_) free(_X_);\
int len = strlen(_Y_);\
_X_ = (char*)calloc( len + 1, 1);\
if(_X_) { memcpy(_X_, _Y_, len); }\
else { perror("\033[38;5;196mLet: No hay memoria para <"#_X_">(CALLOC)\n\033[0m"); }\
}while(0);
 
/* inicia el trabajo con el stack */
#define Stack if( (PILA_GADGET = 1) )
 
/* finaliza el trabajo con el stack. La pila debe quedar en "0" */
#define Stack_off \
PILA_GADGET = 0; \
if(CONTADOR_PILA>=0){ Msg_red("Proceso termina con stack ocupado: borro sobrante\n");\
CONTADOR_PILA=-1; }
 
/*
STORE almacena el valor en la variable indicada, obtenido desde el
stack. */
#define Store(_X_,_Y_) \
do{\
_Y_;\
if(PILA_GADGET){\
if( CONTADOR_PILA>=0 ){\
Let(_X_, pila_de_trabajo[CONTADOR_PILA]);CONTADOR_PILA--;\
}\
}else{ Msg_amber("Store: No hay datos en la pila");}\
}while(0);
...
#define Main \
int main(int argc, char* argv[]){\
__TOKEN__=NULL;\
Init_token();\
Init_stack;
 
/* SALIDA NORMAL */
#define End End_token(); \
Free_stack_str;\
return(0); }
</syntaxhighlight>
<p>With these macros it is possible to write programs like this:</p>
<syntaxhighlight lang="c">
#include <gadget/gadget.h>
LIB_GADGET_START
 
Main
String w, v="María tenía un corderito";
 
Stack{
Store( v, Substr(v, Str_at("tenía",v),Str_len( Upper(v) )) );
Store( v, Trim(Left( Upper(v), Str_at("CORDERITO",Upper(v))-1)));
}Stack_off;
 
Print "msg stack : [%s]\n\n", v;
Let( v, "María tenía un corderito");
 
/* Str_len() sirve sin stack, pero en este caso es mejor usar strlen() de C. */
w = Substr(v, Str_at("tenía",v),Str_len(v));
Print "msg normal: %s\n", w;
 
Free secure w,v;
End
</syntaxhighlight>
<p>Note: the "Free_secure()" and "Str_init()" macros are preprocessed before entering the compile cycle.</p>
 
<p>Other interesting macros that can extend the C language are the "Assert" and "Exception" macros, which use the "hated GOTO":</p>
 
<syntaxhighlight lang="c">
#define Throw(_X_) if( !Is_ok ) { goto _X_; }
#define Exception(_H_) _H_: if( !Is_ok++ )
#define Assert(_X_,_Y_) if( !(_X_) ) { Is_ok=0; goto _Y_; }
</syntaxhighlight>
<p>Example:</p>
<syntaxhighlight lang="c">
#include <gadget/gadget.h>
LIB_GADGET_START
 
Main
int retVal=0;
Assert( Arg_count == 2, fail_input );
Get_arg_str( filename, 0 );
Get_arg_float( number, 1 );
 
Print "First argument (filename) = %s\n", filename;
Print "Second argument (a number) = %f\n", number;
 
Free secure filename;
 
Exception( fail_input ){
Msg_yellow("Use:\n ./prog <number>\n");
retVal=1;
}
Return( retVal );
</syntaxhighlight>
<p>There are also macros that, in combination with functions, allow you to extend the C language and simplify its programming:</p>
<syntaxhighlight lang="c">
/* declara un array vacío */
#define New_mt_array(_X_) \
MT_CELL *_X_ = NULL;\
Define_New_Array(_X_)\
_X_##_data.type = MULTI_TYPE;
....
/* acceso a celdas string */
#define sCell(_X_,...) CONCAT2(Cell_mtstr, COUNT_ARGUMENTS(__VA_ARGS__))(_X_, ##__VA_ARGS__)
 
#define Cell_mtstr1(_X_,ARG1) (_X_[ ARG1 ].value)
#define Cell_mtstr2(_X_,ARG1,ARG2) (_X_[ ( ARG1 ) * ( _X_##_data.cols ) + ( ARG2 ) ].value)
#define Cell_mtstr3(_X_,ARG1,ARG2,ARG3) (_X_[ ( ( ARG1 ) * ( _X_##_data.cols ) + ( ARG2 ) ) + \
( ARG3 ) * ( _X_##_data.cols * _X_##_data.rows ) ].value)
...
/* acceso a celdas long */
#define lCell(_X_,...) CONCAT2(Cell_mtlng, COUNT_ARGUMENTS(__VA_ARGS__))(_X_, ##__VA_ARGS__)
 
#define Cell_mtlng1(_X_,ARG1) *((long *)(_X_[ ARG1 ].value))
#define Cell_mtlng2(_X_,ARG1,ARG2) *((long *)(_X_[ ( ARG1 ) * ( _X_##_data.cols ) + ( ARG2 ) ].value))
#define Cell_mtlng3(_X_,ARG1,ARG2,ARG3) *((long *)(_X_[ ( ( ARG1 ) * ( _X_##_data.cols ) + ( ARG2 ) ) + \
( ARG3 ) * ( _X_##_data.cols * _X_##_data.rows ) ].value))
 
...
/* RANGOS para acceso iterado */
#define Range_for(_X_, ...) CONCAT2(Range_for, COUNT_ARGUMENTS(__VA_ARGS__))(_X_, ##__VA_ARGS__)
 
/* para un array 1D */
#define Range_for3(_X_,A1,A2,A3) \
_X_##_data.rowi=A1;_X_##_data.rowinc=A2;_X_##_data.rowe=A3;
 
/* para un array 2D */
#define Range_for6(_X_,A1,A2,A3,B1,B2,B3) \
_X_##_data.rowi=A1;_X_##_data.rowinc=A2;_X_##_data.rowe=A3; \
_X_##_data.coli=B1;_X_##_data.colinc=B2;_X_##_data.cole=B3;
....
</syntaxhighlight>
<p>Example:</p>
<syntaxhighlight lang="c">
#include <gadget/gadget.h>
 
LIB_GADGET_START
 
void Muestra_archivo_original();
 
Main
Assert (Exist_file("load_matrix.txt"), file_not_found);
 
/* recupero informacion del archivo para su apertura segura */
F_STAT dataFile = Stat_file("load_matrix.txt");
Assert (dataFile.is_matrix, file_not_matrixable) // tiene forma de matriz???
New multitype test;
/* The data range to be read is established.
It is possible to read only part of the file using these ranges. */
Range for test [0:1:dataFile.total_lines-1, 0:1:dataFile.max_tokens_per_line-1];
/* cargamos el array detectando números enteros como long */
test = Load_matrix_mt( pSDS(test), "load_matrix.txt", dataFile, DET_LONG);
/* modifica algunas cosas del archivo */
Let( $s-test[0,1], "Columna 1");
$l-test[2,1] = 1000;
$l-test[2,2] = 2000;
/* inserto filas */
/* preparo la fila a insertar */
New multitype nueva_fila;
sAppend_mt(nueva_fila,"fila 3.1"); /* sAppend_mt() and Append_mt() are macros */
Append_mt(nueva_fila,float,0.0);
Append_mt(nueva_fila,int,0);
Append_mt(nueva_fila,double,0.0);
Append_mt(nueva_fila,long, 0L);
/* insertamos la misma fila en el array, 3 veces */
test = Insert_row_mt(pSDS(test),pSDS(nueva_fila), 4);
test = Insert_row_mt(pSDS(test),pSDS(nueva_fila), 4);
test = Insert_row_mt(pSDS(test),pSDS(nueva_fila), 4);
Free multitype nueva_fila;
Print "\nGuardando archivo en \"save_matrix.txt\"...\n";
DEC_PREC = 20; /* establece precision decimal */
All range for test;
Save_matrix_mt(SDS(test), "save_matrix.txt" );
 
Free multitype test;
Print "\nArchivo original:\n";
Muestra_archivo_original();
Exception( file_not_found ){
Msg_red("File not found\n");
}
Exception( file_not_matrixable ){
Msg_red("File is not matrixable\n");
}
 
End
 
void Muestra_archivo_original(){
String csys;
csys = `cat load_matrix.txt`;
Print "\n%s\n", csys;
Free secure csys;
}
</syntaxhighlight>
<p>Note: "Range_for()", "sCell()", "lCell()", "v=`...`", and "New_mt_array()" macros are preprocessed before entering the compile cycle.</p>
<pre>GADGET has been designed to encapsulate the complicated (and basically utilitarian, that is, what will always be programmed in the same way) without losing the spirit of the C language (the possibility of working at a low level).
 
From Chile with love,
 
Mr Dalien.</pre>
 
=={{header|C sharp|C#}}==
 
Metaprogramming in C# can be achieved using the [https://msdn.microsoft.com/en-us/library/bb126445.aspx Text Template Transformation Toolkit]. It is a textual preprocessor embedded in Visual Studio (it can also be executed from the command-line, e.g. in build scripts). It is language-agnostic, and therefore can generate code for C#, Visual Basic or other languages. This also means that it has no features which help manipulating the underlying language: it is purely textual, and does '''not''' include a C# parser to transform existing C# files (so you will need to roll your own or use [https://roslyn.codeplex.com/ Roslyn]), and does '''not''' include utilities which would help with combining pieces of code.
 
=={{header|Clojure}}==
See [https://clojure.org/reference/macros Clojure Macros Reference] article.
 
=={{header|Common Lisp}}==
 
===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:
 
<syntaxhighlight lang="lisp">
(loop for count from 1
for x in '(1 2 3 4 5)
summing x into sum
summing (* x x) into sum-of-squares
finally
(return
(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)))) </syntaxhighlight>
 
=> <pre>5/2 ;
105 ;
4.582576</pre>
 
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 <code>macroexpand</code> function:
 
<syntaxhighlight lang="lisp">
[5]>
(macroexpand'
(loop for count from 1
for x in '(1 2 3 4 5)
summing x into sum
summing (* x x) into sum-of-squares
finally
(return
(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)))))
(MACROLET ((LOOP-FINISH NIL (SYSTEM::LOOP-FINISH-ERROR)))
(BLOCK NIL
(LET ((COUNT 1))
(LET ((#:LIST-3047 '(1 2 3 4 5)))
(PROGN
(LET ((X NIL))
(LET ((SUM-OF-SQUARES 0) (SUM 0))
(MACROLET ((LOOP-FINISH NIL '(GO SYSTEM::END-LOOP)))
(TAGBODY SYSTEM::BEGIN-LOOP (WHEN (ENDP #:LIST-3047) (LOOP-FINISH))
(SETQ X (CAR #:LIST-3047))
(PROGN (SETQ SUM (+ SUM X))
(SETQ SUM-OF-SQUARES (+ SUM-OF-SQUARES (* X X))))
(PSETQ COUNT (+ COUNT 1)) (PSETQ #:LIST-3047 (CDR #:LIST-3047))
(GO SYSTEM::BEGIN-LOOP) SYSTEM::END-LOOP
(MACROLET
((LOOP-FINISH NIL (SYSTEM::LOOP-FINISH-WARN) '(GO SYSTEM::END-LOOP)))
(PROGN
(RETURN
(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)))))))))))))) ; T</syntaxhighlight>
 
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:
 
<syntaxhighlight lang="lisp">(system::expand-form
'(loop for count from 1
for x in '(1 2 3 4 5)
summing x into sum
summing (* x x) into sum-of-squares
finally
(return
(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))))))
(BLOCK NIL
(LET ((COUNT 1))
(LET ((#:LIST-3230 '(1 2 3 4 5)))
(LET ((X NIL))
(LET ((SUM-OF-SQUARES 0) (SUM 0))
(TAGBODY SYSTEM::BEGIN-LOOP
(WHEN (ENDP #:LIST-3230) (GO SYSTEM::END-LOOP))
(SETQ X (CAR #:LIST-3230))
(PROGN (SETQ SUM (+ SUM X))
(SETQ SUM-OF-SQUARES (+ SUM-OF-SQUARES (* X X))))
(PSETQ COUNT (+ COUNT 1)) (PSETQ #:LIST-3230 (CDR #:LIST-3230))
(GO SYSTEM::BEGIN-LOOP) SYSTEM::END-LOOP
(RETURN-FROM NIL
(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)))))))))</syntaxhighlight>
 
===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:
 
<syntaxhighlight lang="lisp">
;; 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))</syntaxhighlight>
 
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 {&forall;x&forall;y:(cons x y) | x &isin; { 1, 2 ,3 } &and; y &isin; { 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:
<syntaxhighlight lang="lisp">(identity-comp (list x y z) (x 1) (y (* 3 x)) (z (+ x y)))
-> (1 3 4)
</syntaxhighlight>
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. http://paste.lisp.org/display/71196
 
<syntaxhighlight lang="lisp">(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-")))
(cond
((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)
(cond
((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))
,@container-exprs))
(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
&optional
(j-rest-kw '&rest)
(j-rest (gensym "JOIN-REST-")))
&body join-body)))
((:unit ((unit-param
&optional
(u-rest-kw '&rest)
(u-rest (gensym "UNIT-REST-")))
&body unit-body))))
`(progn
(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))
,@map-body)
(defmethod monadic-join ((,monad-param ,class-name)
,join-param &rest ,j-rest)
(declare (ignorable ,monad-param ,j-rest))
,@join-body)
(defmethod monadic-unit ((,monad-param ,class-name)
,unit-param &rest ,u-rest)
(declare (ignorable ,monad-param ,u-rest))
,@unit-body)
,@(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))))</syntaxhighlight>
===Python in Lisp===
The CLPython project (http://common-lisp.net/project/clpython) 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:
 
<blockquote>
CLPython is able to turn a regular Lisp listener (REPL) into a "mixed-mode" listener that supports both Lisp and Python source as input:
<pre>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
246
clpython(215): range(100)[98:2:-2]
#(98 96 94 92 90 88 86 84 82 80 ...)
clpython(216): (+ 1 2)
3</pre>
 
It supports multi-line Python statements as long as the next lines are properly indented:
 
<pre>clpython(70): for i in range(4):
print i,
print i*2
0 0
1 2
2 4
3 6</pre>
</blockquote>
 
Unfortunately, further metaprogramming within the Python is evidently discouraged (see [[#Python|Python]] section below).
 
=={{header|D}}==
 
[http://dlang.org/mixin.html 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.
 
<syntaxhighlight lang="d">enum GenStruct(string name, string fieldName) =
"struct " ~ name ~ "{ int " ~ fieldName ~ "; }";
 
// Equivalent to: struct Foo { int bar; }
mixin(GenStruct!("Foo", "bar"));
 
void main() {
Foo f;
f.bar = 10;
}</syntaxhighlight>
 
=={{header|E}}==
Line 12 ⟶ 780:
* 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]].
 
=={{header|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".
 
=={{header|Forth}}==
Perhaps the most obvious use of Metaprogramming in Forth is Forth itself. The Forth virtual machine traditionally has a primitive operation called BRANCH, which as you could guess, does an unconditional branch to somewhere in the program. There is also ?BRANCH (sometimes called 0BRANCH) which branches only if the top of the Forth DATA stack is zero. There are typically also primitive "DO" and "LOOP" operators. All of these primitives cannot be used on their own and must be compiled into program code by the Forth compiler which needs to compute where to branch or loop to in the context of the code. The compiler itself is implemented in Forth and defines the syntax for conditional branches and loops. Understanding this code is not "needed" for application programming but exists inside the Forth system. The application programmer is free to use these same tools to create new branching and looping syntax if there is a need to do so. (FOR/NEXT, CASE ENDCASE etc.)
 
<syntaxhighlight lang="forth">\ BRANCH and LOOP COMPILERS
 
\ branch offset computation operators
: AHEAD ( -- addr) HERE 0 , ;
: BACK ( addr -- ) HERE - , ;
: RESOLVE ( addr -- ) HERE OVER - SWAP ! ;
 
\ LEAVE stack is called L0. It is initialized by QUIT.
: >L ( x -- ) ( L: -- x ) 2 LP +! LP @ ! ;
: L> ( -- x ) ( L: x -- ) LP @ @ -2 LP +! ;
 
\ finite loop compilers
: DO ( -- ) POSTPONE <DO> HERE 0 >L 3 ; IMMEDIATE
: ?DO ( -- ) POSTPONE <?DO> HERE 0 >L 3 ; IMMEDIATE
: LEAVE ( -- ) ( L: -- addr )
POSTPONE UNLOOP POSTPONE BRANCH AHEAD >L ; IMMEDIATE
 
: RAKE ( -- ) ( L: 0 a1 a2 .. aN -- )
BEGIN L> ?DUP WHILE RESOLVE REPEAT ; IMMEDIATE
 
: LOOP ( -- ) 3 ?PAIRS POSTPONE <LOOP> BACK RAKE ; IMMEDIATE
: +LOOP ( -- ) 3 ?PAIRS POSTPONE <+LOOP> BACK RAKE ; IMMEDIATE
 
\ conditional branches
: IF ( ? -- ) POSTPONE ?BRANCH AHEAD 2 ; IMMEDIATE
: THEN ( -- ) ?COMP 2 ?PAIRS RESOLVE ; IMMEDIATE
: ELSE ( -- ) 2 ?PAIRS POSTPONE BRANCH AHEAD SWAP 2
POSTPONE THEN 2 ; IMMEDIATE
 
\ infinite loop compilers
: BEGIN ( -- addr n) ?COMP HERE 1 ; IMMEDIATE
: AGAIN ( -- ) 1 ?PAIRS POSTPONE BRANCH BACK ; IMMEDIATE
: UNTIL ( ? -- ) 1 ?PAIRS POSTPONE ?BRANCH BACK ; IMMEDIATE
: WHILE ( ? -- ) POSTPONE IF 2+ ; IMMEDIATE
: REPEAT ( -- ) 2>R POSTPONE AGAIN 2R> 2- POSTPONE THEN ; IMMEDIATE</syntaxhighlight>
 
Simple Usage Examples
 
<syntaxhighlight lang="forth"> : CHARSET [CHAR] ~ [CHAR] ! DO I EMIT LOOP ;
 
: >DIGIT ( n -- c) DUP 9 > IF 7 + THEN [CHAR] 0 + ;
 
: -TRAILING ( adr len -- adr len') \ remove trailing blanks (spaces)
BEGIN
2DUP + 1- C@ BL = \ test if last char = blank
WHILE
1- \ dec. length
REPEAT ;</syntaxhighlight>
 
=={{header|FreeBASIC}}==
Single line and multiple line macros can be used to modify or extend the language's syntax and are about as powerful as those found in the C language.
 
For example, we can create a 'forall' loop to iterate through the characters of a string rather than use a traditional 'for' loop:
 
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64
 
#Macro ForAll(C, S)
For _i as integer = 0 To Len(s)
#Define C (Chr(s[_i]))
#EndMacro
#Define In ,
Dim s As String = "Rosetta"
ForAll(c in s)
Print c; " ";
Next
Print
Sleep</syntaxhighlight>
 
{{out}}
<pre>
R o s e t t a
</pre>
 
=={{header|Go}}==
Although Go has a relatively small number of keywords (25), it also has 39 predeclared identifiers many of which would be considered to be keywords in other languages. The latter include:
 
1. The names of the basic types such as int, float64, bool and string.
 
2. Constants such as true, false and nil.
 
3. Functions such as append, copy, len, make, new and panic.
 
The predeclared identifiers have 'universal scope' and can therefore be redeclared to mean something different in all other scopes. To the extent that this can be considered to modify the normal operation of the language, Go has "support for metaprogramming" within the meaning of this task but has no other facilities of this nature.
 
Needless to say, redeclaring the predeclared identifiers in this way is potentially confusing and should not therefore be done without good reason.
 
In the following example the 'copy' function, which is normally used to copy slices, is redeclared to copy a 'person' struct instead:
<syntaxhighlight lang="go">package main
 
import "fmt"
 
type person struct{
name string
age int
}
 
func copy(p person) person {
return person{p.name, p.age}
}
 
func main() {
p := person{"Dave", 40}
fmt.Println(p)
q := copy(p)
fmt.Println(q)
/*
is := []int{1, 2, 3}
it := make([]int, 3)
copy(it, is)
*/
}</syntaxhighlight>
 
{{out}}
<pre>
{Dave 40}
{Dave 40}
</pre>
 
If the commented-out code, which uses 'copy' in its normal sense, were uncommented then the program would fail to compile with the following message:
<pre>
./metaprog.go:22:9: too many arguments in call to copy
have ([]int, []int)
want (person)
</pre>
 
=={{header|Haskell}}==
 
Metaprogramming is implemented using [http://www.haskell.org/haskellwiki/Template_Haskell Template Haskell].
 
=={{header|J}}==
Line 22 ⟶ 929:
 
J's [http://www.jsoftware.com/help/dictionary/d310n.htm explicit definitions] might also be considered an example of metaprogramming, since explicit definitions have data dependent syntactic types.
 
=={{header|Julia}}==
Julia's metaprogramming features are descibed in the online documentation at
https://docs.julialang.org/en/v1/manual/metaprogramming/index.html
 
Here is an example of metaprogramming. Julia in base form does not have C's do { } while() statement.
 
Using metaprogramming, the do/while can be somewhat emulated:
<syntaxhighlight lang="julia">macro dowhile(condition, block)
quote
while true
$(esc(block))
if !$(esc(condition))
break
end
end
end
end
 
macro dountil(condition, block)
quote
while true
$(esc(block))
if $(esc(condition))
break
end
end
end
end
 
using Primes
 
arr = [7, 31]
 
@dowhile (!isprime(arr[1]) && !isprime(arr[2])) begin
println(arr)
arr .+= 1
end
println("Done.")
 
@dountil (isprime(arr[1]) || isprime(arr[2])) begin
println(arr)
arr .+= 1
end
println("Done.")
</syntaxhighlight>{{output}}<pre>
[7, 31]
[8, 32]
[9, 33]
[10, 34]
Done.
[11, 35]
[12, 36]
Done.
</pre>
 
=={{header|Kotlin}}==
Although Kotlin doesn't support 'true' meta-programming, it does have facilities which make it possible to create something which closely resembles a language extension (see [[Extend_your_language#Kotlin]]).
 
It is also possible to define infix functions which look like user defined operators:
 
<syntaxhighlight lang="scala">// version 1.0.6
 
infix fun Double.pwr(exp: Double) = Math.pow(this, exp)
 
fun main(args: Array<String>) {
val d = 2.0 pwr 8.0
println(d)
}</syntaxhighlight>
 
{{out}}
<pre>
256.0
</pre>
 
=={{header|Lingo}}==
Lingo allows to create (and pre-compile) arbitrary code at runtime. You can't really change the language's syntax, but you can overwrite (or extend) built-in commands. Here as example some code that overwrite's Lingo's halt command, which would normally exit the current program:
 
<syntaxhighlight lang="lingo">r = RETURN
str = "on halt"&r&"--do nothing"&r&"end"
new(#script).scripttext = str</syntaxhighlight>
 
=={{header|Lua}}==
Line 28 ⟶ 1,016:
 
For example:
<langsyntaxhighlight lang="lua">
class "foo" : inherits "bar"
{
}
</syntaxhighlight>
</lang>
 
is perfectly valid syntax. (Lua does not having a built in concept of classes or inheritance.)
 
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module Meta {
FunName$="Alfa"
Code1$=FunName$+"=lambda (X)->{"
Code2$={
=x**2
}
Code3$="}"
Inline code1$+code2$+code3$
Print Function(FunName$, 4)=16
}
Meta
</syntaxhighlight>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
Mathematica can overload all symbols, though sometimes Unprotect has to be invoked. You can also introduce your own infix operators:
<syntaxhighlight lang="mathematica">CircleTimes[x_, y_] := Mod[x, 10] Mod[y, 10]
14\[CircleTimes]13</syntaxhighlight>
{{out}}
<pre>12</pre>
For more info see: [http://reference.wolfram.com/mathematica/tutorial/OperatorsWithoutBuiltInMeanings.html Operators in Mathematica]
 
=={{header|Nemerle}}==
Nemerle provides support for macros, which range from defining new infix operators (in fact many 'built-in' operators are [http://nemerle.org/wiki/index.php?title=Macro_operators macros]) to new keywords or control structures.
 
See [http://nemerle.org/wiki/index.php?title=Macros here], [http://nemerle.org/wiki/index.php?title=Macros_tutorial here], and [http://nemerle.org/wiki/index.php?title=Category:Macro_packages here] on the Nemerle wiki for more information.
 
=={{header|Nim}}==
===Infix Operators===
You can define your own infix operators:
<syntaxhighlight lang="nim">proc `^`*[T: SomeInteger](base, 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</syntaxhighlight>
 
===Compile Time evaluation===
<code>when</code> is a compile time <code>if</code> and can be used to prevent code from even being parsed at compile time, for example to write platform specific code:
<syntaxhighlight lang="nim">when defined windows:
echo "Call some Windows specific functions here"
elif defined linux:
echo "Call some Linux specific functions here"
else:
echo "Code for the other platforms"</syntaxhighlight>
Normal code can be executed at compile time if it is in a <code>static</code> block:
<syntaxhighlight lang="nim">static:
echo "Hello Compile time world: ", 2 ^ 10</syntaxhighlight>
As well as stored in compile time constants:
<syntaxhighlight lang="nim">const x = 2 ^ 10</syntaxhighlight>
===Templates===
The <code>expensive</code> procedure has to be evaluated even when <code>debug</code> is <code>false</code>:
<syntaxhighlight lang="nim">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()
</syntaxhighlight>
This can be prevented using templates, as template calls are replaced with the template body at compile time:
<syntaxhighlight lang="text">template log(msg: string) =
if debug:
echo msg
 
for i in 1..10:
log expensive()</syntaxhighlight>
Templates can use block syntax with statement parameters:
<syntaxhighlight lang="nim">template times(x, y: untyped): untyped =
for i in 1..x:
y
 
10.times: # or times 10: or times(10):
echo "hi"
echo "bye"</syntaxhighlight>
 
===Term Rewriting Templates===
Term Rewriting Templates can be used to write your own optimizations:
<syntaxhighlight lang="text">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
 
var
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]</syntaxhighlight>
===Macros===
The most powerful metaprogramming capabilities are offered by macros. They can generate source code or even an AST directly.
 
<code>dumpTree</code> can be useful when creating an AST, as it show you the AST of any code:
<syntaxhighlight lang="nim">import macros
 
dumpTree:
if x:
if y:
p0
else:
p1
else:
if y:
p2
else:
p3</syntaxhighlight>
This prints:
<pre>StmtList
IfStmt
ElifBranch
Ident !"x"
StmtList
IfStmt
ElifBranch
Ident !"y"
StmtList
Ident !"p0"
Else
StmtList
Ident !"p1"
Else
StmtList
IfStmt
ElifBranch
Ident !"y"
StmtList
Ident !"p2"
Else
StmtList
Ident !"p3"</pre>
Using this information we can create an <code>if2</code> macro for two conditions, as is done in the [http://rosettacode.org/wiki/Extend_your_language#Nim "Extend your language" task].
 
=={{header|Ol}}==
Ol supports [http://r7rs.org Scheme r7rs] macro syntax. Moreover, a large part of Ol scheme implementation made with macros.
 
For example the "define" macro implementation based on 'setq' (assigns value to variable) and 'lambda' (creates function) keywords and provides uniform way to define variables and functions.
 
<syntaxhighlight lang="scheme">
(define-syntax define
(syntax-rules (lambda) ;λ
((define ((name . args) . more) . body)
(define (name . args) (lambda more . body)))
((define (name . args) . body)
(setq name (letq (name) ((lambda args . body)) name)))
((define name (lambda (var ...) . body))
(setq name (letq (name) ((lambda (var ...) . body)) name)))
((define name val)
(setq name val))
((define name a b . c)
(define name (begin a b . c)))))
</syntaxhighlight>
 
Now we can use
 
<syntaxhighlight lang="scheme">
(define (sum a b) (+ a b))
; instead of
(setq sum (lambda (a b) (+ a b)))
</syntaxhighlight>
 
=={{header|OxygenBasic}}==
 
OxygenBasic supports metalanguage useable with various macro formats.
 
Unlike the C preprocessor, OxygenBasic metalanguage is resolved inline.
 
<syntaxhighlight lang="text">
 
'EQUATES
 
% half 0.5
$ title "My Metaprogram"
 
'CONDITIONAL BLOCKS
 
#ifdef ...
...
#elseif ...
...
#else
...
#endif
 
'MACROS
 
'msdos-like
def sum
%1 + %2
end def
 
'C-like
#define sum(a,b) a + b
 
'native
macro sum(a,b)
a + b
end macro
 
'native macro functions
macro sum int(r,a,b)
r = a + b
end macro
 
</syntaxhighlight>
 
=={{header|PARI/GP}}==
Line 52 ⟶ 1,265:
 
In (e.g.) basemath/somefile.c:
<langsyntaxhighlight Clang="c">long
smin0ss(long a, long b)
{
Line 65 ⟶ 1,278:
GEN c = gcmp(a, b) < 1 ? a : b; /* copy pointer */
return signe(c) > 0 ? gcopy(c) : gen_0;
}</langsyntaxhighlight>
 
 
=={{header|Perl}}==
Line 72 ⟶ 1,284:
You can textually transform code with a [http://perldoc.perl.org/perlfilter.html source filter], a module that when <code>use</code>d modifies the following lines of source. [http://perldoc.perl.org/Filter/Util/Call.html Filter::Util::Call] provides a general means of writing source filters. [http://perldoc.perl.org/Filter/Simple.html Filter::Simple] is an interface to <code>Filter::Util::Call</code> that lets you elide a lot of boilerplate code. More important, <code>Filter::Simple</code> can hide the contents of quoting constructs from your filter, obviating the biggest dangers of textual metaprogramming. For example, given the following module:
 
<langsyntaxhighlight lang="perl">package UnicodeEllipsis;
 
use Filter::Simple;
 
FILTER_ONLY code => sub { s/…/../g };</langsyntaxhighlight>
 
this program:
 
<langsyntaxhighlight lang="perl">use UnicodeEllipsis;
 
print join(' … ', 1 … 5), "\n";</langsyntaxhighlight>
 
prints:
Line 89 ⟶ 1,301:
 
[http://search.cpan.org/dist/Devel-Declare 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 [http://transfixedbutnotdead.com/2009/12/16/url-develdeclare-and-no-strings-attached/ this blog post] for a relatively simple usage example.
 
=={{header|Phix}}==
Metaprogramming is frowned on in phix and generally considered a deliberate and unnecessary attempt to complicate matters.<br>
Note however that I consider the necessity for metaprogramming in lisp-like languages to be a weakness, not a strength.<br>
Some builtins can be overridden, but the language reserves the right to reject such wanton acts of intellectual terrorism.<br>
One of the core principles of phix is that code should be utterly intuitive and easy to read.
=== compile-time assertions ===
The #isginfo{}, #isinit{}, and #istype{} directives instruct the compiler to perform various type-inference and legal value ranges checks.
Primarily for compiler development use, rather than end user applications. No code is generated, but compilation will abort if they fail.
Some static assertions can be performed with #isginfo{}, eg:
<syntaxhighlight lang="phix">object x
#isginfo{x,0b0101,5,7,integer,3}
-- {var,type,min,max,etype,len}
-- (0b0101 is dword sequence|integer)
x = {1,2,3} -- sequence of integer, length 3
x = 5 -- integer 5 (becomes min)
x = 7 -- integer 7 (becomes max)</syntaxhighlight>
A compile-time error occurs if say either 7 is changed to 6 (but not both).<br>
Note that you only get that error for "p -c test", not "p test".
=== symbol table hacking ===
See builtins\VM\prtnidN.e for details of how to locate and process the symbol table. Again I would not recommend it,
but that would allow you to modify variables and invoke code fragments at will, in a metaprogrammy sort of way.
=== modifying the compiler ===
see [[Extend_your_language#Phix]]
 
=={{header|PicoLisp}}==
Line 99 ⟶ 1,335:
 
=={{header|PostScript}}==
PostScrptPostScript allows the reification of stack, scoping (Dynamicdynamic 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
{{libheader|initlib}}
<langsyntaxhighlight lang="postscript">
 
/ift {
Line 114 ⟶ 1,350:
} ifelse
end}.
</syntaxhighlight>
</lang>
The standard if expression in postscriptPostScript 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
<langsyntaxhighlight lang="postscript">
>| 2 {1 gt} {=} ift
2
</syntaxhighlight>
</lang>
Instead of
 
<langsyntaxhighlight lang="postscript">
>| 2 dup 1 gt {=} ift
2
</syntaxhighlight>
</lang>
 
Note that even the let expression was implemented using meta programming
<langsyntaxhighlight lang="postscript">
/let* {reverse {exch def} forall}.
</syntaxhighlight>
</lang>
 
=={{header|Prolog}}==
 
This example expands and prints a goal using [http://www.swi-prolog.org/pldoc/man?predicate=clause/2 clause/2]:
 
<syntaxhighlight lang="prolog">
:- initialization(main).
main :- clause(less_than(1,2),B),writeln(B).
less_than(A,B) :- A<B.
 
</syntaxhighlight>
New goals can be created at runtime using [http://www.swi-prolog.org/pldoc/man?predicate=assertz/1 assertz/1]:
<syntaxhighlight lang="prolog">
assertz((mother(Child, Mother) :-
parent(Child, Mother),
female(Mother))).
</syntaxhighlight>
 
=={{header|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 [http://entrian.com/goto/ April-fools joke].
 
Another more recent library that shows it can be done in Python is [https://github.com/lihaoyi/macropy MacroPy].
 
==={{works with|https://github.com/lihaoyi/macropy MacroPy}}===
 
This is example is taken from MacroPy's [https://github.com/lihaoyi/macropy/blob/2885df8ca73fa0f6c17168a98d218dc4a3f088c2/docs/examples/first_macro/full/macro_module.py GitHub page]. It creates a macro called <tt>expand</tt> that, when invoked, generates the AST for a function in place of the original expression.
 
<syntaxhighlight lang="python">
from macropy.core.macros import *
from macropy.core.quotes import macros, q, ast, u
 
macros = Macros()
 
@macros.expr
def expand(tree, **kw):
addition = 10
return q[lambda x: x * ast[tree] + u[addition]]
</syntaxhighlight>
 
It is then invoked like this:
<syntaxhighlight lang="python">
func = expand[1 + 2]
print func(5)
</syntaxhighlight>
 
=={{header|Quackery}}==
 
The various forms of metaprogramming available in Quackery are discussed in [https://github.com/GordonCharlton/Quackery The Book of Quackery]. Here, two types are illustrated.
 
1: Extending the Quackery compiler by adding a compiler directive to skip over inline comments indicated by a semicolon. (Quackery has block comments delimited by "(" and ")" but not "comment to end of line".)
 
2: Adding a new control-flow structure (a switch statement) by using meta-control-flow words. (The ones with ]reverse-nested[ names, indicating they convey properties to the nest that invoked them.)
 
<syntaxhighlight lang="quackery">
( +---------------------------------------------------+ )
( | add inline comments ";" to Quackery with "builds" | )
( +---------------------------------------------------+ )
 
[ dup $ "" = not while
behead carriage =
until ] builds ; ( [ $ --> [ $ )
 
 
; +---------------------------------------------------+
; | add switch to Quackery with ]else[ ]'[ & ]done[ |
; +---------------------------------------------------+
 
[ stack ] is switch.arg ( --> s )
protect switch.arg
 
[ switch.arg put ] is switch ( x --> )
 
[ switch.arg release ] is otherwise
 
[ switch.arg share
!= iff ]else[ done
otherwise
]'[ do ]done[ ] is case ( x --> )
 
 
[ switch
1 case [ say "The number 1." cr ]
$ "two" case [ say 'The string "two".' cr ]
otherwise [ say "Something else." cr ] ] is test
( x --> )
 
 
' tally test ; output should be: Something else.
$ "two" test ; output should be: The string "two".
1 test ; output should be: The number 1.
 
</syntaxhighlight>
 
{{Out}}
 
<pre>Something else.
The string "two".
The number 1.
</pre>
=={{header|R}}==
R does not have much to offer in this regard. It has generic functions, but they're little more than the forbidden option of operator overloading. We equally cannot use any eval tricks, because the task has also forbidden those. As for macros, although R is inspired by Scheme, it has nothing of the sort. For example, see the admitted cheating in [[Extend your language#R]].
 
As for the permitted things that R does have, it makes it very easy to define new infix operators. We have shown one such example at [[Matrix-exponentiation operator#Infix operator]]. To my knowledge, this is only documented in 'An Introduction to R', [https://cran.r-project.org/doc/manuals/r-release/R-intro.html#Defining-new-binary-operators section 10.2]. As for doing this ourselves, we will implement a version of the "nCk" syntax that some calculators use for "n choose k", i.e. the binomial coefficient:
<syntaxhighlight lang="rsplus">'%C%' <- function(n, k) choose(n, k)
5 %C% 2 #Outputs 10.</syntaxhighlight>
 
=={{header|Racket}}==
 
Racket has an extremely rich set of metaprogramming tools, which scale from simple pattern-based macros to implementing entire new languages with their own syntax, such as [http://docs.racket-lang.org/datalog/index.html Datalog] and [http://docs.racket-lang.org/algol60/index.html Algol 60]. Many parts of Racket itself, including its class-based object system, are implemented as macros that expand to a much smaller set of core forms.
 
As a descendent of the Scheme tradition, Racket provides [https://en.wikipedia.org/wiki/Hygienic_macro hygienic] pattern-based macros, allows the use of the full Racket language (including programmer-defined extensions) in implementing macros, and supports locally-defined macros.
 
Racket adds many extensions to this tradition, such as syntax-parse, which simplifies writing robust macros with good error reporting. For more information on Racket's metaprogramming features, see the relevant chapters of [https://docs.racket-lang.org/guide/macros.html The Racket Guide] and [https://docs.racket-lang.org/reference/Macros.html The Racket Reference].
 
For a simple example, this is the definition and a use of the macro list-when:
<syntaxhighlight lang="racket">#lang racket
 
(define-syntax-rule (list-when test body)
(if test
body
'()))
 
(let ([not-a-string 42])
(list-when (string? not-a-string)
(string->list not-a-string)))</syntaxhighlight>
 
Unlike a plain function, which would eagerly evaluate its arguments, list-when only evaluates its body expression when its test expression passes: otherwise, it evaluates to the empty list. Therefore, the example above does not produce an error.
 
Alternatively, list-when could be defined using syntax-parse, which provides better error messages for syntax errors:
 
<syntaxhighlight lang="racket">(require (for-syntax syntax/parse))
 
(define-syntax list-when
(syntax-parser
[(_ test:expr body:expr)
#'(if test
body
null)]))</syntaxhighlight>
 
=={{header|Raku}}==
(formerly Perl 6)
 
Raku makes it very easy to do metaprogramming. It is a basic goal of the language.
 
It is trivial to add a new operator. Most Raku operators are written as normal multiple-dispatch functions in the setting (known as a "prelude" in other languages, but in Raku the setting is a lexical scope notionally surrounding your compilation unit).
 
There is no a built in factorial operator Raku. It was purposely left out to use as a demonstration of how easy it is to add it. <tt>:-)</tt>
 
<syntaxhighlight lang="raku" line>sub postfix:<!> { [*] 1..$^n }
say 5!; # prints 120</syntaxhighlight>
 
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 <tt>Any</tt>. (<tt>List</tt> and <tt>Array</tt> are both subclasses of Any)
 
<syntaxhighlight lang="raku" line>use MONKEY-TYPING; # Needed to do runtime augmentation of a base class.
 
augment class List {
method nsort { self.list.sort: {$^a.lc.subst(/(\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;</syntaxhighlight>
 
Prints
<pre>
a2 a3rd a17th a32nd a95 a144th a201st
a144th a17th a2 a201st a32nd a3rd a95</pre>
Grammar mixins work in Raku because grammar rules are just methods in grammar classes, and Raku 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 <tt>augment slang</tt> hook to allow user code to do this mixin. Raku 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 Raku 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 <tt>Q</tt> language.
<syntaxhighlight lang="raku" line>say "Foo = $foo\n"; # normal double quotes
say Q:qq 【Foo = $foo\n】; # a more explicit derivation, new quotes</syntaxhighlight>
 
=={{header|Rascal}}==
Rascal has been developed for metaprogramming. Rascal modules already have functionality to analyse Java code (see [http://tutor.rascal-mpl.org/Courses/Rascal/Rascal.html#/Courses/Rascal/Libraries/lang/java/jdt/jdt.html documentation]).
 
===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.
 
<syntaxhighlight lang="rascal">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 ")"
;</syntaxhighlight>
 
An example of the parse viewer for E1
 
[[File:E1parseviewer.png]]
 
===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.
<syntaxhighlight lang="rascal">map[str, int] operatorUsage(PROGRAM P) {
m = ();
visit(P){
case add(_,_): m["add"] ? 0 += 1;
case sub(_,_): m["sub"] ? 0 += 1;
case conc(_,_): m["conc"] ? 0 += 1;
}
return m;
}</syntaxhighlight>
Where the abstract syntax is defined as follows
<syntaxhighlight lang="rascal">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)
;</syntaxhighlight>
 
===Pico in Rascal===
 
This is part of the Pico syntax expressed in Rascal.
 
<syntaxhighlight lang="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);
} </syntaxhighlight>
 
=={{header|REXX}}==
<syntaxhighlight lang="rexx">/*┌───────────────────────────────────────────────────────────────────┐
REXX doesn't allow for the changing or overriding of syntax per se, but any of
│ The REXX language doesn't allow for the changing or overriding of │
built-in functions can be overided by just specifying your own.
│ 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. │
└───────────────────────────────────────────────────────────────────┘ */
yyy='123456789abcdefghi'
 
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.*/</syntaxhighlight>
 
=={{header|Ring}}==
The next program add new method to the object class during the runtime
<syntaxhighlight lang="ring">
o1 = new point { x=10 y=20 z=30 }
addmethod(o1,"print", func { see x + nl + y + nl + z + nl } )
o1.print()
Class point
x y z
</syntaxhighlight>
 
The next example presents how to create a class that defines two instructions
The first instruction is : I want window
The second instruction is : Window title = Expression
Also keywords that can be ignored like the ‘the’ keyword
 
<syntaxhighlight lang="ring">
New App
{
I want window
The window title = "hello world"
}
 
Class App
 
func geti
if nIwantwindow = 0
nIwantwindow++
ok
 
func getwant
if nIwantwindow = 1
nIwantwindow++
ok
 
func getwindow
if nIwantwindow = 2
nIwantwindow= 0
see "Instruction : I want window" + nl
ok
if nWindowTitle = 0
nWindowTitle++
ok
 
func settitle cValue
if nWindowTitle = 1
nWindowTitle=0
see "Instruction : Window Title = " + cValue + nl
ok
 
private
 
# Attributes for the instruction I want window
i want window
nIwantwindow = 0
# Attributes for the instruction Window title
# Here we don't define the window attribute again
title
nWindowTitle = 0
# Keywords to ignore, just give them any value
the=0
</syntaxhighlight>
 
=={{header|Ruby}}==
An rudimentary example of metaprogramming is presented in this simple identification system template:
<syntaxhighlight lang="ruby">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
end
end</syntaxhighlight>
 
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".
 
=={{header|Run BASIC}}==
(This is not really metaprogramming, at least not under any useful meaning...)
 
<syntaxhighlight lang="runbasic">' ---------------------------------------------------
' 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</syntaxhighlight>
 
=={{header|Rust}}==
Rust supports extensive metaprogramming via macros. Note that rust macros differ from, say, C preprocessor macros in that they are not mere text substitution (so operator precedence is preserved and name shadowing is not an issue). Here is an example from rustbyexample.com that implements and tests the <code>+=</code>, <code>-=</code>, and <code>*=</code> operators for Vectors.
 
<syntaxhighlight lang="rust">// dry.rs
use std::ops::{Add, Mul, Sub};
 
macro_rules! assert_equal_len {
// The `tt` (token tree) designator is used for
// operators and tokens.
($a:ident, $b: ident, $func:ident, $op:tt) => (
assert!($a.len() == $b.len(),
"{:?}: dimension mismatch: {:?} {:?} {:?}",
stringify!($func),
($a.len(),),
stringify!($op),
($b.len(),));
)
}
 
macro_rules! op {
($func:ident, $bound:ident, $op:tt, $method:ident) => (
fn $func<T: $bound<T, Output=T> + Copy>(xs: &mut Vec<T>, ys: &Vec<T>) {
assert_equal_len!(xs, ys, $func, $op);
 
for (x, y) in xs.iter_mut().zip(ys.iter()) {
*x = $bound::$method(*x, *y);
// *x = x.$method(*y);
}
}
)
}
 
// Implement `add_assign`, `mul_assign`, and `sub_assign` functions.
op!(add_assign, Add, +=, add);
op!(mul_assign, Mul, *=, mul);
op!(sub_assign, Sub, -=, sub);
 
mod test {
use std::iter;
macro_rules! test {
($func: ident, $x:expr, $y:expr, $z:expr) => {
#[test]
fn $func() {
for size in 0usize..10 {
let mut x: Vec<_> = iter::repeat($x).take(size).collect();
let y: Vec<_> = iter::repeat($y).take(size).collect();
let z: Vec<_> = iter::repeat($z).take(size).collect();
 
super::$func(&mut x, &y);
 
assert_eq!(x, z);
}
}
}
}
 
// Test `add_assign`, `mul_assign` and `sub_assign`
test!(add_assign, 1u32, 2u32, 3u32);
test!(mul_assign, 2u32, 3u32, 6u32);
test!(sub_assign, 3u32, 2u32, 1u32);
}</syntaxhighlight>
 
{{out}}
<pre>$ rustc --test dry.rs && ./dry
running 3 tests
test test::mul_assign ... ok
test test::add_assign ... ok
test test::sub_assign ... ok
 
test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured</pre>
 
=={{header|Scala}}==
<syntaxhighlight lang="scala">import scala.language.experimental.macros
import scala.reflect.macros.Context
 
object Macros {
def impl(c: Context) = {
import c.universe._
c.Expr[Unit](q"""println("Hello World")""")
}
 
def hello: Unit = macro impl
}</syntaxhighlight>
 
=={{header|Shen}}==
Being a Lisp, metaprogramming is easily achievable in Shen through macros. However, defining macros is only possible when the typechecker is off.
<syntaxhighlight lang="shen">(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</syntaxhighlight>
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.
<syntaxhighlight lang="shen">(0-) (defmacro +-macro
[A + B] -> [+ A B])
macro
+-macro
 
(1-) (1 + (* 2 3))
7</syntaxhighlight>
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:
<syntaxhighlight lang="shen">(2-) (tc +)
true
 
(3+) (+ 1 2 3)
6 : number
 
(4+) +
+ : (number --> (number --> number))
 
(5-) (tc -)
false
 
(6-) (macroexpand [+ 1 2 3])
[+ 1 [+ 2 3]]</syntaxhighlight>
 
=={{header|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.
<syntaxhighlight lang="ruby">class Number {
method ⊕(arg) {
self + arg
}
}
 
say (21 ⊕ 42)</syntaxhighlight>
 
Another example of metaprogramming, is the definition of methods at run-time:
 
<syntaxhighlight lang="ruby">var colors = Hash(
'black' => "000",
'red' => "f00",
'green' => "0f0",
'yellow' => "ff0",
'blue' => "00f",
'magenta' => "f0f",
'cyan' => "0ff",
'white' => "fff",
)
 
for color,code in colors {
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</syntaxhighlight>
{{out}}
<pre>
<span style="color: #00f">blue</span>
<span style="color: #f00">red</span>
<span style="color: #fff">white</span>
</pre>
 
=={{header|Smalltalk}}==
In Smalltalk, a class can redefine which compiler class is to be used when methods are compiled (aka "accepted in the class browser"). That compiler may be as simple as a subclass of the standard compiler with additional language features (such as additional literal types, extended string syntax etc.) or a completely different language build using one of the available compiler-compiler packages (tgen, petite - a peg parser, and others), or a hand written parser. There exists number of such packages to implement Scheme, Prolog, JavaScript, O-Meta, a number of domain specific language and data description languages (eg. for C data structures or ASN1 types).
 
As a simple example, here is how external library functions are handled by a pragma detector, to generate a callout to eg. C-functions:
REXX allows the programmer to set the precision of the numbers it uses in
<syntaxhighlight lang="smalltalk">apiSyslog:priority format:format message:message
calculations and expressions, as well as the FUZZ settings, which effects
<cdecl: int 'syslog' (int char* char*) >
how numbers are compared (for equalness, greater or equal to, less or equal
^ self primitiveFailed.
to, etc).
</syntaxhighlight>
 
=={{header|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 <code>IDENT</code> to <code>SAME</code> and the unary operator <code>*</code> to <code>$</code>:
<langsyntaxhighlight lang="snobol4">
OPSYN('SAME','IDENT')
OPSYN('$','*',1)
</syntaxhighlight>
</lang>
 
This is a simplistic use of <code>OPSYN</code>, however. More interesting is the aliasing of a function to an operator:
<langsyntaxhighlight lang="snobol4">
OPSYN('F','*',1)
</syntaxhighlight>
</lang>
 
In this setup, calling <code>F(X)</code> is the same as using the sequence <code>*X</code> which, in more complicated expressions, could result in better readability.
 
Other metaprogramming features supported would include the use of unevaluated expressions. If, in code, <code>E</code> is an expression it has a value as soon as it is defined and/or assigned to. <code>*E</code>, 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 <code>EVAL</code>. The following example shows the motivation for unevaluated expressions in pattern matching contexts:
<langsyntaxhighlight lang="snobol4">
&ANCHOR = 0 ; &TRIM = 1
WORD = BREAK(' .,') . W SPAN(' .,')
Line 170 ⟶ 2,029:
OUTPUT OUTPUT = LIST
END
</syntaxhighlight>
</lang>
 
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 <code>' ' W ANY(' .,')</code> 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 <code>W</code> until it is needed while keeping the rest of the pattern intact:
<langsyntaxhighlight lang="snobol4">
&ANCHOR = 0 ; &TRIM = 1
WORD = BREAK(' .,') . W SPAN(' .,')
Line 184 ⟶ 2,043:
OUTPUT OUTPUT = LIST
END
</syntaxhighlight>
</lang>
In this code, the pattern is constructed only once in the line <code>FINDW = ' ' *W ANY(' .,')</code>. The value of the variable <code>W</code>, 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 <code>STRING1</code> is matched against the pattern <code>WORD</code>. In this way the expense of building the pattern is paid only once, but the flexibility of matching a sequence of values is retained.
 
Line 190 ⟶ 2,049:
 
Consider this hand-waving example for the motivation:
<langsyntaxhighlight lang="snobol4">
* This example provides a bizarrely-expensive addition operation.
* It assumes the existence of an expensive procedure—say a database
Line 199 ⟶ 2,058:
XADD XADD = X + ADDVALUE :(RETURN)
XADD.END
</syntaxhighlight>
</lang>
 
In normal operation the interpreter will execute the <code>DEFINE</code> function and then execute the <code>ADDVALUE = ...</code> line, branching *past* the actual body of the function to the label <code>XADD.END</code>. 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:
<langsyntaxhighlight lang="snobol4">
DEFINE('XADD(X)','XADD.INIT') :(XADD.END)
XADD.INIT ADDVALUE = CALL_SOME_EXPENSIVE_OPERATION()
Line 208 ⟶ 2,067:
XADD XADD = X + ADDVALUE :(RETURN)
XADD.END
</syntaxhighlight>
</lang>
 
The code now defines the <code>XADD</code> function and immediately, without doing initialization, jumps to the <code>XADD.END</code> label, bypassing both initialization and the function body. The trick here is that it defines the entry point of the function to be the <code>XADD.INIT</code> label. Now the first time <code>XADD</code> is called, control is transferred to <code>XADD.INIT</code>, the expensive initialization is performed, then the <code>XADD</code> function is *redefined* to point to the <code>XADD</code> label as the entry point. From this point onward all calls to <code>XADD</code> 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 usefulsuitable for metaprogramming efforts. Indeed such features are used prominently in the debugging subsystems of SNOBOL4 implementations.
 
=={{header|Standard ML}}==
<syntaxhighlight lang="standard ml">
fun to (a, b) = List.tabulate (b-a,fn i => a+i ) ;
infix 5 to ;
</syntaxhighlight>
example
<syntaxhighlight lang="standard ml">
- 2 to 9 ;
val it = [2,3,4,5,6,7,8] : int list
</syntaxhighlight>
 
=={{header|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 <code>upvar</code> and <code>uplevel</code> 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:
<langsyntaxhighlight lang="tcl">proc loopVar {var from lower to upper script} {
if {$from ne "from" || $to ne "to"} {error "syntax error"}
upvar 1 $var v
Line 229 ⟶ 2,099:
}
}
}</langsyntaxhighlight>
The above creates a new <code>loopVar</code> command that might be used like this:
<langsyntaxhighlight lang="tcl">loopVar x from 1 to 4 {
loopVar y from $x to 6 {
puts "pair is ($x,$y)"
if {$y >= 4} break
}
}</langsyntaxhighlight>
Which prints this:
<pre>
Line 256 ⟶ 2,126:
 
Finally, the total lack of keywords is exemplified by this classic fragment of Tcl:
<syntaxhighlight lang ="tcl">set set set</langsyntaxhighlight>
In this, the first <code>set</code> 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.
 
=={{Omit fromheader|AdaTXR}}==
 
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: <code>(read "(+ a b c)")</code>;
* a parser for regular exprssions: <code>(regex-parse "a.*b")</code> which produces abstract syntax;
* a run-time compiler for converting regular expression abstract syntax to compiled regular expression object;
* a <code>eval</code> 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 <code>defmacro</code>, <code>defsymacro</code>, <code>macrolet</code> and <code>symacrolet</code>;
* structural quasiquote for convenient macro writing.
 
Example define a while loop which supports break and continue. Two forms of break are supported <code>break</code> which causes the loop to terminate with the return value <code>nil</code> and <code>(break &lt;form&gt;)</code> which returns the specified value.
 
<syntaxhighlight lang="txrlisp">(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)
continue)
(if (> i 30)
break)
(prinl i)))
 
(prinl
(sys:expand
'(whil ((< i 100))
(if (< (inc i) 20)
continue)
(if (> i 30)
break)
(prinl i))))</syntaxhighlight>
 
{{out}}
 
<pre>20
21
22
23
24
25
26
27
28
29
30
(block #:brk-blk-0062
(for () ((< i 100) ())
() (block #:cnt-blk-0061
(if (< (sys:setq i (succ i))
20) (return-from
#:cnt-blk-0061))
(if (> i 30)
(return-from
#:brk-blk-0062))
(prinl i))))</pre>
 
=={{header|Wren}}==
Analogous to D's mixins, Wren has an optional Meta module which enables strings to be compiled to regular Wren code or expressions and inserted into the script. The D example looks like this in Wren.
<syntaxhighlight lang="wren">import "meta" for Meta
 
var genericClass = Fn.new { |cname, fname|
var s1 = "class %(cname) {\n"
var s2 = "construct new(%(fname)){\n_%(fname) = %(fname)\n}\n"
var s3 = "%(fname) { _%(fname) }\n"
var s4 = "}\nreturn %(cname)\n"
return Meta.compile(s1 + s2 + s3 + s4).call() // returns the Class object
}
 
var CFoo = genericClass.call("Foo", "bar")
var foo = CFoo.new(10)
System.print([foo.bar, foo.type])</syntaxhighlight>
 
{{out}}
<pre>
[10, Foo]
</pre>
 
=={{header|Z80 Assembly}}==
Meta-programming is very limited, but macros can make parameter passing much more straightforward.
 
<syntaxhighlight lang="z80">macro xchg,regpair1,regpair2
;swaps the contents of two registers.
push regpair1
push regpair2
pop regpair1
pop regpair2
endm</syntaxhighlight>
 
Then in your code you can do the following:
<syntaxhighlight lang="z80">xchg bc,de ;exchanges BC with DE</syntaxhighlight>
 
 
=={{header|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.
<syntaxhighlight lang="zkl">#define name [0|1]
#if [0|1|name]
#else, #endif</syntaxhighlight>
 
<syntaxhighlight lang="zkl">//Full zkl functionality but limited access to the parse stream; only #defines
#ifdef name
#fcn name {code}</syntaxhighlight>
 
<syntaxhighlight lang="zkl">// Shove text into the parse stream
#text name text
#tokenize name, #tokenize f, #tokenize f(a)</syntaxhighlight>
 
<syntaxhighlight lang="zkl">#<<<#
text, any text, inside #<<<# pairs is ignored
#<<<#</syntaxhighlight>
<syntaxhighlight lang="zkl">string:=
#<<<
"here docs:
all text in #<<< pairs is collected into one [long] line and passed
verbatim to the tokenizer. Illustrated here as quoted (\") strings
can not span lines.";
#<<<
println(string); // contains newlines</syntaxhighlight>
In addition, there is a concept of "parse space/time" - it is after parsing and before compiling where the full power of the language can be used to "so stuff". For example, enums can be implemented like so:
<syntaxhighlight lang="zkl">const{ var _n=-1; var [proxy] N=fcn{ _n+=1 } }
const X=N; // → 0
println(_n); // → 2 code time is after const time
const Y=N,Z=N; // → 1,2</syntaxhighlight>
 
{{omit from|Ada}}
{{omit from|AWK}}
{{omit from|bc}}
{{Omitomit from|GoJavaScript}}
{{omit from|sed}}
9,485

edits