Game.Poker.Hands

Documentation

data Hand

Constrained cards in hand

>>> :type fromHand
fromHand :: Hand -> [Card]

Instances

Eq Hand

Methods

(==) :: Hand -> Hand -> Bool

(/=) :: Hand -> Hand -> Bool

Ord Hand

Methods

compare :: Hand -> Hand -> Ordering

(<) :: Hand -> Hand -> Bool

(<=) :: Hand -> Hand -> Bool

(>) :: Hand -> Hand -> Bool

(>=) :: Hand -> Hand -> Bool

max :: Hand -> Hand -> Hand

min :: Hand -> Hand -> Hand

Show Hand

Methods

showsPrec :: Int -> Hand -> ShowS

show :: Hand -> String

showList :: [Hand] -> ShowS

toHand :: [Card] -> Maybe Hand

Cards to Hard

>>> toHand allCards
Nothing

>>> fmap (length . fromHand) (toHand $ take 5 allCards)
Just 5

fromHand :: Hand -> [Card]

pokerHand :: Hand -> (PokerHand, Card)

Detect poker hand and return strength Card

>>> let sameNum = filter ((==14) . cardNumber) allCards
>>> let sameSuit = filter ((==Hearts) . cardSuit) allCards

>>> pokerHand (Hand $ take 5 sameSuit)
(StraightFlush,H6_)

>>> let buta = take 2 allCards ++ (take 2 $ drop 17 allCards) ++ [last allCards]
>>> pokerHand (Hand buta)
(HighCards,SA_)

data PokerHand

Instances

Enum PokerHand

Methods

succ :: PokerHand -> PokerHand

pred :: PokerHand -> PokerHand

toEnum :: Int -> PokerHand

fromEnum :: PokerHand -> Int

enumFrom :: PokerHand -> [PokerHand]

enumFromThen :: PokerHand -> PokerHand -> [PokerHand]

enumFromTo :: PokerHand -> PokerHand -> [PokerHand]

enumFromThenTo :: PokerHand -> PokerHand -> PokerHand -> [PokerHand]

Eq PokerHand

Methods

(==) :: PokerHand -> PokerHand -> Bool

(/=) :: PokerHand -> PokerHand -> Bool

Ord PokerHand

Methods

compare :: PokerHand -> PokerHand -> Ordering

(<) :: PokerHand -> PokerHand -> Bool

(<=) :: PokerHand -> PokerHand -> Bool

(>) :: PokerHand -> PokerHand -> Bool

(>=) :: PokerHand -> PokerHand -> Bool

max :: PokerHand -> PokerHand -> PokerHand

min :: PokerHand -> PokerHand -> PokerHand

Read PokerHand

Methods

readsPrec :: Int -> ReadS PokerHand

readList :: ReadS [PokerHand]

readPrec :: ReadPrec PokerHand

readListPrec :: ReadPrec [PokerHand]

Show PokerHand

Methods

showsPrec :: Int -> PokerHand -> ShowS

show :: PokerHand -> String

showList :: [PokerHand] -> ShowS

straightHint :: Hand -> Maybe Card

Check straight in Hand

>>> straightHint $ Hand (take 5 allCards)
Just H6_

>>> straightHint $ Hand (take 5 $ drop 8 allCards)
Just HA_

>>> straightHint $ Hand (take 2 $ allCards)
Nothing

flushHint :: Hand -> Maybe Card

Check flush in Hand

>>> flushHint $ Hand (take 5 $ filter (\x -> cardSuit x == Hearts) allCards )
Just H6_

>>> flushHint $ Hand (take 5 $ filter (\x -> cardNumber x == 2) allCards )
Nothing

nOfKindHint :: Int -> Hand -> Maybe [[Card]]

n of Kind in Hand

>>> let treeCards = take 3 $ filter ((==2) . cardNumber) $ allCards
>>> let twoCards = take 2 $ filter ((==10) . cardNumber) $ allCards
>>> let fullhouse = toHand $ treeCards ++ twoCards

>>> fullhouse >>= nOfKindHint 2
Just [[H10,D10]]

>>> fullhouse >>= nOfKindHint 3
Just [[H2_,D2_,C2_]]

>>> fullhouse >>= nOfKindHint 4
Nothing

straightFlush :: Hand -> Maybe (PokerHand, Card)

Detect StraightFlush and return strongest Card

>>> straightFlush $ Hand (take 5 $ filter ((==Hearts) . cardSuit) allCards)
Just (StraightFlush,H6_)

>>> straightFlush $ Hand (take 5 $ filter (\x -> cardSuit x == Hearts && even (cardNumber x)) allCards)
Nothing

>>> let sameSuit = filter ((==Hearts) . cardSuit) allCards
>>> let sameSuit' = filter ((==Spades) . cardSuit) allCards
>>> straightFlush $ Hand (take 3 sameSuit ++ take 2 (drop 3 sameSuit'))
Nothing

>>> straightFlush $ Hand (take 5 $ filter (even . cardNumber) allCards)
Nothing

fourOfAKind :: Hand -> Maybe (PokerHand, Card)

Detect FourOfAKind and return strongest Card

>>> let sameNum = filter ((==4) . cardNumber) allCards
>>> let sameSuit = filter ((==Spades) . cardSuit) allCards
>>> fourOfAKind $ Hand (take 4 sameNum ++ take 1 sameSuit)
Just (FourOfAKind,S4_)

>>> fourOfAKind $ Hand (take 5 sameSuit)
Nothing

fullHouse :: Hand -> Maybe (PokerHand, Card)

Detect fullHouse and return strongest Card

>>> let sameNum = filter ((==9) . cardNumber) allCards
>>> let sameNum' = filter ((==10) . cardNumber) allCards
>>> let sameSuit = filter ((==Spades) . cardSuit) allCards
>>> fullHouse $ Hand (take 2 sameNum ++ take 3 sameNum')
Just (FullHouse,C10)

>>> fullHouse $ Hand (take 3 sameNum ++ take 2 sameNum')
Just (FullHouse,C9_)

>>> fullHouse $ Hand (take 2 sameNum ++ take 3 sameSuit)
Nothing

>>> fullHouse $ Hand (take 5 sameSuit)
Nothing

flush :: Hand -> Maybe (PokerHand, Card)

Detect Flush and return strongest Card

>>> flush $ Hand (take 5 $ filter ((==Hearts) . cardSuit ) allCards)
Just (Flush,H6_)

>>> flush $ Hand (take 5 $ filter ((<= 3) . cardNumber) allCards)
Nothing

straight :: Hand -> Maybe (PokerHand, Card)

Detect Straight and return strongest Card

>>> straight $ Hand (take 5 $ filter ((==Hearts) . cardSuit) allCards)
Just (Straight,H6_)

>>> straight $ Hand (take 5 $ filter (even . cardNumber) allCards)
Nothing

threeOfAKind :: Hand -> Maybe (PokerHand, Card)

Detect ThreeOfAKind and return strongest Card

>>> let sameNum = filter ((==4) . cardNumber) allCards
>>> let sameSuit = filter ((==Spades) . cardSuit) allCards
>>> threeOfAKind $ Hand (take 3 sameNum ++ take 2 sameSuit)
Just (ThreeOfAKind,C4_)

>>> threeOfAKind $ Hand (take 5 sameSuit)
Nothing

twoPair :: Hand -> Maybe (PokerHand, Card)

Detect TwoPair and return strongest Card

>>> let sameNum = filter ((==9) . cardNumber) allCards
>>> let sameNum' = filter ((==10) . cardNumber) allCards
>>> let sameSuit = filter ((==Spades) . cardSuit) allCards
>>> twoPair $ Hand (take 2 sameNum ++ take 2 sameNum' ++ take 1 sameSuit)
Just (TwoPair,D10)

>>> twoPair $ Hand (take 2 sameNum ++ take 3 sameSuit)
Nothing

>>> twoPair $ Hand (take 5 sameSuit)
Nothing

onePair :: Hand -> Maybe (PokerHand, Card)

Detect onePair and return strongest Card

>>> let sameNum = filter ((==9) . cardNumber) allCards
>>> let sameSuit = filter ((==Spades) . cardSuit) allCards
>>> onePair $ Hand (take 2 sameNum ++ take 3 sameSuit)
Just (OnePair,D9_)

>>> onePair $ Hand (take 5 sameSuit)
Nothing