What is metaprogramming?

Sadly there is no single definition on which everybody agrees. So let’s investigate

Metaprogramming is a programming technique in which computer programs have the ability to treat other programs as their data.


Metaprogramming refers to a variety of ways a program has knowledge of itself or can manipulate itself.

Popular answer at stackoverflow

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



We don’t have one good definition, so let’s see examples. When people talk about metaprogramming they may refer to:

Those are just some examples - a lot of languages support metaprogramming.

Two categories

Metaprogramming styles can be roughly divided into two categories:

  • ones which work with source code (macros, preprocessors, templates). Often referred to as “macros”
  • ones which are based on “OOP tricks” (like, dynamic dispatch and reflections) to provide additional behavior. I don’t think it has a name, so I will call it “dynamic”.
compile timeruntime
macros in Lisp?+
Preprocessor, templates+
Dynamic metaprogramming+

Dynamic metaprogramming

Metaprogramming is writing code that manipulates language constructs (itself) at runtime.

– Metaprogramming Ruby

In Ruby, it seems, metaprogramming is used more often than in other dynamically typed languages, especially in Rails, for example: Path and URL Helpers.

The downside of dynamic metaprogramming is that there is no source code for the “thing”: you see a function, but you don’t understand where it is defined. It breaks “grep test”.

The second downside is that it tends to be slower, for example, see Rails/DynamicFindBy.


Main use cases:

  • remove code repetition (DRY). For example, David Beazley shows a lot of examples in the talk.
  • create embedded domain-specific language (EDSL). Martin Fowler calls them Internal DSLs. For example, Sass (Ruby EDSL that translates to CSS), haml (Ruby EDSL that translates to HTML), Active Record Query Interface (Ruby EDSL that translates to SQL), rake (Ruby EDSL to replace make), chief
  • “extend language”

About extending the language

How can we extend the language? We can add more words to it (extend lexicon), we can add more rules on how words can combine (extend syntax).

We can easily add more words, for example, define new functions, modules, variables. But not all kinds of words - most likely we limited to what grammar of language allows to use as identifiers (for example, I can’t define new word :?:). In Ruby and Python it is possible to overload operators (+,-,>,<, etc.) but not to define new ones.

As far as I can tell none of those languages allow me to define new syntax rules, for example, I can’t define my version of if/else.

But programmers always find a way around it - it is possible to reuse existing syntax, to make it look like another syntax. For example, there is a beautiful concept of pattern matching in functional languages. OCaml:

1match value with
2| pattern    ->  result
3| pattern    ->  result

or Scheme:

1(let ((l '(hello (world))))
2  (match l
3    ((x y)
4     (values x y))))

And this is how it can be done in JavaScript:

1const { matches } = require("z");
2const result = matches(1)(
3  (x = 2) => "number 2 is the best!!!",
4  (x = Number) => `number ${x} is not that good`,
5  (x = Date) => "blaa.. dates are awful!"

It’s an old syntax, but if you squint enough it looks like pattern matching in OCaml. Behind the scene, it uses toString to inspect actual code, because there are (were?) no first-class reflections.

Another noticeable technique in this area is “chaining” (for example, jQuery and Active Record Query Interface).


We have closely investigated the following eight macro languages and their individual semantic characteristics: the C preprocessor, CPP[11, 19]; the Unix macro preprocessor, M4; TEX’s built-in macro mechanism; the macro mechanism of Dylan[18]; the C++ templates[21]; Scheme’s hygienic macros[10, 13]; the macro mechanism of the Jakarta Tool Suite, JTS[2]; and the Meta Syntactic Macro System, MS2[26]. The JSE system [1] is a version of Dylan macros adapted to Java and is not treated independently here. This survey has led us to identify and group 32 properties that characterize a macro language and which we think are relevant for comparing such work.

Growing Languages with Metamorphic Syntax Macros

Macros are quite a broad category, but let’s see examples of usage to get the idea.

Syntax extension

In Lisp if/elsse expression looks like this:

1(if condition
2  (print 1)
3  (print 2))

It is easy to define a function with the same structure:

1(my-if condition
2  (print 1)
3  (print 2))

the problem is that in Lisp arguments are eagerly evaluated, which means it will execute both then and else branches, before even passing them to the function. That is where macros come into play. With macros, it is possible to implement my-if which would behave as you expect.

See also:


JSX is an XML-like syntax extension to ECMAScript without any defined semantics

Draft: JSX Specification

It is essentially a DSL. And babel plugin responsible for compiling it is a preprocessor. You can use other metaprogramming techniques to achieve the same-ish result - see alternatives to JSX.


…polymorphic languages in which some values and variables may have more than one type. Polymorphic functions are functions whose operands (actual parameters) can have more than one type. Polymorphic types are types whose operations are applicable to values of more than one type.

On Understanding Types, Data Abstraction, and Polymorphism

It came to me as a surprise. There are:

  • dynamically typed languages, which are very flexible (but is also easy to shoot yourself in the foot)
  • statically typed languages with full polymorphism support, like OCaml, Haskell, etc.
  • statically typed languages without polymorphism (Pascal, Go) or with some limitations in polymorphism

Programming languages from the last category may use metaprogramming to achieve something that feels like polymorphism (“improve flexibility”).

In golang there is no parametric polymorphism (or “type parameters”, or “generics”). So people created workarounds, for example, gengen (similar solutions genny, generic, gen):

1package list
3import ""
5type List struct {
6    data generic.T
7    next *List

Then you need to run the preprocessor

1$ gengen string

And you will get code with exact types:

1package list
3type List struct {
4    data string
5    next *List

See also: Who needs generics? Use … instead!, The Next Step for Generics.


Template metaprogrammers exploit this machinery to improve: source code flexibility and runtime performance

Walter E. Brown “Modern Template Metaprogramming: A Compendium, Part I”

In C++ there is function overloading (i.e. kind of polymorphism), but it creates a lot of repetion:

1double abs(double x) {
2  return (x >= 0) ? x : -x;
4int abs(int x) {
5  return (x >= 0) ? x : -x;

Instead you can write (function template):

1template<typename T>
2T abs(T x) {
3  return (x >= 0) ? x : -x;


It is often claimed that macro expansion at compile time can improve performance. It sounds reasonable to me, but I don’t have good examples.

Related: Compile-time reflection and compile-time code execution in Zig.

Macros and types

Lisp (and Scheme) macros are very powerful, but… they don’t work well with static type checkers. We can assume that we have macros that are guaranteed to terminate and we can expand them at compile time (syntax sugar) and type check generated code, the next problem is that type error can be reported in the generated code and it will be confusing.

There are different attempts to make macros work better with static types, for example:

See also:

Other languages

Other languages with interesting metaprogramming facilities which I haven’t explored closely, but want to check later:


Interestingly, some languages, which doesn’t seem to support macros have quotation facilities. I need to dig deeper there:

Except where otherwise noted, content on this site is licensed under Creative Commons Attribution-NonCommercial-ShareAlike 4.0