Struct t4t::History

pub struct History<G: Game<P>, const P: usize> { /* private fields */ }

For repeated games, a history of previously played games.

Implementations

impl<G: Game<P>, const P: usize> History<G, P>

pub fn empty() -> Self

Construct a new, empty history.

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

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

pub fn outcomes(&self) -> Past<'_, &G::Outcome>

Get an iterator over the outcomes of previously played games.

pub fn records( &self, ) -> Past<'_, &<G::Outcome as Outcome<G::Move, G::Utility, P>>::Record>

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

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

Get an iterator over the payoffs of previously played games.

pub fn score(&self) -> &Payoff<G::Utility, P>

Get the cumulative score of all previously played games.

impl<M, U, G, const P: usize> History<G, P>

where M: Move, U: Utility, G: Game<P, Move = M, Utility = U, Outcome = SimultaneousOutcome<M, U, P>>,

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

Get an iterator over the profiles of previously played games.

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

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

impl<M, U, G, const P: usize> History<G, P>

where M: Move, U: Utility, G: Game<P, Move = M, Utility = U, Outcome = SequentialOutcome<M, U, P>>,

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

Get an iterator over the transcripts of previously played games.

Trait Implementations

impl<G: Game<P>, const P: usize> Clone for History<G, P>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<G: Game<P>, const P: usize> Debug for History<G, P>

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

Formats the value using the given formatter.

impl<G: Game<P>, const P: usize> Default for History<G, P>

fn default() -> Self

Returns the “default value” for a type.

impl<G: Game<P>, const P: usize> Hash for History<G, P>

where G::Outcome: Hash, G::Utility: Hash,

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<G: Game<P>, const P: usize> Outcome<<G as Game<P>>::Move, <G as Game<P>>::Utility, P> for History<G, P>

type Record = History<G, 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<G::Utility, P>

The payoff associated with this outcome.

impl<G: Game<P>, const P: usize> PartialEq for History<G, P>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<G: Game<P>, const P: usize> Record<<G as Game<P>>::Move, P> for History<G, P>

fn plies(&self) -> Plies<'_, G::Move, 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.