Struct Card 

pub struct Card(/* private fields */);

A Card is a Newtype u32 representation of a variant of Cactus Kev’s binary representation of a poker card as designed for rapid hand evaluation as documented here.

The variation being that the Suit bits order is inverted for easier sorting.

+--------+--------+--------+--------+
|mmmbbbbb|bbbbbbbb|SHDCrrrr|xxpppppp|
+--------+--------+--------+--------+

p = prime number of rank (deuce=2,trey=3,four=5,...,ace=41)
r = rank of card (deuce=0,trey=1,four=2,five=3,...,ace=12)
SHDC = suit of card (bit turned on based on suit of card)
b = bit turned on depending on rank of card
m = Flags reserved for multiples of the same rank. Stripped for evals.

Implementations

impl Card

pub const RANK_FLAG_FILTER: u32 = 0x1FFF_0000

pub const RANK_FLAG_SHIFT: u32 = 16

pub const RANK_PRIME_FILTER: u32 = 0b0011_1111

pub const SUIT_FLAG_FILTER: u32 = 0xF000

Binary filter for CardNumber Suit flags. 00000000 00000000 11110000 00000000

pub const SUIT_SHORT_MASK: u32 = 0b1111

pub const SUIT_FLAG_SHIFT: u32 = 12

pub const FREQUENCY_PAIRED_MASK: u32 = 0b0010_0000_0000_0000_0000_0000_0000_0000

Frequency Weight masks

pub const FREQUENCY_TRIPPED_MASK: u32 = 0b0100_0000_0000_0000_0000_0000_0000_0000

pub const FREQUENCY_QUADED_MASK: u32 = 0b1000_0000_0000_0000_0000_0000_0000_0000

pub const FREQUENCY_MASK: u32 = 0b1110_0000_0000_0000_0000_0000_0000_0000

pub const FREQUENCY_MASK_FILTER: u32 = 0b0001_1111_1111_1111_1111_1111_1111_1111

pub const ACE_SPADES: Card

pub const KING_SPADES: Card

pub const QUEEN_SPADES: Card

pub const JACK_SPADES: Card

pub const TEN_SPADES: Card

pub const NINE_SPADES: Card

pub const EIGHT_SPADES: Card

pub const SEVEN_SPADES: Card

pub const SIX_SPADES: Card

pub const FIVE_SPADES: Card

pub const FOUR_SPADES: Card

pub const TREY_SPADES: Card

pub const DEUCE_SPADES: Card

pub const ACE_HEARTS: Card

pub const KING_HEARTS: Card

pub const QUEEN_HEARTS: Card

pub const JACK_HEARTS: Card

pub const TEN_HEARTS: Card

pub const NINE_HEARTS: Card

pub const EIGHT_HEARTS: Card

pub const SEVEN_HEARTS: Card

pub const SIX_HEARTS: Card

pub const FIVE_HEARTS: Card

pub const FOUR_HEARTS: Card

pub const TREY_HEARTS: Card

pub const DEUCE_HEARTS: Card

pub const ACE_DIAMONDS: Card

pub const KING_DIAMONDS: Card

pub const QUEEN_DIAMONDS: Card

pub const JACK_DIAMONDS: Card

pub const TEN_DIAMONDS: Card

pub const NINE_DIAMONDS: Card

pub const EIGHT_DIAMONDS: Card

pub const SEVEN_DIAMONDS: Card

pub const SIX_DIAMONDS: Card

pub const FIVE_DIAMONDS: Card

pub const FOUR_DIAMONDS: Card

pub const TREY_DIAMONDS: Card

pub const DEUCE_DIAMONDS: Card

pub const ACE_CLUBS: Card

pub const KING_CLUBS: Card

pub const QUEEN_CLUBS: Card

pub const JACK_CLUBS: Card

pub const TEN_CLUBS: Card

pub const NINE_CLUBS: Card

pub const EIGHT_CLUBS: Card

pub const SEVEN_CLUBS: Card

pub const SIX_CLUBS: Card

pub const FIVE_CLUBS: Card

pub const FOUR_CLUBS: Card

pub const TREY_CLUBS: Card

pub const DEUCE_CLUBS: Card

pub const BLANK: Card

pub fn new(rank: Rank, suit: Suit) -> Self

pub fn filter(card: Card) -> Result<Self, PKError>

Errors

Returns PKError::BlankCard if the Card is blank.

pub fn as_u32(&self) -> u32

Returns the Cactus Kev Card u32 number of the Card.

pub fn bit_string(&self) -> String

pub fn bit_string_guided(&self) -> String

This code is doing too much. I need to Uncle Bob it. Aside on why I am giving up that phrase.

pub fn frequency_paired(&self) -> Card

Returns a new version of Card with the paired frequency bit set.

pub fn frequency_tripped(&self) -> Card

Returns a new version of Card with the tripped frequency bit set.

pub fn frequency_quaded(&self) -> Card

Returns a new version of Card with the quaded frequency bit set.

Quaded??!!

pub fn get_letter_index(&self) -> String

pub fn get_rank(&self) -> Rank

pub fn get_rank_prime(&self) -> u32

pub fn get_suit(&self) -> Suit

pub fn is_flagged(&self, flag: u32) -> bool

Trait Implementations

impl Clone for Card

fn clone(&self) -> Card

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Card

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

Formats the value using the given formatter.

impl Default for Card

fn default() -> Card

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Card

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Card

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

use pkcore::prelude::*;

assert_eq!("A♠", Card::ACE_SPADES.to_string());
assert_eq!("__", Card::BLANK.to_string());

impl From<&Card> for Bard

fn from(card: &Card) -> Self

Converts to this type from the input type.

impl From<&Card> for Cards

fn from(card: &Card) -> Self

Turns out we already have a TryFrom<Card> implemented, but I want something similar. This will give us the contract that if it’s blank it won’t be inserted, which is fine. I can see wanted to do both versions of the functionality.

When I am coding in rust, I do feel the constant tension between my desire to make things just flow as easily as possible in the short term, and wanting to code things the right, “rusty” way.

My general rule is to follow Socrates’ maxim: the unexamined life is not worth living. Know why you are doing anything. Following rules blindly makes you a tool. If you can’t answer questions like: why did you code it this way? and what’s the purpose of this test? you need to take a step back

impl From<Card> for Bard

fn from(card: Card) -> Self

Converts to this type from the input type.

impl From<u32> for Card

Filters u32 so that only valid Cactus Kev Card values are set.

fn from(ckc_number: u32) -> Self

Converts to this type from the input type.

impl FromIterator<Card> for Cards

fn from_iter<T: IntoIterator<Item = Card>>(iter: T) -> Self

Creates a value from an iterator.

impl FromStr for Card

type Err = PKError

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 Hash for Card

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 Ord for Card

fn cmp(&self, other: &Card) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Card

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

fn partial_cmp(&self, other: &Card) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Pile for Card

fn add<P: Pile>(&self, _other: P) -> Self

where Self: Sized,

fn card_at(self, _index: usize) -> Option<Card>

fn clean(&self) -> Self

Will this work? Can I create a self-referential clean? Only one way to find out…

fn contains_blank(&self) -> bool

fn swap(&mut self, _index: usize, card: Card) -> Option<Card>

fn the_nuts(&self) -> TheNuts

fn to_vec(&self) -> Vec<Card>

fn are_unique(&self) -> bool

This code is cribbed from oli_obk.

fn bard(&self) -> Bard

fn cards(&self) -> Cards

fn collapse(&self) -> u32

This is a bit of a hack. I’m not sure if I should be doing this. I’m going to try it and

fn combinations_after( &self, k: usize, cards: &Cards, ) -> Combinations<IntoIter<Card>>

If I can move logic to a trait that can be automatically reusable by other implementations that I do it. A strict TDD person could argue that you shouldn’t do this unless you have a need for more than one use case that demands it. As an anti-fundamentalist, when I see these moments of beauty, I do them. It simplifies my code, and I have a good enough feel for the domain at this point to know that it will come in handy later.

fn combinations_remaining(&self, k: usize) -> Combinations<IntoIter<Card>>

fn par_combinations_remaining( &self, k: usize, ) -> IterBridge<Combinations<IntoIter<Card>>>

fn contains(&self, card: &Card) -> bool

Tried refactoring this as self.cards().index_set().contains(card), but it broke a lot of negative tests, since it just stripped out Card::BLANK.

fn enumerate_after( &self, k: usize, cards: &Cards, ) -> Enumerate<Combinations<IntoIter<Card>>>

fn enumerate_remaining( &self, k: usize, ) -> Enumerate<Combinations<IntoIter<Card>>>

fn get_rank_bits(&self) -> u16

fn how_many(&self, cards: &Cards) -> usize

fn common(&self, cards: &Cards) -> Cards

fn is_dealt(&self) -> bool

This feels like the best name for this functionality. If a Pile doesn’t contain a blank card, and all of the cards are unique, that it has been dealt.

fn remaining(&self) -> Cards

fn remaining_after(&self, cards: &Cards) -> Cards

fn ranks(&self) -> Ranks

Returns the Ranks vector struct for the Pile.

fn ranks_index(&self) -> String

fn suits(&self) -> HashSet<Suit>

fn to_eight_or_better_bits(&self) -> u8

fn evals(&self) -> Evals

impl Serialize for Card

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl SuitShift for Card

fn shift_suit_down(&self) -> Self

fn shift_suit_up(&self) -> Self

fn opposite(&self) -> Self

I don’t trust this concept. Up and down are straightforward, but not this I need to do a deep dive into unique and distinct patterns.

impl TryFrom<Bard> for Card

type Error = PKError

The type returned in the event of a conversion error.

fn try_from(bard: Bard) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Card> for Cards

type Error = PKError

The type returned in the event of a conversion error.

fn try_from(card: Card) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for Card

impl Eq for Card

impl StructuralPartialEq for Card