-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Library supporting simulation of a number of games
--   
--   Library providing framework for simulating outcomes of a variety of
--   games, including Poker.
@package general-games
@version 1.1.1


-- | The Game.Implement.Card module provides fundamental operations for a
--   deck of cards.
module Game.Implement.Card

-- | Represents a physical card with no order and no value. Inherited Enum,
--   Eq, Ord and Bounded typeclasses are used to distingish cards for the
--   purposes of manipulation within lists. Game value functions are
--   provided by other typeclasses.
class (Enum c, Eq c, Ord c, Bounded c) => Card c

-- | Return all combinations of size n of a deck of cards
choose :: Card c => Int -> [c] -> [[c]]

-- | Return a full deck of cards. Cards are unique. Order is not
--   guaranteed.
--   
--   <pre>
--   &gt;&gt;&gt; fullDeck :: [PlayingCard]
--   [Ace of Clubs,Two of Clubs,Three of Clubs,Four of Clubs,Five of Clubs,Six of Clubs,Seven of Clubs,Eight of Clubs,Nine of Clubs,Ten of Clubs,Jack of Clubs,Queen of Clubs,King of Clubs,Ace of Diamonds,Two of Diamonds,Three of Diamonds,Four of Diamonds,Five of Diamonds,Six of Diamonds,Seven of Diamonds,Eight of Diamonds,Nine of Diamonds,Ten of Diamonds,Jack of Diamonds,Queen of Diamonds,King of Diamonds,Ace of Hearts,Two of Hearts,Three of Hearts,Four of Hearts,Five of Hearts,Six of Hearts,Seven of Hearts,Eight of Hearts,Nine of Hearts,Ten of Hearts,Jack of Hearts,Queen of Hearts,King of Hearts,Ace of Spades,Two of Spades,Three of Spades,Four of Spades,Five of Spades,Six of Spades,Seven of Spades,Eight of Spades,Nine of Spades,Ten of Spades,Jack of Spades,Queen of Spades,King of Spades]
--   </pre>
fullDeck :: Card c => [c]

-- | Returns all unique cards in a list. All duplicates are removed.
dedupe :: Card c => [c] -> [c]

-- | Draws cards from a deck, and groups them based on the list provided in
--   the first argument. Returns the grouped hands and the remaining deck.
--   Arguments that are negative or exceed bounds return Nothing.
--   
--   For instance, to simulate a three player Hold'em game, one might wish
--   to draw two cards for each player, and five cards for the community:
--   
--   <pre>
--   &gt;&gt;&gt; deck &lt;- evalRandIO $ shuffle $ (fullDeck :: [PlayingCard])
--   
--   &gt;&gt;&gt; draw [2,2,2,5] deck
--   Just ([[Ace of Spades,Jack of Spades],[Queen of Hearts,Seven of Clubs],[Jack of Diamonds,Six of Hearts],[Jack of Hearts,Five of Spades,Three of Spades,Two of Diamonds,Ace of Hearts]],[Four of Clubs,Six of Diamonds,Four of Diamonds,Eight of Spades,Six of Clubs,Seven of Spades,Three of Diamonds,Ten of Diamonds,Eight of Hearts,Nine of Diamonds,Three of Clubs,Six of Spades,King of Clubs,Nine of Clubs,Four of Spades,Five of Diamonds,Nine of Spades,Queen of Spades,Ace of Diamonds,Four of Hearts,Two of Clubs,Five of Clubs,Two of Hearts,King of Diamonds,Ten of Spades,Eight of Clubs,Seven of Hearts,Three of Hearts,Queen of Diamonds,Queen of Clubs,Ten of Clubs,King of Hearts,Eight of Diamonds,Jack of Clubs,Ten of Hearts,Seven of Diamonds,Two of Spades,Nine of Hearts,King of Spades,Ace of Clubs,Five of Hearts])
--   </pre>
draw :: Card c => [Int] -> [c] -> Maybe ([[c]], [c])

-- | The same as <a>draw</a>, except throw away the deck
--   
--   <pre>
--   &gt;&gt;&gt; deck &lt;- evalRandIO $ shuffle $ (fullDeck :: [PlayingCard])
--   
--   &gt;&gt;&gt; draw_ [2,2,2,5] deck
--   Just [[Eight of Hearts,Queen of Hearts],[Two of Clubs,Seven of Diamonds],[Ten of Clubs,Three of Hearts],[Ace of Spades,Nine of Spades,Five of Spades,Four of Diamonds,Two of Spades]]
--   </pre>
draw_ :: Card c => [Int] -> [c] -> Maybe [[c]]

-- | The same as <a>draw</a>, except draw only one hand of specified size.
--   
--   <pre>
--   &gt;&gt;&gt; deck &lt;- evalRandIO $ shuffle $ (fullDeck :: [PlayingCard])
--   
--   &gt;&gt;&gt; draw1 5 deck
--   Just ([Six of Clubs,Ace of Hearts,Nine of Hearts,Four of Hearts,Two of Diamonds],[King of Diamonds,Queen of Spades,Four of Spades,Seven of Hearts,Five of Hearts,Seven of Clubs,Three of Hearts,Ace of Spades,Three of Diamonds,Seven of Diamonds,Two of Clubs,Five of Spades,King of Hearts,Jack of Hearts,Queen of Hearts,Ten of Clubs,Five of Clubs,Eight of Spades,Ace of Clubs,King of Clubs,Five of Diamonds,Queen of Diamonds,Eight of Hearts,Four of Clubs,Three of Clubs,Jack of Clubs,Jack of Diamonds,Ten of Diamonds,Queen of Clubs,Eight of Diamonds,Six of Diamonds,Eight of Clubs,Three of Spades,Two of Hearts,Six of Spades,King of Spades,Ten of Hearts,Nine of Spades,Nine of Diamonds,Two of Spades,Ten of Spades,Nine of Clubs,Four of Diamonds,Ace of Diamonds,Six of Hearts,Seven of Spades,Jack of Spades])
--   </pre>
draw1 :: Card c => Int -> [c] -> Maybe ([c], [c])

-- | The same as <a>draw1</a>, except throw away the deck.
--   
--   <pre>
--   &gt;&gt;&gt; deck &lt;- evalRandIO $ shuffle $ (fullDeck :: [PlayingCard])
--   
--   &gt;&gt;&gt; draw1_ 5 deck
--   Just [Five of Hearts,Ace of Diamonds,Ten of Hearts,Two of Spades,Six of Clubs]
--   </pre>
draw1_ :: Card c => Int -> [c] -> Maybe [c]

-- | Shuffle a deck of cards.
--   
--   <pre>
--   &gt;&gt;&gt; deck &lt;- evalRandIO $ shuffle $ (fullDeck :: [PlayingCard])
--   
--   &gt;&gt;&gt; [Three of Clubs,Nine of Spades,Five of Clubs,Two of Hearts,Four of Spades,King of Hearts,Ten of Hearts,Two of Clubs,Ace of Hearts,Eight of Diamonds,Six of Diamonds,Seven of Diamonds,Jack of Spades,Three of Hearts,Three of Spades,Queen of Clubs,Ten of Diamonds,Six of Spades,Two of Diamonds,Nine of Clubs,Five of Diamonds,Five of Spades,Seven of Spades,Jack of Clubs,Six of Hearts,Jack of Diamonds,Four of Hearts,Ace of Spades,Nine of Diamonds,King of Clubs,Two of Spades,Four of Clubs,Eight of Hearts,Queen of Hearts,Ace of Clubs,Five of Hearts,Ten of Spades,Six of Clubs,Ten of Clubs,Four of Diamonds,Three of Diamonds,Seven of Hearts,King of Diamonds,Ace of Diamonds,Nine of Hearts,Queen of Spades,Seven of Clubs,Jack of Hearts,King of Spades,Eight of Spades,Queen of Diamonds,Eight of Clubs]
--   </pre>
shuffle :: (Card c, RandomGen m) => [c] -> Rand m [c]

-- | Return a random card.
--   
--   <pre>
--   &gt;&gt;&gt; card :: PlayingCard &lt;- evalRandIO $ randomCard
--   
--   &gt;&gt;&gt; card
--   Four of Diamonds
--   </pre>
randomCard :: (Card c, RandomGen m) => Rand m c

-- | Represents a playing card with a game value. For instance, a standard
--   playing card with a type representing rank and suit.
class (Card c) => ValuedCard c v

-- | Return a value associated with a card.
--   
--   <pre>
--   &gt;&gt;&gt; card = PlayingCard Six Clubs
--   
--   &gt;&gt;&gt; toValue card :: Rank
--   Six
--   
--   &gt;&gt;&gt; toValue card :: Suit
--   Clubs
--   </pre>
toValue :: ValuedCard c v => c -> v

-- | Return values associated with multiple cards.
--   
--   <pre>
--   &gt;&gt;&gt; cards = [PlayingCard Six Clubs, PlayingCard Four Diamonds]
--   
--   &gt;&gt;&gt; toValueLst cards :: [Rank]
--   [Six,Four]
--   
--   &gt;&gt;&gt; toValueLst cards :: [Suit]
--   [Clubs,Diamonds]
--   </pre>
toValueLst :: ValuedCard c v => [c] -> [v]

-- | Orderings independent of a specific value type of a Card.
class (Card c) => OrderedCard c o
highestCardBy :: OrderedCard c o => o -> [c] -> c
lowestCardBy :: OrderedCard c o => o -> [c] -> c
compareCardBy :: OrderedCard c o => o -> c -> c -> Ordering
sortCardsBy :: OrderedCard c o => o -> [c] -> [c]

-- | Orderings dependent on the specific value type of a Card
class (OrderedCard c o) => OrderedValuedCard c o vt

-- | Return an Int based on a card, an ordering and a value type.
toOrderedValue :: OrderedValuedCard c o vt => o -> vt -> c -> Int


-- | The Game.Game.Poker module defines structures and operations for a
--   standard set of 52 playing cards.
module Game.Implement.Card.Standard

-- | A representation of a standard playing card, distinguishable by rank
--   and suit.
data PlayingCard
PlayingCard :: Rank -> Suit -> PlayingCard

-- | The rank of a standard playing card.
data Rank
Ace :: Rank
Two :: Rank
Three :: Rank
Four :: Rank
Five :: Rank
Six :: Rank
Seven :: Rank
Eight :: Rank
Nine :: Rank
Ten :: Rank
Jack :: Rank
Queen :: Rank
King :: Rank

-- | The suit of a standard playing card.
data Suit
Clubs :: Suit
Diamonds :: Suit
Hearts :: Suit
Spades :: Suit

-- | Returns a random standard playing card rank, with Ace low.
randomRank :: RandomGen m => Rand m Rank

-- | Returns a random standard playing card from a range, with Ace low.
randomRankR :: RandomGen m => Rank -> Rank -> Rand m Rank

-- | Returns a random Suit.
randomSuit :: RandomGen m => Rand m Suit

-- | Returns a random suit in a given range.
randomSuitR :: RandomGen m => Suit -> Suit -> Rand m Suit

-- | Returns all standard playing card ranks, with Ace low.
ranks :: [Rank]

-- | Returns the number of unique standard playing card ranksu.
nRanks :: Int

-- | Returns the <a>Rank</a> of a <a>PlayingCard</a>
toRank :: PlayingCard -> Rank

-- | Returns a list of <a>Rank</a> of a list of <a>PlayingCard</a>
toRankLst :: [PlayingCard] -> [Rank]

-- | Returns all standard card suits.
suits :: [Suit]

-- | Returns the number of all standard card unique suits.
nSuits :: Int

-- | Returns the <a>Suit</a> of a <a>PlayingCard</a>
toSuit :: PlayingCard -> Suit

-- | Return a list of unique numbers, of length s, drawn without
--   replacement from the set [n..m]
uniqueNumList :: RandomGen g => Int -> Int -> Int -> Rand g (Maybe [Int])

-- | Return lists of lists of unique numbers, of length [s], drawn without
--   replacement from the set [n..m]
uniqueNumLists :: RandomGen g => [Int] -> Int -> Int -> Rand g (Maybe [[Int]])
instance GHC.Classes.Eq Game.Implement.Card.Standard.Value
instance GHC.Enum.Bounded Game.Implement.Card.Standard.PlayingCard
instance GHC.Classes.Ord Game.Implement.Card.Standard.PlayingCard
instance GHC.Classes.Eq Game.Implement.Card.Standard.PlayingCard
instance GHC.Read.Read Game.Implement.Card.Standard.Suit
instance GHC.Enum.Bounded Game.Implement.Card.Standard.Suit
instance GHC.Classes.Ord Game.Implement.Card.Standard.Suit
instance GHC.Classes.Eq Game.Implement.Card.Standard.Suit
instance GHC.Enum.Enum Game.Implement.Card.Standard.Suit
instance GHC.Show.Show Game.Implement.Card.Standard.Suit
instance GHC.Read.Read Game.Implement.Card.Standard.Rank
instance GHC.Enum.Bounded Game.Implement.Card.Standard.Rank
instance GHC.Classes.Ord Game.Implement.Card.Standard.Rank
instance GHC.Classes.Eq Game.Implement.Card.Standard.Rank
instance GHC.Enum.Enum Game.Implement.Card.Standard.Rank
instance GHC.Show.Show Game.Implement.Card.Standard.Rank
instance Game.Implement.Card.Card Game.Implement.Card.Standard.PlayingCard
instance GHC.Enum.Enum Game.Implement.Card.Standard.PlayingCard
instance GHC.Show.Show Game.Implement.Card.Standard.PlayingCard
instance GHC.Read.Read Game.Implement.Card.Standard.PlayingCard
instance Game.Implement.Card.ValuedCard Game.Implement.Card.Standard.PlayingCard Game.Implement.Card.Standard.Rank
instance Game.Implement.Card.ValuedCard Game.Implement.Card.Standard.PlayingCard Game.Implement.Card.Standard.Suit


-- | The Game.Implement.Card.Standard.Poker module defines data types and
--   type class instances for ordered operations on PlayingCard cards.
module Game.Implement.Card.Standard.Poker

-- | <a>Order</a> defines an order to use when sorting a card.
--   <a>AceHighRankOrder</a> sorts under the assumption that an Ace is a
--   high card, and <a>AceLowRankOrder</a> under the assumption that an Ace
--   is a low card. <a>SuitOrder</a> sorts cards by suit, irrespective of
--   their rank.
data Order
AceHighRankOrder :: Order
AceLowRankOrder :: Order
SuitOrder :: Order

-- | <a>ValueType</a> indicates the type Int value to be assigned to a card
--   when the card is evaluated by game value.
data ValueType
RankValueType :: ValueType
SuitValueType :: ValueType
instance GHC.Classes.Eq Game.Implement.Card.Standard.Poker.Order
instance Game.Implement.Card.OrderedValuedCard Game.Implement.Card.Standard.PlayingCard Game.Implement.Card.Standard.Poker.Order Game.Implement.Card.Standard.Poker.ValueType
instance Game.Implement.Card.OrderedCard Game.Implement.Card.Standard.PlayingCard Game.Implement.Card.Standard.Poker.Order


-- | The Game.Game.Poker module provides operations for five card poker.
module Game.Game.Poker

-- | A poker hand. Constructors are hidden, so any hand encapsulated in
--   this type can be considered a valid hand.
--   
--   <pre>
--   &gt;&gt;&gt; deck &lt;- evalRandIO $ shuffle $ (fullDeck :: [PlayingCard])
--   
--   &gt;&gt;&gt; hand = draw1_ 5 deck
--   
--   &gt;&gt;&gt; hand
--   [Five of Diamonds,Jack of Spades,Queen of Spades,Queen of Diamonds,Jack of Hearts]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; pokerhand = fromJust $ mkHand hand
--   
--   &gt;&gt;&gt; pokerhand
--   PokerHand TwoPair [Five of Diamonds,Jack of Spades,Queen of Spades,Queen of Diamonds,Jack of Hearts]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; typeOfPokerHand pokerhand
--   TwoPair
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; cardsOfPokerHand pokerhand
--   [Five of Diamonds,Jack of Spades,Queen of Spades,Queen of Diamonds,Jack of Hearts]
--   </pre>
data PokerHand

-- | The type of a <a>PokerHand</a>.
data PokerHandType
HighCard :: PokerHandType
Pair :: PokerHandType
TwoPair :: PokerHandType
ThreeOfAKind :: PokerHandType
Straight :: AceRank -> PokerHandType
Flush :: PokerHandType
FullHouse :: PokerHandType
FourOfAKind :: PokerHandType
StraightFlush :: AceRank -> PokerHandType
RoyalFlush :: PokerHandType

-- | Indicates if a poker hand uses the Ace as a high card or a low card.
--   AceLow is only used when an Ace is in a hand. Any hand without an Ace
--   is considered AceHigh.
--   
--   <pre>
--   &gt;&gt;&gt; 
--   </pre>
data AceRank
AceHigh :: AceRank
AceLow :: AceRank

-- | Return the cards in a <a>PokerHand</a>
cardsOfPokerHand :: PokerHand -> [PlayingCard]

-- | Return the <a>PokerHandType</a> of a <a>PokerHand</a>
typeOfPokerHand :: PokerHand -> PokerHandType

-- | Given a list of cards, find the best hand in the set. If the number of
--   cards is not equal to five, or there are duplicate cards, mkHand
--   returns Nothing.
mkHand :: [PlayingCard] -> Maybe PokerHand

-- | Return True if a hand matches a specific PokerHandType. False
--   otherwise.
isHand :: PokerHandType -> [PlayingCard] -> Bool

-- | All possible hands of a full deck of playing cards
allPossibleHands :: [[PlayingCard]]

-- | All royal flushes in a full deck of playing cards. The current
--   implementation traverses the entire list of allPossibleHands, and is
--   not efficient.
allRoyalFlush :: [[PlayingCard]]

-- | All straight flushes in a full deck of playing cards. The current
--   implementation traverses the entire list of allPossibleHands, and is
--   not efficient.
allStraightFlush :: [[PlayingCard]]

-- | All four-of-a-kinds in a full deck of playing cards. The current
--   implementation traverses the entire list of allPossibleHands, and is
--   not efficient.
allFourOfAKind :: [[PlayingCard]]

-- | All full houses in a full deck of playing cards. The current
--   implementation traverses the entire list of allPossibleHands, and is
--   not efficient.
allFullHouse :: [[PlayingCard]]

-- | All flushes in a full deck of playing cards. The current
--   implementation traverses the entire list of allPossibleHands, and is
--   not efficient.
allFlush :: [[PlayingCard]]

-- | All straights in a full deck of playing cards. The current
--   implementation traverses the entire list of allPossibleHands, and is
--   not efficient.
allStraight :: [[PlayingCard]]

-- | All three-of-a-kind in a full deck of playing cards. The current
--   implementation traverses the entire list of allPossibleHands, and is
--   not efficient.
allThreeOfAKind :: [[PlayingCard]]

-- | All two pairs in a full deck of playing cards. The current
--   implementation traverses the entire list of allPossibleHands, and is
--   not efficient.
allTwoPair :: [[PlayingCard]]

-- | All pairs in a full deck of playing cards. The current implementation
--   traverses the entire list of allPossibleHands, and is not efficient.
allPair :: [[PlayingCard]]

-- | All high card hands in a full deck of playing cards. The current
--   implementation traverses the entire list of allPossibleHands, and is
--   not efficient.
allHighCard :: [[PlayingCard]]

-- | Return a random hand that is not any other hand, also known as "High
--   Card"
randomHighCard :: RandomGen g => Rand g PokerHand

-- | Return a random hand that is a Pair
randomPair :: RandomGen g => Rand g PokerHand

-- | Return a random hand that is a Two Pair
randomTwoPair :: RandomGen g => Rand g PokerHand

-- | Return a random hand that is a Three of a Kind
randomThreeOfAKind :: RandomGen g => Rand g PokerHand

-- | Return a random hand that is a Straight
randomStraight :: RandomGen g => Rand g PokerHand

-- | Return a random hand that is a Flush
randomFlush :: RandomGen g => Rand g PokerHand

-- | Return a random hand that is a Full House
randomFullHouse :: RandomGen g => Rand g PokerHand

-- | Return a random hand that is a Four of a Kind
randomFourOfAKind :: RandomGen g => Rand g PokerHand

-- | Return a random hand that is a Straight Flush
randomStraightFlush :: RandomGen g => Rand g PokerHand

-- | Return a random hand that is a Royal Flush
randomRoyalFlush :: RandomGen g => Rand g PokerHand

-- | Verify that the best hand of a set of cards is a high card hand, and
--   if so, return a <a>PokerHand</a>. Otherwise, return Nothing.
mkHighCard :: [PlayingCard] -> Maybe PokerHand

-- | Verify that the best hand of a set of cards is a pair hand, and if so,
--   return a <a>PokerHand</a>. Otherwise, return Nothing.
mkPair :: [PlayingCard] -> Maybe PokerHand

-- | Verify that the best hand of a set of cards is a two pair, and if so,
--   return a <a>PokerHand</a>. Otherwise, return Nothing.
mkTwoPair :: [PlayingCard] -> Maybe PokerHand

-- | Verify that the best hand of a set of cards is a three-of-a-kind hand,
--   and if so, return a <a>PokerHand</a>. Otherwise, return Nothing.
mkThreeOfAKind :: [PlayingCard] -> Maybe PokerHand

-- | Verify that the best hand of a set of cards is a straight hand, and if
--   so, return a <a>PokerHand</a>. Otherwise, return Nothing.
mkStraight :: [PlayingCard] -> Maybe PokerHand

-- | Verify that the best hand of a set of cards is a flush hand, and if
--   so, return a <a>PokerHand</a>. Otherwise, return Nothing.
mkFlush :: [PlayingCard] -> Maybe PokerHand

-- | Verify that the best hand of a set of cards is a full house hand, and
--   if so, return a <a>PokerHand</a>. Otherwise, return Nothing.
mkFullHouse :: [PlayingCard] -> Maybe PokerHand

-- | Verify that the best hand of a set of cards is a four-of-a-kind hand,
--   and if so, return a <a>PokerHand</a>. Otherwise, return Nothing.
mkFourOfAKind :: [PlayingCard] -> Maybe PokerHand

-- | Verify that the best hand of a set of cards is a straight flush hand,
--   and if so, return a <a>PokerHand</a>. Otherwise, return Nothing.
mkStraightFlush :: [PlayingCard] -> Maybe PokerHand

-- | Verify that the best hand of a set of cards is a royal flush hand, and
--   if so, return a <a>PokerHand</a>. Otherwise, return Nothing.
mkRoyalFlush :: [PlayingCard] -> Maybe PokerHand

-- | Verify that the best hand of a set of cards is a high card hand, and
--   if so, return True. Otherwise, return False.
isHighCard :: [PlayingCard] -> Bool

-- | Verify that the best hand of a set of cards is a pair hand, and if so,
--   return True. Otherwise, return False.
isPair :: [PlayingCard] -> Bool

-- | Verify that the best hand of a set of cards is a two pair hand, and if
--   so, return True. Otherwise, return False.
isTwoPair :: [PlayingCard] -> Bool

-- | Verify that the best hand of a set of cards is a three-of-a-kind hand,
--   and if so, return True. Otherwise, return False.
isThreeOfAKind :: [PlayingCard] -> Bool

-- | Verify that the best hand of a set of cards is a straight hand, and if
--   so, return True. Otherwise, return False.
isStraight :: [PlayingCard] -> Bool

-- | Verify that the best hand of a set of cards is a flush hand, and if
--   so, return True. Otherwise, return False.
isFlush :: [PlayingCard] -> Bool

-- | Verify that the best hand of a set of cards is a full house hand, and
--   if so, return True. Otherwise, return False.
isFullHouse :: [PlayingCard] -> Bool

-- | Verify that the best hand of a set of cards is a four-of-a-kind hand,
--   and if so, return True. Otherwise, return False.
isFourOfAKind :: [PlayingCard] -> Bool

-- | Verify that the best hand of a set of cards is a straight flush hand,
--   and if so, return True. Otherwise, return False.
isStraightFlush :: [PlayingCard] -> Bool

-- | Verify that the best hand of a set of cards is a royal flush hand, and
--   if so, return True. Otherwise, return False.
isRoyalFlush :: [PlayingCard] -> Bool
instance GHC.Show.Show Game.Game.Poker.PokerHand
instance GHC.Classes.Eq Game.Game.Poker.PokerHand
instance GHC.Show.Show Game.Game.Poker.PokerHandType
instance GHC.Classes.Eq Game.Game.Poker.PokerHandType
instance GHC.Enum.Bounded Game.Game.Poker.AceRank
instance GHC.Enum.Enum Game.Game.Poker.AceRank
instance GHC.Classes.Ord Game.Game.Poker.AceRank
instance GHC.Show.Show Game.Game.Poker.AceRank
instance GHC.Classes.Eq Game.Game.Poker.AceRank
