Struct MainThreadExecutor 

pub struct MainThreadExecutor {}

An executor that runs futures on the application’s main thread.

MainThreadExecutor implements the some_executor traits (SomeExecutor, SomeLocalExecutor, and SomeStaticExecutor), allowing it to be used with any code that accepts executor-agnostic task spawning.

This executor integrates with the platform’s native event loop, ensuring futures can yield control back to the OS for smooth operation. All futures spawned on this executor will run on the main thread, which is required for UI operations on many platforms.

Example

use app_window::some_executor::MainThreadExecutor;
use some_executor::SomeExecutor;

let mut executor = MainThreadExecutor {};

// Spawn a task on the main thread
// let task = Task::new("my_task".to_string(), async {
//     // This runs on the main thread
//     println!("Hello from main thread!");
// });
// let observer = executor.spawn(task);

Integration

When application::main() is called, a MainThreadExecutor is automatically installed as both the thread-local and thread-static executor, making it available to any code using the some_executor crate’s convenience functions.

Trait Implementations

impl Clone for MainThreadExecutor

fn clone(&self) -> MainThreadExecutor

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MainThreadExecutor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl LocalExecutorExt<'static> for MainThreadExecutor

impl SomeExecutor for MainThreadExecutor

type ExecutorNotifier = Infallible

Design notes

fn spawn<F: Future + Send + 'static, Notifier: ObserverNotified<F::Output> + Send>( &mut self, task: Task<F, Notifier>, ) -> impl Observer<Value = F::Output>

where Self: Sized, F::Output: Send + Unpin,

Spawns a future onto the runtime.

async fn spawn_async<F: Future + Send + 'static, Notifier: ObserverNotified<F::Output> + Send>( &mut self, task: Task<F, Notifier>, ) -> impl Observer<Value = F::Output>

where Self: Sized, F::Output: Send + Unpin,

Spawns a future onto the runtime.

fn spawn_objsafe(&mut self, task: ObjSafeTask) -> BoxedSendObserver

Spawns a future onto the runtime.

fn spawn_objsafe_async<'s>( &'s mut self, task: ObjSafeTask, ) -> BoxedSendObserverFuture<'s>

Spawns a future onto the runtime.

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

Clones the executor.

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

Produces an executor notifier.

fn block_on<F>(&mut self, future: F) -> <F as Future>::Output

where F: Future, Self: Sized, <F as Future>::Output: Send + 'static,

Drives future to completion on this executor, blocking the calling thread until it resolves.

fn block_on_objsafe( &mut self, future: Pin<Box<dyn Future<Output = Box<dyn Any + Send>> + '_>>, ) -> Box<dyn Any + Send>

Drives a type-erased future to completion, blocking the calling thread.

impl SomeExecutorExt for MainThreadExecutor

impl SomeLocalExecutor<'static> for MainThreadExecutor

type ExecutorNotifier = Infallible

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

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

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

Spawns a future onto the runtime.

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

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

Spawns a future onto the runtime.

fn spawn_local_objsafe( &mut self, task: Task<Pin<Box<dyn Future<Output = Box<dyn Any>>>>, Box<dyn ObserverNotified<dyn Any + 'static>>>, ) -> Box<dyn Observer<Output = FinishedObservation<Box<dyn Any + 'static>>, Value = Box<dyn Any + 'static>> + 'static>

Spawns a future onto the runtime.

fn spawn_local_objsafe_async<'s>( &'s mut self, task: Task<Pin<Box<dyn Future<Output = Box<dyn Any>>>>, Box<dyn ObserverNotified<dyn Any + 'static>>>, ) -> Box<dyn Future<Output = Box<dyn Observer<Output = FinishedObservation<Box<dyn Any + 'static>>, Value = Box<dyn Any + 'static>> + 'static>> + 's>

Object-safe async variant of Self::spawn_local_objsafe.

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

Returns an executor notifier when notification is supported.

impl SomeStaticExecutor for MainThreadExecutor

type ExecutorNotifier = Box<dyn ExecutorNotified>

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

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

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

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

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

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

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

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

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

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

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

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

Clones the executor.

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

Produces an executor notifier.