{-# LANGUAGE PatternSynonyms #-}
module Game.Chess.Internal.Square where

import           Control.Lens   (Iso', from, iso, view)
import           Data.Bifunctor (Bifunctor (..))
import           Data.Binary    (Binary (get, put), getWord8, putWord8)
import           Data.Bits      (Bits (testBit))
import           Data.Char      (chr, ord)
import           Data.Coerce    (coerce)
import           Data.Ix        (Ix (..))
import           Data.String    (IsString (fromString))
import           Data.Word      (Word64)
import           GHC.Stack      (HasCallStack)

newtype Rank = Rank Int deriving (Rank -> Rank -> Bool
(Rank -> Rank -> Bool) -> (Rank -> Rank -> Bool) -> Eq Rank
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Rank -> Rank -> Bool
== :: Rank -> Rank -> Bool
$c/= :: Rank -> Rank -> Bool
/= :: Rank -> Rank -> Bool
Eq, Eq Rank
Eq Rank =>
(Rank -> Rank -> Ordering)
-> (Rank -> Rank -> Bool)
-> (Rank -> Rank -> Bool)
-> (Rank -> Rank -> Bool)
-> (Rank -> Rank -> Bool)
-> (Rank -> Rank -> Rank)
-> (Rank -> Rank -> Rank)
-> Ord Rank
Rank -> Rank -> Bool
Rank -> Rank -> Ordering
Rank -> Rank -> Rank
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Rank -> Rank -> Ordering
compare :: Rank -> Rank -> Ordering
$c< :: Rank -> Rank -> Bool
< :: Rank -> Rank -> Bool
$c<= :: Rank -> Rank -> Bool
<= :: Rank -> Rank -> Bool
$c> :: Rank -> Rank -> Bool
> :: Rank -> Rank -> Bool
$c>= :: Rank -> Rank -> Bool
>= :: Rank -> Rank -> Bool
$cmax :: Rank -> Rank -> Rank
max :: Rank -> Rank -> Rank
$cmin :: Rank -> Rank -> Rank
min :: Rank -> Rank -> Rank
Ord)

unRank :: Rank -> Int
unRank :: Rank -> Int
unRank = Rank -> Int
forall a b. Coercible a b => a -> b
coerce

mkRank :: HasCallStack => Int -> Rank
mkRank :: HasCallStack => Int -> Rank
mkRank Int
n | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
7 = Int -> Rank
Rank Int
n
         | Bool
otherwise        = [Char] -> Rank
forall a. HasCallStack => [Char] -> a
error ([Char] -> Rank) -> [Char] -> Rank
forall a b. (a -> b) -> a -> b
$ [Char]
"mkRank " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
n

instance Show Rank where
  showsPrec :: Int -> Rank -> [Char] -> [Char]
showsPrec Int
_ (Rank Int
0) = [Char] -> [Char] -> [Char]
showString [Char]
"Rank1"
  showsPrec Int
_ (Rank Int
1) = [Char] -> [Char] -> [Char]
showString [Char]
"Rank2"
  showsPrec Int
_ (Rank Int
2) = [Char] -> [Char] -> [Char]
showString [Char]
"Rank3"
  showsPrec Int
_ (Rank Int
3) = [Char] -> [Char] -> [Char]
showString [Char]
"Rank4"
  showsPrec Int
_ (Rank Int
4) = [Char] -> [Char] -> [Char]
showString [Char]
"Rank5"
  showsPrec Int
_ (Rank Int
5) = [Char] -> [Char] -> [Char]
showString [Char]
"Rank6"
  showsPrec Int
_ (Rank Int
6) = [Char] -> [Char] -> [Char]
showString [Char]
"Rank7"
  showsPrec Int
_ (Rank Int
7) = [Char] -> [Char] -> [Char]
showString [Char]
"Rank8"
  showsPrec Int
d (Rank Int
n) = Bool -> ([Char] -> [Char]) -> [Char] -> [Char]
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (([Char] -> [Char]) -> [Char] -> [Char])
-> ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$
                         [Char] -> [Char] -> [Char]
showString [Char]
"Rank " ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> [Char] -> [Char]
forall a. Show a => Int -> a -> [Char] -> [Char]
showsPrec Int
11 Int
n

instance Enum Rank where
  toEnum :: Int -> Rank
toEnum Int
n | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
7 = Int -> Rank
Rank Int
n
           | Bool
otherwise        = [Char] -> Rank
forall a. HasCallStack => [Char] -> a
error ([Char] -> Rank) -> [Char] -> Rank
forall a b. (a -> b) -> a -> b
$ [Char]
"Rank out-of-bound " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
n
  fromEnum :: Rank -> Int
fromEnum = Rank -> Int
forall a b. Coercible a b => a -> b
coerce

instance Bounded Rank where
  minBound :: Rank
minBound = Rank
Rank1
  maxBound :: Rank
maxBound = Rank
Rank8

pattern Rank1, Rank2, Rank3, Rank4, Rank5, Rank6, Rank7, Rank8 :: Rank
pattern $mRank1 :: forall {r}. Rank -> ((# #) -> r) -> ((# #) -> r) -> r
$bRank1 :: Rank
Rank1 = Rank 0
pattern $mRank2 :: forall {r}. Rank -> ((# #) -> r) -> ((# #) -> r) -> r
$bRank2 :: Rank
Rank2 = Rank 1
pattern $mRank3 :: forall {r}. Rank -> ((# #) -> r) -> ((# #) -> r) -> r
$bRank3 :: Rank
Rank3 = Rank 2
pattern $mRank4 :: forall {r}. Rank -> ((# #) -> r) -> ((# #) -> r) -> r
$bRank4 :: Rank
Rank4 = Rank 3
pattern $mRank5 :: forall {r}. Rank -> ((# #) -> r) -> ((# #) -> r) -> r
$bRank5 :: Rank
Rank5 = Rank 4
pattern $mRank6 :: forall {r}. Rank -> ((# #) -> r) -> ((# #) -> r) -> r
$bRank6 :: Rank
Rank6 = Rank 5
pattern $mRank7 :: forall {r}. Rank -> ((# #) -> r) -> ((# #) -> r) -> r
$bRank7 :: Rank
Rank7 = Rank 6
pattern $mRank8 :: forall {r}. Rank -> ((# #) -> r) -> ((# #) -> r) -> r
$bRank8 :: Rank
Rank8 = Rank 7

{-# COMPLETE Rank1, Rank2, Rank3, Rank4, Rank5, Rank6, Rank7, Rank8 :: Rank #-}

newtype File = File Int deriving (File -> File -> Bool
(File -> File -> Bool) -> (File -> File -> Bool) -> Eq File
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: File -> File -> Bool
== :: File -> File -> Bool
$c/= :: File -> File -> Bool
/= :: File -> File -> Bool
Eq, Eq File
Eq File =>
(File -> File -> Ordering)
-> (File -> File -> Bool)
-> (File -> File -> Bool)
-> (File -> File -> Bool)
-> (File -> File -> Bool)
-> (File -> File -> File)
-> (File -> File -> File)
-> Ord File
File -> File -> Bool
File -> File -> Ordering
File -> File -> File
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: File -> File -> Ordering
compare :: File -> File -> Ordering
$c< :: File -> File -> Bool
< :: File -> File -> Bool
$c<= :: File -> File -> Bool
<= :: File -> File -> Bool
$c> :: File -> File -> Bool
> :: File -> File -> Bool
$c>= :: File -> File -> Bool
>= :: File -> File -> Bool
$cmax :: File -> File -> File
max :: File -> File -> File
$cmin :: File -> File -> File
min :: File -> File -> File
Ord)

unFile :: File -> Int
unFile :: File -> Int
unFile = File -> Int
forall a b. Coercible a b => a -> b
coerce

mkFile :: HasCallStack => Int -> File
mkFile :: HasCallStack => Int -> File
mkFile Int
n | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
7 = Int -> File
File Int
n
         | Bool
otherwise        = [Char] -> File
forall a. HasCallStack => [Char] -> a
error ([Char] -> File) -> [Char] -> File
forall a b. (a -> b) -> a -> b
$ [Char]
"mkFile " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
n

instance Show File where
  showsPrec :: Int -> File -> [Char] -> [Char]
showsPrec Int
_ (File Int
0) = [Char] -> [Char] -> [Char]
showString [Char]
"FileA"
  showsPrec Int
_ (File Int
1) = [Char] -> [Char] -> [Char]
showString [Char]
"FileB"
  showsPrec Int
_ (File Int
2) = [Char] -> [Char] -> [Char]
showString [Char]
"FileC"
  showsPrec Int
_ (File Int
3) = [Char] -> [Char] -> [Char]
showString [Char]
"FileD"
  showsPrec Int
_ (File Int
4) = [Char] -> [Char] -> [Char]
showString [Char]
"FileE"
  showsPrec Int
_ (File Int
5) = [Char] -> [Char] -> [Char]
showString [Char]
"FileF"
  showsPrec Int
_ (File Int
6) = [Char] -> [Char] -> [Char]
showString [Char]
"FileG"
  showsPrec Int
_ (File Int
7) = [Char] -> [Char] -> [Char]
showString [Char]
"FileH"
  showsPrec Int
d (File Int
n) = Bool -> ([Char] -> [Char]) -> [Char] -> [Char]
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (([Char] -> [Char]) -> [Char] -> [Char])
-> ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$
                         [Char] -> [Char] -> [Char]
showString [Char]
"File " ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> [Char] -> [Char]
forall a. Show a => Int -> a -> [Char] -> [Char]
showsPrec Int
11 Int
n

instance Enum File where
  toEnum :: Int -> File
toEnum Int
n | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
7 = Int -> File
File Int
n
           | Bool
otherwise        = [Char] -> File
forall a. HasCallStack => [Char] -> a
error ([Char] -> File) -> [Char] -> File
forall a b. (a -> b) -> a -> b
$ [Char]
"File out-of-bound " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
n
  fromEnum :: File -> Int
fromEnum = File -> Int
forall a b. Coercible a b => a -> b
coerce

instance Bounded File where
  minBound :: File
minBound = File
FileA
  maxBound :: File
maxBound = File
FileH

pattern FileA, FileB, FileC, FileD, FileE, FileF, FileG, FileH :: File
pattern $mFileA :: forall {r}. File -> ((# #) -> r) -> ((# #) -> r) -> r
$bFileA :: File
FileA = File 0
pattern $mFileB :: forall {r}. File -> ((# #) -> r) -> ((# #) -> r) -> r
$bFileB :: File
FileB = File 1
pattern $mFileC :: forall {r}. File -> ((# #) -> r) -> ((# #) -> r) -> r
$bFileC :: File
FileC = File 2
pattern $mFileD :: forall {r}. File -> ((# #) -> r) -> ((# #) -> r) -> r
$bFileD :: File
FileD = File 3
pattern $mFileE :: forall {r}. File -> ((# #) -> r) -> ((# #) -> r) -> r
$bFileE :: File
FileE = File 4
pattern $mFileF :: forall {r}. File -> ((# #) -> r) -> ((# #) -> r) -> r
$bFileF :: File
FileF = File 5
pattern $mFileG :: forall {r}. File -> ((# #) -> r) -> ((# #) -> r) -> r
$bFileG :: File
FileG = File 6
pattern $mFileH :: forall {r}. File -> ((# #) -> r) -> ((# #) -> r) -> r
$bFileH :: File
FileH = File 7

{-# COMPLETE FileA, FileB, FileC, FileD, FileE, FileF, FileG, FileH :: File #-}

newtype Square = Sq Int deriving (Square -> Square -> Bool
(Square -> Square -> Bool)
-> (Square -> Square -> Bool) -> Eq Square
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Square -> Square -> Bool
== :: Square -> Square -> Bool
$c/= :: Square -> Square -> Bool
/= :: Square -> Square -> Bool
Eq, Eq Square
Eq Square =>
(Square -> Square -> Ordering)
-> (Square -> Square -> Bool)
-> (Square -> Square -> Bool)
-> (Square -> Square -> Bool)
-> (Square -> Square -> Bool)
-> (Square -> Square -> Square)
-> (Square -> Square -> Square)
-> Ord Square
Square -> Square -> Bool
Square -> Square -> Ordering
Square -> Square -> Square
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Square -> Square -> Ordering
compare :: Square -> Square -> Ordering
$c< :: Square -> Square -> Bool
< :: Square -> Square -> Bool
$c<= :: Square -> Square -> Bool
<= :: Square -> Square -> Bool
$c> :: Square -> Square -> Bool
> :: Square -> Square -> Bool
$c>= :: Square -> Square -> Bool
>= :: Square -> Square -> Bool
$cmax :: Square -> Square -> Square
max :: Square -> Square -> Square
$cmin :: Square -> Square -> Square
min :: Square -> Square -> Square
Ord)

instance Binary Square where
  put :: Square -> Put
put = Word8 -> Put
putWord8 (Word8 -> Put) -> (Square -> Word8) -> Square -> Put
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word8) -> (Square -> Int) -> Square -> Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Square -> Int
unSquare
  get :: Get Square
get = HasCallStack => Int -> Square
Int -> Square
mkSq (Int -> Square) -> (Word8 -> Int) -> Word8 -> Square
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8 -> Square) -> Get Word8 -> Get Square
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word8
getWord8

instance Ix Square where
  range :: (Square, Square) -> [Square]
range (Sq Int
i, Sq Int
j) = [Int -> Square
Sq Int
k | Int
k <- [Int
i..Int
j]]
  index :: (Square, Square) -> Square -> Int
index (Sq Int
i, Sq Int
j) (Sq Int
k) = (Int, Int) -> Int -> Int
forall a. Ix a => (a, a) -> a -> Int
index (Int
i, Int
j) Int
k
  inRange :: (Square, Square) -> Square -> Bool
inRange (Sq Int
i, Sq Int
j) (Sq Int
k) = (Int, Int) -> Int -> Bool
forall a. Ix a => (a, a) -> a -> Bool
inRange (Int
i, Int
j) Int
k
  rangeSize :: (Square, Square) -> Int
rangeSize (Sq Int
i, Sq Int
j) = Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
i

unSquare :: Square -> Int
unSquare :: Square -> Int
unSquare = Square -> Int
forall a b. Coercible a b => a -> b
coerce
{-# INLINE unSquare #-}

-- TODO: this check is expensive, maybe only worth in "debug" builds.
mkSq :: HasCallStack => Int -> Square
mkSq :: HasCallStack => Int -> Square
mkSq Int
n | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
63 = Int -> Square
Sq Int
n
       | Bool
otherwise         = [Char] -> Square
forall a. HasCallStack => [Char] -> a
error ([Char] -> Square) -> [Char] -> Square
forall a b. (a -> b) -> a -> b
$ [Char]
"mkSq " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
n

instance Show Square where
  showsPrec :: Int -> Square -> [Char] -> [Char]
showsPrec Int
d (Sq Int
i) | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
63 = [Char] -> [Char] -> [Char]
showString [Char
f', Char
r']
                     | Bool
otherwise         = Bool -> ([Char] -> [Char]) -> [Char] -> [Char]
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (([Char] -> [Char]) -> [Char] -> [Char])
-> ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$
                                           [Char] -> [Char] -> [Char]
showString [Char]
"Sq " ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> [Char] -> [Char]
forall a. Show a => Int -> a -> [Char] -> [Char]
showsPrec Int
11 Int
i
      where
        (Int
r, Int
f) = Int
i Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`divMod` Int
8
        r' :: Char
r' = Int -> Char
chr (Int
r Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Char -> Int
ord Char
'1')
        f' :: Char
f' = Int -> Char
chr (Int
f Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Char -> Int
ord Char
'A')

instance Enum Square where
  toEnum :: Int -> Square
toEnum Int
n | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
63 = Int -> Square
Sq Int
n
           | Bool
otherwise         = [Char] -> Square
forall a. HasCallStack => [Char] -> a
error ([Char] -> Square) -> [Char] -> Square
forall a b. (a -> b) -> a -> b
$ [Char]
"Sq out-of-bound " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
n
  fromEnum :: Square -> Int
fromEnum = Square -> Int
forall a b. Coercible a b => a -> b
coerce

instance Bounded Square where
  minBound :: Square
minBound = Square
A1
  maxBound :: Square
maxBound = Square
H8

pattern A1, A2, A3, A4, A5, A6, A7, A8 :: Square
pattern B1, B2, B3, B4, B5, B6, B7, B8 :: Square
pattern C1, C2, C3, C4, C5, C6, C7, C8 :: Square
pattern D1, D2, D3, D4, D5, D6, D7, D8 :: Square
pattern E1, E2, E3, E4, E5, E6, E7, E8 :: Square
pattern F1, F2, F3, F4, F5, F6, F7, F8 :: Square
pattern G1, G2, G3, G4, G5, G6, G7, G8 :: Square
pattern H1, H2, H3, H4, H5, H6, H7, H8 :: Square

pattern $mA1 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bA1 :: Square
A1 = Sq 0
pattern $mB1 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bB1 :: Square
B1 = Sq 1
pattern $mC1 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bC1 :: Square
C1 = Sq 2
pattern $mD1 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bD1 :: Square
D1 = Sq 3
pattern $mE1 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bE1 :: Square
E1 = Sq 4
pattern $mF1 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bF1 :: Square
F1 = Sq 5
pattern $mG1 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bG1 :: Square
G1 = Sq 6
pattern $mH1 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bH1 :: Square
H1 = Sq 7

pattern $mA2 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bA2 :: Square
A2 = Sq 8
pattern $mB2 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bB2 :: Square
B2 = Sq 9
pattern $mC2 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bC2 :: Square
C2 = Sq 10
pattern $mD2 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bD2 :: Square
D2 = Sq 11
pattern $mE2 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bE2 :: Square
E2 = Sq 12
pattern $mF2 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bF2 :: Square
F2 = Sq 13
pattern $mG2 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bG2 :: Square
G2 = Sq 14
pattern $mH2 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bH2 :: Square
H2 = Sq 15

pattern $mA3 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bA3 :: Square
A3 = Sq 16
pattern $mB3 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bB3 :: Square
B3 = Sq 17
pattern $mC3 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bC3 :: Square
C3 = Sq 18
pattern $mD3 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bD3 :: Square
D3 = Sq 19
pattern $mE3 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bE3 :: Square
E3 = Sq 20
pattern $mF3 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bF3 :: Square
F3 = Sq 21
pattern $mG3 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bG3 :: Square
G3 = Sq 22
pattern $mH3 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bH3 :: Square
H3 = Sq 23

pattern $mA4 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bA4 :: Square
A4 = Sq 24
pattern $mB4 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bB4 :: Square
B4 = Sq 25
pattern $mC4 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bC4 :: Square
C4 = Sq 26
pattern $mD4 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bD4 :: Square
D4 = Sq 27
pattern $mE4 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bE4 :: Square
E4 = Sq 28
pattern $mF4 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bF4 :: Square
F4 = Sq 29
pattern $mG4 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bG4 :: Square
G4 = Sq 30
pattern $mH4 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bH4 :: Square
H4 = Sq 31

pattern $mA5 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bA5 :: Square
A5 = Sq 32
pattern $mB5 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bB5 :: Square
B5 = Sq 33
pattern $mC5 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bC5 :: Square
C5 = Sq 34
pattern $mD5 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bD5 :: Square
D5 = Sq 35
pattern $mE5 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bE5 :: Square
E5 = Sq 36
pattern $mF5 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bF5 :: Square
F5 = Sq 37
pattern $mG5 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bG5 :: Square
G5 = Sq 38
pattern $mH5 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bH5 :: Square
H5 = Sq 39

pattern $mA6 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bA6 :: Square
A6 = Sq 40
pattern $mB6 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bB6 :: Square
B6 = Sq 41
pattern $mC6 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bC6 :: Square
C6 = Sq 42
pattern $mD6 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bD6 :: Square
D6 = Sq 43
pattern $mE6 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bE6 :: Square
E6 = Sq 44
pattern $mF6 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bF6 :: Square
F6 = Sq 45
pattern $mG6 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bG6 :: Square
G6 = Sq 46
pattern $mH6 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bH6 :: Square
H6 = Sq 47

pattern $mA7 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bA7 :: Square
A7 = Sq 48
pattern $mB7 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bB7 :: Square
B7 = Sq 49
pattern $mC7 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bC7 :: Square
C7 = Sq 50
pattern $mD7 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bD7 :: Square
D7 = Sq 51
pattern $mE7 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bE7 :: Square
E7 = Sq 52
pattern $mF7 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bF7 :: Square
F7 = Sq 53
pattern $mG7 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bG7 :: Square
G7 = Sq 54
pattern $mH7 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bH7 :: Square
H7 = Sq 55

pattern $mA8 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bA8 :: Square
A8 = Sq 56
pattern $mB8 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bB8 :: Square
B8 = Sq 57
pattern $mC8 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bC8 :: Square
C8 = Sq 58
pattern $mD8 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bD8 :: Square
D8 = Sq 59
pattern $mE8 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bE8 :: Square
E8 = Sq 60
pattern $mF8 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bF8 :: Square
F8 = Sq 61
pattern $mG8 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bG8 :: Square
G8 = Sq 62
pattern $mH8 :: forall {r}. Square -> ((# #) -> r) -> ((# #) -> r) -> r
$bH8 :: Square
H8 = Sq 63

rank :: Square -> Rank
rank :: Square -> Rank
rank = Int -> Rank
Rank (Int -> Rank) -> (Square -> Int) -> Square -> Rank
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
8) (Int -> Int) -> (Square -> Int) -> Square -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Square -> Int
forall a b. Coercible a b => a -> b
coerce

file :: Square -> File
file :: Square -> File
file = Int -> File
File (Int -> File) -> (Square -> Int) -> Square -> File
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Int -> Int
forall a. Integral a => a -> a -> a
`mod` Int
8) (Int -> Int) -> (Square -> Int) -> Square -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Square -> Int
forall a b. Coercible a b => a -> b
coerce

rankFile :: Iso' Square (Rank, File)
rankFile :: Iso' Square (Rank, File)
rankFile = (Square -> (Rank, File))
-> ((Rank, File) -> Square) -> Iso' Square (Rank, File)
forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
iso Square -> (Rank, File)
rf (Rank, File) -> Square
sq where
  rf :: Square -> (Rank, File)
rf (Sq Int
i) = (Int -> Rank) -> (Int -> File) -> (Int, Int) -> (Rank, File)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap Int -> Rank
Rank Int -> File
File ((Int, Int) -> (Rank, File)) -> (Int, Int) -> (Rank, File)
forall a b. (a -> b) -> a -> b
$ Int
i Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`divMod` Int
8
  sq :: (Rank, File) -> Square
sq (Rank Int
r, File Int
f) = Int -> Square
Sq (Int -> Square) -> Int -> Square
forall a b. (a -> b) -> a -> b
$ Int
rInt -> Int -> Int
forall a. Num a => a -> a -> a
*Int
8 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
f

mapRank :: (Rank -> Rank) -> Square -> Square
mapRank :: (Rank -> Rank) -> Square -> Square
mapRank Rank -> Rank
f = Getting Square (Rank, File) Square -> (Rank, File) -> Square
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view (AnIso Square Square (Rank, File) (Rank, File)
-> Iso (Rank, File) (Rank, File) Square Square
forall s t a b. AnIso s t a b -> Iso b a t s
from AnIso Square Square (Rank, File) (Rank, File)
Iso' Square (Rank, File)
rankFile) ((Rank, File) -> Square)
-> (Square -> (Rank, File)) -> Square -> Square
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Rank -> Rank) -> (Rank, File) -> (Rank, File)
forall a b c. (a -> b) -> (a, c) -> (b, c)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first Rank -> Rank
f ((Rank, File) -> (Rank, File))
-> (Square -> (Rank, File)) -> Square -> (Rank, File)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting (Rank, File) Square (Rank, File) -> Square -> (Rank, File)
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Rank, File) Square (Rank, File)
Iso' Square (Rank, File)
rankFile

mapFile :: (File -> File) -> Square -> Square
mapFile :: (File -> File) -> Square -> Square
mapFile File -> File
f = Getting Square (Rank, File) Square -> (Rank, File) -> Square
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view (AnIso Square Square (Rank, File) (Rank, File)
-> Iso (Rank, File) (Rank, File) Square Square
forall s t a b. AnIso s t a b -> Iso b a t s
from AnIso Square Square (Rank, File) (Rank, File)
Iso' Square (Rank, File)
rankFile) ((Rank, File) -> Square)
-> (Square -> (Rank, File)) -> Square -> Square
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (File -> File) -> (Rank, File) -> (Rank, File)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second File -> File
f ((Rank, File) -> (Rank, File))
-> (Square -> (Rank, File)) -> Square -> (Rank, File)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting (Rank, File) Square (Rank, File) -> Square -> (Rank, File)
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Rank, File) Square (Rank, File)
Iso' Square (Rank, File)
rankFile

fileChar, rankChar :: Square -> Char
fileChar :: Square -> Char
fileChar = Int -> Char
chr (Int -> Char) -> (Square -> Int) -> Square -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Int
ord Char
'a' Int -> Int -> Int
forall a. Num a => a -> a -> a
+) (Int -> Int) -> (Square -> Int) -> Square -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. File -> Int
unFile (File -> Int) -> (Square -> File) -> Square -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Square -> File
file
rankChar :: Square -> Char
rankChar = Int -> Char
chr (Int -> Char) -> (Square -> Int) -> Square -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Int
ord Char
'1' Int -> Int -> Int
forall a. Num a => a -> a -> a
+) (Int -> Int) -> (Square -> Int) -> Square -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rank -> Int
unRank (Rank -> Int) -> (Square -> Rank) -> Square -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Square -> Rank
rank

toCoord :: IsString s => Square -> s
toCoord :: forall s. IsString s => Square -> s
toCoord Square
sq = [Char] -> s
forall a. IsString a => [Char] -> a
fromString ([Char] -> s) -> [Char] -> s
forall a b. (a -> b) -> a -> b
$ ((Square -> Char) -> Square -> Char
forall a b. (a -> b) -> a -> b
$ Square
sq) ((Square -> Char) -> Char) -> [Square -> Char] -> [Char]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Square -> Char
fileChar, Square -> Char
rankChar]

isDark :: Square -> Bool
isDark :: Square -> Bool
isDark (Sq Int
i) = (Word64
0xaa55aa55aa55aa55 :: Word64) Word64 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
`testBit` Int
i

isLight :: Square -> Bool
isLight :: Square -> Bool
isLight = Bool -> Bool
not (Bool -> Bool) -> (Square -> Bool) -> Square -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Square -> Bool
isDark