Struct TaskHandle 

pub struct TaskHandle { /* private fields */ }

A unified handle for scheduled tasks that serves dual purposes.

TaskHandle implements both Subscription and Future, providing:

• Cancellation: Call unsubscribe() to stop the task
• Completion tracking: Await the handle to wait for task completion
• Status checking: Use is_closed() to check if task is done or cancelled

Thread Safety

TaskHandle is Clone + Send + Sync, allowing it to be shared across threads and async contexts safely.

Example

use std::sync::{Arc, Mutex};

use rxrust::{
  scheduler::{LocalScheduler, Scheduler, Task, TaskState},
  subscription::Subscription,
};

let scheduler = LocalScheduler;
let data = Arc::new(Mutex::new(0));
let task = Task::new(data, |_| TaskState::Finished);

let handle = scheduler.schedule(task, None);

// Option 1: Cancel the task
handle.clone().unsubscribe();

// Option 2: Wait for completion
// In async context: handle.await;

// Option 3: Check status
if handle.is_closed() {
  println!("Task finished or was cancelled");
}

Implementations

impl TaskHandle

pub fn finished() -> Self

Create a handle for a task that has already completed.

This is useful for:

• Synchronous operations that complete immediately
• Error cases where no actual scheduling is needed
• Testing scenarios

The returned handle will immediately return Poll::Ready(()) when polled and is_closed() will return true.

Trait Implementations

impl Clone for TaskHandle

fn clone(&self) -> TaskHandle

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Future for TaskHandle

type Output = ()

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl Subscription for TaskHandle

fn unsubscribe(self)

Cancel the subscription (terminal operation, consumes self)

fn is_closed(&self) -> bool

Check if the subscription is closed (completed or unsubscribed)

fn unsubscribe_when_dropped(self) -> SubscriptionGuard<Self>

where Self: Sized,

Activates “RAII” behavior for this subscription. That means unsubscribe() will be called automatically as soon as the returned value goes out of scope.