Enum MemoryRelationKind 

pub enum MemoryRelationKind {
    Answers,
    Authorizes,
    ChosenBecause,
    AchievedBy,
    FollowsFrom,
    SatisfiesConstraint,
    ViolatesConstraint,
    Supersedes,
    Contradicts,
}

How one remembered thing explains another.

Named in this engine’s terms and not a memory backend’s. What a particular backend calls these, and how it classes them, is a mapping an adapter owns — an engine that spoke one backend’s taxonomy would have to change when that backend did.

Each kind says who is in a position to assert it, because that is the difference between a reason and a guess. The engine asserts only what it can see in its own aggregate; everything else is asserted by whoever did the reasoning.

Variants

Answers

This is the reply to what that one asked.

The engine asserts this: a contribution and the agenda item it was made against are both in the session, and which answers which is not a judgement.

Authorizes

That decision is what permitted this action.

Causal rather than motivational: a decision that permits an action is part of why the action was possible, not part of why anybody wanted it.

ChosenBecause

This was decided because of that.

Asserted by whoever decided. The engine cannot infer it — something being written down before a decision is not what made the decision, and recording it as though it were is how a coincidence becomes a precedent.

AchievedBy

This was brought about by doing that — the how.

Not a weaker form of cause. A reason says what made something necessary; this says what was actually done, and it is what makes a memory repeatable rather than only understandable. A session that recorded why it resolved and not how leaves a precedent nobody can turn into a procedure.

FollowsFrom

This came about because of that.

Asserted by whoever can vouch for it. The strongest claim available and the easiest to make carelessly: a session ending well after an action is not the action having worked.

SatisfiesConstraint

This honours a limit that one set.

ViolatesConstraint

This breaks a limit that one set, knowingly.

Supersedes

This replaces that as what is believed now.

What was superseded is not deleted: a later session asking what was thought at the time needs the belief that was replaced, and a session that quietly overwrote it would answer with today’s knowledge about yesterday’s decision.

Contradicts

These cannot both be true.

Kept rather than resolved. Two sessions that reached opposite conclusions are a fact about the problem, and flattening them into one would lose the only warning a third session gets.

Implementations

impl MemoryRelationKind

pub const fn as_label(self) -> &'static str

pub const fn is_observable_by_the_engine(self) -> bool

Whether this engine can assert the relation on its own.

Everything else needs someone who did the reasoning to say so. Kept as a property rather than as a comment so a caller that generates relations automatically can be stopped from generating the ones nobody is entitled to.

pub const fn is_method(self) -> bool

Whether this says how something was done rather than why.

Worth telling apart: a memory backend measuring how explanatory a memory is counts causes, motives and evidence, and does not count method. A session with method and no cause scores zero on that measure and is not thereby worthless — it is repeatable and unexplained, which is a different thing from explained and unrepeatable.

Trait Implementations

impl Clone for MemoryRelationKind

fn clone(&self) -> MemoryRelationKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for MemoryRelationKind

impl Debug for MemoryRelationKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MemoryRelationKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for MemoryRelationKind

impl Hash for MemoryRelationKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for MemoryRelationKind

fn cmp(&self, other: &MemoryRelationKind) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for MemoryRelationKind

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for MemoryRelationKind

fn partial_cmp(&self, other: &MemoryRelationKind) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for MemoryRelationKind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MemoryRelationKind