Trait Sim

pub trait Sim<N>
where
    N: Neighborhood,
{
    type Cell: 'static;
    type Diff: 'static;
    type Flow;

    // Required methods
    fn compute(&self, cells: N::Neighbors<'_, Self::Cell>) -> Self::Diff;
    fn egress(
        &self,
        cell: &mut Self::Cell,
        diffs: N::Neighbors<'_, Self::Diff>,
    ) -> N::Edges<Self::Flow>;
    fn ingress(&self, cell: &mut Self::Cell, flows: N::Edges<Self::Flow>);
    fn cell_padding(&self) -> Self::Cell;
    fn diff_padding(&self) -> Self::Diff;
    fn flow_padding(&self) -> Self::Flow;
}

Defines a simulation for complicated things that have too much state to abandon on the next cycle.

This enforces a rule in that all new cells are only produced from old board state. This prevents the update order from breaking the simulation.

Required Associated Types

type Cell: 'static

The cells of the grid

type Diff: 'static

Result of the neighbor-observing computation

type Flow

The data which flows to each neighbor.

Required Methods

fn compute(&self, cells: N::Neighbors<'_, Self::Cell>) -> Self::Diff

At this stage, everything is immutable, and the diff can be computed that describes what will change between simulation states.

fn egress( &self, cell: &mut Self::Cell, diffs: N::Neighbors<'_, Self::Diff>, ) -> N::Edges<Self::Flow>

At this stage, changes are made to the cell based on the diff and then any owned state that needs to be moved to neighbors must be returned as part of the flow.

fn ingress(&self, cell: &mut Self::Cell, flows: N::Edges<Self::Flow>)

At this stage, the flow is received from all neighbors, allowing state to be added to this cell.

fn cell_padding(&self) -> Self::Cell

The cell used as padding.

fn diff_padding(&self) -> Self::Diff

The diff used as padding.

fn flow_padding(&self) -> Self::Flow

The flow used as padding.

Implementors