The Rank of a playing Card

>>> allRanks
[Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Jack,Queen,King,Ace]

The Suit of a playing Card

>>> allSuits
[Club,Diamond,Heart,Spade]

>>> suitToUnicode <$> [Club, Diamond, Heart, Spade]
"\9827\9830\9829\9824"
>>> suitFromUnicode . suitToUnicode <$> [Club, Diamond, Heart, Spade]
[Just Club,Just Diamond,Just Heart,Just Spade]

>>> suitFromUnicode <$> ['♣', '♦', '♥', '♠']
[Just Club,Just Diamond,Just Heart,Just Spade]

\s -> suitFromUnicode (suitToUnicode s) == Just s

Representation of a playing card.

All cards in a Deck

>>> length allCards
52

Hole represents a player's hole cards in a game of Texas Hold'Em

Returns a Hole if the incoming Cards are unique, else Nothing. Note that mkHole automatically normalises the order of the given Cards. See Hole for details.

\c1 c2 -> mkHole c1 c2 == mkHole c2 c1

\c1 c2 -> (c1 /= c2) ==> isJust (mkHole c1 c2)

All possible valid Holes (the Holes are already normalised).

>>> length allCards * length allCards
2704
>>> length allHoles
1326
>>> Data.List.nub allHoles == allHoles
True
>>> pretty $ take 10 allHoles
[AsAh, AsAd, AhAd, AsAc, AhAc, AdAc, AsKs, AhKs, AdKs, AcKs]

A ShapedHole is the Suit-normalised representation of a poker Hole. For example, the Hole "King of Diamonds, 5 of Hearts" is often referred to as "King-5 offsuit".

To construct a ShapedHole, see mkPair, mkOffsuit, and mkSuited'.

>>> "22p" :: ShapedHole
Pair Two
>>> "A4o" :: ShapedHole
UnsafeOffsuit Ace Four
>>> "KJs" :: ShapedHole
UnsafeSuited King Jack

Build a pair ShapedHole from the given Rank

Returns an offsuit ShapedHole if the incoming Ranks are unique, else Nothing. Note that the internal representation of ShapedHole is normalised:

\r1 r2 -> mkOffsuit r1 r2 == mkOffsuit r2 r1

Returns a suited ShapedHole if the incoming Ranks are unique, else Nothing. Note that mkSuited normalises the order of the incoming Ranks.

\r1 r2 -> mkSuited r1 r2 == mkSuited r2 r1

>>> length allShapedHoles
169
>>> Data.List.nub allShapedHoles == allShapedHoles
True
>>> pretty $ take 15 allShapedHoles
[AAp, AKs, AQs, AJs, ATs, A9s, A8s, A7s, A6s, A5s, A4s, A3s, A2s, AKo, KKp]

>>> holeToShapedHole "AcKd"
UnsafeOffsuit Ace King
>>> holeToShapedHole "AcKc"
UnsafeSuited Ace King
>>> holeToShapedHole "AcAs"
Pair Ace

A Deck of Cards

A unshuffled Deck with all Cards

>>> freshDeck == unsafeDeck allCards
True

The input Cards are not checked in any way.

>>> fmap holeToShortTxt . shapedHoleToHoles $ "55p"
["5d5c","5h5c","5s5c","5h5d","5s5d","5s5h"]
>>> fmap holeToShortTxt . shapedHoleToHoles $ "97o"
["9c7d","9c7h","9c7s","9d7c","9d7h","9d7s","9h7c","9h7d","9h7s","9s7c","9s7d","9s7h"]
>>> fmap holeToShortTxt . shapedHoleToHoles $ "QTs"
["QcTc","QdTd","QhTh","QsTs"]

>>> rankToChr <$> allRanks
"23456789TJQKA"

>>> map (fromJust . chrToRank) "23456789TJQKA"
[Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Jack,Queen,King,Ace]
>>> chrToRank 'x'
Nothing

\r -> chrToRank (rankToChr r) == Just r

>>> suitToChr <$> allSuits
"cdhs"

>>> map (fromJust . chrToSuit) "cdhs"
[Club,Diamond,Heart,Spade]
>>> chrToSuit 'x'
Nothing

\s -> chrToSuit (suitToChr s) == Just s

>>> cardToShortTxt "Ac"
"Ac"

>>> cardFromShortTxt "Ac"
Just (Card {rank = Ace, suit = Club})

\c -> cardFromShortTxt (cardToShortTxt c) == Just c

>>> shapedHoleToShortTxt (mkPair Ace)
"AAp"
>>> shapedHoleToShortTxt <$> (mkOffsuit Ace King)
Just "AKo"
>>> shapedHoleToShortTxt <$> (mkSuited Ace King)
Just "AKs"

>>> holeToShortTxt "AcKd"
"AcKd"

First Rank should > than second Rank

First Rank should be > than second Rank

Unsafely create a new Hole. The first Card should be > than the second. See mkHole for a safe way to create a Hole.

>>> holeFromShortTxt "AcKd"
Just (UnsafeHole (Card {rank = Ace, suit = Club}) (Card {rank = King, suit = Diamond}))
>>> ("KdAc" :: Hole) == "AcKd"
True

\h -> holeFromShortTxt (holeToShortTxt h) == Just h

A player's Position in a game of poker.

Positions are ordered by table order (clockwise). The smallest Position, Position 0, is the first player to act preflop. The largest Position is always the big blind.

>>> allPositions SixPlayers
[Position 0,Position 1,Position 2,Position 3,Position 4,Position 5]
>>> positionToTxt SixPlayers <$> allPositions SixPlayers
["LJ","HJ","CO","BU","SB","BB"]
>>> positionToTxt NinePlayers <$> allPositions NinePlayers
["UTG","UTG1","UTG2","LJ","HJ","CO","BU","SB","BB"]

The API for Position is unstable. We are open to better ideas :)

Number of active players at a poker table. Players sitting out do not count, as they do not contribute to the number of Positions.

Convert a NumPlayers to a Word8.

Convert a Word8 to a NumPlayers.

WARNING: The incoming Integral is downcast to a Word8

>>> allPositions SixPlayers
[Position 0,Position 1,Position 2,Position 3,Position 4,Position 5]

>>> positionToTxt TwoPlayers <$> allPositions TwoPlayers
["BU","BB"]
>>> positionToTxt SixPlayers <$> allPositions SixPlayers
["LJ","HJ","CO","BU","SB","BB"]
>>> positionToTxt NinePlayers <$> allPositions NinePlayers
["UTG","UTG1","UTG2","LJ","HJ","CO","BU","SB","BB"]

>>> positionToTxt TwoPlayers <$> getPreflopOrder TwoPlayers
["BU","BB"]
>>> positionToTxt SixPlayers <$> getPreflopOrder SixPlayers
["LJ","HJ","CO","BU","SB","BB"]
>>> positionToTxt NinePlayers <$> getPreflopOrder NinePlayers
["UTG","UTG1","UTG2","LJ","HJ","CO","BU","SB","BB"]

>>> buttonPosition TwoPlayers
Position 0
>>> (\numPlayers -> positionToTxt numPlayers $ buttonPosition numPlayers) <$> enumFromTo TwoPlayers NinePlayers
["BU","BU","BU","BU","BU","BU","BU","BU"]

>>> bigBlindPosition TwoPlayers
Position 1
>>> (\numPlayers -> positionToTxt numPlayers $ bigBlindPosition numPlayers) <$> enumFromTo TwoPlayers NinePlayers
["BB","BB","BB","BB","BB","BB","BB","BB"]

>>> positionToTxt TwoPlayers <$> getPostFlopOrder TwoPlayers
["BB","BU"]
>>> positionToTxt ThreePlayers <$> getPostFlopOrder ThreePlayers
["SB","BB","BU"]
>>> positionToTxt SixPlayers <$> getPostFlopOrder SixPlayers
["SB","BB","LJ","HJ","CO","BU"]
>>> positionToTxt NinePlayers <$> getPostFlopOrder NinePlayers
["SB","BB","UTG","UTG1","UTG2","LJ","HJ","CO","BU"]

Sort a list of positions acccording to postflop ordering

>>> positionToTxt TwoPlayers <$> sortPostflop TwoPlayers (allPositions TwoPlayers)
["BB","BU"]
>>> positionToTxt ThreePlayers <$> sortPostflop ThreePlayers (allPositions ThreePlayers)
["SB","BB","BU"]
>>> positionToTxt SixPlayers <$> sortPostflop SixPlayers (allPositions SixPlayers)
["SB","BB","LJ","HJ","CO","BU"]
>>> positionToTxt NinePlayers <$> sortPostflop NinePlayers (allPositions NinePlayers)
["SB","BB","UTG","UTG1","UTG2","LJ","HJ","CO","BU"]

A player's seat number at a poker table.

Total amount of money in the Pot.

Amount of money in a player's stack (not having been bet).

Amount of money needed to join a game.

Amount is the type used to represent amounts of money during a game of poker. The internal representation of Amount is a Discrete' from the safe-money package. The exposed constructors for Amount ensure that no Amount can have a negative value.

The use of the safe-money package allows for lossless conversion between currencies with well-maintained support for type safety, serialisation, and currency conversions.

{-# Language TypeApplications #-}

case unsafeAmount @"USD" (discrete 100) of
  UnsafeAmount x -> x     -- x == discrete 100

Make an Amount from a Discrete'. Only use when you are certain that your Discrete' value is positive, since most usages of Amount will break for negative quantities.

A type b satisfies IsBet if we know:

• A Monoid instance for b. This allows us to construct a zero amount of b and to add two amounts of b together.
• the smallest non-zero currency unit for b (smallestAmount). For example, for USD the minimum currency amount is $0.01.
• how to add two bs. By default, this is the Monoid instance's append for b.
• how to minus two bs, which may fail (returning Nothing), if the resulting Amount is negative.

Types that satisfy IsBet are expected to have both Ord and Show instances, so that packages such as poker-game can handle arbitrary new user bet types.

For an example instance of the IsBet class, see Poker.BigBlind.

Returns an Amount from a Discrete' so long as the given Discrete' is non-negative.

>>> mkAmount @"USD" 0
Just (UnsafeAmount {unAmount = Discrete "USD" 100%1 0})
>>> mkAmount @"USD" (-1)
Nothing

BigBlind is the type describing poker chip amounts that are measured in big blinds.

The internal representation of BigBlind is Amount BB. This module introduces a new instance of CurrencyScale (from the safe-money package), which allows translation from BigBlind to any valid currency in a lossless manner.

The small unit of a "BB" is a "bb", with 100 "bb"s in a "BB".

TODO include an API for translating from BigBlind to any safe-money currency, given a Stake.

Calculations in the safe-money package are done with Discrete and Dense types. Discrete values are used to describe a regular BigBlind value, such as 1.30bb. Dense values are used when calculating some complex (non-discrete) value such as one third of a big blind. When using the BigBlind type, it is best to do all calculation with Dense BB values and then convert back to a Discrete BB "bb" after all calculation has been completed:

When working with a BigBlind you might want to (cautiously) retain losslessness when using functions such as % calculations or division. A Dense allows you to do so.

A frequency is an unevaluated ratio that indicates how often a decision was made. For example, the value Freq (12, 34) indicates that out of the 34 people who faced this decision, 12 chose to make this decision.

A simple wrapper around a Map that uses different instances for Semigroup. Range's Semigroup instance combines values at the same keys with <> (unlike the Map Semigroup instance from containers).

Note that the Range's internal Map is strict.

Converts a Range from key to action, to a Range from key to decision frequency, given a predicate that returns True if the action matched the decision.

Convert from a Range of hole cards to a Range of ShapedHole.

Add a singleton Hole hand to a Range of ShapedHole.