Struct RealizeRequest 

pub struct RealizeRequest {
    pub term: Term,
    pub result_shape: Option<Ref>,
    pub required_capabilities: Vec<CapabilityName>,
    pub deadline: Option<Duration>,
    pub consistency: Consistency,
    pub mode: EvalMode,
    pub answer_limit: Option<usize>,
    pub buffer_limit: Option<usize>,
    pub observe: ObserveMode,
}

A reference-based realize request: the portable form of an EvalRequest.

Where EvalRequest carries an in-process Expr and live values, a RealizeRequest carries a Term and Refs, so it can cross a transport boundary. The two convert via from_eval_request and to_eval_request. See the README section “Distributed evaluation”.

Examples

use sim_kernel::realize::{ObserveMode, RealizeRequest};
use sim_kernel::term::Term;
use sim_kernel::Symbol;

let request = RealizeRequest::new(Term::Local(Symbol::new("x")))
    .observing(ObserveMode::Events);
assert_eq!(request.observe, ObserveMode::Events);
assert!(request.required_capabilities.is_empty());

Fields

term: Term

The term to evaluate.

result_shape: Option<Ref>

Optional reference to a shape the result must satisfy.

required_capabilities: Vec<CapabilityName>

Capabilities the evaluation requires.

deadline: Option<Duration>

Optional wall-clock deadline for the evaluation.

consistency: Consistency

Where the request may be answered from.

mode: EvalMode

Which evaluation discipline to run under.

answer_limit: Option<usize>

Optional cap on the number of answers (logic mode).

buffer_limit: Option<usize>

Optional buffer size for streamed events.

observe: ObserveMode

How much of the evaluation to observe.

Implementations

impl RealizeRequest

pub fn new(term: Term) -> Self

Creates a request to realize term with all defaults.

pub fn observing(self, observe: ObserveMode) -> Self

Sets the ObserveMode, returning the request (builder style).

pub fn requiring(self, capability: CapabilityName) -> Self

Adds a required capability, returning the request (builder style).

pub fn from_eval_request(cx: &mut Cx, request: &EvalRequest) -> Result<Self>

Builds a RealizeRequest from an in-process EvalRequest.

Live values become Refs and the Expr becomes a Term so the request can cross a transport boundary.

pub fn to_eval_request(&self, cx: &mut Cx) -> Result<EvalRequest>

Resolves this request back into an in-process EvalRequest.

The inverse of from_eval_request: Term and Refs are resolved against cx into an Expr and live values.

Trait Implementations

impl Clone for RealizeRequest

fn clone(&self) -> RealizeRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RealizeRequest

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

Formats the value using the given formatter.

impl Eq for RealizeRequest

impl PartialEq for RealizeRequest

fn eq(&self, other: &RealizeRequest) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for RealizeRequest