Trait SomeStaticExecutor 

pub trait SomeStaticExecutor: 'static + Debug {
    type ExecutorNotifier: ExecutorNotified;

    // Required methods
    fn spawn_static<F, Notifier: ObserverNotified<F::Output>>(
        &mut self,
        task: Task<F, Notifier>,
    ) -> impl Observer<Value = F::Output>
       where Self: Sized,
             F: Future + 'static,
             F::Output: 'static + Unpin;
    fn spawn_static_async<F, Notifier: ObserverNotified<F::Output>>(
        &mut self,
        task: Task<F, Notifier>,
    ) -> impl Future<Output = impl Observer<Value = F::Output>>
       where Self: Sized,
             F: Future + 'static,
             F::Output: 'static + Unpin;
    fn spawn_static_objsafe(
        &mut self,
        task: ObjSafeStaticTask,
    ) -> BoxedStaticObserver;
    fn spawn_static_objsafe_async<'s>(
        &'s mut self,
        task: ObjSafeStaticTask,
    ) -> BoxedStaticObserverFuture<'s>;
    fn clone_box(&self) -> Box<DynStaticExecutor>;
    fn executor_notifier(&mut self) -> Option<Self::ExecutorNotifier>;
}

A trait for executors that can spawn static, non-Send tasks.

This trait is designed for executors that can handle futures with a 'static lifetime but without the Send bound. This is useful for cases where you need static data without the overhead of Send synchronization.

Unlike SomeExecutor which requires Send and SomeLocalExecutor which supports arbitrary lifetimes, SomeStaticExecutor specifically targets the middle ground of static lifetime without Send requirements.

Use Cases

• Thread-local static data access
• Executors that work with static futures but don’t need Send
• Applications with static lifetimes but thread-local execution
• Bridge between local and global executor patterns

Required Associated Types

type ExecutorNotifier: ExecutorNotified

The notifier handle that can wake or signal work for this executor.

Required Methods

fn spawn_static<F, Notifier: ObserverNotified<F::Output>>( &mut self, task: Task<F, Notifier>, ) -> impl Observer<Value = F::Output>

where Self: Sized, F: Future + 'static, F::Output: 'static + Unpin,

Spawns a static, non-Send future onto the runtime.

Parameters

• task: The task to spawn containing a ’static future

Note

The future must be 'static but does not need to be Send. This allows for static data access without the synchronization overhead of Send.

Implementation notes

For details on why F::Output is Unpin, see the comment on observer::TypedObserver.

fn spawn_static_async<F, Notifier: ObserverNotified<F::Output>>( &mut self, task: Task<F, Notifier>, ) -> impl Future<Output = impl Observer<Value = F::Output>>

where Self: Sized, F: Future + 'static, F::Output: 'static + Unpin,

Spawns a static, non-Send future onto the runtime.

Like Self::spawn_static, but some implementors may have a fast path for the async context.

Implementation notes

For details on why F::Output is Unpin, see the comment on observer::TypedObserver.

fn spawn_static_objsafe( &mut self, task: ObjSafeStaticTask, ) -> BoxedStaticObserver

Spawns a static, non-Send future onto the runtime.

Note

This differs from Self::spawn_static in that we take a boxed future, since we can’t have generic fn. Implementations probably pin this with Box::into_pin.

fn spawn_static_objsafe_async<'s>( &'s mut self, task: ObjSafeStaticTask, ) -> BoxedStaticObserverFuture<'s>

Spawns a static, non-Send future onto the runtime.

Note

This differs from Self::spawn_static in that we take a boxed future, since we can’t have generic fn. Implementations probably pin this with Box::into_pin.

fn clone_box(&self) -> Box<DynStaticExecutor>

Clones the executor.

The returned value will spawn tasks onto the same executor.

fn executor_notifier(&mut self) -> Option<Self::ExecutorNotifier>

Produces an executor notifier.

Trait Implementations

impl<UnderlyingNotifier: ExecutorNotified> SomeStaticExecutor for Box<dyn SomeStaticExecutor<ExecutorNotifier = UnderlyingNotifier>>

Implementation of SomeStaticExecutor for boxed static executor trait objects.

This implementation enables Box<dyn SomeStaticExecutor> to act as a static executor, supporting !Send futures through type erasure. This is particularly useful for single-threaded or local executors.

Differences from SomeExecutor

Unlike the SomeExecutor implementation, this works with futures that are not Send, making it suitable for JavaScript/WASM environments or thread-local execution contexts.

Examples

let mut executor: Box<dyn SomeStaticExecutor<ExecutorNotifier = Infallible>> = todo!();

// Can spawn !Send futures
let rc = Rc::new(42);
let task = Task::without_notifications(
    "rc-task".to_string(),
    Configuration::default(),
    async move { *rc }
);

fn spawn_static<F, Notifier: ObserverNotified<F::Output>>( &mut self, task: Task<F, Notifier>, ) -> impl Observer<Value = F::Output>

where Self: Sized, F: Future + 'static, F::Output: 'static + Unpin,

Spawns a static (potentially !Send) future onto the underlying executor.

This method supports futures that don’t implement Send, making it suitable for single-threaded environments.

async fn spawn_static_async<F, Notifier: ObserverNotified<F::Output>>( &mut self, task: Task<F, Notifier>, ) -> impl Observer<Value = F::Output>

where Self: Sized, F: Future + 'static, F::Output: 'static + Unpin,

Asynchronously spawns a static future onto the underlying executor.

The async version of spawn_static for executors that need async initialization.

fn spawn_static_objsafe( &mut self, task: ObjSafeStaticTask, ) -> BoxedStaticObserver

Spawns an already type-erased static task.

This is the object-safe method for static executors. User code typically doesn’t call this directly.

fn spawn_static_objsafe_async<'s>( &'s mut self, task: ObjSafeStaticTask, ) -> BoxedStaticObserverFuture<'s>

Asynchronously spawns an already type-erased static task.

The async version of spawn_static_objsafe.

fn clone_box(&self) -> Box<DynStaticExecutor>

Creates a boxed clone of the static executor.

fn executor_notifier(&mut self) -> Option<Self::ExecutorNotifier>

Gets a notifier for executor-level events, if supported.

type ExecutorNotifier = Box<dyn ExecutorNotified>

The notifier handle that can wake or signal work for this executor.

Implementations on Foreign Types

impl SomeStaticExecutor for Infallible

type ExecutorNotifier = Infallible

fn spawn_static<F, Notifier: ObserverNotified<F::Output>>( &mut self, _task: Task<F, Notifier>, ) -> impl Observer<Value = F::Output>

where Self: Sized, F: Future + 'static, F::Output: 'static + Unpin,

fn spawn_static_async<F, Notifier: ObserverNotified<F::Output>>( &mut self, _task: Task<F, Notifier>, ) -> impl Future<Output = impl Observer<Value = F::Output>>

where Self: Sized, F: Future + 'static, F::Output: 'static + Unpin,

fn spawn_static_objsafe( &mut self, _task: ObjSafeStaticTask, ) -> BoxedStaticObserver

fn spawn_static_objsafe_async<'s>( &'s mut self, _task: ObjSafeStaticTask, ) -> BoxedStaticObserverFuture<'s>

fn clone_box(&self) -> Box<DynStaticExecutor>

fn executor_notifier(&mut self) -> Option<Self::ExecutorNotifier>

impl<UnderlyingNotifier: ExecutorNotified> SomeStaticExecutor for Box<dyn SomeStaticExecutor<ExecutorNotifier = UnderlyingNotifier>>

Implementation of SomeStaticExecutor for boxed static executor trait objects.

This implementation enables Box<dyn SomeStaticExecutor> to act as a static executor, supporting !Send futures through type erasure. This is particularly useful for single-threaded or local executors.

Differences from SomeExecutor

Unlike the SomeExecutor implementation, this works with futures that are not Send, making it suitable for JavaScript/WASM environments or thread-local execution contexts.

Examples

let mut executor: Box<dyn SomeStaticExecutor<ExecutorNotifier = Infallible>> = todo!();

// Can spawn !Send futures
let rc = Rc::new(42);
let task = Task::without_notifications(
    "rc-task".to_string(),
    Configuration::default(),
    async move { *rc }
);

fn spawn_static<F, Notifier: ObserverNotified<F::Output>>( &mut self, task: Task<F, Notifier>, ) -> impl Observer<Value = F::Output>

where Self: Sized, F: Future + 'static, F::Output: 'static + Unpin,

Spawns a static (potentially !Send) future onto the underlying executor.

This method supports futures that don’t implement Send, making it suitable for single-threaded environments.

async fn spawn_static_async<F, Notifier: ObserverNotified<F::Output>>( &mut self, task: Task<F, Notifier>, ) -> impl Observer<Value = F::Output>

where Self: Sized, F: Future + 'static, F::Output: 'static + Unpin,

Asynchronously spawns a static future onto the underlying executor.

The async version of spawn_static for executors that need async initialization.

fn spawn_static_objsafe( &mut self, task: ObjSafeStaticTask, ) -> BoxedStaticObserver

Spawns an already type-erased static task.

This is the object-safe method for static executors. User code typically doesn’t call this directly.

fn spawn_static_objsafe_async<'s>( &'s mut self, task: ObjSafeStaticTask, ) -> BoxedStaticObserverFuture<'s>

Asynchronously spawns an already type-erased static task.

The async version of spawn_static_objsafe.

fn clone_box(&self) -> Box<DynStaticExecutor>

Creates a boxed clone of the static executor.

fn executor_notifier(&mut self) -> Option<Self::ExecutorNotifier>

Gets a notifier for executor-level events, if supported.

type ExecutorNotifier = Box<dyn ExecutorNotified>

Implementors

impl<UnderlyingExecutor: SomeStaticExecutor> SomeStaticExecutor for OwnedSomeStaticExecutorErasingNotifier<UnderlyingExecutor>

type ExecutorNotifier = Box<dyn ExecutorNotified>