Top 1,000 Features Creators Resources Extensions Blog Explorer CSV Download
GitHub icon

Macros

< >
Example from 1 languages: C
// https://learn.microsoft.com/en-us/cpp/preprocessor/macros-c-cpp?redirectedfrom=MSDN&view=msvc-170 // https://gcc.gnu.org/onlinedocs/cpp/Macro-Arguments.html #define min(X, Y) ((X) < (Y) ? (X) : (Y)) x = min(a, b); → x = ((a) < (b) ? (a) : (b)); y = min(1, 2); → y = ((1) < (2) ? (1) : (2)); z = min(a + 28, *p); → z = ((a + 28) < (*p) ? (a + 28) : (*p));
Example from 1 languages: Rust
// https://doc.rust-lang.org/book/ch19-06-macros.html #[macro_export] macro_rules! vec { ( $( $x:expr ),* ) => { { let mut temp_vec = Vec::new(); $( temp_vec.push($x); )* temp_vec } }; }
Example from 1 languages: Scala
// https://docs.scala-lang.org/scala3/guides/macros/macros.html import scala.quoted.* // imports Quotes, Expr def inspectCode(x: Expr[Any])(using Quotes): Expr[Any] = println(x.show) x
Example from 1 languages: Clojure
; https://www.braveclojure.com/writing-macros/ ; https://clojure.org/reference/macros (defmacro and "Evaluates exprs one at a time, from left to right. If a form returns logical false (nil or false), and returns that value and doesn't evaluate any of the other expressions, otherwise it returns the value of the last expr. (and) returns true." {:added "1.0"} ([] true) ([x] x) ([x & next] `(let [and# ~x] (if and# (and ~@next) and#))))
Example from 1 languages: Elixir
# https://hexdocs.pm/elixir/Macro.html defmodule Example do defmacro macro_inspect(value) do IO.inspect(value) value end def fun_inspect(value) do IO.inspect(value) value end end
Example from 1 languages: Julia
# https://jkrumbiegel.com/pages/2021-06-07-macros-for-beginners/ macro show_value(variable) quote println("The ", $(string(variable)), " you passed is ", $(esc(variable))) end end @show_value(orange) @show_value(apple)
Example from 1 languages: Erlang
-define(Const, Replacement). -define(Func(Var1,...,VarN), Replacement).
Example from 1 languages: Prolog
term_expansion(parent_child(Parent, Child), child_parent(Child, Parent)). parent_child(trevor, simon). % With the above definitions, we can query (even though the predicate child_parent/2 is nowhere explicitly defined in the code above): ?- child_parent(Child, Parent). Child = simon, Parent = trevor.
Example from 1 languages: Nim
# https://hookrace.net/blog/introduction-to-metaprogramming-in-nim/#macros import macros dumpTree: result = 10
Example from 1 languages: Racket
; https://docs.racket-lang.org/guide/macros.html (define-syntax-rule (swap x y) (let ([tmp x]) (set! x y) (set! y tmp)))
Example from 1 languages: Scheme
(define-syntax backwards (syntax-rules () ((_) (syntax-error "(backwards) not allowed")) ((_ e) e) ((_ e1 ... e2) (begin e2 (backwards e1 ...)))))
Example from 1 languages: C3
macro square(x) { return x * x; }
Example from 1 languages: Nemerle
// http://nemerle.org/About def title = "Programming language authors"; def authors = ["Anders Hejlsberg", "Simon Peyton-Jones"]; // 'xml' - macro from Nemerle.Xml.Macro library which alows to inline XML literals into the nemerle-code def html = xml <# <html> <head> <title>$title</title> </head> <body> <ul $when(authors.Any())> <li $foreach(author in authors)>$author</li> </ul> </body> </html> #> Trace.Assert(html.GetType().Equals(typeof(XElement))); WriteLine(html.GetType());
Example from 1 languages: Dylan
define macro table { table(?table-class:expression, ?table-contents) } => { let ht = make(?table-class); ?table-contents; ht; } { table(?rest:*) } => { table(<table>, ?rest); } table-contents: { } => { } { ?key:expression => ?value:expression, ... } => { ht[?key] := ?value; ... } end macro table
Example from 1 languages: Arc
; http://www.arclanguage.org/tut.txt ; We know enough now to start writing macros. Macros are basically ; functions that generate code. Of course, generating code is easy; ; just call list. ; ; arc> (list '+ 1 2) ; (+ 1 2) ; ; What macros offer is a way of getting code generated this way into ; your programs. Here's a (rather stupid) macro definition: ; ; arc> (mac foo () ; (list '+ 1 2)) ; *** redefining foo ; #3(tagged mac #<procedure>) ; ; Notice that a macro definition looks exactly like a function ; definition, but with def replaced by mac. ; ; What this macro says is that whenever the expression (foo) occurs ; in your code, it shouldn't be evaluated in the normal way like a ; function call. Instead it should be replaced by the result of ; evaluating the body of the macro definition, (list '+ 1 2). ; This is called the "expansion" of the macro call.
Example from 1 languages: Pike
#define CYCLES 20
Example from 1 languages: groff
.de P . br . sp .8v ..
Example from 1 languages: High Level Assembly
// _SortCases_ // // This routine does a bubble sort on an array // of _caseRecord_ objects. It sorts in ascending // order using the "value" field as the key. // // This is a good old fashioned bubble sort which // turns out to be very efficient because: // // (1) The list of cases is usually quite small, and // (2) The data is usually already sorted (or mostly sorted). macro _SortCases_( ary, size ):i, bnd, didswap, temp; ?bnd := size - 1; ?didswap := true; #while( didswap ) ?didswap := false; ?i := 0; #while( i < bnd ) #if( ary[i].value > ary[i+1].value ) ?temp := ary[i]; ?ary[i] := ary[i+1]; ?ary[i+1] := temp; ?didswap := true; #endif ?i := i + 1; #endwhile ?bnd := bnd - 1; #endwhile; endmacro;
Example from 1 languages: Bel
; A macro is essentially a function that generates code. I would have ; liked the first example of a macro to be something simpler, but fn ; is the one we need first. So I'll introduce macros using a simpler ; macro that isn't part of Bel, then explain fn. ; Here is a very simple macro: (mac nilwith (x) (list 'cons nil x))
Example from 1 languages: Wax
(@define MY_CONSTANT 5) (@if MY_CONSTANT 5 (print "yes, it's") (print @MY_CONSTANT) )
Example from 1 languages: YAMP
- defmacro: name: foo args: [who] value: Hello: who - foo: who: World
*

Languages with Macros include C, Rust, Scala, Clojure, Elixir, Julia, Erlang, Prolog, Nim, Racket, Scheme, Factor, C3, Slope, Nemerle, Dylan, Arc, Pike, groff, Gerbil Scheme, High Level Assembly, Speedie, Bel, Wax, YAMP, honu

*

Languages without Macros include JavaScript, Python, Java, HTML, JSON, XML, Kotlin, Smalltalk, progsbase

*

View all concepts with or missing a hasMacros measurement

*

Read more about Macros on the web: 1.

View source

- Build the next great programming language · About · Acknowledgements · Part of the World Wide Scroll