▲ 99 points
back
71 comments
Factorial macro example in C++23 metaprogramming,
#include <iostream>
consteval long factorial (int n) {
if (n == 0) return 1;
return n * factorial(n - 1);
}
int main() {
std::cout << factorial(7) << std::endl;
}
-- https://godbolt.org/z/TWe11hM6j
Nicely put 5040 in ESI register at compile time.
Granted, C++ isn't Lisp, but already has quite a room for creativity at compile time, and C++26 might finally have compile time reflection as well.
The terms "macro" and "metaprogramming" already have well-defined meanings in the C++ community. You're just hijacking the terms and using them with some new definition.
The C++ standard is consistent in how it uses "macro," and it's strictly about the preprocessor kind of macros. "Metaprogramming" is also used in the standard, though not as extensively or rigidly (only 8 times in N4950), but both in the specification and colloquially it's more than just slapping consteval on a function.
While I agree regarding the macro term, consteval very much count as metaprogramming in C++.
There is no reason to encode value computations using template expansion anymore. Even a lot of type level computation can be done via plain function calls and decltype. "Old school" recursive template installation is really only needed when you need specifically the capability to pattern match on types of template specialization.
Yeah, because using preprocessor macros would do the trick. /s
macro programming in Lisp would be "programming programs".
I don't see it here. This looks like compile-time execution to compute values. If it would be a macro, it could return source code.
In general, a macro produces code at compile time, doesn't matter in which form it ends up in the binary, as long as the observable side effects are the same.
Example of a library that generates serialization code, https://github.com/getml/reflect-cpp
As mentioned the ongoing C++26 proposal with produce the desired source code at compile time, thus reducing the amount of code of libraries such that one.
Some people are calling this "multistage programming" [1] which is kind of related but not exactly the same as a macro system.
--
For n<=8, GCC will also just inline it for the naive version in C: https://godbolt.org/z/TvdcTvEKx
That’s neither a macro nor template metaprogramming.
one fundamental difference being that clisp (i keep writing this as 'clips', talk about lisp !) does not suffer from precision issues, f.e. writing this
[1]> (defmacro factorial (n)
(labels ((fact (m)
(if (= m 0)
1
(* m (fact (1- m)))))) `,(fact n)))
[2]> (factorial 1000) [3]>
for the c++ version i don't think even `unsigned long long` can accommodate results from larger than approx. 21! or thereabouts.
It's always braggable to be able to do that more than another language, but I'm not sure how mainstream or common it is to have the use case of requiring numerical manipulation at the scale of number of molecules in the universe
That is when you would take advantage of C++ type system and use a class implementing multi-precision numbers and operator overloading.
clisp is an unfortunately named specific implementation of common lisp, like sbcl ecl clasp ccl abcl etc.
That is not a macro.
I doubt a #define would suffice.
Common misconception of non Lispers that macros are equivalent to compile time programming. You’re not simply moving the evaluation to compile time, you’re moving it upwards outside the program space into a higher dimension of programmability.
Not to dog on C++ unfairly, CTE is pretty neat after all.
Funnily enough, PGs “On Lisp” has some really neat macros in it that demonstrate capabilities that just can’t be replicated with template based macros, iirc.
"outside the program space into a higher dimension of programmability"
I can visualize this metaphor just fine, but I can't tell why it's useful. Can you make this concept more concrete?
This is probably not the whole picture, and I have a very Rust-centric view of this, but I'll take a stab at it.
The correct analogue for Lisp macros is not C++ templates, but the C preprocessor itself. Specifically, a Lisp macro gets to take a particular section of code and change it as it wishes, with everything already conveniently tokenized for the programmer's convenience. Imagine if you could just write your own C preprocessor as part of your program and have the compiler automatically execute it on specific program areas that want your preprocessing.
Rust macros work similarly to this, the main difference being your syntax needs to be tokenizable as Rust instead of Lisp. But they're also rather powerful. So, for example, in Rust you only have one object system which has structs, traits, and very limited higher-kindedness[0]. But there's plenty of other object systems Rust would like to interop with: Objective-C, Swift, COM, and C++ among others.
The canonical way of doing this in Rust is to write a macro[1] that takes your class definition and converts it into a series of structs, traits, and/or function pointers that suitably interop with the foreign code. Code outside the macro then can reference the class created by the system.
If you don't have macros, your other options are:
- Metaclasses, which are the canonical way in Python of doing foreign object interfaces, though with an added wrinkle: multiple inheritance from classes of different metaclasses requires writing a combined metaclass that does both. In macros you usually just can't mix them like that, though I doubt you'd need to define a single class accessible from, say, both Objective-C and Windows COM.
- Write your own damned preprocessor. This is what Qt did with MOC (metaobject compiler) to get signals and slots[2]. If C++ had macros, Trolltech probably would have written MOC as a macro instead of a separate build step with a separate C++ tokenizer.
[0] A concept which I will not be explaining in this post, but it has to do with things like generic associated types which were needed for lifetime bounds on async traits
[1] Usually a "procedural macro", which is different from the pattern-matching macros Rust usually teaches in ways that don't matter here
it's "meta" programming, since Lisp macros do source transformations: code to new code. So one writes code which will rewrite code. For example some programming language lacks a control structure one would want. Instead of waiting for the benevolent dictator for life implementing this feature, one can do it by creating a macro, which implements the control structure.
For example, imagine that you want to program with state machines and you need a short notation for that in your programming language. In Lisp you could design a syntax for a state machine and the Lisp macro would transform state machine descriptions into the code used to implement them -> the generated code typically will be longer and full of implementation details -> in the state machine description one would only specify what's necessary. The Lisp macro will do the code transformation from using the new control structure to the implementation of the control structure.
Thus one can view Lisp as a programmable programming language.
Let’s say, you’re writing a web application. In most programming language you’d be using libraries or rely on a framework. With Lisp macros, you can program the archetype of a web application. And then use a simpler language to describe you application. Think of it as programmable snippets. Something like Ultisnips [0], but inherent to the language.
Think how much common code can exist in a software but cannot be refactored to a functions because it will have too many variables. Or the multiple problems with classes tree and overloading. Macros let you solve that.
I think an example would be helpful, conditionals:
Within the "program dimension" there is just no way to run code conditionally without an if, no matter how much you move left and right, you are constrained. It is only possible by using the "higher dimension".
Speaking frankly, I firmly believe it’s all a matter of taste. I like lisp because it matches the way I approach problems. I like to think of the program as a jig I’m building rather than a static component.
Being able to write macros means I can write code the SHAPE that I want, regardless of underlying implementation, but I can also manipulate other equivalently meta forms as well as primitives, which sets it at a higher level than templates.
I’m terrible at explaining, but if you’ve never tried lisp I strongly and wholeheartedly suggest you give it a try. For learning, I’d recommend Racket. Try and get at least as far as syntax-rules and syntax-case.
Anyways, sorry for the bad explanation!
You can give the language new features, using the features that the language provides.
(defmacro factorial (n)
(labels ((fact (m)
(if (= m 0)
1
(* m (fact (1- m))))))
`,(fact n)))
Thus, this is okay:
(defmacro factorial (n)
(labels ((fact (m)
(if (= m 0)
1
(* m (fact (1- m))))))
(fact n)))
CL-USER > (macroexpand-1 '(factorial 10))
3628800
TAgreed with the technical content and conclusion. However, I think it is worth pointing out that since C++11, it has had a mechanism to specify (maybe) compile-time computations that are written in plain C++: constexpr, https://en.cppreference.com/w/cpp/language/constexpr
(My parenthetical "maybe" is that I don't think compilers have to compute constexpr expressions at compile time. The compiler will be forced to when such expressions are used in contexts that require values at compile time. But I think it would be permissible for a compile to defer computation of a constexpr to runtime if the value isn't needed until runtime.)
Note that C++20 introduced consteval as a means to enforce compile time computation. See https://en.cppreference.com/w/cpp/language/consteval
Besides consteval and constinit, you can force evaluation with static constexpr.
Lisp macros can take arbitrary parameters and are written in lisp.
C++ macros can only take types and numbers (until variadic), and writing any code to operate on those inputs is challenging.
https://github.com/knome/metabrainfuck/blob/master/bf.cpp
It's not too bad :)
As a code golfer, this is beyond satisfying. Doing things in a few bytes is nice, yes, but doing them in a way no reasonable mortal ever would is even better.
There is the lisp meme “mom can we have defmacro? No we have defmacro at home”
The post is actually about template metaprogramming. 'template macroprogramming' isn't really a thing.
Yes, the purpose of C++ templates (not macros, macros are C preprocessor) is to implement generic classes and functions, not to implement arbitrary computation, and (iirc) it was only discovered after their publication that they are in fact Turing-complete.
C++ templates can also take other C++ templates (the template itself, not just an instantiation), enum values and I think in C++23 maybe even structs but I need to check
C++20 added the ability to take class instances as non-type parameters but the rules around the types of classes that can be used in this way are pretty restrictive (for good reason).
C++ templates do have the advantage that they can dispatch on their argument types. Lisp macros are expanded at a purely syntactic level, well before the compiler attempts to do any type deduction, and you cannot provide different macro expansions for different argument types without heroic efforts (which will most likely be specific to a single Lisp compiler). Dispatching on argument types is very useful in expression template based metaprogramming, for example in the Eigen library for linear algebra (https://eigen.tuxfamily.org/).
Another post comparing C and lisp Macros: http://lists.warhead.org.uk/pipermail/iwe/2005-July/000130.h...
HN discussion: https://news.ycombinator.com/item?id=31199992
It’s clumsy because C++ templates are an implementation of generic and dependent types, while C++ constexpr and consteval functions are for arbitrary computation. The fact that template metaprogramming _can_ be used for arbitrary computation is actually an unhappy accident of its design that was only proven after its publication.
Macaroni art versus the Mona Lisa.
Does this article have a (2002) that I missed or something?
I hate to agree. For an article about metaprogramming in C++, you'd expect expert level C++ code, and not what's presented here. It's bad. And the first example with the list even has a bug.
I don’t have any experience with Lisp. But I think C++ templates and Rust macros are both super bad and impoverished compared to what can be done in Jai.
https://www.forrestthewoods.com/blog/using-jais-unique-and-p...
Except Jai is never going to get the use any of them have, so we use what is there.
> I can't find a decent C++ units system. If one existed it would involve similarly grotesque templates full of std::enable_if and assorted wizardry.
Boost.Units is 20 years old. There is an unit system built in in c++11 just for duration, but shows what it can be done. There is no reason ever to use enable_if since C++20.
> Here's where Jai has a feature I've never seen before. I'm sure it exists in some language, but certainly not C++ or Rust!
The feature is #modify which is not needed in C++; for historical reasons, typically type level metaprogramming still different from value level, but it is not hard:
https://gcc.godbolt.org/z/PbzKeh38a
The `#modify` thing looks pretty cool, but I can't help but think how a compiler/ide is supposed to analyze the body of such function and provide suggestions. Rust macros have a similar issue, but it's offsetted by the fact that generics are pretty powerful too and can be fully analyzed by the compiler.
The "next" field in the lead code sample is supposed to be a pointer, right?
Pffft, I’d just #. that factorial call and it’d be a normal defun.