Struct agent_safety_layers::AgentZ

pub struct AgentZ<M, A, D> {
    pub model: M,
    pub decider: fn(_: &M) -> A,
    pub actor: fn(_: &mut M, _: A),
    pub mutater: fn(_: &mut M) -> D,
    pub undoer: fn(_: &mut M, _: D),
}

Stores an agent that only acts, assuming its model is perfect.

Fields

model: M

Stores the model.

decider: fn(_: &M) -> A

Decides what to do based on some model.

actor: fn(_: &mut M, _: A)

Performs an action on the model.

mutater: fn(_: &mut M) -> D

Mutates the model and returns a delta change.

undoer: fn(_: &mut M, _: D)

Undoes a delta change by resetting the model.

Methods

impl<M, A, D> AgentZ<M, A, D>

pub fn add(self, n: usize) -> AgentN<M, A, D>

Add extra layers of safety.

Trait Implementations

impl<M, A, D> Agent for AgentZ<M, A, D>

type Model = M

The type of the model.

type Action = A

The type of actions.

type Delta = D

The type of delta changes (caused by mutation).

fn update_model(&mut self, model: M)

Update internal model.

fn decide(&mut self) -> Decision<A>

Decide what to do next.

fn act(&mut self, action: A)

Perform an action on its internal model.

fn mutate(&mut self) -> D

Mutates the agent.

fn undo(&mut self, delta: D)

Undo mutation.

impl<M: Clone, A: Clone, D: Clone> Clone for AgentZ<M, A, D>

fn clone(&self) -> AgentZ<M, A, D>

Returns a copy of the value.

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

Performs copy-assignment from source.