Domain Logic Embedding

In this lesson, you will learn how to bake domain-specific rules directly into your binary at compile time, bypassing the overhead of runtime dispatch and state machines.

The Problem: Runtime Tax

In many high-performance systems, we define domain logic (such as validation rules, routing tables, or state transition matrices) as data structures. At runtime, the application iterates over these structures to make decisions. This introduces branches, cache misses, and memory overhead. "Domain Logic Embedding" shifts this computation into the compiler, transforming your logic into hardcoded, machine-optimized instructions before the executable is ever built.

Embedding Logic via Macros

Rather than parsing a configuration file or traversing a graph at runtime, you can write a procedural macro that parses your domain rules during expansion. The macro then generates a static implementation—such as a series of match arms or constant lookup arrays—that the compiler can optimize aggressively.

For example, consider a routing validator. Instead of a HashMap<Route, Permission>, you can define a macro that generates a custom is_allowed function:

// Macro usage
validate_routes! {
    "/admin" => Admin,
    "/user"  => User,
}

// Generated output (compiled directly into the binary)
fn is_allowed(path: &str, role: Role) -> bool {
    match (path, role) {
        ("/admin", Role::Admin) => true,
        ("/user", Role::User) => true,
        _ => false,
    }
}

By embedding the routing logic into a match expression, the compiler can use jump tables or decision trees to evaluate the authorization in constant time. There is no HashMap to allocate, no hashing function to execute, and no heap lookup. The logic is effectively "folded" into the hardware's execution flow.

When to Use This

This pattern is ideal for "stable" domain logic that doesn't change without a full recompilation. By embedding the logic, you trade compilation speed for absolute runtime efficiency. The macro acts as an optimizing compiler for your domain-specific language, translating high-level business rules into low-level machine code patterns that satisfy the Rust compiler’s borrow checker and optimizer simultaneously.

Key Takeaway: Domain Logic Embedding transforms declarative business rules into static, inlineable Rust code, eliminating runtime interpretation overhead by turning data into machine instructions.