Next up is define-compiler-macro. This provides the programmer with an optimization option that has no parallel in C++. To begin, I’m going to point to the entry in the CLHS, which has a good example of when this might be useful.
What this macro does is to provide a way for a programmer to rewrite forms in the program based on information available at compile-time. The substituted forms should be alternative ways at arriving at the same result, but presumably in a way that is more efficient given the context. Note that this is not a way to specialize on information available at run-time, such as the types of variables, or their values, but is a way for the compiler to look at the way some forms are built up after macro substitution, and possibly improve the efficiency by conditionally rewriting those forms before the compiler acts on them.
One common use of this macro is in the context of expensive functions with no side-effects, being passed literal constants. The programmer can use define-compiler-macro to move the calculations to compile-time, and so avoid the cost of performing that calculation every time the running program encounters it, while leaving the code intact in the case that the arguments are unknown at compile time.
As pointed out in the CLHS, the programmer may not use this to write optimizations of the Lisp language functions themselves, and is encouraged to restrict the implementation of define-compiler-macro forms to code that the programmer is responsible for maintaining.