pub struct PoetSnapshot {
pub committed: Vec<NQuin>,
pub revision: u64,
pub published: Vec<PulseRecord>,
pub attached: bool,
pub graph_read_during_eval: bool,
pub time_read_during_eval: bool,
pub tick_controller: TickController,
pub hid_events: HidEventBuffer,
pub trace_ledger: InstrumentTraceLedger,
pub last_eval_workspace_left: u64,
pub admitted_views: Vec<AdmittedQ42View>,
pub key_vault: HashMap<String, [u8; 32]>,
/* private fields */
}Expand description
In-memory graph revision used as the 0.1 live host.
When attached, queries refresh from the native daemon graph and commits
extend it. WASM has no daemon_graph — attach is always false there.
Fields§
§committed: Vec<NQuin>§revision: u64§published: Vec<PulseRecord>§attached: bool§graph_read_during_eval: boolSet to true when graph_query is called during an evaluation.
The desktop harness resets this before each eval_cell_src and reads
it after to determine whether the cell is graph-dependent (reactive).
time_read_during_eval: boolSet to true when time_unix is called during an evaluation.
The desktop harness resets this before each eval_cell_src and reads
it after to determine whether the cell is time-dependent (reactive on tick).
tick_controller: TickControllerController managing tick admission and coalescing under load (T68).
hid_events: HidEventBufferHID event ring buffer (T46). 4096-sample quota — host constant, not a language constant. Fail-closed when full.
trace_ledger: InstrumentTraceLedgerInstrument trace ledger (R12). Records instrument acts for customer-readable audit. NOT a provider byline (CLAUDE.md §16).
last_eval_workspace_left: u64Remaining 42 MB Sentinel budget after the last eval (P16.6).
admitted_views: Vec<AdmittedQ42View>Admitted isolated read-only Q42 semantic views (G50).
key_vault: HashMap<String, [u8; 32]>Key vault storing Ed25519 signing seeds for crypto operations.
Implementations§
Source§impl PoetSnapshot
impl PoetSnapshot
Sourcepub fn with_seed(quins: Vec<NQuin>) -> Self
pub fn with_seed(quins: Vec<NQuin>) -> Self
Detached snapshot seeded with quins at revision 1 — no daemon
attachment, no published events.
Sourcepub fn from_daemon() -> Self
pub fn from_daemon() -> Self
Snapshot attached to the process daemon graph — reads/delegates
go through daemon_graph, committed stays empty.
Sourcepub fn honesty(&self) -> &'static str
pub fn honesty(&self) -> &'static str
Evidence-level string: "live" when attached to the daemon
graph, "partial" for a detached snapshot.
Sourcepub fn visible_count(&self) -> usize
pub fn visible_count(&self) -> usize
Quins visible to this snapshot — the daemon count when attached,
else committed.len().
Sourcepub fn with_demo_seed() -> Self
pub fn with_demo_seed() -> Self
Clinic + catchment seed so the harness query sample is not empty.
Sourcepub fn ingest_sealed(&mut self, quin: NQuin)
pub fn ingest_sealed(&mut self, quin: NQuin)
Ingest an externally sealed quin — into the daemon graph when
attached (revision refreshed), else appended to committed.
Sourcepub fn bump_revision(&mut self)
pub fn bump_revision(&mut self)
Advance the snapshot revision (wrapping) after an out-of-band mutation the commit path didn’t observe.
Sourcepub fn fork(&self) -> Self
pub fn fork(&self) -> Self
Fork this snapshot into a detached, isolated copy for dry-run evaluation (reflection Stage 3, JudgeFrame verification, etc.).
The fork inherits the current committed quins (a snapshot of the live graph at this revision) but is never attached — commits to the fork stay in the fork and cannot reach the daemon graph. The staged deltas are cleared (a dry-run starts from the committed baseline, not from in-flight staged changes).
This is the R4 isolation boundary: reflection stage 3 and judge frames evaluate against the fork, not the live host.
Sourcepub fn commit_staged(&mut self)
pub fn commit_staged(&mut self)
Commit staged deltas into the committed set (used by dry-run forks to simulate a commit without touching the live graph).
Sourcepub fn rollback_staged(&mut self)
pub fn rollback_staged(&mut self)
Discard all staged deltas without committing (rollback).
Sourcepub fn admit_q42_slice(
&mut self,
bytes: &[u8],
pack_identity: &str,
entry_key: &str,
expected_digest: Option<&[u8; 32]>,
load_into_committed: bool,
) -> Result<AdmittedQ42ViewReceipt, String>
pub fn admit_q42_slice( &mut self, bytes: &[u8], pack_identity: &str, entry_key: &str, expected_digest: Option<&[u8; 32]>, load_into_committed: bool, ) -> Result<AdmittedQ42ViewReceipt, String>
Admit an in-memory/byte-backed Q42 slice into an isolated read-only semantic view (G50).
Validates:
- Entry SHA-256 digest (if expected_digest is provided).
- Q42 header bounds and supported format version (v3/v4).
- Caller-buffered SuperBlock decompression and Quin parity checks for all Quins.
- Embedded Q42LEX lexicon decoding into an isolated term map.
Fail-closed guarantee: any corruption, digest mismatch, or budget error rejects admission immediately WITHOUT altering previously admitted views or resident committed graph.
When load_into_committed is true, also appends admitted Quins to self.committed
and bumps revision so queries (GraphDatabase.sparql, SHACL.validate) see them.
Sourcepub fn resolve_admitted_lexicon_term(&self, hash: u64) -> Option<&str>
pub fn resolve_admitted_lexicon_term(&self, hash: u64) -> Option<&str>
Resolve a hash term against admitted lexicon views.
Sourcepub fn staged_count(&self) -> usize
pub fn staged_count(&self) -> usize
Number of staged (uncommitted) quins.
Sourcepub fn trace(&mut self, entry: TraceEntry)
pub fn trace(&mut self, entry: TraceEntry)
Record an instrument trace entry (R12). This is a customer-readable audit trail, NOT a provider byline.
Sourcepub fn trace_invoke(
&mut self,
invoke_id: &str,
success: bool,
cost: Option<u64>,
)
pub fn trace_invoke( &mut self, invoke_id: &str, success: bool, cost: Option<u64>, )
Convenience: record a simple trace entry for a capability invoke.
Sourcepub fn eval_program_src(&mut self, src: &str) -> Result<Value, Diagnostic>
pub fn eval_program_src(&mut self, src: &str) -> Result<Value, Diagnostic>
Parse, check, and evaluate a full VibeScript program source —
resets the graph/time-read honesty flags first and records the
post-eval workspace headroom in last_eval_workspace_left.
Sourcepub fn seal_eval_quins_into_arena(&self, arena: &mut SlgArena) -> usize
pub fn seal_eval_quins_into_arena(&self, arena: &mut SlgArena) -> usize
Write committed + staged quins into the 42 MB Sentinel arena (P16.6).
Sourcepub fn eval_cell_src(&mut self, src: &str) -> Result<Value, Diagnostic>
pub fn eval_cell_src(&mut self, src: &str) -> Result<Value, Diagnostic>
Evaluate one notebook cell source against this snapshot; resets the read flags first (left uncleared on failure — an incomplete cell keeps its flags).
Sourcepub fn eval_fn(
&mut self,
src: &str,
name: &str,
args: Vec<Value>,
) -> Result<Value, Diagnostic>
pub fn eval_fn( &mut self, src: &str, name: &str, args: Vec<Value>, ) -> Result<Value, Diagnostic>
Call function name from program source src with args,
evaluated against this snapshot.
Sourcepub fn dispatch_hook_src(
&mut self,
src: &str,
path: &[String],
args: Vec<Value>,
) -> Result<Value, Diagnostic>
pub fn dispatch_hook_src( &mut self, src: &str, path: &[String], args: Vec<Value>, ) -> Result<Value, Diagnostic>
Dispatch a hook event (on <path>(…)) on a checked program.
path is the event path segments (e.g. ["pulse", "message"] for
on pulse:message(…), or ["tick"] for on tick(…)). args are
bound to the hook’s parameters in declaration order. Returns
Ok(Value::Null) if no matching hook exists in the program.
Source§impl PoetSnapshot
Convert an InboundEvent to a compact HidEventSlot for the ring buffer (T42).
The source_id is hashed to fit in u64. The event kind is stored as u8.
impl PoetSnapshot
Convert an InboundEvent to a compact HidEventSlot for the ring buffer (T42). The source_id is hashed to fit in u64. The event kind is stored as u8.
Sourcepub fn enqueue_hid_event(
&mut self,
event: &InboundEvent,
) -> Result<(), &'static str>
pub fn enqueue_hid_event( &mut self, event: &InboundEvent, ) -> Result<(), &'static str>
Enqueue an InboundEvent into the HID ring buffer (T42). Returns Err if the buffer is full (fail-closed).
Sourcepub fn drain_hid_events(&mut self) -> Vec<Value>
pub fn drain_hid_events(&mut self) -> Vec<Value>
Drain all HID events from the ring buffer (T42). Returns a Vec of event Values in FIFO order.
Sourcepub fn hid_event_count(&self) -> usize
pub fn hid_event_count(&self) -> usize
Number of HID events currently buffered (T42).
Trait Implementations§
Source§impl Clone for PoetSnapshot
impl Clone for PoetSnapshot
Source§impl Debug for PoetSnapshot
impl Debug for PoetSnapshot
Source§impl Default for PoetSnapshot
impl Default for PoetSnapshot
Source§impl Host for PoetSnapshot
impl Host for PoetSnapshot
Source§fn graph_query(
&mut self,
args: &[Value],
take: u64,
_span: Span,
) -> Result<Value, Diagnostic>
fn graph_query( &mut self, args: &[Value], take: u64, _span: Span, ) -> Result<Value, Diagnostic>
graph.query — match s/p/o patterns (any may be absent) against
the live or committed quins, up to take results; sets the
graph_read_during_eval honesty flag.
Source§fn graph_stage(&mut self, term: &Value, span: Span) -> Result<Value, Diagnostic>
fn graph_stage(&mut self, term: &Value, span: Span) -> Result<Value, Diagnostic>
graph.stage — buffer term (triple, reified term, or Quin)
into staged for the next commit; E600 when the value encodes
no stageable quin.
Source§fn graph_begin(&mut self, _span: Span) -> Result<(), Diagnostic>
fn graph_begin(&mut self, _span: Span) -> Result<(), Diagnostic>
graph.begin — no-op: staging is implicit, no explicit
transaction state to open.
Source§fn graph_abort(&mut self, _span: Span) -> Result<(), Diagnostic>
fn graph_abort(&mut self, _span: Span) -> Result<(), Diagnostic>
graph.abort — drop every staged quin without committing.
Source§fn graph_commit(&mut self, _span: Span) -> Result<Value, Diagnostic>
fn graph_commit(&mut self, _span: Span) -> Result<Value, Diagnostic>
graph.commit — flush staged into the daemon graph (attached)
or committed (detached), bump the revision, and return a
Receipt. Committing an empty stage is a no-op Receipt.
Source§fn aura_validate(
&mut self,
node: &Value,
shape: &Value,
_span: Span,
) -> Result<Value, Diagnostic>
fn aura_validate( &mut self, node: &Value, shape: &Value, _span: Span, ) -> Result<Value, Diagnostic>
aura.validate — validate node against a named shape; only
the built-in EmergencyAlertShape/ReifierPresent shapes are
honest in this build (false otherwise / for unhashable nodes).
Source§fn pulse_publish(
&mut self,
topic: &str,
payload: &Value,
span: Span,
) -> Result<Value, Diagnostic>
fn pulse_publish( &mut self, topic: &str, payload: &Value, span: Span, ) -> Result<Value, Diagnostic>
pulse.publish — emit payload on topic (E500 unless the
topic is on PULSE_ALLOW_PREFIXES); goes through the process
pulse transport when attached, and is always journaled into
published.
Source§fn time_now(&mut self, span: Span) -> Result<Value, Diagnostic>
fn time_now(&mut self, span: Span) -> Result<Value, Diagnostic>
time.now — current instant built on time_unix (E600 if the
clock read produced something unexpected).
Source§fn environment(&self) -> HostEnvironment
fn environment(&self) -> HostEnvironment
Host environment — WasmSandbox on wasm32, NativeDesktop
otherwise.
Source§fn acceleration_tier(&self) -> AccelerationTier
fn acceleration_tier(&self) -> AccelerationTier
The tier this host will actually use — ScalarCpu.
Source§fn available_acceleration(&self) -> AccelerationTier
fn available_acceleration(&self) -> AccelerationTier
The best acceleration tier hardware-probed on this machine.
Source§fn time_unix(&mut self, span: Span) -> Result<Value, Diagnostic>
fn time_unix(&mut self, span: Span) -> Result<Value, Diagnostic>
time.unix — seconds since epoch; sets time_read_during_eval.
WASM has no wall clock and returns 0 (receipt-injected clocks
handle replay).
Source§fn graph_snapshot(&mut self, _span: Span) -> Result<Value, Diagnostic>
fn graph_snapshot(&mut self, _span: Span) -> Result<Value, Diagnostic>
graph.snapshot — the current revision (U64); refreshes from
the daemon when attached.
Source§fn capability_resolve(
&mut self,
id: &str,
_span: Span,
) -> Result<Value, Diagnostic>
fn capability_resolve( &mut self, id: &str, _span: Span, ) -> Result<Value, Diagnostic>
capability.resolve — look up invoke-id id in the catalog,
honesty-tagged by attachment state.
Source§fn capability_invoke(
&mut self,
id: &str,
args: &Value,
span: Span,
) -> Result<Value, Diagnostic>
fn capability_invoke( &mut self, id: &str, args: &Value, span: Span, ) -> Result<Value, Diagnostic>
capability.invoke — dispatch invoke-id id through
invoke::dispatch.
Source§fn quin_seal(
&mut self,
subject: u64,
predicate: u64,
object: u64,
context: u64,
_span: Span,
) -> Result<Value, Diagnostic>
fn quin_seal( &mut self, subject: u64, predicate: u64, object: u64, context: u64, _span: Span, ) -> Result<Value, Diagnostic>
quin.seal — wrap raw s/p/o/c u64s into a QuinRef (metadata
0, parity recomputed); the script never sees the parity field.
Source§fn hash_iri(&self, iri: &str) -> u64
fn hash_iri(&self, iri: &str) -> u64
hash_iri — the 60-bit token hash of iri (bits 60–63 free
for type tags).
Source§fn crypto_hash(
&mut self,
algorithm: &str,
data: &str,
span: Span,
) -> Result<Value, Diagnostic>
fn crypto_hash( &mut self, algorithm: &str, data: &str, span: Span, ) -> Result<Value, Diagnostic>
crypto.hash — SHA-256/SHA-512/BLAKE3 of data, returned as a
hash-result record; E100 for other algorithm names.
crypto.hash — SHA-256/SHA-512/BLAKE3 of data, returned as a
hash-result record; E100 for other algorithm names.
Source§fn crypto_hkdf(
&mut self,
ikm: &str,
info: &str,
length: u64,
span: Span,
) -> Result<Value, Diagnostic>
fn crypto_hkdf( &mut self, ikm: &str, info: &str, length: u64, span: Span, ) -> Result<Value, Diagnostic>
crypto.hkdf — HKDF-SHA256 expand of ikm/info to length
bytes, hex-encoded; E100 on expansion failure.
Source§fn crypto_aead_encrypt(
&mut self,
algorithm: &str,
key_hex: &str,
nonce_hex: &str,
plaintext: &str,
aad: &str,
span: Span,
) -> Result<Value, Diagnostic>
fn crypto_aead_encrypt( &mut self, algorithm: &str, key_hex: &str, nonce_hex: &str, plaintext: &str, aad: &str, span: Span, ) -> Result<Value, Diagnostic>
crypto.aead_encrypt — AEAD-encrypt plaintext (AES-256-GCM:
32-byte key, 12-byte nonce, hex input) with aad; E100 on bad
hex, wrong sizes, or an unsupported algorithm.
Source§fn crypto_aead_decrypt(
&mut self,
algorithm: &str,
key_hex: &str,
nonce_hex: &str,
ciphertext_hex: &str,
tag_hex: &str,
aad: &str,
span: Span,
) -> Result<Value, Diagnostic>
fn crypto_aead_decrypt( &mut self, algorithm: &str, key_hex: &str, nonce_hex: &str, ciphertext_hex: &str, tag_hex: &str, aad: &str, span: Span, ) -> Result<Value, Diagnostic>
crypto.aead_decrypt — AEAD-decrypt with the same hex contract
as crypto_aead_encrypt; E100 on bad input or auth failure.
Source§fn crypto_sign(
&mut self,
key_id: &str,
data: &str,
span: Span,
) -> Result<Value, Diagnostic>
fn crypto_sign( &mut self, key_id: &str, data: &str, span: Span, ) -> Result<Value, Diagnostic>
crypto.sign — signs data with key identified by key_id.
Source§fn crypto_verify(
&mut self,
key_id: &str,
data: &str,
signature_hex: &str,
span: Span,
) -> Result<Value, Diagnostic>
fn crypto_verify( &mut self, key_id: &str, data: &str, signature_hex: &str, span: Span, ) -> Result<Value, Diagnostic>
crypto.verify — verifies data against signature_hex using key_id or raw public key hex.
Source§fn crypto_generate_key(
&mut self,
algorithm: &str,
span: Span,
) -> Result<Value, Diagnostic>
fn crypto_generate_key( &mut self, algorithm: &str, span: Span, ) -> Result<Value, Diagnostic>
crypto.generate_key — generates an Ed25519 keypair and registers it in the key vault.
Source§fn zk_prove_threshold(
&mut self,
value: u64,
threshold: u64,
span: Span,
) -> Result<Value, Diagnostic>
fn zk_prove_threshold( &mut self, value: u64, threshold: u64, span: Span, ) -> Result<Value, Diagnostic>
zk.prove_threshold — prove value >= threshold via
crypto::zk_predicates; E702 when zk-culling is off, E100 on
prover failure.
Source§fn zk_verify_threshold(
&mut self,
proof_hex: &str,
vk_hex: &str,
threshold: u64,
span: Span,
) -> Result<Value, Diagnostic>
fn zk_verify_threshold( &mut self, proof_hex: &str, vk_hex: &str, threshold: u64, span: Span, ) -> Result<Value, Diagnostic>
zk.verify_threshold — verify a threshold proof (proof_hex,
vk_hex) against threshold; E702 when zk-culling is off.
Source§fn zk_prove_range(
&mut self,
value: u64,
lo: u64,
hi: u64,
span: Span,
) -> Result<Value, Diagnostic>
fn zk_prove_range( &mut self, value: u64, lo: u64, hi: u64, span: Span, ) -> Result<Value, Diagnostic>
zk.prove_range — prove lo <= value <= hi via
crypto::zk_predicates::prove_range; E702 when zk-culling is off.
Source§fn zk_verify_range(
&mut self,
proof_hex: &str,
vk_hex: &str,
lo: u64,
hi: u64,
span: Span,
) -> Result<Value, Diagnostic>
fn zk_verify_range( &mut self, proof_hex: &str, vk_hex: &str, lo: u64, hi: u64, span: Span, ) -> Result<Value, Diagnostic>
zk.verify_range — verify a range proof against lo/hi;
E702 when zk-culling is off.
Source§fn zk_prove_matmul(
&mut self,
m: u64,
k: u64,
n: u64,
a: &[i128],
b: &[i128],
span: Span,
) -> Result<Value, Diagnostic>
fn zk_prove_matmul( &mut self, m: u64, k: u64, n: u64, a: &[i128], b: &[i128], span: Span, ) -> Result<Value, Diagnostic>
zk.prove_matmul — prove a m×k × k×n integer matmul via
ZkProofSystem::prove_matrix_multiply; E702 when zk-culling
is off.
Source§fn zk_list_circuits(&mut self, _span: Span) -> Result<Value, Diagnostic>
fn zk_list_circuits(&mut self, _span: Span) -> Result<Value, Diagnostic>
zk.list_circuits — the registered ZK circuit names; E702 when
zk-culling is off.
Source§fn hid_poll(&mut self, _span: Span) -> Result<Value, Diagnostic>
fn hid_poll(&mut self, _span: Span) -> Result<Value, Diagnostic>
Poll for the next HID event from the ring buffer (T42). Non-blocking: returns Null if no event is available.
Source§fn hid_wait(
&mut self,
_timeout_ns: u64,
_span: Span,
) -> Result<Value, Diagnostic>
fn hid_wait( &mut self, _timeout_ns: u64, _span: Span, ) -> Result<Value, Diagnostic>
Wait for the next HID event with a timeout (T42). Currently non-blocking (polls once). A blocking implementation would require platform-specific async infrastructure.
Source§fn supports_isolation(&self) -> bool
fn supports_isolation(&self) -> bool
R4: PoetSnapshot supports isolation via fork().
A forked snapshot has attached = false, so graph writes stay in
the fork’s staged deltas and never reach the daemon graph.
Source§fn graph_end(&mut self, span: Span) -> Result<(), Diagnostic>
fn graph_end(&mut self, span: Span) -> Result<(), Diagnostic>
transaction { ... } block on normal exit. Read moreSource§fn time_unix_nanos(&mut self, span: Span) -> Result<Value, Diagnostic>
fn time_unix_nanos(&mut self, span: Span) -> Result<Value, Diagnostic>
{ secs: I64, nanos: U64 } (T19).
Default calls time_unix and wraps it into a Record.Source§fn time_monotonic_nanos(&mut self, _span: Span) -> Result<Value, Diagnostic>
fn time_monotonic_nanos(&mut self, _span: Span) -> Result<Value, Diagnostic>
Source§fn host_version(&self) -> &str
fn host_version(&self) -> &str
Source§fn time_proper_time(
&mut self,
_worldline_id: u64,
span: Span,
) -> Result<Value, Diagnostic>
fn time_proper_time( &mut self, _worldline_id: u64, span: Span, ) -> Result<Value, Diagnostic>
Source§fn receipt_clock(&mut self, span: Span) -> Result<Value, Diagnostic>
fn receipt_clock(&mut self, span: Span) -> Result<Value, Diagnostic>
Source§fn field_sample(
&mut self,
_field_ref: u64,
_pose: &Value,
span: Span,
) -> Result<Value, Diagnostic>
fn field_sample( &mut self, _field_ref: u64, _pose: &Value, span: Span, ) -> Result<Value, Diagnostic>
Source§fn law_apply(
&mut self,
_law_ref: u64,
_args: &[Value],
span: Span,
) -> Result<Value, Diagnostic>
fn law_apply( &mut self, _law_ref: u64, _args: &[Value], span: Span, ) -> Result<Value, Diagnostic>
Source§fn conservation_check(
&mut self,
_quantity: &ConservationQuantity,
_before: &Value,
_after: &Value,
_tolerance: f64,
span: Span,
) -> Result<Value, Diagnostic>
fn conservation_check( &mut self, _quantity: &ConservationQuantity, _before: &Value, _after: &Value, _tolerance: f64, span: Span, ) -> Result<Value, Diagnostic>
Source§fn causal_relation(
&mut self,
_event_a: &Value,
_event_b: &Value,
span: Span,
) -> Result<Value, Diagnostic>
fn causal_relation( &mut self, _event_a: &Value, _event_b: &Value, span: Span, ) -> Result<Value, Diagnostic>
Source§fn dag_execute(
&mut self,
_pipeline: &Value,
_blackboard: &Value,
span: Span,
) -> Result<Value, Diagnostic>
fn dag_execute( &mut self, _pipeline: &Value, _blackboard: &Value, span: Span, ) -> Result<Value, Diagnostic>
Source§fn dag_validate(
&mut self,
_pipeline: &Value,
span: Span,
) -> Result<Value, Diagnostic>
fn dag_validate( &mut self, _pipeline: &Value, span: Span, ) -> Result<Value, Diagnostic>
Source§fn deontic_check(
&mut self,
_capability: &str,
_phase: &str,
span: Span,
) -> Result<Value, Diagnostic>
fn deontic_check( &mut self, _capability: &str, _phase: &str, span: Span, ) -> Result<Value, Diagnostic>
Auto Trait Implementations§
impl Freeze for PoetSnapshot
impl RefUnwindSafe for PoetSnapshot
impl Send for PoetSnapshot
impl Sync for PoetSnapshot
impl Unpin for PoetSnapshot
impl UnsafeUnpin for PoetSnapshot
impl UnwindSafe for PoetSnapshot
Blanket Implementations§
§impl<S, A> Aggregate<Result<S, Error>> for Awhere
A: Aggregate<S>,
impl<S, A> Aggregate<Result<S, Error>> for Awhere
A: Aggregate<S>,
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read more