Struct Digester 

pub struct Digester { /* private fields */ }

A text-digesting agent — the computational macrophage.

Implementations

impl Digester

pub fn new(position: Position) -> Digester

pub fn with_seed(position: Position, seed: u64) -> Digester

Create a digester with a deterministic ID (for testing).

pub fn with_max_idle(self, max_idle: u64) -> Digester

Create a digester with custom idle threshold.

pub fn total_fragments(&self) -> usize

Total fragments produced in lifetime.

pub fn increment_idle(&mut self)

Simulate an idle tick (for testing/demo purposes).

pub fn idle_ticks(&self) -> u64

Current idle tick count (for testing/inspection).

pub fn set_idle_ticks(&mut self, ticks: u64)

Set idle ticks directly (for testing).

pub fn digest_text(&mut self, text: String) -> Vec<String>

Direct digestion: feed text and get fragments back immediately. This is a convenience for testing — in a colony, agents get input via SENSE + ENGULF from the substrate.

pub fn feed_document(&mut self, doc_id: DocumentId, content: String)

Feed document content to this agent (called by colony after EngulfDocument). Sets internal state so the next tick processes the content.

Trait Implementations

impl Agent for Digester

fn id(&self) -> AgentId

The agent’s unique identity.

fn position(&self) -> Position

The agent’s current position in the substrate.

fn set_position(&mut self, position: Position)

Set the agent’s position.

fn agent_type(&self) -> &str

The agent’s type name (for display and logging).

fn tick(&mut self, substrate: &dyn Substrate) -> AgentAction

Execute one tick of the agent’s lifecycle.

fn age(&self) -> u64

How many ticks this agent has been alive.

fn export_vocabulary(&self) -> Option<Vec<u8>>

Export this agent’s vocabulary as serialized bytes. Returns None if the agent has no vocabulary to export.

fn integrate_vocabulary(&mut self, data: &[u8]) -> bool

Integrate foreign vocabulary from serialized bytes. Returns true if integration succeeded.

fn profile(&self) -> AgentProfile

Build a profile describing this agent’s capabilities.

fn evaluate_symbiosis(&self, other: &AgentProfile) -> Option<SymbiosisEval>

Evaluate whether to absorb another agent as a symbiont.

fn absorb_symbiont(&mut self, profile: AgentProfile, data: Vec<u8>) -> bool

Absorb another agent’s profile and vocabulary data as a symbiont. Returns true if absorption succeeded.

fn permeability(&self) -> f64

Current boundary permeability (0.0 = rigid, 1.0 = fully dissolved).

fn modulate_boundary(&mut self, context: &BoundaryContext)

Adjust boundary permeability based on environmental context.

fn externalize_vocabulary(&self) -> Vec<String>

Return vocabulary terms to externalize (reinforce in the substrate).

fn internalize_vocabulary(&mut self, terms: &[String])

Absorb nearby concept terms from the substrate.

fn vocabulary_size(&self) -> usize

Return the size of this agent’s vocabulary (for metrics).

impl Apoptose for Digester

fn self_assess(&self) -> CellHealth

Evaluate own health and usefulness.

fn prepare_death_signal(&self) -> DeathSignal

Package final state into a death signal before destruction.

fn should_die(&self) -> bool

Whether the agent should initiate death.

fn trigger_apoptosis(self) -> DeathSignal

where Self: Sized,

Initiate orderly self-destruction (for concrete types).

impl Digest for Digester

type Input = String

The raw input to consume. Ownership is transferred — the input is destroyed.

type Fragment = String

Structural fragments extracted during digestion.

type Presentation = Vec<String>

What is presented to other agents after digestion.

fn engulf(&mut self, input: String) -> DigestionResult

Engulf: take ownership of input.

fn lyse(&mut self) -> Vec<String>

Lyse: break the engulfed material into fragments.

fn present(&self) -> Vec<String>

Present: expose fragments on the agent’s surface.

fn digest(&mut self, input: Self::Input) -> Self::Presentation

Run the full digestion cycle: engulf → lyse → present.

impl Sense for Digester

fn sense_radius(&self) -> f64

The radius within which this agent can sense signals.

fn sense_position(&self) -> Position

The position from which this agent senses.

fn gradient(&self, substrate: &dyn Substrate) -> Vec<Gradient>

Compute the gradient — direction of increasing signal strength.

fn orient(&self, gradients: &[Gradient]) -> Orientation

Determine next orientation based on sensed gradients.

fn sense(&self, substrate: &dyn Substrate) -> Vec<Signal>

Read signals from the local environment.

fn emit(&self, signal: Signal, substrate: &mut dyn Substrate)

Emit a signal into the substrate.

impl SerializableAgent for Digester

fn export_state(&self) -> SerializedAgent

Export the agent’s state for serialization.

fn from_state(state: &SerializedAgent) -> Option<Digester>

Create an agent from serialized state.