Metaprogramming: Difference between revisions

 

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

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.

 

 

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

 

=={{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 + ;

 

BEGIN

WHILE

 

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

<pre>

R o s e t t a

</pre>

 

 

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|Kotlin}}==

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

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

[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|PicoLisp}}==

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

 

=={{header|Run BASIC}}==

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

 

' create a file to be run

' RB can run the entire program

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|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}}

#:brk-blk-0062))

(prinl i))))</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}}

{{omit from|AWK}}

{{omit from|bc}}

{{omit from|JavaScript}}

{{omit from|sed}}