Struct cardpack::cards::pack::Pack

pub struct Pack { /* private fields */ }

A Pack is an immutable pile of cards. Packs are designed to be a flexible representation of a deck, stack, discard pile, or hand.

Packs available are for a traditional 52 card French Deck, pinochle, spades, skat and tarot.

Usage:

let pack = cardpack::Pack::french_deck();

let mut shuffled = pack.cards().shuffle();
let sb = shuffled.draw(2).unwrap();
let bb = shuffled.draw(2).unwrap();

println!("small blind: {}", sb.to_symbol_index());
println!("big blind:   {}", bb);

println!();
println!("flop : {}", shuffled.draw(3).unwrap());
println!("turn : {}", shuffled.draw(1).unwrap());
println!("river: {}", shuffled.draw(1).unwrap());

Implementations

impl Pack

pub fn is_complete(&self, piles: &[Pile]) -> bool

Returns true of the combined Cards from the passed in Vector match the Cards in the Pack.

pub fn cards(&self) -> &Pile

Returns a reference to the cards in the Pack.

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

Returns true if the passed in Card is a part of the Pack.

pub fn canasta_deck() -> Self

pub fn euchre_deck() -> Self

pub fn hand_and_foot_deck() -> Self

pub fn french_deck() -> Self

pub fn french_deck_with_jokers() -> Self

pub fn pinochle_deck() -> Self

pub fn short_deck() -> Self

pub fn skat_deck() -> Self

pub fn spades_deck() -> Self

pub fn tarot_deck() -> Self

Trait Implementations

impl Clone for Pack

fn clone(&self) -> Pack

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Pack

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

Formats the value using the given formatter.

impl Hash for Pack

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 Pack

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