Safe Haskell  None 

Language  Haskell2010 
AUTHOR
 Dr. Alistair Ward
DESCRIPTION
 The abscissae of those
Rook
s, for the player of each logicalColour, which can still participate in castling.
Synopsis
 type TurnsByLogicalColour x y = TurnsByLogicalColour (Turn x y)
 data CastleableRooksByLogicalColour x
 locateForLogicalColour :: LogicalColour > CastleableRooksByLogicalColour x > Maybe [x]
 fromAssocs :: (Enum x, Ord x, Show x) => [(LogicalColour, [x])] > CastleableRooksByLogicalColour x
 fromBoard :: (Enum x, Enum y, Ord x, Ord y, Show x) => Board x y > CastleableRooksByLogicalColour x
 fromTurnsByLogicalColour :: (Enum x, Enum y, Eq x, Eq y) => TurnsByLogicalColour x y > CastleableRooksByLogicalColour x
 listIncrementalRandoms :: Ix x => CastleableRooksByLogicalColour x > CastleableRooksByLogicalColour x > Zobrist x y random > [random]
 unify :: Transformation x
 takeTurn :: (Enum x, Enum y, Ord x, Ord y) => LogicalColour > Turn x y > Transformation x
 hasCastled :: LogicalColour > CastleableRooksByLogicalColour x > Bool
 canCastle :: LogicalColour > CastleableRooksByLogicalColour x > Bool
 canCastleWith :: (Enum x, Enum y, Ord x, Ord y) => LogicalColour > Coordinates x y > CastleableRooksByLogicalColour x > Bool
 cantConverge :: CastleableRooksByLogicalColour x > CastleableRooksByLogicalColour x > Bool
Types
Typesynonyms
type TurnsByLogicalColour x y = TurnsByLogicalColour (Turn x y) Source #
Narrow the type, so the turn can be queried.
Datatypes
data CastleableRooksByLogicalColour x Source #
For the players of each logical colour, identifies the abscissae of those Rook
s which can still participate in castling (when other constraints are removed).
Instances
Functions
locateForLogicalColour :: LogicalColour > CastleableRooksByLogicalColour x > Maybe [x] Source #
Find the abscissae of all Rook
s of the specified logical colour, which can still participate in castling.
Constructors
fromAssocs :: (Enum x, Ord x, Show x) => [(LogicalColour, [x])] > CastleableRooksByLogicalColour x Source #
Smart constructor.
fromBoard :: (Enum x, Enum y, Ord x, Ord y, Show x) => Board x y > CastleableRooksByLogicalColour x Source #
 Smart constructor.
 CAVEAT: doesn't know the movehistory, so the wrong answer is possible.
fromTurnsByLogicalColour :: (Enum x, Enum y, Eq x, Eq y) => TurnsByLogicalColour x y > CastleableRooksByLogicalColour x Source #
Constructor.
listIncrementalRandoms Source #
:: Ix x  
=> CastleableRooksByLogicalColour x  The old value. 
> CastleableRooksByLogicalColour x  The new value. 
> Zobrist x y random  
> [random] 
Generate the additional randomnumbers required to correct the hash resulting from a change to the castleable Rook
s.
Mutators
unify :: Transformation x Source #
Relinquish the ability to disambiguate between "have Castled" (& therefore can't subsequently), & "Have lost the option to castle".
:: (Enum x, Enum y, Ord x, Ord y)  
=> LogicalColour  Defines the side who took the specified turn. 
> Turn x y  
> Transformation x 
Update with the latest turn.
Predicates
hasCastled :: LogicalColour > CastleableRooksByLogicalColour x > Bool Source #
Predicate.
canCastle :: LogicalColour > CastleableRooksByLogicalColour x > Bool Source #
Predicate.
:: (Enum x, Enum y, Ord x, Ord y)  
=> LogicalColour  
> Coordinates x y 

> CastleableRooksByLogicalColour x  
> Bool 
Predicate.
cantConverge :: CastleableRooksByLogicalColour x > CastleableRooksByLogicalColour x > Bool Source #
 Determines whether two positions can't converge on each other.
 N.B.: in this function, the two positions are considered to be peers; nothing is assumed regarding which must do the convergence, perhaps both.
 From the initial board, one may converge onto any other position, but any of a set of irreversible changes may compromise this;
the total number of pieces & specifically
Pawn
s, of each logical colour, can't increase;Pawn
s can only advance; the difference in the ranks of all pieces of each logical colour, which can only be reduced through promotion of aPawn
; castling can't be undone. This function only assesses this final change.  CAVEAT: since the potential of one position to converge on another, depends on a wider set of criteria, this function can only be definitive regarding when convergence is impossible, rather than when is possible.
 CAVEAT: this function depends on one side having lost the right to castle, when the other side already has; this is quite rare.