Struct History

pub struct History<M: Move, U: Utility, O: Outcome<M, U, P>, const P: usize> { /* private fields */ }

For repeated games, a history of previously played games.

Implementations

impl<M: Move, U: Utility, O: Outcome<M, U, P>, const P: usize> History<M, U, O, P>

pub fn empty() -> Self

Construct a new, empty history.

pub fn add(&mut self, outcome: O) -> &O

Update the history by adding a new game outcome. Returns a reference to the newly added outcome.

pub fn outcomes(&self) -> Past<'_, &O>

Get an iterator over the outcomes of previously played games.

pub fn records(&self) -> Past<'_, &<O as Outcome<M, U, P>>::Record>

Get an iterator over the move records of previously played games.

pub fn payoffs(&self) -> Past<'_, &Payoff<U, P>>

Get an iterator over the payoffs of previously played games.

pub fn score(&self) -> &Payoff<U, P>

Get the cumulative score of all previously played games.

impl<M: Move, U: Utility, const P: usize> History<M, U, SimultaneousOutcome<M, U, P>, P>

pub fn profiles(&self) -> Past<'_, &Profile<M, P>>

Get an iterator over the profiles of previously played games.

pub fn moves_for_player(&self, player: PlayerIndex<P>) -> Past<'_, M>

Get an iterator over all moves played by a given player.

impl<S: State, M: Move, U: Utility, const P: usize> History<M, U, SequentialOutcome<S, M, U, P>, P>

pub fn transcripts(&self) -> Past<'_, &Transcript<M, P>>

Get an iterator over the transcripts of previously played games.

Trait Implementations

impl<M: Clone + Move, U: Clone + Utility, O: Clone + Outcome<M, U, P>, const P: usize> Clone for History<M, U, O, P>

fn clone(&self) -> History<M, U, O, P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: Debug + Move, U: Debug + Utility, O: Debug + Outcome<M, U, P>, const P: usize> Debug for History<M, U, O, P>

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

Formats the value using the given formatter.

impl<M: Move, U: Utility, O: Outcome<M, U, P>, const P: usize> Default for History<M, U, O, P>

fn default() -> Self

Returns the “default value” for a type.

impl<M: Hash + Move, U: Hash + Utility, O: Hash + Outcome<M, U, P>, const P: usize> Hash for History<M, U, O, P>

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<M: Move, U: Utility, O: Outcome<M, U, P>, const P: usize> Outcome<M, U, P> for History<M, U, O, P>

type Record = History<M, U, O, P>

A type for capturing the record of moves that produced (or would produce) this outcome.

fn record(&self) -> &Self

A record of the moves that produced this outcome.

fn payoff(&self) -> &Payoff<U, P>

The payoff associated with this outcome.

impl<M: PartialEq + Move, U: PartialEq + Utility, O: PartialEq + Outcome<M, U, P>, const P: usize> PartialEq for History<M, U, O, P>

fn eq(&self, other: &History<M, U, O, P>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<M: Move, U: Utility, O: Outcome<M, U, P>, const P: usize> Record<M, P> for History<M, U, O, P>

fn plies(&self) -> Plies<'_, M, P>

An iterator over the played moves in this record.

fn summary(&self) -> Summary<P>

A summary of the number of moves in this record.

fn to_transcript(&self) -> Transcript<M, P>

Get the moves played in the form of a transcript.

fn played_moves_by_chance(&self) -> PlayedMoves<'_, M>

An iterator over all moves by chance.

fn played_moves_by_player(&self, player: PlayerIndex<P>) -> PlayedMoves<'_, M>

An iterator over all moves by a particular player.

fn played_moves_per_player(&self) -> PerPlayer<PlayedMoves<'_, M>, P>

Iterators over the moves by each player.

impl<M: Eq + Move, U: Eq + Utility, O: Eq + Outcome<M, U, P>, const P: usize> Eq for History<M, U, O, P>

impl<M: Move, U: Utility, O: Outcome<M, U, P>, const P: usize> StructuralPartialEq for History<M, U, O, P>