Struct Call 

pub struct Call<F: Function> { /* private fields */ }

One call of a function, waiting to be awaited: what call returns.

It is IntoFuture, so .await runs it, and the future is Send and 'static, so a test may also spawn it.

Implementations

impl<F: Function> Call<F>

pub fn message(self, m: Message) -> Self

The message the call runs over. By default an empty one: a null payload and empty roots.

pub fn layer<L: CallLayer>(self, l: L) -> Self

Adds a layer around the call, as a run’s layers wrap a call. The first given is the outermost.

pub fn exprs(self, e: ExprEngine) -> Self

The engine the config compiles with and the call evaluates with, secrets included. By default ExprEngine::default.

pub fn name(self, n: &str) -> Self

The name the function is registered and called by: what Prepare and CallInfo::function say. By default "function"; a built-in’s name is reserved, as Registry::register reserves it.

pub fn capture_changes(self, on: bool) -> Self

Whether the call records its Changes, as a run’s capture_changes says. On by default.

pub fn channel(self, c: &str) -> Self

The channel the call’s run was started on, as CallInfo::channel says. By default none.

pub fn routing_bucket(self, b: u8) -> Self

The run’s routing bucket, as CallInfo::routing_bucket says. By default none.

pub fn deadline(self, at: Instant) -> Self

The run’s deadline, as Ctx::deadline says. The call is checked against it and, natively, raced against it, as a run’s host call is: one it passes ends Err of kind TimedOut, its writes dropped. A deadline needs a Tokio runtime with its time driver. By default none.

pub fn cancel(self, token: CancelToken) -> Self

The run’s cancellation token, as Ctx::cancel says. The call is checked against it and, natively, raced against it, as a run’s host call is: one it cancels ends Err of kind Cancelled, its writes dropped. By default none.

Trait Implementations

impl<F: Function> Debug for Call<F>

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

The name, the input, the layer count, whether changes are captured, the channel and the deadline; not the function, the layers or the token.

impl<F: Function> IntoFuture for Call<F>

type Output = Called

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = Called> + Send>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.