Struct Partial 

pub struct Partial { /* private fields */ }

Perfect-recall game history from a single player’s perspective.

While Game is memoryless, Partial tracks the complete action sequence from the start of a hand. This is the primary type for inference time: hero knows their own cards but not the opponent’s.

Information Boundary

Type	Perspective	Used For
Partial	Hero only (own cards)	Inference, UI, opponent iteration
Perfect	God’s view (both hands)	Training CFR traversal

Key Operations

• NlheInfo::from((&partial, abstraction)) for strategy lookup
• Perfect::from((&partial, hole)) for opponent modeling
• partial.histories() → iterate all possible opponent hands

Structure

• pov — Which player’s perspective we’re tracking
• actions — Action sequence excluding blinds (bets, draws)
• reveals — The card arrangement for this hand (hero’s observation)

Invariants

Assumes default stacks (100bb) and P0 on button. Blinds are constant and handled by root() returning a POST-blind state.

Implementations

impl Partial

pub fn initial(pov: Turn) -> Self

Creates a recall at the start of a hand (blinds posted, no decisions).

pub fn with_pov(&self, pov: Turn) -> Self

Returns a new recall with the given perspective.

impl Partial

Strategy lookup methods.

pub fn betting_edges(&self) -> Vec<Edge>

Returns all betting edges (Open or Raise) available at the current state.

pub fn histories(&self) -> Vec<(Observation, Perfect)>

Iterates over all possible opponent hands.

For each opponent observation, yields a complete-information Perfect that can compute exact reach probabilities. Since Partial has partial information (only hero’s cards), this method enumerates the unknown opponent hands.

impl Partial

pub fn try_build( pov: Turn, seen: Observation, actions: Vec<Action>, ) -> Result<Self>

Fallible constructor from (POV, observation, actions).

Returns Err if any action in the sequence is illegal, enabling graceful error handling for untrusted input. The actions parameter should NOT include blinds.

impl Partial

State reconstruction methods.

pub fn base(&self) -> Game

Returns the initial game state (before blinds, with hero’s hole cards).

pub fn street(&self) -> Street

The current betting street.

pub fn dealt(&self) -> Street

The street based on Draw actions in the action sequence.

pub fn turn(&self) -> Turn

The player perspective for this recall.

pub fn arr(&self) -> Arrangement

The card arrangement for this recall.

pub fn seen(&self) -> Observation

The observation (hole cards + board) for this recall.

pub fn reset(&self) -> Self

Resets to initial state (no decisions), preserving POV and cards.

pub fn cursor(&self) -> NodeIndex

Node index for graph traversal.

pub fn plays(&self) -> Vec<(Position, Action, Street)>

Returns (position, action, street) for each action in the sequence.

pub fn aggressor(&self) -> Option<Position>

Finds the last aggressor on the final betting street. Returns None if no aggressive action was taken (all checks/calls).

pub fn truncate(&self, street: Street) -> Self

Truncates actions to a specific street.

pub fn replace(&self, reveals: Arrangement) -> Self

Swaps the card arrangement, updating draw actions to match.

pub fn decisions(&self, street: Street) -> Vec<Action>

Player decisions (non-draw) for a specific street.

pub fn board(&self) -> Vec<Card>

Community cards dealt so far (in deal order).

pub fn revealed(&self, street: Street) -> Vec<Card>

Cards revealed on a specific street.

pub fn isomorphism(&self) -> Isomorphism

The canonical form of the observation.

pub fn empty(&self) -> bool

True if no decisions have been made.

pub fn aligned(&self) -> bool

True if observation’s public cards match the dealt draw actions.

impl Partial

Action modification methods.

pub fn undo(&self) -> Self

Removes the most recent action and any trailing draws.

pub fn push(&self, action: Action) -> Self

Adds an action, auto-inserting draw actions when needed.

pub fn try_push(&self, action: Action) -> Result<Self>

Fallible version of push.

Returns Err if the action is not legal in the current state, enabling graceful error handling instead of panicking.

impl Partial

Validation.

pub fn validate(self) -> Result<Self>

Validates alignment and playability, returning error if invalid.

impl Partial

State predicates.

pub fn can_play(&self) -> bool

True if it’s hero’s turn and observation is current.

pub fn can_push(&self, action: &Action) -> bool

True if the action is legal in the current state.

pub fn can_undo(&self) -> bool

True if there are actions to undo.

Trait Implementations

impl Arbitrary for Partial

fn random() -> Self

Generate a uniformly random instance.

impl Clone for Partial

fn clone(&self) -> Partial

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Partial

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

Formats the value using the given formatter.

impl Display for Partial

Display shows a compact visual representation of the game history Format: table with cards from arrangement (preserving deal order) and actions in a fixed-width grid layout

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

Formats the value using the given formatter.

impl From<(Turn, Arrangement)> for Partial

Constructs recall from a POV and arrangement (no decisions yet).

fn from((pov, reveals): (Turn, Arrangement)) -> Self

Converts to this type from the input type.

impl From<(Turn, Observation, Vec<Action>)> for Partial

fn from((pov, seen, actions): (Turn, Observation, Vec<Action>)) -> Self

Converts to this type from the input type.

impl From<Street> for Partial

random non-folding actions lead to this street

fn from(_: Street) -> Self

Converts to this type from the input type.

impl Hash for Partial

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 PartialEq for Partial

fn eq(&self, other: &Partial) -> 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 Recall for Partial

fn root(&self) -> Game

The starting game state for replaying actions (POST-blind).

fn actions(&self) -> &[Action]

The action sequence from root to current state (excludes blinds).

fn complete(&self) -> Vec<Action>

Complete action sequence including blinds (for client display).

fn head(&self) -> Game

Current game state (replay actions from root).

fn states(&self) -> Vec<Game>

Sequence of game states from root to head.

fn aggression(&self) -> usize

Current aggression (trailing aggressive actions on current street).

fn history(&self) -> Vec<Edge>

Full edge history (all streets).

fn subgame(&self) -> Path

Current street edges only (trailing choice edges before any Draw).

fn choices(&self) -> Path

Available actions at current state.

impl Eq for Partial

impl StructuralPartialEq for Partial