Data.Poker

Evaluation

handValue

Arguments

:: CardSet

Available cards.

-> HandValue

Find the strongest possible hand using the given cards.

handValue_n

Arguments

:: Int

Size of card set.

-> CardSet

Available cards.

-> HandValue

Find the strongest possible hand using the given cards. This function is significantly faster than handValue if the size of the card set is constant.

numericalHandValue

Arguments

:: CardSet

Available cards.

-> NumericalHandValue

Find the strongest possible hand using the given cards.

It is significantly faster to compute a NumericalHandValue than a HandValue. Use this function instead of handValue when possible.

numericalHandValue_n

Arguments

:: Int

Size of card set.

-> CardSet

Available cards.

-> NumericalHandValue

Find the strongest possible hand using the given cards. This function is significantly faster than numericalHandValue if the size of the card set is constant.

It is significantly faster to compute a NumericalHandValue than a HandValue. Use this function instead of handValue_n when possible.

Enumeration

foldlSevenCards

Arguments

:: (CardSet -> a -> a)

-> a

-> CardSet

Dead cards.

-> a

Strict left-fold over all 7 card combinations excluding the dead cards.

foldlFiveCards

Arguments

:: (CardSet -> a -> a)

-> a

-> CardSet

Dead cards.

-> a

Strict left-fold over all 5 card combinations excluding the dead cards.

foldlFourCards

Arguments

:: (CardSet -> a -> a)

-> a

-> CardSet

Dead cards.

-> a

Strict left-fold over all 4 card combinations excluding the dead cards.

foldlThreeCards

Arguments

:: (CardSet -> a -> a)

-> a

-> CardSet

Dead cards.

-> a

Strict left-fold over all 3 card combinations excluding the dead cards.

foldlTwoCards

Arguments

:: (CardSet -> a -> a)

-> a

-> CardSet

Dead cards.

-> a

Strict left-fold over all 2 card combinations excluding the dead cards.

foldlOneCard

Arguments

:: (CardSet -> a -> a)

-> a

-> CardSet

Dead cards.

-> a

Strict left-fold over all 1 card combinations excluding the dead cards.

enumerateFiveCards :: Monad m => CardSet -> (CardSet -> m ()) -> m ()

Given a set of dead cards, enumerate over all possible selections of five cards. The generated card sets do not contain the dead cards.

HandValue

data HandValue

This structure represents the value of a poker hand as a high-level ADT.

The following must be true for a HandValue to be valid:

• All kickers must be in decending order.
• No Rank may not occur twice.
• The kickers may not construct higher-value hands.

For example, NoPair Six Five Four Three Two is not a valid HandValue.

Constructors

NoPair Kicker Kicker Kicker Kicker Kicker

OnePair Rank Kicker Kicker Kicker

TwoPair Rank Rank Kicker

ThreeOfAKind Rank Kicker Kicker

Straight Rank

Flush Kicker Kicker Kicker Kicker Kicker

FullHouse Rank Rank

FourOfAKind Rank Kicker

StraightFlush Rank

Instances

Bounded HandValue

Enum HandValue

Eq HandValue

Ord HandValue

Show HandValue

Random HandValue

data NumericalHandValue

Isomorphic to HandValue but computed much more efficiently.

If possible, this is the structure to use.

Instances

Eq NumericalHandValue

Ord NumericalHandValue

Show NumericalHandValue

data ConsecutiveHandValue

Isomorphic to HandValue but stored more efficiently.

This structure has the special property of being bounded and an enum. It is especially useful as an Array index.

Instances

Bounded ConsecutiveHandValue

Eq ConsecutiveHandValue

Ord ConsecutiveHandValue

Show ConsecutiveHandValue

Ix ConsecutiveHandValue

Random ConsecutiveHandValue

Cards

data Card

Abstract representation of a card consisting of a Rank and a Suit

Instances

Bounded Card

Enum Card

Eq Card

Ord Card

Read Card

Show Card

Random Card

data Rank

Constructors

Two

Three

Four

Five

Six

Seven

Eight

Nine

Ten

Jack

Queen

King

Ace

Instances

Bounded Rank

Enum Rank

Eq Rank

Ord Rank

Show Rank

Random Rank

data Suit

Constructors

Hearts

Diamonds

Clubs

Spades

Instances

Bounded Suit

Enum Suit

Eq Suit

Ord Suit

Show Suit

Random Suit

type Kicker = Rank

mkCard :: Rank -> Suit -> Card

Construct a card with the given rank and suit.

cardRank :: Card -> Rank

Inspect the rank of a card.

cardSuit :: Card -> Suit

Inspect the suit of a card.

Card sets

data CardSet

A set of cards.

Instances

Bounded CardSet

Eq CardSet

Ord CardSet

Read CardSet

Show CardSet

Random CardSet

toList :: CardSet -> [Card]

O(n). Convert the set to a list of cards.

fromList :: [Card] -> CardSet

O(n). Create a set from a list of cards.

singleton :: Card -> CardSet

O(1). Create a singleton set.

size :: CardSet -> Int

O(n). The number of cards in the set.

Performance note: Try to avoid using this function in an inner loop.

empty :: CardSet

O(1). The empty set.

isEmpty :: CardSet -> Bool

O(1). Is this the empty set?

union :: CardSet -> CardSet -> CardSet

O(1). The union of two sets.

intersection :: CardSet -> CardSet -> CardSet

O(1). The intersection of two sets.

inverse :: CardSet -> CardSet

O(1). Find the inverse set such that set intersection inverse = empty and set union inverse set = fromList [minBound ..].

member :: CardSet -> Card -> Bool

O(1). Is the card in the set?

countRank :: CardSet -> Rank -> Int

O(n). Count the number of cards with a specific Rank in a set.

countSuit :: CardSet -> Suit -> Int

O(n). Count the number of cards with a specific Suit in a set.

Auxiliary functions

HandValue

isNoPair :: HandValue -> Bool

True for all NoPair hands.

isOnePair :: HandValue -> Bool

True for all OnePair hands.

isTwoPair :: HandValue -> Bool

True for all TwoPair hands.

isThreeOfAKind :: HandValue -> Bool

True for all ThreeOfAKind hands.

isStraight :: HandValue -> Bool

True for all Straight hands.

isFlush :: HandValue -> Bool

True for all Flush hands.

isFullHouse :: HandValue -> Bool

True for all FullHouse hands.

isFourOfAKind :: HandValue -> Bool

True for all FourOfAKind hands.

isStraightFlush :: HandValue -> Bool

True for all StraightFlush hands.