Macro init 

init!() { /* proc-macro */ }

Simplify provider initialisation by automatically creating the chain of intermediate providers.

Instead of manually defining intermediate providers and chaining .provide() calls, use init! with the list of module types in dependency order.

Expression form

Returns the provider as an owned value. Works with struct-level #[export] (owned values).

use nject::{init, injectable, module, provider};

#[injectable]
#[module]
#[export(i32, 42)]
struct ConfigModule;

#[injectable]
#[module]
#[export(String, |x: i32| format!("value: {}", x))]
struct FormatModule;

#[injectable]
#[provider]
struct AppProvider(#[import] ConfigModule, #[import] FormatModule);

let provider: AppProvider = init!(ConfigModule, FormatModule);
let greeting: String = provider.provide();
assert_eq!(greeting, "value: 42");

Block form

Expands let declarations into the enclosing scope, keeping intermediate providers alive. This supports field-level #[export] (references) and multiple declarations (like lazy_static!).

use nject::{init, injectable, module, provider};

#[derive(Debug)]
#[injectable]
struct Secret(#[inject(42)] i32);

#[injectable]
#[module]
struct SecretModule {
    #[export]
    secret: Secret,
}

#[injectable]
struct Consumer<'a>(&'a Secret);

#[injectable]
#[provider]
struct AppProvider(#[import] SecretModule);

init! {
    let provider: AppProvider = SecretModule;
}
let consumer: Consumer = provider.provide();
assert_eq!(consumer.0.0, 42);