Struct Response 

pub struct Response<T>(/* private fields */);

Concrete wrapper for protocol request-response methods that works in both tasks (async) and threads (blocking) modes.

• Tasks mode: wraps a oneshot receiver; .await returns Result<T, ActorError>
• Threads mode: wraps a pre-computed result; use .unwrap() / .expect() directly

Protocol methods return Response<T>:

#[protocol]
pub trait MyProtocol: Send + Sync {
    fn query(&self) -> Response<String>;
}

// Tasks: actor.query().await.unwrap()
// Threads: actor.query().unwrap()

Implementations

impl<T> Response<T>

pub fn ready(result: Result<T, ActorError>) -> Self

Create a Response from a pre-computed result.

Used by the threads runtime where the request blocks at call time and the result is immediately available.

pub fn unwrap(self) -> T

Extract the value, panicking on error.

For ready (pre-computed) responses. Panics on pending responses — use .await.unwrap() in async contexts instead.

pub fn expect(self, msg: &str) -> T

Extract the value, panicking with a custom message on error.

pub fn is_ok(&self) -> bool

Returns true if the response contains Ok. Only meaningful for ready responses. Returns false for pending (Receiver) or consumed (Done) states.

pub fn is_err(&self) -> bool

Returns true if the response contains Err. Only meaningful for ready responses. Returns false for pending (Receiver) or consumed (Done) states.

pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Response<U>

Maps the inner value if the response is ready and Ok.

Panics on pending or consumed responses.

impl<T: Send + 'static> Response<T>

pub fn from_with_timeout( result: Result<Receiver<T>, ActorError>, duration: Duration, ) -> Self

Create a Response from a oneshot receiver with a timeout.

Used by tasks-mode protocol blanket impls. Returns Err(ActorError::RequestTimeout) if the timeout expires.

Trait Implementations

impl<T> From<Result<Receiver<T>, ActorError>> for Response<T>

fn from(result: Result<Receiver<T>, ActorError>) -> Self

Converts to this type from the input type.

impl<T: Send + 'static> Future for Response<T>

type Output = Result<T, ActorError>

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<T> Unpin for Response<T>