Contextual Logic via Generic Wrappers

In this lesson, you will learn how to inject runtime context into generic data structures by wrapping them in types that carry additional logic or metadata.

The Problem: Naked Data

Often, a generic structure (like a DataProcessor<T>) needs to behave differently depending on the "environment" or "context" it inhabits—such as whether the code is running in a production server, a unit test, or a development environment. Passing that context into every single method call is tedious and breaks your clean API.

The Solution: Contextual Wrappers

Instead of passing context through your methods, you can create a wrapper that bundles your generic type with a "context tag." By using a trait-based approach, you can define how that structure should behave based on the context type it holds.

Consider this example where we wrap a generic payload with a Context trait:

trait ExecutionContext {
    fn log_action(&self, msg: &str);
}

struct Production;
impl ExecutionContext for Production {
    fn log_action(&self, m: &str) { println!("PROD: {}", m); }
}

// Our generic wrapper
struct ContextualWrapper<T, C: ExecutionContext> {
    inner: T,
    context: C,
}

impl<T, C: ExecutionContext> ContextualWrapper<T, C> {
    fn process(&self) {
        self.context.log_action("Processing data...");
        // Logic for T goes here
    }
}

Why This Works

By wrapping your T in ContextualWrapper<T, C>, you effectively "inject" the logic of C into the lifecycle of T.

1. Static Dispatch: Because C is a generic parameter, the compiler replaces the calls to log_action with the exact implementation for your context at compile time.
2. Encapsulation: The internal data (T) doesn’t need to know about the environment. Only the wrapper handles the "where" and "how" of the execution.
3. Safety: You cannot accidentally use the wrong context for a specific piece of data because the context is part of the struct's type signature.

This pattern keeps your core logic decoupled from the environment, allowing you to swap behaviors (like logging, authentication, or caching strategies) just by changing the wrapper's type parameter.

Key Takeaway: Use generic wrappers to bind runtime environment behaviors to your data types, ensuring context-specific logic remains decoupled from your core business entities.