Enum HandType 

pub enum HandType {
    HighCard,
    Pair,
    TwoPair,
    Trips,
    Straight,
    Flush,
    FullHouse,
    Quads,
    StraightFlush,
}

Represents the categorical type of a poker hand.

This enum classifies poker hands into their standard categories, ordered from weakest to strongest. It is used to quickly identify what type of hand a player has without considering the specific ranks involved.

Ordering

The variants are ordered from weakest (HighCard) to strongest (StraightFlush), matching standard poker hand rankings.

Variants

HighCard

No matching cards (default/weakest hand type)

Pair

Two cards of the same rank

TwoPair

Two different pairs

Trips

Three cards of the same rank

Straight

Five cards in sequential rank

Flush

Five cards of the same suit

FullHouse

Three of a kind plus a pair

Quads

Four cards of the same rank

StraightFlush

Five cards in sequential rank, all of the same suit

Implementations

impl HandType

pub const MAX: Self = Self::StraightFlush

pub const MIN: Self = Self::HighCard

pub const ARR_ALL: [Self; 9]

pub fn compare<const SD: bool>(self, other: Self) -> Ordering

Trait Implementations

impl Clone for HandType

fn clone(&self) -> HandType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HandType

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

Formats the value using the given formatter.

impl Default for HandType

fn default() -> HandType

Returns the “default value” for a type.

impl Display for HandType

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

Formats the value using the given formatter.

impl From<HandRating> for HandType

fn from(hand_ranking: HandRating) -> Self

Extracts the categorical hand type from a HandRanking.

This implementation decodes the bit-packed HandRanking to determine the hand type. It uses bit masking to identify the hand category from the upper bits and additional bit checks to distinguish between hands that share the same mask (e.g., Flush vs FullHouse, Quads vs StraightFlush).

impl FromStr for HandType

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq for HandType

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

impl Eq for HandType

impl StructuralPartialEq for HandType