Nonmacro

Nonmacro is a term used in programming discussions to describe code, libraries, or tooling that does not rely on macros for code generation or transformation. It is not a formal feature in most languages, but a category used to contrast macro-based approaches with conventional constructs such as functions, inline routines, templates, or runtime abstractions. The term is encountered in discussions of languages that support macros, including Lisp, C, C++, and Rust, where developers weigh macro systems against non-macro alternatives.

In practice, a nonmacro approach relies on explicit, non-expansive constructs rather than macro definitions. Examples include using plain or inline functions instead of function-like macros, or using templates and generic programming instead of syntactic macros. This emphasizes straightforward semantics, easier debugging, and more predictable behavior at compile time or runtime.

Benefits of nonmacro code typically include improved readability, simpler debugging, better type checking, and easier tooling integration. Nonmacro code is generally more portable across compilers and platforms and often integrates more cleanly with static analysis and refactoring tools. However, macros can provide powerful metaprogramming capabilities, enabling domain-specific languages or boilerplate reduction where nonmacro solutions would be verbose or repetitive. The choice between macro and nonmacro approaches depends on the goals of abstraction, performance, safety, and maintenance.

In practice the term nonmacro appears in API design guidelines, compiler documentation, and discussions of macro hygiene, where it serves to distinguish non-transformative constructs from macro-based patterns.