Makroexpansion

Makroexpansion, or macro expansion, is a metaprogramming technique used in certain programming languages to generate or transform code automatically. A macro defines a rule or set of rules for producing new code when invoked with arguments, allowing programmers to extend the language syntax or automate repetitive patterns without changing the compiler.

Macro expansion typically occurs at compile time or during preprocessing. When a macro is invoked, its body is substituted with the result of applying the macro rules to the supplied arguments. The resulting code is then compiled or interpreted as if written directly by the programmer.

Macro systems vary in how they handle name binding and scope. Non-hygienic macros perform simple textual substitution, which can lead to variable capture and subtle bugs. Hygienic macros, by contrast, preserve lexical scope and automatically rename introduced identifiers when needed. Examples include the Lisp and Scheme macro systems (defmacro, syntax-rules) and Rust's macro_rules! and procedural macros; C's preprocessor macros are an older, widely used example but are non-hygienic and can be error-prone.

Benefits of macro expansion include abstraction beyond functions, the creation of domain-specific languages, and reduction of boilerplate. They enable compile-time code generation and DSL embedding, improving expressiveness in some contexts. Drawbacks include potential difficulties in debugging, complexity of macro hygiene, and code that can be harder to read or reason about.

In practice, macro expansion is central to languages with powerful metaprogramming facilities and has a long history dating back to early Lisp systems. It remains a design trade-off among expressiveness, safety, and performance.