Poker.Game

Representation of a game of holdem, including table structure, positioning, pot and betting state.

Documentation

newtype Position

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 :)

Constructors

Position Word8

Instances

Bounded Position

Defined in Poker.Game

Methods

minBound :: Position

maxBound :: Position

Enum Position

Defined in Poker.Game

Methods

succ :: Position -> Position

pred :: Position -> Position

toEnum :: Int -> Position

fromEnum :: Position -> Int

enumFrom :: Position -> [Position]

enumFromThen :: Position -> Position -> [Position]

enumFromTo :: Position -> Position -> [Position]

enumFromThenTo :: Position -> Position -> Position -> [Position]

Eq Position

Defined in Poker.Game

Methods

(==) :: Position -> Position -> Bool

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

Data Position

Defined in Poker.Game

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Position -> c Position

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Position

toConstr :: Position -> Constr

dataTypeOf :: Position -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Position)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Position)

gmapT :: (forall b. Data b => b -> b) -> Position -> Position

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Position -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Position -> r

gmapQ :: (forall d. Data d => d -> u) -> Position -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Position -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Position -> m Position

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Position -> m Position

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Position -> m Position

Ord Position

Defined in Poker.Game

Methods

compare :: Position -> Position -> Ordering

(<) :: Position -> Position -> Bool

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

(>) :: Position -> Position -> Bool

(>=) :: Position -> Position -> Bool

max :: Position -> Position -> Position

min :: Position -> Position -> Position

Read Position

Defined in Poker.Game

Methods

readsPrec :: Int -> ReadS Position

readList :: ReadS [Position]

readPrec :: ReadPrec Position

readListPrec :: ReadPrec [Position]

Show Position

Defined in Poker.Game

Methods

showsPrec :: Int -> Position -> ShowS

show :: Position -> String

showList :: [Position] -> ShowS

Pretty Position

Defined in Poker.Game

Methods

pretty :: Position -> Doc ann

prettyList :: [Position] -> Doc ann

data NumPlayers

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

Constructors

TwoPlayers

ThreePlayers

FourPlayers

FivePlayers

SixPlayers

SevenPlayers

EightPlayers

NinePlayers

Instances

Enum NumPlayers

Defined in Poker.Game

Methods

succ :: NumPlayers -> NumPlayers

pred :: NumPlayers -> NumPlayers

toEnum :: Int -> NumPlayers

fromEnum :: NumPlayers -> Int

enumFrom :: NumPlayers -> [NumPlayers]

enumFromThen :: NumPlayers -> NumPlayers -> [NumPlayers]

enumFromTo :: NumPlayers -> NumPlayers -> [NumPlayers]

enumFromThenTo :: NumPlayers -> NumPlayers -> NumPlayers -> [NumPlayers]

Eq NumPlayers

Defined in Poker.Game

Methods

(==) :: NumPlayers -> NumPlayers -> Bool

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

Ord NumPlayers

Defined in Poker.Game

Methods

compare :: NumPlayers -> NumPlayers -> Ordering

(<) :: NumPlayers -> NumPlayers -> Bool

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

(>) :: NumPlayers -> NumPlayers -> Bool

(>=) :: NumPlayers -> NumPlayers -> Bool

max :: NumPlayers -> NumPlayers -> NumPlayers

min :: NumPlayers -> NumPlayers -> NumPlayers

numPlayersToWord8 :: NumPlayers -> Word8

Convert a NumPlayers to a Word8.

numPlayersFromWord8 :: Word8 -> Maybe NumPlayers

Convert a Word8 to a NumPlayers.

mkNumPlayers :: Integral a => a -> Maybe NumPlayers

WARNING: The incoming Integral is downcast to a Word8

allPositions :: NumPlayers -> [Position]

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

positionToTxt :: NumPlayers -> Position -> Text

>>> 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"]

getPreflopOrder :: NumPlayers -> [Position]

>>> 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 :: NumPlayers -> Position

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

bigBlindPosition :: NumPlayers -> Position

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

getPostFlopOrder :: NumPlayers -> [Position]

>>> 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"]

sortPostflop :: NumPlayers -> [Position] -> [Position]

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"]

newtype Seat

A player's seat number at a poker table.

Constructors

Seat

Fields

• _seat :: Int

Instances

Eq Seat

Defined in Poker.Game

Methods

(==) :: Seat -> Seat -> Bool

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

Num Seat

Defined in Poker.Game

Methods

(+) :: Seat -> Seat -> Seat

(-) :: Seat -> Seat -> Seat

(*) :: Seat -> Seat -> Seat

negate :: Seat -> Seat

abs :: Seat -> Seat

signum :: Seat -> Seat

fromInteger :: Integer -> Seat

Ord Seat

Defined in Poker.Game

Methods

compare :: Seat -> Seat -> Ordering

(<) :: Seat -> Seat -> Bool

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

(>) :: Seat -> Seat -> Bool

(>=) :: Seat -> Seat -> Bool

max :: Seat -> Seat -> Seat

min :: Seat -> Seat -> Seat

Read Seat

Defined in Poker.Game

Methods

readsPrec :: Int -> ReadS Seat

readList :: ReadS [Seat]

readPrec :: ReadPrec Seat

readListPrec :: ReadPrec [Seat]

Show Seat

Defined in Poker.Game

Methods

showsPrec :: Int -> Seat -> ShowS

show :: Seat -> String

showList :: [Seat] -> ShowS

newtype Pot b

Total amount of money in the Pot.

Constructors

Pot

Fields

• _pot :: b

Instances

Functor Pot

Defined in Poker.Game

Methods

fmap :: (a -> b) -> Pot a -> Pot b

(<$) :: a -> Pot b -> Pot a

Eq b => Eq (Pot b)

Defined in Poker.Game

Methods

(==) :: Pot b -> Pot b -> Bool

(/=) :: Pot b -> Pot b -> Bool

Num b => Num (Pot b)

Defined in Poker.Game

Methods

(+) :: Pot b -> Pot b -> Pot b

(-) :: Pot b -> Pot b -> Pot b

(*) :: Pot b -> Pot b -> Pot b

negate :: Pot b -> Pot b

abs :: Pot b -> Pot b

signum :: Pot b -> Pot b

fromInteger :: Integer -> Pot b

Ord b => Ord (Pot b)

Defined in Poker.Game

Methods

compare :: Pot b -> Pot b -> Ordering

(<) :: Pot b -> Pot b -> Bool

(<=) :: Pot b -> Pot b -> Bool

(>) :: Pot b -> Pot b -> Bool

(>=) :: Pot b -> Pot b -> Bool

max :: Pot b -> Pot b -> Pot b

min :: Pot b -> Pot b -> Pot b

Show b => Show (Pot b)

Defined in Poker.Game

Methods

showsPrec :: Int -> Pot b -> ShowS

show :: Pot b -> String

showList :: [Pot b] -> ShowS

Semigroup b => Semigroup (Pot b)

Defined in Poker.Game

Methods

(<>) :: Pot b -> Pot b -> Pot b

sconcat :: NonEmpty (Pot b) -> Pot b

stimes :: Integral b0 => b0 -> Pot b -> Pot b

Monoid b => Monoid (Pot b)

Defined in Poker.Game

Methods

mempty :: Pot b

mappend :: Pot b -> Pot b -> Pot b

mconcat :: [Pot b] -> Pot b

Pretty b => Pretty (Pot b)

Defined in Poker.Game

Methods

pretty :: Pot b -> Doc ann

prettyList :: [Pot b] -> Doc ann

newtype Stack b

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

Constructors

Stack

Fields

• _stack :: b

Instances

Functor Stack

Defined in Poker.Game

Methods

fmap :: (a -> b) -> Stack a -> Stack b

(<$) :: a -> Stack b -> Stack a

Eq b => Eq (Stack b)

Defined in Poker.Game

Methods

(==) :: Stack b -> Stack b -> Bool

(/=) :: Stack b -> Stack b -> Bool

Num b => Num (Stack b)

Defined in Poker.Game

Methods

(+) :: Stack b -> Stack b -> Stack b

(-) :: Stack b -> Stack b -> Stack b

(*) :: Stack b -> Stack b -> Stack b

negate :: Stack b -> Stack b

abs :: Stack b -> Stack b

signum :: Stack b -> Stack b

fromInteger :: Integer -> Stack b

Ord b => Ord (Stack b)

Defined in Poker.Game

Methods

compare :: Stack b -> Stack b -> Ordering

(<) :: Stack b -> Stack b -> Bool

(<=) :: Stack b -> Stack b -> Bool

(>) :: Stack b -> Stack b -> Bool

(>=) :: Stack b -> Stack b -> Bool

max :: Stack b -> Stack b -> Stack b

min :: Stack b -> Stack b -> Stack b

Show b => Show (Stack b)

Defined in Poker.Game

Methods

showsPrec :: Int -> Stack b -> ShowS

show :: Stack b -> String

showList :: [Stack b] -> ShowS

Semigroup b => Semigroup (Stack b)

Defined in Poker.Game

Methods

(<>) :: Stack b -> Stack b -> Stack b

sconcat :: NonEmpty (Stack b) -> Stack b

stimes :: Integral b0 => b0 -> Stack b -> Stack b

Pretty b => Pretty (Stack b)

Defined in Poker.Game

Methods

pretty :: Stack b -> Doc ann

prettyList :: [Stack b] -> Doc ann

newtype Stake b

Amount of money needed to join a game.

Constructors

Stake

Fields

• _stake :: b

Instances

Functor Stake

Defined in Poker.Game

Methods

fmap :: (a -> b) -> Stake a -> Stake b

(<$) :: a -> Stake b -> Stake a

Eq b => Eq (Stake b)

Defined in Poker.Game

Methods

(==) :: Stake b -> Stake b -> Bool

(/=) :: Stake b -> Stake b -> Bool

Ord b => Ord (Stake b)

Defined in Poker.Game

Methods

compare :: Stake b -> Stake b -> Ordering

(<) :: Stake b -> Stake b -> Bool

(<=) :: Stake b -> Stake b -> Bool

(>) :: Stake b -> Stake b -> Bool

(>=) :: Stake b -> Stake b -> Bool

max :: Stake b -> Stake b -> Stake b

min :: Stake b -> Stake b -> Stake b

Read b => Read (Stake b)

Defined in Poker.Game

Methods

readsPrec :: Int -> ReadS (Stake b)

readList :: ReadS [Stake b]

readPrec :: ReadPrec (Stake b)

readListPrec :: ReadPrec [Stake b]

Show b => Show (Stake b)

Defined in Poker.Game

Methods

showsPrec :: Int -> Stake b -> ShowS

show :: Stake b -> String

showList :: [Stake b] -> ShowS

Pretty b => Pretty (Stake b)

Defined in Poker.Game

Methods

pretty :: Stake b -> Doc ann

prettyList :: [Stake b] -> Doc ann