Struct MemorySlot 

pub struct MemorySlot {
    pub predicate: CanonicalPredicate,
    pub state_key: String,
}

A mapping from a memory predicate to the governed State slot it fills.

Fields

predicate: CanonicalPredicate

The canonical predicate to look for, e.g. dietary_identity.

state_key: String

The State key to fill, e.g. user:diet.

Implementations

impl MemorySlot

pub fn new(predicate: impl AsRef<str>, state_key: impl Into<String>) -> Self

Map predicate onto state_key.

The key must use the platform’s scope:key convention — user:diet, not user.diet. The gates themselves do not care: needs, requires and Guard::is_set route through State::contains, which treats the key as an opaque string. What the colon buys is composition with the prefix scopes, so state.user().get::<String>("diet") finds the slot. A dotted key would read back None there — silently, for a developer doing exactly what the platform documentation says.

That is a programming error knowable at construction, so this panics on a malformed key rather than documenting the trap and handing it over. Use try_new where the key is not a literal.

The predicate is not checked against the corpus: a slot naming a fact the user has not stated yet is the normal case, and for a brand-new user every slot is.

MemorySlot::new("dietary_identity", "user:diet");            // fine
assert!(MemorySlot::try_new("dietary_identity", "user.diet").is_err());
assert!(MemorySlot::try_new("dietary_identity", "derived:diet").is_err());

pub fn try_new( predicate: impl AsRef<str>, state_key: impl Into<String>, ) -> Result<Self, MemorySlotError>

new without the panic, for keys built at runtime.

Use this when the slot comes from configuration or user input; use new for the literals in application code, where a bad key is a programming error worth failing on immediately.

Trait Implementations

impl Clone for MemorySlot

fn clone(&self) -> MemorySlot

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MemorySlot

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

Formats the value using the given formatter.

impl PartialEq for MemorySlot

fn eq(&self, other: &MemorySlot) -> 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 MemorySlot