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


-- | Basic chess library
--   
--   A simple library for generating legal chess moves. Also includes a
--   module for communication with external processes that speak the UCI
--   (Universal Chess Interface) protocol, a PGN parser/pretty printer, and
--   Polyglot opening book support. On top of that, provides a console
--   frontend program (cboard) that can be used to interactively play
--   against UCI engines.
@package chessIO
@version 0.3.1.0


-- | A small collection of data types and functions to represent Chess
--   positions and moves including move generation and parsing from
--   external sources.
--   
--   This module does deliberately not implement any search or evaluation
--   functionality. It is intended to be used to lay the ground for
--   communicating with other programs or players, hence the package name
--   chessIO.
module Game.Chess
data Color
Black :: Color
White :: Color
opponent :: Color -> Color
data Sq
A1 :: Sq
B1 :: Sq
C1 :: Sq
D1 :: Sq
E1 :: Sq
F1 :: Sq
G1 :: Sq
H1 :: Sq
A2 :: Sq
B2 :: Sq
C2 :: Sq
D2 :: Sq
E2 :: Sq
F2 :: Sq
G2 :: Sq
H2 :: Sq
A3 :: Sq
B3 :: Sq
C3 :: Sq
D3 :: Sq
E3 :: Sq
F3 :: Sq
G3 :: Sq
H3 :: Sq
A4 :: Sq
B4 :: Sq
C4 :: Sq
D4 :: Sq
E4 :: Sq
F4 :: Sq
G4 :: Sq
H4 :: Sq
A5 :: Sq
B5 :: Sq
C5 :: Sq
D5 :: Sq
E5 :: Sq
F5 :: Sq
G5 :: Sq
H5 :: Sq
A6 :: Sq
B6 :: Sq
C6 :: Sq
D6 :: Sq
E6 :: Sq
F6 :: Sq
G6 :: Sq
H6 :: Sq
A7 :: Sq
B7 :: Sq
C7 :: Sq
D7 :: Sq
E7 :: Sq
F7 :: Sq
G7 :: Sq
H7 :: Sq
A8 :: Sq
B8 :: Sq
C8 :: Sq
D8 :: Sq
E8 :: Sq
F8 :: Sq
G8 :: Sq
H8 :: Sq
isLight :: IsSquare sq => sq -> Bool
isDark :: IsSquare sq => sq -> Bool
data PieceType
Pawn :: PieceType
Knight :: PieceType
Bishop :: PieceType
Rook :: PieceType
Queen :: PieceType
King :: PieceType
data Castle
Kingside :: Castle
Queenside :: Castle
data Position

-- | The starting position as given by the FEN string
--   "rnbqkbnr<i>pppppppp</i>8<i>8</i>8<i>8</i>PPPPPPPP/RNBQKBNR w KQkq - 0
--   1".
startpos :: Position

-- | active color
color :: Position -> Color

-- | number of the full move
moveNumber :: Position -> Int
halfMoveClock :: Position -> Int
pieceAt :: IsSquare sq => Position -> sq -> Maybe (Color, PieceType)

-- | Returns <a>True</a> if <a>Color</a> is in check in the given position.
inCheck :: Color -> Position -> Bool
castlingRights :: Position -> [(Color, Castle)]
canCastleKingside :: Position -> Bool
canCastleQueenside :: Position -> Bool

-- | Construct a position from Forsyth-Edwards-Notation.
fromFEN :: String -> Maybe Position

-- | Convert a position to Forsyth-Edwards-Notation.
toFEN :: Position -> String
newtype Ply
Ply :: Word16 -> Ply
strictSAN :: forall s. (Stream s, SANToken (Token s), IsString (Tokens s)) => Position -> Parser s Ply
relaxedSAN :: (Stream s, SANToken (Token s), IsString (Tokens s)) => Position -> Parser s Ply
fromSAN :: (Stream s, SANToken (Token s), IsString (Tokens s)) => Position -> s -> Either String Ply
toSAN :: Position -> Ply -> String
unsafeToSAN :: Position -> Ply -> String

-- | Parse a move in the format used by the Universal Chess Interface
--   protocol.
fromUCI :: Position -> String -> Maybe Ply

-- | Convert a move to the format used by the Universal Chess Interface
--   protocol.
toUCI :: Ply -> String
fromPolyglot :: Position -> Ply -> Ply

-- | Generate a list of possible moves for the given position.
legalPlies :: Position -> [Ply]

-- | Apply a move to the given position.
--   
--   This function checks if the move is actually legal and throws and
--   error if it isn't. See <a>unsafeDoPly</a> for a version that omits the
--   legality check.
doPly :: Position -> Ply -> Position

-- | An unsafe version of <a>doPly</a>. Only use this if you are sure the
--   given move can be applied to the position. This is useful if the move
--   has been generated by the <tt>moves</tt> function.
unsafeDoPly :: Position -> Ply -> Position
instance GHC.Show.Show Game.Chess.Direction
instance GHC.Classes.Eq Game.Chess.Direction
instance GHC.Show.Show Game.Chess.Castle
instance GHC.Classes.Ord Game.Chess.Castle
instance GHC.Arr.Ix Game.Chess.Castle
instance GHC.Classes.Eq Game.Chess.Castle
instance GHC.Classes.Eq Game.Chess.Ply
instance GHC.Show.Show Game.Chess.Sq
instance GHC.Classes.Ord Game.Chess.Sq
instance GHC.Arr.Ix Game.Chess.Sq
instance GHC.Classes.Eq Game.Chess.Sq
instance GHC.Enum.Enum Game.Chess.Sq
instance GHC.Enum.Bounded Game.Chess.Sq
instance GHC.Show.Show Game.Chess.Piece
instance GHC.Classes.Eq Game.Chess.Piece
instance GHC.Show.Show Game.Chess.Color
instance GHC.Classes.Ord Game.Chess.Color
instance GHC.Arr.Ix Game.Chess.Color
instance GHC.Classes.Eq Game.Chess.Color
instance GHC.Show.Show Game.Chess.PieceType
instance GHC.Classes.Ord Game.Chess.PieceType
instance GHC.Arr.Ix Game.Chess.PieceType
instance GHC.Classes.Eq Game.Chess.PieceType
instance GHC.Show.Show Game.Chess.SANStatus
instance GHC.Read.Read Game.Chess.SANStatus
instance GHC.Classes.Eq Game.Chess.SANStatus
instance GHC.Show.Show Game.Chess.From
instance GHC.Show.Show Game.Chess.Ply
instance GHC.Classes.Eq Game.Chess.Position
instance Game.Chess.IsSquare Game.Chess.Sq
instance Game.Chess.IsSquare GHC.Types.Int
instance Game.Chess.SANToken GHC.Types.Char
instance Game.Chess.SANToken GHC.Word.Word8

module Game.Chess.Polyglot.Hash
hashPosition :: Position -> Word64
pieceKey :: (PieceType, Color, Sq) -> Word64
castleKey :: (Color, Castle) -> Word64
turnKey :: Word64

module Game.Chess.Polyglot.Book

-- | A Polyglot opening book.
data PolyglotBook

-- | Create a PolyglotBook from a ByteString.
fromByteString :: ByteString -> PolyglotBook
defaultBook :: PolyglotBook
twic :: PolyglotBook
readPolyglotFile :: FilePath -> IO PolyglotBook

-- | Pick a random ply from the book.
bookPly :: RandomGen g => PolyglotBook -> Position -> Maybe (Rand g Ply)

-- | Probe the book for all plies known for the given position.
bookPlies :: PolyglotBook -> Position -> [Ply]
bookForest :: PolyglotBook -> Position -> Forest Ply
instance GHC.Classes.Eq Game.Chess.Polyglot.Book.PolyglotBook
instance GHC.Show.Show Game.Chess.Polyglot.Book.BookEntry
instance GHC.Classes.Eq Game.Chess.Polyglot.Book.BookEntry
instance Foreign.Storable.Storable Game.Chess.Polyglot.Book.BookEntry

module Game.Chess.PGN
readPGNFile :: FilePath -> IO (Either String PGN)
gameFromForest :: [(ByteString, Text)] -> Forest Ply -> Outcome -> Game
newtype PGN
PGN :: [Game] -> PGN
type Game = ([(ByteString, Text)], (Outcome, Forest PlyData))
data Outcome
Win :: Color -> Outcome
Draw :: Outcome
Undecided :: Outcome
hPutPGN :: Handle -> RAVOrder (Doc ann) -> PGN -> IO ()
pgnDoc :: RAVOrder (Doc ann) -> PGN -> Doc ann
type RAVOrder a = (Forest PlyData -> a) -> Forest PlyData -> [a]
breadthFirst :: RAVOrder a
depthFirst :: RAVOrder a
gameDoc :: RAVOrder (Doc ann) -> Game -> Doc ann
instance GHC.Base.Semigroup Game.Chess.PGN.PGN
instance GHC.Base.Monoid Game.Chess.PGN.PGN
instance GHC.Classes.Eq Game.Chess.PGN.PGN
instance GHC.Show.Show Game.Chess.PGN.PlyData
instance GHC.Classes.Eq Game.Chess.PGN.PlyData
instance GHC.Show.Show Game.Chess.PGN.Outcome
instance GHC.Classes.Eq Game.Chess.PGN.Outcome
instance Data.Text.Prettyprint.Doc.Internal.Pretty Game.Chess.PGN.Outcome

module Game.Chess.UCI
data UCIException
IllegalMove :: Ply -> UCIException
data Engine
name :: Engine -> Maybe ByteString
author :: Engine -> Maybe ByteString

-- | Start a UCI engine with the given executable name and command line
--   arguments.
start :: String -> [String] -> IO (Maybe Engine)

-- | Start a UCI engine with the given timeout for initialisation.
--   
--   If the engine takes more then the given microseconds to answer to the
--   initialisation request, <a>Nothing</a> is returned and the external
--   process will be terminated.
start' :: KnownDivRat unit Microsecond => Time unit -> (String -> IO ()) -> String -> [String] -> IO (Maybe Engine)
data Option
CheckBox :: Bool -> Option
ComboBox :: ByteString -> [ByteString] -> Option
[comboBoxValue] :: Option -> ByteString
[comboBoxValues] :: Option -> [ByteString]
SpinButton :: Int -> Option
[spinButtonValue, spinButtonMinBound, spinButtonMaxBound] :: Option -> Int
OString :: ByteString -> Option
Button :: Option
options :: Engine -> HashMap ByteString Option
getOption :: ByteString -> Engine -> Maybe Option

-- | Set a spin option to a particular value.
--   
--   Bounds are validated. Make sure you don't set a value which is out of
--   range.
setOptionSpinButton :: MonadIO m => ByteString -> Int -> Engine -> m Engine
setOptionString :: MonadIO m => ByteString -> ByteString -> Engine -> m Engine

-- | Wait until the engine is ready to take more commands.
isready :: Engine -> IO ()

-- | Return the final position of the currently active game.
currentPosition :: MonadIO m => Engine -> m Position

-- | Set the starting position of the current game, also clearing any
--   pre-existing history.
setPosition :: MonadIO m => Engine -> Position -> m (Position, [Ply])

-- | Add a <tt>Move</tt> to the game history.
--   
--   This function checks if the move is actually legal, and throws a
--   <a>UCIException</a> if it isn't.
addPly :: MonadIO m => Engine -> Ply -> m ()
data Info
PV :: [Ply] -> Info
Depth :: Int -> Info
SelDepth :: Int -> Info
Elapsed :: Time Millisecond -> Info
MultiPV :: Int -> Info
Score :: Score -> Maybe Bounds -> Info
Nodes :: Int -> Info
NPS :: Int -> Info
TBHits :: Int -> Info
HashFull :: Int -> Info
CurrMove :: Ply -> Info
CurrMoveNumber :: Int -> Info
String :: ByteString -> Info
data Score
CentiPawns :: Int -> Score
MateIn :: Int -> Score
data Bounds
UpperBound :: Bounds
LowerBound :: Bounds

-- | Instruct the engine to begin searching.
search :: MonadIO m => Engine -> [SearchParam] -> m (TChan (Ply, Maybe Ply), TChan [Info])
searching :: MonadIO m => Engine -> m Bool
data SearchParam
searchmoves :: [Ply] -> SearchParam
timeleft :: KnownDivRat unit Millisecond => Color -> Time unit -> SearchParam
timeincrement :: KnownDivRat unit Millisecond => Color -> Time unit -> SearchParam
movestogo :: Natural -> SearchParam
movetime :: KnownDivRat unit Millisecond => Time unit -> SearchParam
nodes :: Natural -> SearchParam
depth :: Natural -> SearchParam
infinite :: SearchParam

-- | Stop a search in progress.
stop :: MonadIO m => Engine -> m ()

-- | Quit the engine.
quit :: MonadIO m => Engine -> m (Maybe ExitCode)
quit' :: (KnownDivRat unit Microsecond, MonadIO m) => Time unit -> Engine -> m (Maybe ExitCode)
instance GHC.Show.Show Game.Chess.UCI.SearchParam
instance GHC.Classes.Eq Game.Chess.UCI.SearchParam
instance GHC.Show.Show Game.Chess.UCI.Command
instance GHC.Show.Show Game.Chess.UCI.Option
instance GHC.Classes.Eq Game.Chess.UCI.Option
instance GHC.Show.Show Game.Chess.UCI.Info
instance GHC.Classes.Eq Game.Chess.UCI.Info
instance GHC.Show.Show Game.Chess.UCI.Bounds
instance GHC.Classes.Eq Game.Chess.UCI.Bounds
instance GHC.Show.Show Game.Chess.UCI.Score
instance GHC.Classes.Ord Game.Chess.UCI.Score
instance GHC.Classes.Eq Game.Chess.UCI.Score
instance GHC.Show.Show Game.Chess.UCI.UCIException
instance Data.String.IsString Game.Chess.UCI.Option
instance GHC.Exception.Type.Exception Game.Chess.UCI.UCIException