Metaprogramming: Difference between revisions

This sample adds a COBOL-like INSPECT "statement" by defining suitable operators.

 

# "INSPECT statement" to ALGOL 68 #

# #

 

 

Output:

<pre>some text

kXXc some

</pre>

 

=={{header|C}}==

It's possible to create [http://stackoverflow.com/questions/3385515/static-assert-in-c static assertions]

 

// http://stackoverflow.com/questions/3385515/static-assert-in-c

#define STATIC_ASSERT(COND,MSG) typedef char static_assertion_##MSG[(!!(COND))*2-1]

COMPILE_TIME_ASSERT(sizeof(int)==4);

}

 

Another common usage is to create custom loops

 

//requires C99

#define ITERATE_LIST(n, list) \

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

}

 

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).

 

 

#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|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.

 

=={{header|C sharp|C#}}==

 

=={{header|Clojure}}==

 

=={{header|Common Lisp}}==

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)

(spl-var (- (* count sum-of-squares) (* sum sum)))

(spl-dev (sqrt (/ spl-var (1- count)))))

 

=> <pre>5/2 ;

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

 

[5]>

(macroexpand'

(SPL-VAR (- (* COUNT SUM-OF-SQUARES) (* SUM SUM)))

(SPL-DEV (SQRT (/ SPL-VAR (1- COUNT)))))

 

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)

(SPL-VAR (- (* COUNT SUM-OF-SQUARES) (* SUM SUM)))

(SPL-DEV (SQRT (/ SPL-VAR (1- COUNT)))))

 

===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.

;;

-> ((1 . A) (1 . B) (1 . C)

(2 . A) (2 . B) (2 . 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.

 

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:

-> (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. http://paste.lisp.org/display/71196

 

 

(defgeneric monadic-join (monad-class container-of-containers &rest additional))

((x new-state)

(funcall embedded-xformer intermediate-state)))))

===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:

[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.

 

"struct " ~ name ~ "{ int " ~ fieldName ~ "; }";

 

Foo f;

f.bar = 10;

 

=={{header|E}}==

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.)

 

 

\ branch offset computation operators

: UNTIL ( ? -- ) 1 ?PAIRS POSTPONE ?BRANCH BACK ; IMMEDIATE

: WHILE ( ? -- ) POSTPONE IF 2+ ; IMMEDIATE

 

Simple Usage Examples

 

 

: >DIGIT ( n -- c) DUP 9 > IF 7 + THEN [CHAR] 0 + ;

WHILE

1- \ dec. length

 

=={{header|FreeBASIC}}==

For example, we can create a 'forall' loop to iterate through the characters of a string rather than use a traditional 'for' loop:

 

 

#Macro ForAll(C, S)

Print

 

{{out}}

 

In the following example the 'copy' function, which is normally used to copy slices, is redeclared to copy a 'person' struct instead:

 

import "fmt"

copy(it, is)

*/

 

{{out}}

 

Using metaprogramming, the do/while can be somewhat emulated:

quote

while true

end

println("Done.")

[7, 31]

[8, 32]

It is also possible to define infix functions which look like user defined operators:

 

 

infix fun Double.pwr(exp: Double) = Math.pow(this, exp)

val d = 2.0 pwr 8.0

println(d)

 

{{out}}

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:

 

str = "on halt"&r&"--do nothing"&r&"end"

 

=={{header|Lua}}==

 

For example:

class "foo" : inherits "bar"

{

}

 

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

 

=={{header|M2000 Interpreter}}==

Module Meta {

FunName$="Alfa"

}

Meta

 

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

{{out}}

<pre>12</pre>

===Infix Operators===

You can define your own infix operators:

var (base, exp) = (base, exp)

result = 1

base *= base

 

===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:

echo "Call some Windows specific functions here"

elif defined linux:

echo "Call some Linux specific functions here"

else:

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

As well as stored in compile time constants:

===Templates===

The <code>expensive</code> procedure has to be evaluated even when <code>debug</code> is <code>false</code>:

 

const debug = false

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:

if debug:

echo msg

 

for i in 1..10:

Templates can use block syntax with statement parameters:

for i in 1..x:

y

10.times: # or times 10: or times(10):

echo "hi"

 

===Term Rewriting Templates===

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

template optLog2{a and (b or (not b))}(a,b): auto = a

template optLog3{a and not a}(a: int): auto = 0

 

q = (s and not x) and not (s and not x)

===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:

 

dumpTree:

p2

else:

This prints:

<pre>StmtList

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.

 

(define-syntax define

(syntax-rules (lambda) ;λ

((define name a b . c)

(define name (begin a b . c)))))

 

Now we can use

 

(define (sum a b) (+ a b))

; instead of

(setq sum (lambda (a b) (+ a b)))

 

=={{header|PARI/GP}}==

 

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

smin0ss(long a, long b)

{

GEN c = gcmp(a, b) < 1 ? a : b; /* copy pointer */

return signe(c) > 0 ? gcopy(c) : gen_0;

 

=={{header|Perl}}==

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:

 

 

use Filter::Simple;

 

 

this program:

 

 

 

prints:

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:

#isginfo{x,0b0101,5,7,integer,3}

-- {var,type,min,max,etype,len}

x = {1,2,3} -- sequence of integer, length 3

x = 5 -- integer 5 (becomes min)

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".

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

{{libheader|initlib}}

 

/ift {

} ifelse

end}.

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

2

Instead of

 

>| 2 dup 1 gt {=} ift

2

 

Note that even the let expression was implemented using meta programming

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

 

=={{header|Prolog}}==

This example expands and prints a goal using [http://www.swi-prolog.org/pldoc/man?predicate=clause/2 clause/2]:

 

:- initialization(main).

main :- clause(less_than(1,2),B),writeln(B).

less_than(A,B) :- A<B.

 

New goals can be created at runtime using [http://www.swi-prolog.org/pldoc/man?predicate=assertz/1 assertz/1]:

assertz((mother(Child, Mother) :-

parent(Child, Mother),

female(Mother))).

 

=={{header|Python}}==

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.

 

from macropy.core.macros import *

from macropy.core.quotes import macros, q, ast, u

addition = 10

return q[lambda x: x * ast[tree] + u[addition]]

 

It is then invoked like this:

func = expand[1 + 2]

print func(5)

 

=={{header|Racket}}==

 

For a simple example, this is the definition and a use of the macro list-when:

 

(define-syntax-rule (list-when test body)

(let ([not-a-string 42])

(list-when (string? not-a-string)

 

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:

 

 

(define-syntax list-when

#'(if test

body

 

=={{header|Raku}}==

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>

 

 

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)

 

 

augment class List {

 

say ~<a201st a32nd a3rd a144th a17th a2 a95>.nsort;

 

Prints

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.

 

=={{header|Rascal}}==

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.

 

 

layout Whitespace = [\ \t\n]*;

> E "+" E

| "(" E ")"

 

An example of the parse viewer for E1

===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.

m = ();

visit(P){

}

return m;

Where the abstract syntax is defined as follows

natural() | string();

| doUntilStat(EXP exp, list[STATEMENT] body)

| unlessStat(EXP exp, list[STATEMENT] body)

 

===Pico in Rascal===

This is part of the Pico syntax expressed in Rascal.

 

 

import Prelude;

public start[Program] program(str s, loc l) {

return parse(#start[Program], s, l);

 

=={{header|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 │

│ the (below) statement as an error. │

└───────────────────────────────────────────────────────────────────┘ */

 

=={{header|Ring}}==

The next program add new method to the object class during the runtime

o1 = new point { x=10 y=20 z=30 }

addmethod(o1,"print", func { see x + nl + y + nl + z + nl } )

Class point

x y z

 

The next example presents how to create a class that defines two instructions

Also keywords that can be ignored like the ‘the’ keyword

 

New App

{

# Keywords to ignore, just give them any value

the=0

 

=={{header|Ruby}}==

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

# Create elements of this man, woman, or child's identification.

end

 

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".

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

 

' create a file to be run

' RB can run the entire 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

 

=={{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.

 

use std::ops::{Add, Mul, Sub};

 

test!(mul_assign, 2u32, 3u32, 6u32);

test!(sub_assign, 3u32, 2u32, 1u32);

 

{{out}}

 

=={{header|Scala}}==

import scala.reflect.macros.Context

 

 

def hello: Unit = macro impl

 

=={{header|Shen}}==

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

[A|D] -> [cons (make-list A) (make-list D)]

X -> X)

[info Exp] -> [output "~A: ~A~%" (make-list Exp) Exp])

 

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.

[A + B] -> [+ A B])

macro

 

(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:

true

 

 

(6-) (macroexpand [+ 1 2 3])

 

=={{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.

method ⊕(arg) {

self + arg

}

 

 

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

 

'black' => "000",

'red' => "f00",

say "blue".in_blue

say "red".in_red

{{out}}

<pre>

<span style="color: #fff">white</span>

</pre>

 

=={{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>:

OPSYN('SAME','IDENT')

OPSYN('$','*',1)

 

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

OPSYN('F','*',1)

 

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:

&ANCHOR = 0 ; &TRIM = 1

WORD = BREAK(' .,') . W SPAN(' .,')

OUTPUT OUTPUT = LIST

END

 

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:

&ANCHOR = 0 ; &TRIM = 1

WORD = BREAK(' .,') . W SPAN(' .,')

OUTPUT OUTPUT = LIST

END

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.

 

 

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

XADD XADD = X + ADDVALUE :(RETURN)

XADD.END

 

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:

DEFINE('XADD(X)','XADD.INIT') :(XADD.END)

XADD.INIT ADDVALUE = CALL_SOME_EXPENSIVE_OPERATION()

XADD XADD = X + ADDVALUE :(RETURN)

XADD.END

 

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.

 

=={{header|Standard ML}}==

fun to (a, b) = List.tabulate (b-a,fn i => a+i ) ;

infix 5 to ;

example

- 2 to 9 ;

val it = [2,3,4,5,6,7,8] : int list

 

=={{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:

if {$from ne "from" || $to ne "to"} {error "syntax error"}

upvar 1 $var v

}

}

The above creates a new <code>loopVar</code> command that might be used like this:

loopVar y from $x to 6 {

puts "pair is ($x,$y)"

if {$y >= 4} break

}

Which prints this:

<pre>

 

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

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.

 

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.

 

(let ((cblk (gensym "cnt-blk-"))

(bblk (gensym "brk-blk-")))

(if (> i 30)

break)

 

{{out}}

=={{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.

 

var genericClass = Fn.new { |cname, fname|

var CFoo = genericClass.call("Foo", "bar")

var foo = CFoo.new(10)

 

{{out}}

[10, Foo]

</pre>

 

=={{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.

#if [0|1|name]

 

#ifdef name

 

#text name text

 

text, any text, inside #<<<# pairs is ignored

#<<<

"here docs:

can not span lines.";

#<<<

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:

const X=N; // → 0

println(_n); // → 2 code time is after const time

 

{{omit from|Ada}}