Enum Decay 

pub enum Decay {
    None,
    Linear {
        span: u64,
    },
    Exponential {
        half_life: u64,
    },
}

How a record’s age is priced into its recall score.

The age term is the last term, deliberately: ADR-0013 depreciates by evidence first and clock last, so an anchor that no longer resolves and an explicit supersession both outrank age. Age is the tiebreak between records that are otherwise equally valid.

Age is measured in generations, not time. A generation is one written record (MemoryRecord::id, AUTOINCREMENT), so “old” means a lot has been learned since, not a while has passed. That is what makes it skew-proof: the store is shared across worktrees and branches, where wall-clock is not monotone and datetime('now') ties on intra-second writes.

The factor is computed on every read and never stored. A stored score that ticked down would rewrite the store on every read and would be wrong in between, making recall depend on when you last looked.

Variants

None

No age term at all: every record’s factor is exactly 1.0.

This is the reproducible mode, and it is the default. With no age term the score depends only on what is stored and on the tree the anchors are resolved against, so the same store and the same tree recall the same records in the same order with the same scores — byte-identically, across runs and across machines. Every other mode is a deliberate trade of that property for recency.

Linear

Falls linearly to zero over span generations.

A record older than span scores 0.0 in the age term and therefore sorts last — it is still returned and still labelled. Decay ranks; it never filters and never deletes.

Fields

span: u64

Generations over which the factor reaches zero. Clamped to at least 1.

Exponential

Halves every half_life generations, and never reaches zero.

Fields

half_life: u64

Generations per halving. Clamped to at least 1.

Implementations

impl Decay

pub fn factor(self, age: u64) -> f64

The age factor for a record age generations old, always in [0.0, 1.0].

A pure function of (self, age): no clock, no store state, no I/O.

pub fn as_str(self) -> &'static str

Stable token naming the mode, without its parameter.

pub fn is_reproducible(self) -> bool

Whether this mode guarantees reproducible recall — true only for Decay::None.

Trait Implementations

impl Clone for Decay

fn clone(&self) -> Decay

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Decay

impl Debug for Decay

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

Formats the value using the given formatter.

impl Default for Decay

fn default() -> Self

Decay::None — the reproducible answer is the default answer, on the same terms as crate::SearchOptions defaulting generated content off.

impl<'de> Deserialize<'de> for Decay

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Decay

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

Formats the value using the given formatter.

impl Eq for Decay

impl FromStr for Decay

fn from_str(s: &str) -> Result<Self, Self::Err>

none | linear[:span] | exponential[:half-life].

type Err = String

The associated error which can be returned from parsing.

impl PartialEq for Decay

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Decay

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 Decay