Trait Extract 

pub trait Extract: Sized {
    // Required method
    fn extract<'life0, 'async_trait>(
        ctx: &'life0 ResolveContext,
    ) -> Pin<Box<dyn Future<Output = Result<Self, InjectableError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
}

Axum-inspired extractor trait for dependency resolution.

Types that implement Extract can be pulled from a ResolveContext without any TypeId or dynamic downcasting. The generated provider code calls <Inject<Database> as Extract>::extract(ctx).await? for each constructor parameter.

Implementations

This trait is automatically implemented for:

• Inject<T> when T: Injectable — shared (Arc) access
• T when T: Injectable — owned value access
• Option<T> when T: Extract — optional dependency

Users never need to implement Extract manually.

Required Methods

fn extract<'life0, 'async_trait>( ctx: &'life0 ResolveContext, ) -> Pin<Box<dyn Future<Output = Result<Self, InjectableError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Extract a value from the given resolution context.

This is the core resolution method. It is called by generated provider code for each constructor parameter or struct field marked with an extractor type.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl Extract for ()

Extract for the unit type — always succeeds with ().

Useful as a factory input when no context value is needed.

fn extract<'life0, 'async_trait>( _ctx: &'life0 ResolveContext, ) -> Pin<Box<dyn Future<Output = Result<(), InjectableError>> + Send + 'async_trait>>

where 'life0: 'async_trait, (): 'async_trait,

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Extract for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)

where T1: Extract + Send + Sync + 'static, T2: Extract + Send + Sync + 'static, T3: Extract + Send + Sync + 'static, T4: Extract + Send + Sync + 'static, T5: Extract + Send + Sync + 'static, T6: Extract + Send + Sync + 'static, T7: Extract + Send + Sync + 'static, T8: Extract + Send + Sync + 'static, T9: Extract + Send + Sync + 'static, T10: Extract + Send + Sync + 'static, T11: Extract + Send + Sync + 'static, T12: Extract + Send + Sync + 'static, T13: Extract + Send + Sync + 'static, T14: Extract + Send + Sync + 'static, T15: Extract + Send + Sync + 'static, T16: Extract + Send + Sync + 'static,

fn extract<'life0, 'async_trait>( ctx: &'life0 ResolveContext, ) -> Pin<Box<dyn Future<Output = Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), InjectableError>> + Send + 'async_trait>>

where 'life0: 'async_trait, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16): 'async_trait,

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Extract for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

where T1: Extract + Send + Sync + 'static, T2: Extract + Send + Sync + 'static, T3: Extract + Send + Sync + 'static, T4: Extract + Send + Sync + 'static, T5: Extract + Send + Sync + 'static, T6: Extract + Send + Sync + 'static, T7: Extract + Send + Sync + 'static, T8: Extract + Send + Sync + 'static, T9: Extract + Send + Sync + 'static, T10: Extract + Send + Sync + 'static, T11: Extract + Send + Sync + 'static, T12: Extract + Send + Sync + 'static, T13: Extract + Send + Sync + 'static, T14: Extract + Send + Sync + 'static, T15: Extract + Send + Sync + 'static,

fn extract<'life0, 'async_trait>( ctx: &'life0 ResolveContext, ) -> Pin<Box<dyn Future<Output = Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), InjectableError>> + Send + 'async_trait>>

where 'life0: 'async_trait, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15): 'async_trait,

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Extract for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

where T1: Extract + Send + Sync + 'static, T2: Extract + Send + Sync + 'static, T3: Extract + Send + Sync + 'static, T4: Extract + Send + Sync + 'static, T5: Extract + Send + Sync + 'static, T6: Extract + Send + Sync + 'static, T7: Extract + Send + Sync + 'static, T8: Extract + Send + Sync + 'static, T9: Extract + Send + Sync + 'static, T10: Extract + Send + Sync + 'static, T11: Extract + Send + Sync + 'static, T12: Extract + Send + Sync + 'static, T13: Extract + Send + Sync + 'static, T14: Extract + Send + Sync + 'static,

fn extract<'life0, 'async_trait>( ctx: &'life0 ResolveContext, ) -> Pin<Box<dyn Future<Output = Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), InjectableError>> + Send + 'async_trait>>

where 'life0: 'async_trait, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14): 'async_trait,

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Extract for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

where T1: Extract + Send + Sync + 'static, T2: Extract + Send + Sync + 'static, T3: Extract + Send + Sync + 'static, T4: Extract + Send + Sync + 'static, T5: Extract + Send + Sync + 'static, T6: Extract + Send + Sync + 'static, T7: Extract + Send + Sync + 'static, T8: Extract + Send + Sync + 'static, T9: Extract + Send + Sync + 'static, T10: Extract + Send + Sync + 'static, T11: Extract + Send + Sync + 'static, T12: Extract + Send + Sync + 'static, T13: Extract + Send + Sync + 'static,

fn extract<'life0, 'async_trait>( ctx: &'life0 ResolveContext, ) -> Pin<Box<dyn Future<Output = Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), InjectableError>> + Send + 'async_trait>>

where 'life0: 'async_trait, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13): 'async_trait,

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Extract for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

where T1: Extract + Send + Sync + 'static, T2: Extract + Send + Sync + 'static, T3: Extract + Send + Sync + 'static, T4: Extract + Send + Sync + 'static, T5: Extract + Send + Sync + 'static, T6: Extract + Send + Sync + 'static, T7: Extract + Send + Sync + 'static, T8: Extract + Send + Sync + 'static, T9: Extract + Send + Sync + 'static, T10: Extract + Send + Sync + 'static, T11: Extract + Send + Sync + 'static, T12: Extract + Send + Sync + 'static,

fn extract<'life0, 'async_trait>( ctx: &'life0 ResolveContext, ) -> Pin<Box<dyn Future<Output = Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), InjectableError>> + Send + 'async_trait>>

where 'life0: 'async_trait, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12): 'async_trait,

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Extract for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where T1: Extract + Send + Sync + 'static, T2: Extract + Send + Sync + 'static, T3: Extract + Send + Sync + 'static, T4: Extract + Send + Sync + 'static, T5: Extract + Send + Sync + 'static, T6: Extract + Send + Sync + 'static, T7: Extract + Send + Sync + 'static, T8: Extract + Send + Sync + 'static, T9: Extract + Send + Sync + 'static, T10: Extract + Send + Sync + 'static, T11: Extract + Send + Sync + 'static,

fn extract<'life0, 'async_trait>( ctx: &'life0 ResolveContext, ) -> Pin<Box<dyn Future<Output = Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), InjectableError>> + Send + 'async_trait>>

where 'life0: 'async_trait, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11): 'async_trait,

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Extract for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where T1: Extract + Send + Sync + 'static, T2: Extract + Send + Sync + 'static, T3: Extract + Send + Sync + 'static, T4: Extract + Send + Sync + 'static, T5: Extract + Send + Sync + 'static, T6: Extract + Send + Sync + 'static, T7: Extract + Send + Sync + 'static, T8: Extract + Send + Sync + 'static, T9: Extract + Send + Sync + 'static, T10: Extract + Send + Sync + 'static,

fn extract<'life0, 'async_trait>( ctx: &'life0 ResolveContext, ) -> Pin<Box<dyn Future<Output = Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), InjectableError>> + Send + 'async_trait>>

where 'life0: 'async_trait, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10): 'async_trait,

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9> Extract for (T1, T2, T3, T4, T5, T6, T7, T8, T9)

where T1: Extract + Send + Sync + 'static, T2: Extract + Send + Sync + 'static, T3: Extract + Send + Sync + 'static, T4: Extract + Send + Sync + 'static, T5: Extract + Send + Sync + 'static, T6: Extract + Send + Sync + 'static, T7: Extract + Send + Sync + 'static, T8: Extract + Send + Sync + 'static, T9: Extract + Send + Sync + 'static,

fn extract<'life0, 'async_trait>( ctx: &'life0 ResolveContext, ) -> Pin<Box<dyn Future<Output = Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9), InjectableError>> + Send + 'async_trait>>

where 'life0: 'async_trait, (T1, T2, T3, T4, T5, T6, T7, T8, T9): 'async_trait,

impl<T1, T2, T3, T4, T5, T6, T7, T8> Extract for (T1, T2, T3, T4, T5, T6, T7, T8)

where T1: Extract + Send + Sync + 'static, T2: Extract + Send + Sync + 'static, T3: Extract + Send + Sync + 'static, T4: Extract + Send + Sync + 'static, T5: Extract + Send + Sync + 'static, T6: Extract + Send + Sync + 'static, T7: Extract + Send + Sync + 'static, T8: Extract + Send + Sync + 'static,

fn extract<'life0, 'async_trait>( ctx: &'life0 ResolveContext, ) -> Pin<Box<dyn Future<Output = Result<(T1, T2, T3, T4, T5, T6, T7, T8), InjectableError>> + Send + 'async_trait>>

where 'life0: 'async_trait, (T1, T2, T3, T4, T5, T6, T7, T8): 'async_trait,

impl<T1, T2, T3, T4, T5, T6, T7> Extract for (T1, T2, T3, T4, T5, T6, T7)

where T1: Extract + Send + Sync + 'static, T2: Extract + Send + Sync + 'static, T3: Extract + Send + Sync + 'static, T4: Extract + Send + Sync + 'static, T5: Extract + Send + Sync + 'static, T6: Extract + Send + Sync + 'static, T7: Extract + Send + Sync + 'static,

fn extract<'life0, 'async_trait>( ctx: &'life0 ResolveContext, ) -> Pin<Box<dyn Future<Output = Result<(T1, T2, T3, T4, T5, T6, T7), InjectableError>> + Send + 'async_trait>>

where 'life0: 'async_trait, (T1, T2, T3, T4, T5, T6, T7): 'async_trait,

impl<T1, T2, T3, T4, T5, T6> Extract for (T1, T2, T3, T4, T5, T6)

where T1: Extract + Send + Sync + 'static, T2: Extract + Send + Sync + 'static, T3: Extract + Send + Sync + 'static, T4: Extract + Send + Sync + 'static, T5: Extract + Send + Sync + 'static, T6: Extract + Send + Sync + 'static,

fn extract<'life0, 'async_trait>( ctx: &'life0 ResolveContext, ) -> Pin<Box<dyn Future<Output = Result<(T1, T2, T3, T4, T5, T6), InjectableError>> + Send + 'async_trait>>

where 'life0: 'async_trait, (T1, T2, T3, T4, T5, T6): 'async_trait,

impl<T1, T2, T3, T4, T5> Extract for (T1, T2, T3, T4, T5)

where T1: Extract + Send + Sync + 'static, T2: Extract + Send + Sync + 'static, T3: Extract + Send + Sync + 'static, T4: Extract + Send + Sync + 'static, T5: Extract + Send + Sync + 'static,

fn extract<'life0, 'async_trait>( ctx: &'life0 ResolveContext, ) -> Pin<Box<dyn Future<Output = Result<(T1, T2, T3, T4, T5), InjectableError>> + Send + 'async_trait>>

where 'life0: 'async_trait, (T1, T2, T3, T4, T5): 'async_trait,

impl<T1, T2, T3, T4> Extract for (T1, T2, T3, T4)

where T1: Extract + Send + Sync + 'static, T2: Extract + Send + Sync + 'static, T3: Extract + Send + Sync + 'static, T4: Extract + Send + Sync + 'static,

fn extract<'life0, 'async_trait>( ctx: &'life0 ResolveContext, ) -> Pin<Box<dyn Future<Output = Result<(T1, T2, T3, T4), InjectableError>> + Send + 'async_trait>>

where 'life0: 'async_trait, (T1, T2, T3, T4): 'async_trait,

impl<T1, T2, T3> Extract for (T1, T2, T3)

where T1: Extract + Send + Sync + 'static, T2: Extract + Send + Sync + 'static, T3: Extract + Send + Sync + 'static,

fn extract<'life0, 'async_trait>( ctx: &'life0 ResolveContext, ) -> Pin<Box<dyn Future<Output = Result<(T1, T2, T3), InjectableError>> + Send + 'async_trait>>

where 'life0: 'async_trait, (T1, T2, T3): 'async_trait,

impl<T1, T2> Extract for (T1, T2)

where T1: Extract + Send + Sync + 'static, T2: Extract + Send + Sync + 'static,

fn extract<'life0, 'async_trait>( ctx: &'life0 ResolveContext, ) -> Pin<Box<dyn Future<Output = Result<(T1, T2), InjectableError>> + Send + 'async_trait>>

where 'life0: 'async_trait, (T1, T2): 'async_trait,

impl<T1> Extract for (T1,)

where T1: Extract + Send + Sync + 'static,

fn extract<'life0, 'async_trait>( ctx: &'life0 ResolveContext, ) -> Pin<Box<dyn Future<Output = Result<(T1,), InjectableError>> + Send + 'async_trait>>

where 'life0: 'async_trait, (T1,): 'async_trait,

impl<T> Extract for Option<T>

where T: Extract + Send + Sync + 'static,

Blanket Extract implementation for Option<T> where T: Extract.

If the inner extraction fails with MissingDependency, this returns None instead of propagating the error. Other errors are propagated.

Note: This impl takes priority over the T: Injectable blanket impl for Option<T> because Option<T> does not implement Injectable.

fn extract<'life0, 'async_trait>( ctx: &'life0 ResolveContext, ) -> Pin<Box<dyn Future<Output = Result<Option<T>, InjectableError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Option<T>: 'async_trait,

Implementors

impl<T> Extract for Arc<T>

where T: Injectable,

Extract for Arc<T> where T: Injectable.

Defined inside injectable_rs_runtime (where Extract is local) so the orphan rule is satisfied. This replaces the previous special-case codegen for Arc<T> fields — the Extract impl lives in one place and any Arc<WeatherService> field just works without annotation.

Singletons: returns the cached Arc (same pointer every call). Transients: wraps a fresh instance in Arc::new.

impl<T> Extract for Inject<T>

where T: Send + Sync + 'static,

Extract implementation for Inject<T> where T: Sized + Send + Sync + 'static.

Resolution order:

1. Try resolve_external::<Arc<T>>() — finds InjectableArcFactory entries submitted by #[injectable] macros. These entries call resolve_singleton_arc internally, so singletons are properly cached.
2. Fall back to resolve_external::<T>() — finds DynProvider<T> registrations for external types, then wraps the result in Arc::new.