Struct NonDet 

pub struct NonDet<H = ()> { /* private fields */ }

A non-determinism guard, which documents how a source of non-determinism affects the application.

To create a non-determinism guard, use the nondet! macro, which takes in a doc comment explaining the effects of the particular source of non-determinism, and additional non-determinism guards that justify the form of non-determinism.

The H type parameter is the simulator hook payload the guard can carry (see hydro_lang::sim::hooks), and defaults to () so that plain NonDet means what it always did. A hook lets a simulation test take manual control of the non-deterministic decisions guarded by this value:

• An unsafe operator (like batch) takes a guard with an optional handle for that one operator, e.g. NonDet<Option<BatchHook<T>>>. A component that declares a parameter of exactly this type passes it directly to the operator it controls, documenting it in a # Non-Determinism section of its Rustdoc.
• A component that contains several unsafe operators can expose them all through one guard by using a tuple payload, e.g. NonDet<(Option<BatchHook<T>>, Option<SnapshotHook<S>>)>, letting the test hook some, all, or none of them. The component splits the payload with NonDet::take_hook and attaches each part to the operator it controls via nondet!(... hook = part).

Payload types implement Default (“no hook”), which is what nondet!(...) without a hook = argument produces.

Implementations

impl<H> NonDet<H>

pub fn take_hook(&mut self) -> H

where H: Default,

Takes the hook payload out of this guard, leaving the default (“no hook”) payload in place.

This is how a component splits a composite guard across the unsafe operators it contains: take the payload once, destructure it, and attach each part to the operator it controls via nondet!(... hook = part). (A guard whose type already matches a single operator’s parameter is simply passed to that operator directly.) Taking the payload (rather than copying it) ensures a hook is only ever bound where the binding is visible — re-wrapping a guard with nondet! never propagates a binding.

Trait Implementations

impl<H: Clone> Clone for NonDet<H>

fn clone(&self) -> NonDet<H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<H: Copy> Copy for NonDet<H>