Data.Char.Chess

One can make use of a block 2600 and block 1fa00 of Unicode characters to render chess characters. One can render chess characters as netral, white, or black pieces, for such pieces one can render these rotated by 0, 90, 180 and 270 degrees. Knights can be rendered on 45, 135, 225 and 315 degrees as well. Furthermore unicode allows to render an equihopper, and special variants like a knight-queen, knight-rook, and knight-bishop.

The module contains pattern synonyms for names that are often given to the pieces.

Data structures to represent the possible chess pieces.

data ChessColor

The color of a chess piece, this can for most pieces be Black, White, or Neutral.

Constructors

White

White color.

Black

Black color.

Neutral

Neutral chess pieces, sometimes depicted half white and half black.

Instances

Bounded ChessColor

Defined in Data.Char.Chess

Methods

minBound :: ChessColor

maxBound :: ChessColor

Enum ChessColor

Defined in Data.Char.Chess

Methods

succ :: ChessColor -> ChessColor

pred :: ChessColor -> ChessColor

toEnum :: Int -> ChessColor

fromEnum :: ChessColor -> Int

enumFrom :: ChessColor -> [ChessColor]

enumFromThen :: ChessColor -> ChessColor -> [ChessColor]

enumFromTo :: ChessColor -> ChessColor -> [ChessColor]

enumFromThenTo :: ChessColor -> ChessColor -> ChessColor -> [ChessColor]

Eq ChessColor

Defined in Data.Char.Chess

Methods

(==) :: ChessColor -> ChessColor -> Bool

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

Data ChessColor

Defined in Data.Char.Chess

Methods

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

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

toConstr :: ChessColor -> Constr

dataTypeOf :: ChessColor -> DataType

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

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

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

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

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

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

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

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

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

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

Ord ChessColor

Defined in Data.Char.Chess

Methods

compare :: ChessColor -> ChessColor -> Ordering

(<) :: ChessColor -> ChessColor -> Bool

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

(>) :: ChessColor -> ChessColor -> Bool

(>=) :: ChessColor -> ChessColor -> Bool

max :: ChessColor -> ChessColor -> ChessColor

min :: ChessColor -> ChessColor -> ChessColor

Read ChessColor

Defined in Data.Char.Chess

Methods

readsPrec :: Int -> ReadS ChessColor

readList :: ReadS [ChessColor]

readPrec :: ReadPrec ChessColor

readListPrec :: ReadPrec [ChessColor]

Show ChessColor

Defined in Data.Char.Chess

Methods

showsPrec :: Int -> ChessColor -> ShowS

show :: ChessColor -> String

showList :: [ChessColor] -> ShowS

Generic ChessColor

Defined in Data.Char.Chess

Associated Types

type Rep ChessColor :: Type -> Type

Methods

from :: ChessColor -> Rep ChessColor x

to :: Rep ChessColor x -> ChessColor

Arbitrary ChessColor

Defined in Data.Char.Chess

Methods

arbitrary :: Gen ChessColor

shrink :: ChessColor -> [ChessColor]

NFData ChessColor

Defined in Data.Char.Chess

Methods

rnf :: ChessColor -> ()

Hashable ChessColor

Defined in Data.Char.Chess

Methods

hashWithSalt :: Int -> ChessColor -> Int

hash :: ChessColor -> Int

type Rep ChessColor

Defined in Data.Char.Chess

type Rep ChessColor = D1 ('MetaData "ChessColor" "Data.Char.Chess" "unicode-tricks-0.11.0.0-C7NrNgm5l6sAip6k96QRri" 'False) (C1 ('MetaCons "White" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Black" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Neutral" 'PrefixI 'False) (U1 :: Type -> Type)))

data ChessColorBinary

A data type that defined binary colors (BWhite, and BBlack), this is used for special chess pieces like a knight queen, knight rook, and knight bishop that only have no neutral color in unicode.

Constructors

BWhite

White color.

BBlack

Black color.

Instances

Bounded ChessColorBinary

Defined in Data.Char.Chess

Methods

minBound :: ChessColorBinary

maxBound :: ChessColorBinary

Enum ChessColorBinary

Defined in Data.Char.Chess

Methods

succ :: ChessColorBinary -> ChessColorBinary

pred :: ChessColorBinary -> ChessColorBinary

toEnum :: Int -> ChessColorBinary

fromEnum :: ChessColorBinary -> Int

enumFrom :: ChessColorBinary -> [ChessColorBinary]

enumFromThen :: ChessColorBinary -> ChessColorBinary -> [ChessColorBinary]

enumFromTo :: ChessColorBinary -> ChessColorBinary -> [ChessColorBinary]

enumFromThenTo :: ChessColorBinary -> ChessColorBinary -> ChessColorBinary -> [ChessColorBinary]

Eq ChessColorBinary

Defined in Data.Char.Chess

Methods

(==) :: ChessColorBinary -> ChessColorBinary -> Bool

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

Data ChessColorBinary

Defined in Data.Char.Chess

Methods

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

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

toConstr :: ChessColorBinary -> Constr

dataTypeOf :: ChessColorBinary -> DataType

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

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

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

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

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

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

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

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

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

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

Ord ChessColorBinary

Defined in Data.Char.Chess

Methods

compare :: ChessColorBinary -> ChessColorBinary -> Ordering

(<) :: ChessColorBinary -> ChessColorBinary -> Bool

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

(>) :: ChessColorBinary -> ChessColorBinary -> Bool

(>=) :: ChessColorBinary -> ChessColorBinary -> Bool

max :: ChessColorBinary -> ChessColorBinary -> ChessColorBinary

min :: ChessColorBinary -> ChessColorBinary -> ChessColorBinary

Read ChessColorBinary

Defined in Data.Char.Chess

Methods

readsPrec :: Int -> ReadS ChessColorBinary

readList :: ReadS [ChessColorBinary]

readPrec :: ReadPrec ChessColorBinary

readListPrec :: ReadPrec [ChessColorBinary]

Show ChessColorBinary

Defined in Data.Char.Chess

Methods

showsPrec :: Int -> ChessColorBinary -> ShowS

show :: ChessColorBinary -> String

showList :: [ChessColorBinary] -> ShowS

Generic ChessColorBinary

Defined in Data.Char.Chess

Associated Types

type Rep ChessColorBinary :: Type -> Type

Methods

from :: ChessColorBinary -> Rep ChessColorBinary x

to :: Rep ChessColorBinary x -> ChessColorBinary

Arbitrary ChessColorBinary

Defined in Data.Char.Chess

Methods

arbitrary :: Gen ChessColorBinary

shrink :: ChessColorBinary -> [ChessColorBinary]

NFData ChessColorBinary

Defined in Data.Char.Chess

Methods

rnf :: ChessColorBinary -> ()

Hashable ChessColorBinary

Defined in Data.Char.Chess

Methods

hashWithSalt :: Int -> ChessColorBinary -> Int

hash :: ChessColorBinary -> Int

type Rep ChessColorBinary

Defined in Data.Char.Chess

type Rep ChessColorBinary = D1 ('MetaData "ChessColorBinary" "Data.Char.Chess" "unicode-tricks-0.11.0.0-C7NrNgm5l6sAip6k96QRri" 'False) (C1 ('MetaCons "BWhite" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "BBlack" 'PrefixI 'False) (U1 :: Type -> Type))

data ChessPieceType

The type of chess pieces. Unicode includes an Equihopper as piece as well.

Constructors

King

The king chess piece.

Queen

The queen chess piece.

Rook

The rook chess piece.

Bishop

The bishop chess piece.

Knight

The knight chess piece.

Pawn

The pawn chess piece.

Equihopper

The equihopper chess piece.

Instances

Bounded ChessPieceType

Defined in Data.Char.Chess

Methods

minBound :: ChessPieceType

maxBound :: ChessPieceType

Enum ChessPieceType

Defined in Data.Char.Chess

Methods

succ :: ChessPieceType -> ChessPieceType

pred :: ChessPieceType -> ChessPieceType

toEnum :: Int -> ChessPieceType

fromEnum :: ChessPieceType -> Int

enumFrom :: ChessPieceType -> [ChessPieceType]

enumFromThen :: ChessPieceType -> ChessPieceType -> [ChessPieceType]

enumFromTo :: ChessPieceType -> ChessPieceType -> [ChessPieceType]

enumFromThenTo :: ChessPieceType -> ChessPieceType -> ChessPieceType -> [ChessPieceType]

Eq ChessPieceType

Defined in Data.Char.Chess

Methods

(==) :: ChessPieceType -> ChessPieceType -> Bool

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

Data ChessPieceType

Defined in Data.Char.Chess

Methods

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

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

toConstr :: ChessPieceType -> Constr

dataTypeOf :: ChessPieceType -> DataType

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

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

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

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

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

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

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

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

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

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

Ord ChessPieceType

Defined in Data.Char.Chess

Methods

compare :: ChessPieceType -> ChessPieceType -> Ordering

(<) :: ChessPieceType -> ChessPieceType -> Bool

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

(>) :: ChessPieceType -> ChessPieceType -> Bool

(>=) :: ChessPieceType -> ChessPieceType -> Bool

max :: ChessPieceType -> ChessPieceType -> ChessPieceType

min :: ChessPieceType -> ChessPieceType -> ChessPieceType

Read ChessPieceType

Defined in Data.Char.Chess

Methods

readsPrec :: Int -> ReadS ChessPieceType

readList :: ReadS [ChessPieceType]

readPrec :: ReadPrec ChessPieceType

readListPrec :: ReadPrec [ChessPieceType]

Show ChessPieceType

Defined in Data.Char.Chess

Methods

showsPrec :: Int -> ChessPieceType -> ShowS

show :: ChessPieceType -> String

showList :: [ChessPieceType] -> ShowS

Generic ChessPieceType

Defined in Data.Char.Chess

Associated Types

type Rep ChessPieceType :: Type -> Type

Methods

from :: ChessPieceType -> Rep ChessPieceType x

to :: Rep ChessPieceType x -> ChessPieceType

Arbitrary ChessPieceType

Defined in Data.Char.Chess

Methods

arbitrary :: Gen ChessPieceType

shrink :: ChessPieceType -> [ChessPieceType]

NFData ChessPieceType

Defined in Data.Char.Chess

Methods

rnf :: ChessPieceType -> ()

Hashable ChessPieceType

Defined in Data.Char.Chess

Methods

hashWithSalt :: Int -> ChessPieceType -> Int

hash :: ChessPieceType -> Int

type Rep ChessPieceType

Defined in Data.Char.Chess

type Rep ChessPieceType = D1 ('MetaData "ChessPieceType" "Data.Char.Chess" "unicode-tricks-0.11.0.0-C7NrNgm5l6sAip6k96QRri" 'False) ((C1 ('MetaCons "King" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Queen" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Rook" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "Bishop" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Knight" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Pawn" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Equihopper" 'PrefixI 'False) (U1 :: Type -> Type))))

data ChessHybridType

Hybrid chess pieces like the knight-queen, knight-rook and knight-bishop.

Constructors

KnightQueen

The knight-queen chess piece.

KnightRook

The knight-rook chess piece.

KnightBishop

The knight-bishop chess piece.

Instances

Bounded ChessHybridType

Defined in Data.Char.Chess

Methods

minBound :: ChessHybridType

maxBound :: ChessHybridType

Enum ChessHybridType

Defined in Data.Char.Chess

Methods

succ :: ChessHybridType -> ChessHybridType

pred :: ChessHybridType -> ChessHybridType

toEnum :: Int -> ChessHybridType

fromEnum :: ChessHybridType -> Int

enumFrom :: ChessHybridType -> [ChessHybridType]

enumFromThen :: ChessHybridType -> ChessHybridType -> [ChessHybridType]

enumFromTo :: ChessHybridType -> ChessHybridType -> [ChessHybridType]

enumFromThenTo :: ChessHybridType -> ChessHybridType -> ChessHybridType -> [ChessHybridType]

Eq ChessHybridType

Defined in Data.Char.Chess

Methods

(==) :: ChessHybridType -> ChessHybridType -> Bool

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

Data ChessHybridType

Defined in Data.Char.Chess

Methods

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

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

toConstr :: ChessHybridType -> Constr

dataTypeOf :: ChessHybridType -> DataType

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

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

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

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

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

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

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

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

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

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

Ord ChessHybridType

Defined in Data.Char.Chess

Methods

compare :: ChessHybridType -> ChessHybridType -> Ordering

(<) :: ChessHybridType -> ChessHybridType -> Bool

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

(>) :: ChessHybridType -> ChessHybridType -> Bool

(>=) :: ChessHybridType -> ChessHybridType -> Bool

max :: ChessHybridType -> ChessHybridType -> ChessHybridType

min :: ChessHybridType -> ChessHybridType -> ChessHybridType

Read ChessHybridType

Defined in Data.Char.Chess

Methods

readsPrec :: Int -> ReadS ChessHybridType

readList :: ReadS [ChessHybridType]

readPrec :: ReadPrec ChessHybridType

readListPrec :: ReadPrec [ChessHybridType]

Show ChessHybridType

Defined in Data.Char.Chess

Methods

showsPrec :: Int -> ChessHybridType -> ShowS

show :: ChessHybridType -> String

showList :: [ChessHybridType] -> ShowS

Generic ChessHybridType

Defined in Data.Char.Chess

Associated Types

type Rep ChessHybridType :: Type -> Type

Methods

from :: ChessHybridType -> Rep ChessHybridType x

to :: Rep ChessHybridType x -> ChessHybridType

Arbitrary ChessHybridType

Defined in Data.Char.Chess

Methods

arbitrary :: Gen ChessHybridType

shrink :: ChessHybridType -> [ChessHybridType]

NFData ChessHybridType

Defined in Data.Char.Chess

Methods

rnf :: ChessHybridType -> ()

Hashable ChessHybridType

Defined in Data.Char.Chess

Methods

hashWithSalt :: Int -> ChessHybridType -> Int

hash :: ChessHybridType -> Int

type Rep ChessHybridType

Defined in Data.Char.Chess

type Rep ChessHybridType = D1 ('MetaData "ChessHybridType" "Data.Char.Chess" "unicode-tricks-0.11.0.0-C7NrNgm5l6sAip6k96QRri" 'False) (C1 ('MetaCons "KnightQueen" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "KnightRook" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KnightBishop" 'PrefixI 'False) (U1 :: Type -> Type)))

data ChessPiece

Chess pieces that can be represented in Unicode. These are the king, queen, rook, bishop, knight, pawn, and equihopper over 0, 90, 180, and 270 degrees; and the knight over 45, 135, 225, and 315 degrees in Black, White and Neutral. Furthermore one can draw a knight-queen, knight-rook, and knight-bishop pieces can be drawn without rotation and only in BBlack or BWhite.

Constructors

Chess90 ChessColor ChessPieceType Rotate90

Standard pieces drawn in black, white, or neutral and with rotation.

Chess45Knight ChessColor Rotate45

Knights have unicode characters to render these rotated over 45, 135, 225 and 315 degrees.

ChessHybrid ChessHybridType ChessColorBinary

Hybrid chess pieces can only be rendered in BBlack and BWhite.

Instances

Eq ChessPiece

Defined in Data.Char.Chess

Methods

(==) :: ChessPiece -> ChessPiece -> Bool

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

Data ChessPiece

Defined in Data.Char.Chess

Methods

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

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

toConstr :: ChessPiece -> Constr

dataTypeOf :: ChessPiece -> DataType

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

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

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

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

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

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

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

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

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

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

Ord ChessPiece

Defined in Data.Char.Chess

Methods

compare :: ChessPiece -> ChessPiece -> Ordering

(<) :: ChessPiece -> ChessPiece -> Bool

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

(>) :: ChessPiece -> ChessPiece -> Bool

(>=) :: ChessPiece -> ChessPiece -> Bool

max :: ChessPiece -> ChessPiece -> ChessPiece

min :: ChessPiece -> ChessPiece -> ChessPiece

Read ChessPiece

Defined in Data.Char.Chess

Methods

readsPrec :: Int -> ReadS ChessPiece

readList :: ReadS [ChessPiece]

readPrec :: ReadPrec ChessPiece

readListPrec :: ReadPrec [ChessPiece]

Show ChessPiece

Defined in Data.Char.Chess

Methods

showsPrec :: Int -> ChessPiece -> ShowS

show :: ChessPiece -> String

showList :: [ChessPiece] -> ShowS

Generic ChessPiece

Defined in Data.Char.Chess

Associated Types

type Rep ChessPiece :: Type -> Type

Methods

from :: ChessPiece -> Rep ChessPiece x

to :: Rep ChessPiece x -> ChessPiece

Arbitrary ChessPiece

Defined in Data.Char.Chess

Methods

arbitrary :: Gen ChessPiece

shrink :: ChessPiece -> [ChessPiece]

NFData ChessPiece

Defined in Data.Char.Chess

Methods

rnf :: ChessPiece -> ()

Hashable ChessPiece

Defined in Data.Char.Chess

Methods

hashWithSalt :: Int -> ChessPiece -> Int

hash :: ChessPiece -> Int

type Rep ChessPiece

Defined in Data.Char.Chess

type Rep ChessPiece = D1 ('MetaData "ChessPiece" "Data.Char.Chess" "unicode-tricks-0.11.0.0-C7NrNgm5l6sAip6k96QRri" 'False) (C1 ('MetaCons "Chess90" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ChessColor) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ChessPieceType) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Rotate90))) :+: (C1 ('MetaCons "Chess45Knight" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ChessColor) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Rotate45)) :+: C1 ('MetaCons "ChessHybrid" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ChessHybridType) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ChessColorBinary))))

data Rotate45

Extra rotations that can be performed for knight chess pieces.

Constructors

R45

Rotation over 45 degrees.

R135

Rotation over 135 degrees.

R225

Rotation over 225 degrees.

R315

Rotation over 315 degrees.

Instances

Bounded Rotate45

Defined in Data.Char.Chess

Methods

minBound :: Rotate45

maxBound :: Rotate45

Enum Rotate45

Defined in Data.Char.Chess

Methods

succ :: Rotate45 -> Rotate45

pred :: Rotate45 -> Rotate45

toEnum :: Int -> Rotate45

fromEnum :: Rotate45 -> Int

enumFrom :: Rotate45 -> [Rotate45]

enumFromThen :: Rotate45 -> Rotate45 -> [Rotate45]

enumFromTo :: Rotate45 -> Rotate45 -> [Rotate45]

enumFromThenTo :: Rotate45 -> Rotate45 -> Rotate45 -> [Rotate45]

Eq Rotate45

Defined in Data.Char.Chess

Methods

(==) :: Rotate45 -> Rotate45 -> Bool

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

Data Rotate45

Defined in Data.Char.Chess

Methods

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

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

toConstr :: Rotate45 -> Constr

dataTypeOf :: Rotate45 -> DataType

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

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

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

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

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

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

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

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

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

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

Ord Rotate45

Defined in Data.Char.Chess

Methods

compare :: Rotate45 -> Rotate45 -> Ordering

(<) :: Rotate45 -> Rotate45 -> Bool

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

(>) :: Rotate45 -> Rotate45 -> Bool

(>=) :: Rotate45 -> Rotate45 -> Bool

max :: Rotate45 -> Rotate45 -> Rotate45

min :: Rotate45 -> Rotate45 -> Rotate45

Read Rotate45

Defined in Data.Char.Chess

Methods

readsPrec :: Int -> ReadS Rotate45

readList :: ReadS [Rotate45]

readPrec :: ReadPrec Rotate45

readListPrec :: ReadPrec [Rotate45]

Show Rotate45

Defined in Data.Char.Chess

Methods

showsPrec :: Int -> Rotate45 -> ShowS

show :: Rotate45 -> String

showList :: [Rotate45] -> ShowS

Generic Rotate45

Defined in Data.Char.Chess

Associated Types

type Rep Rotate45 :: Type -> Type

Methods

from :: Rotate45 -> Rep Rotate45 x

to :: Rep Rotate45 x -> Rotate45

Arbitrary Rotate45

Defined in Data.Char.Chess

Methods

arbitrary :: Gen Rotate45

shrink :: Rotate45 -> [Rotate45]

NFData Rotate45

Defined in Data.Char.Chess

Methods

rnf :: Rotate45 -> ()

Hashable Rotate45

Defined in Data.Char.Chess

Methods

hashWithSalt :: Int -> Rotate45 -> Int

hash :: Rotate45 -> Int

type Rep Rotate45

Defined in Data.Char.Chess

type Rep Rotate45 = D1 ('MetaData "Rotate45" "Data.Char.Chess" "unicode-tricks-0.11.0.0-C7NrNgm5l6sAip6k96QRri" 'False) ((C1 ('MetaCons "R45" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "R135" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "R225" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "R315" 'PrefixI 'False) (U1 :: Type -> Type)))

Convert the chess piece to its unicode equivalent.

chessPiece

Arguments

:: ChessPiece

The given ChessPiece to convert.

-> Char

The unicode character that represents the given ChessPiece.

Convert the given ChessPiece to the corresponding unicode character.

Pattern synonyms of special pieces

pattern Grasshopper :: ChessColor -> ChessPiece

A grasshopper is a queen rotated over 180 degrees.

pattern Nightrider :: ChessColor -> ChessPiece

A Nightrider is a knight rotated over 180 degrees.

pattern Amazon :: ChessColorBinary -> ChessPiece

An amazon is alterative name for a knight-queen.

pattern Terror :: ChessColorBinary -> ChessPiece

A terror is alterative name for a knight-queen.

pattern OmnipotentQueen :: ChessColorBinary -> ChessPiece

An omnipotent queen is alterative name for a knight-queen.

pattern Superqueen :: ChessColorBinary -> ChessPiece

A superqueen is alterative name for a knight-queen.

pattern Chancellor :: ChessColorBinary -> ChessPiece

A chancellor is alterative name for a knight-rook.

pattern Marshall :: ChessColorBinary -> ChessPiece

A marshall is alterative name for a knight-rook.

pattern Empress :: ChessColorBinary -> ChessPiece

An empress is alterative name for a knight-rook.

pattern Cardinal :: ChessColorBinary -> ChessPiece

A cardinal is alterative name for a knight-bishop.

pattern Princess :: ChessColorBinary -> ChessPiece

A princess is alterative name for a knight-bishop.