Safe Haskell	None
Language	Haskell2010

Game.Labyrinth

Synopsis

newtype Board = Board Word64
data Coord
- = C0
- | C1
- | C2
- | C3
- | C4
- | C5
- | C6
boardIndex :: (Coord, Coord) -> Int
isCellFixed :: (Coord, Coord) -> Bool
boardGet :: Board -> (Coord, Coord) -> Bool
boardSet :: Bool -> (Coord, Coord) -> Board
singleCell :: (Coord, Coord) -> Board
listsFromBoard :: Board -> [[Bool]]
allEnums :: (Enum a, Bounded a) => [a]
rowMask :: Word64
columnMask :: Word64
boardMask :: Word64
rowKMask :: Coord -> Word64
columnKMask :: Coord -> Word64
(.-.) :: Bits a => a -> a -> a
shiftBoardLeft :: Board -> Board
shiftBoardRight :: Board -> Board
shiftBoardUp :: Board -> Board
shiftBoardDown :: Board -> Board
splitBoard :: Board -> Board -> (Board, Board)
shiftRowLeft :: Coord -> (Bool, Board) -> (Bool, Board)
shiftRowRight :: Coord -> (Bool, Board) -> (Bool, Board)
shiftColumnUp :: Coord -> (Bool, Board) -> (Bool, Board)
shiftColumnDown :: Coord -> (Bool, Board) -> (Bool, Board)
cycleBoardLeft :: Board -> Board
cycleBoardRight :: Board -> Board
cycleBoardUp :: Board -> Board
cycleBoardDown :: Board -> Board
cycleGen :: (Board -> Board) -> (Coord -> Word64) -> Coord -> Board -> Board
cycleRowLeft :: Coord -> Board -> Board
cycleRowRight :: Coord -> Board -> Board
cycleColumnUp :: Coord -> Board -> Board
cycleColumnDown :: Coord -> Board -> Board
cycleStripe :: Border -> Coord -> Board -> Board
rotateMasked :: (Directions Board -> Directions Board) -> Board -> Directions Board -> Directions Board
rotateDir90 :: Directions a -> Directions a
rotateDir180 :: Directions a -> Directions a
randomRotate :: RandomGen g => Directions Board -> State g (Directions Board)
data Directions a = Directions {
- north :: a
- west :: a
- south :: a
- east :: a
}
transposeDirections :: Directions [[a]] -> [[Directions a]]
boolChar :: Char -> Bool -> Char
formatBoard :: Board -> String
wallChar :: Char
wayChar :: Char
selectWallWayChar :: Bool -> Bool -> Char
boxTable :: [[Box]] -> Box
formatCell :: EnumSet Player -> Directions Bool -> Char -> Directions Bool -> Box
format :: Directions Board -> Box
formatWays :: Directions Board -> Board -> Box
connectReachable :: Directions Board -> Board -> Directions Board
arrows :: Directions Char
arrowFrame :: Maybe (Border, Coord) -> Box -> Box
constMap :: Ord k => [k] -> a -> Map k a
shiftCharMap :: Directions (Map Coord Char)
arrowMap :: Map Char (Border, Coord)
coordinateFrame :: Box -> Box
rowMap :: Map Char Coord
columnMap :: Map Char Coord
data Shape
- = I
- | L
- | T
type InitTile = (Shape, Maybe Char)
data Rotation
- = R0
- | R1
- | R2
- | R3
dirsFromShape :: Shape -> Directions Bool
defaultBoardDirs :: [[Directions Bool]]
defaultBoard :: Directions Board
randomChoose :: RandomGen g => StateT [a] (State g) a
shuffle :: RandomGen g => State g (InitTile, [InitTile])
singleCellShape :: (Coord, Coord) -> Shape -> Directions Board
grid :: [a] -> [(a, a)]
layoutMoveableCells :: [InitTile] -> (Directions Board, SymbolMap)
randomBoard :: RandomGen g => State g (InitTile, (Directions Board, SymbolMap))
shuffleTargets :: RandomGen g => State g [Char]
associateTargets :: T [] Player -> [Char] -> T Seq (Player, T [] Char)
bfsStep :: Directions Board -> Board -> Board
bfs :: Directions Board -> Board -> Board
data Player
- = Player0
- | Player1
- | Player2
- | Player3
playerChar :: Bool -> Player -> Char
moveableSymbols :: [Char]
playerSymbols :: [Char]
fixedSymbols :: [Char]
type SymbolMap = Map (Coord, Coord) Char
fixedSymbolMap :: SymbolMap
randomSymbolMap :: RandomGen g => State g SymbolMap
removeFromMap :: Ord k => k -> Map k a -> (Maybe a, Map k a)
insertMaybeMap :: Ord k => k -> Maybe a -> Map k a -> Map k a
shiftRowLeftMap :: Coord -> (Maybe Char, SymbolMap) -> (Maybe Char, SymbolMap)
shiftRowRightMap :: Coord -> (Maybe Char, SymbolMap) -> (Maybe Char, SymbolMap)
shiftColumnUpMap :: Coord -> (Maybe Char, SymbolMap) -> (Maybe Char, SymbolMap)
shiftColumnDownMap :: Coord -> (Maybe Char, SymbolMap) -> (Maybe Char, SymbolMap)
formatWithSymbols :: BoardState -> Board -> Box
type PlayerMap = EnumMap Player (Coord, Coord)
shiftPlayersGen :: Eq a => (b -> a) -> (b -> b) -> a -> EnumMap k b -> EnumMap k b
shiftRowLeftPlayers :: Coord -> PlayerMap -> PlayerMap
shiftRowRightPlayers :: Coord -> PlayerMap -> PlayerMap
shiftColumnUpPlayers :: Coord -> PlayerMap -> PlayerMap
shiftColumnDownPlayers :: Coord -> PlayerMap -> PlayerMap
data BoardState = BoardState {
- stateBoard :: Directions Board
- stateSymbolMap :: SymbolMap
- statePlayerMap :: PlayerMap
}
type Tile = (Directions Bool, Maybe Char)
cyclicPred :: (Eq a, Enum a, Bounded a) => a -> a
cyclicSucc :: (Eq a, Enum a, Bounded a) => a -> a
shiftStateGen :: (Coord -> (Bool, Board) -> (Bool, Board)) -> (Coord -> (Maybe Char, SymbolMap) -> (Maybe Char, SymbolMap)) -> (Coord -> PlayerMap -> PlayerMap) -> Coord -> (Tile, BoardState) -> (Tile, BoardState)
data Border
- = North
- | West
- | South
- | East
borderSet :: Directions Border
singleBorder :: Border -> a -> Directions a -> Directions a
lookupBorder :: Border -> Directions a -> a
flipBorder :: Border -> Border
shiftState :: Border -> Coord -> (Tile, BoardState) -> (Tile, BoardState)
reachableFromPlayer :: Player -> BoardState -> Board
shapeRotations :: Eq a => Directions a -> [(Rotation, Directions a)]
reachable1Single :: Board -> (Border, Coord) -> Tile -> BoardState -> Bool
reachable1 :: (Tile, BoardState) -> [((Border, Coord), ([Rotation], Bool))]
reachable2Single :: Board -> (Border, Coord) -> Tile -> BoardState -> Int
reachable2 :: (Tile, BoardState) -> [(((Border, Coord), Rotation), Int)]
formatRotation :: Rotation -> String
formatShift :: ((Border, Coord), Rotation) -> String
formatShifts :: ((Border, Coord), ([Rotation], Bool)) -> String
parseShift :: Maybe (Border, Coord) -> String -> Exceptional String ((Border, Coord), Rotation)
parsePosition :: Board -> String -> Exceptional String (Coord, Coord)
inputLoop :: (String -> Exceptional String a) -> IO a
playerCharSet :: EnumSet Char
inversePlayerChar :: Char -> String
printBox :: Box -> IO ()
main :: IO ()

Documentation

>>> import qualified Game.Labyrinth as Labyrinth

newtype Board Source #

Constructors

Board Word64

Instances

Instances details

Arbitrary Board Source #
Instance details Defined in Game.Labyrinth Methods arbitrary :: Gen Board # shrink :: Board -> [Board] #
Monoid Board Source #
Instance details Defined in Game.Labyrinth Methods mempty :: Board # mappend :: Board -> Board -> Board # mconcat :: [Board] -> Board #
Semigroup Board Source #
Instance details Defined in Game.Labyrinth Methods (<>) :: Board -> Board -> Board # sconcat :: NonEmpty Board -> Board # stimes :: Integral b => b -> Board -> Board #
Show Board Source #
Instance details Defined in Game.Labyrinth Methods showsPrec :: Int -> Board -> ShowS # show :: Board -> String # showList :: [Board] -> ShowS #
Eq Board Source #
Instance details Defined in Game.Labyrinth Methods (==) :: Board -> Board -> Bool # (/=) :: Board -> Board -> Bool #

data Coord Source #

Constructors

C0
C1
C2
C3
C4
C5
C6

Instances

Instances details

Arbitrary Coord Source #
Instance details Defined in Game.Labyrinth Methods arbitrary :: Gen Coord # shrink :: Coord -> [Coord] #
Bounded Coord Source #
Instance details Defined in Game.Labyrinth Methods minBound :: Coord # maxBound :: Coord #
Enum Coord Source #
Instance details Defined in Game.Labyrinth Methods succ :: Coord -> Coord # pred :: Coord -> Coord # toEnum :: Int -> Coord # fromEnum :: Coord -> Int # enumFrom :: Coord -> [Coord] # enumFromThen :: Coord -> Coord -> [Coord] # enumFromTo :: Coord -> Coord -> [Coord] # enumFromThenTo :: Coord -> Coord -> Coord -> [Coord] #
Show Coord Source #
Instance details Defined in Game.Labyrinth Methods showsPrec :: Int -> Coord -> ShowS # show :: Coord -> String # showList :: [Coord] -> ShowS #
Eq Coord Source #
Instance details Defined in Game.Labyrinth Methods (==) :: Coord -> Coord -> Bool # (/=) :: Coord -> Coord -> Bool #
Ord Coord Source #
Instance details Defined in Game.Labyrinth Methods compare :: Coord -> Coord -> Ordering # (<) :: Coord -> Coord -> Bool # (<=) :: Coord -> Coord -> Bool # (>) :: Coord -> Coord -> Bool # (>=) :: Coord -> Coord -> Bool # max :: Coord -> Coord -> Coord # min :: Coord -> Coord -> Coord #

boardIndex :: (Coord, Coord) -> Int Source #

isCellFixed :: (Coord, Coord) -> Bool Source #

boardGet :: Board -> (Coord, Coord) -> Bool Source #

boardSet :: Bool -> (Coord, Coord) -> Board Source #

singleCell :: (Coord, Coord) -> Board Source #

listsFromBoard :: Board -> [[Bool]] Source #

allEnums :: (Enum a, Bounded a) => [a] Source #

rowMask :: Word64 Source #

columnMask :: Word64 Source #

boardMask :: Word64 Source #

rowKMask :: Coord -> Word64 Source #

columnKMask :: Coord -> Word64 Source #

(.-.) :: Bits a => a -> a -> a infixl 7 Source #

shiftBoardLeft :: Board -> Board Source #

shiftBoardRight :: Board -> Board Source #

shiftBoardUp :: Board -> Board Source #

shiftBoardDown :: Board -> Board Source #

splitBoard :: Board -> Board -> (Board, Board) Source #

shiftRowLeft :: Coord -> (Bool, Board) -> (Bool, Board) Source #

\k b -> b == Labyrinth.shiftRowLeft k (Labyrinth.shiftRowRight k b)

\k b -> b == Labyrinth.shiftRowRight k (Labyrinth.shiftRowLeft k b)

shiftRowRight :: Coord -> (Bool, Board) -> (Bool, Board) Source #

shiftColumnUp :: Coord -> (Bool, Board) -> (Bool, Board) Source #

\k b -> b == Labyrinth.shiftColumnUp k (Labyrinth.shiftColumnDown k b)

\k b -> b == Labyrinth.shiftColumnDown k (Labyrinth.shiftColumnUp k b)

shiftColumnDown :: Coord -> (Bool, Board) -> (Bool, Board) Source #

cycleBoardLeft :: Board -> Board Source #

cycleBoardRight :: Board -> Board Source #

cycleBoardUp :: Board -> Board Source #

cycleBoardDown :: Board -> Board Source #

cycleGen :: (Board -> Board) -> (Coord -> Word64) -> Coord -> Board -> Board Source #

cycleRowLeft :: Coord -> Board -> Board Source #

\k b -> b == Labyrinth.cycleRowLeft k (Labyrinth.cycleRowRight k b)

\k b -> b == Labyrinth.cycleRowRight k (Labyrinth.cycleRowLeft k b)

cycleRowRight :: Coord -> Board -> Board Source #

cycleColumnUp :: Coord -> Board -> Board Source #

\k b -> b == Labyrinth.cycleColumnUp k (Labyrinth.cycleColumnDown k b)

\k b -> b == Labyrinth.cycleColumnDown k (Labyrinth.cycleColumnUp k b)

cycleColumnDown :: Coord -> Board -> Board Source #

cycleStripe :: Border -> Coord -> Board -> Board Source #

rotateMasked :: (Directions Board -> Directions Board) -> Board -> Directions Board -> Directions Board Source #

rotateDir90 :: Directions a -> Directions a Source #

rotateDir180 :: Directions a -> Directions a Source #

randomRotate :: RandomGen g => Directions Board -> State g (Directions Board) Source #

data Directions a Source #

Constructors

Directions
Fields north :: a west :: a south :: a east :: a

Instances

Instances details

Foldable Directions Source #
Instance details Defined in Game.Labyrinth Methods fold :: Monoid m => Directions m -> m # foldMap :: Monoid m => (a -> m) -> Directions a -> m # foldMap' :: Monoid m => (a -> m) -> Directions a -> m # foldr :: (a -> b -> b) -> b -> Directions a -> b # foldr' :: (a -> b -> b) -> b -> Directions a -> b # foldl :: (b -> a -> b) -> b -> Directions a -> b # foldl' :: (b -> a -> b) -> b -> Directions a -> b # foldr1 :: (a -> a -> a) -> Directions a -> a # foldl1 :: (a -> a -> a) -> Directions a -> a # toList :: Directions a -> [a] # null :: Directions a -> Bool # length :: Directions a -> Int # elem :: Eq a => a -> Directions a -> Bool # maximum :: Ord a => Directions a -> a # minimum :: Ord a => Directions a -> a # sum :: Num a => Directions a -> a # product :: Num a => Directions a -> a #
Traversable Directions Source #
Instance details Defined in Game.Labyrinth Methods traverse :: Applicative f => (a -> f b) -> Directions a -> f (Directions b) # sequenceA :: Applicative f => Directions (f a) -> f (Directions a) # mapM :: Monad m => (a -> m b) -> Directions a -> m (Directions b) # sequence :: Monad m => Directions (m a) -> m (Directions a) #
Applicative Directions Source #
Instance details Defined in Game.Labyrinth Methods pure :: a -> Directions a # (<>) :: Directions (a -> b) -> Directions a -> Directions b # liftA2 :: (a -> b -> c) -> Directions a -> Directions b -> Directions c # (>) :: Directions a -> Directions b -> Directions b # (<*) :: Directions a -> Directions b -> Directions a #
Functor Directions Source #
Instance details Defined in Game.Labyrinth Methods fmap :: (a -> b) -> Directions a -> Directions b # (<$) :: a -> Directions b -> Directions a #
Monoid a => Monoid (Directions a) Source #
Instance details Defined in Game.Labyrinth Methods mempty :: Directions a # mappend :: Directions a -> Directions a -> Directions a # mconcat :: [Directions a] -> Directions a #
Semigroup a => Semigroup (Directions a) Source #
Instance details Defined in Game.Labyrinth Methods (<>) :: Directions a -> Directions a -> Directions a # sconcat :: NonEmpty (Directions a) -> Directions a # stimes :: Integral b => b -> Directions a -> Directions a #
Eq a => Eq (Directions a) Source #
Instance details Defined in Game.Labyrinth Methods (==) :: Directions a -> Directions a -> Bool # (/=) :: Directions a -> Directions a -> Bool #

transposeDirections :: Directions [[a]] -> [[Directions a]] Source #

boolChar :: Char -> Bool -> Char Source #

formatBoard :: Board -> String Source #

wallChar :: Char Source #

wayChar :: Char Source #

selectWallWayChar :: Bool -> Bool -> Char Source #

boxTable :: [[Box]] -> Box Source #

formatCell :: EnumSet Player -> Directions Bool -> Char -> Directions Bool -> Box Source #

format :: Directions Board -> Box Source #

formatWays :: Directions Board -> Board -> Box Source #

connectReachable :: Directions Board -> Board -> Directions Board Source #

arrows :: Directions Char Source #

arrowFrame :: Maybe (Border, Coord) -> Box -> Box Source #

constMap :: Ord k => [k] -> a -> Map k a Source #

shiftCharMap :: Directions (Map Coord Char) Source #

arrowMap :: Map Char (Border, Coord) Source #

coordinateFrame :: Box -> Box Source #

rowMap :: Map Char Coord Source #

columnMap :: Map Char Coord Source #

data Shape Source #

Constructors

I
L
T

Instances

Instances details

Enum Shape Source #
Instance details Defined in Game.Labyrinth Methods succ :: Shape -> Shape # pred :: Shape -> Shape # toEnum :: Int -> Shape # fromEnum :: Shape -> Int # enumFrom :: Shape -> [Shape] # enumFromThen :: Shape -> Shape -> [Shape] # enumFromTo :: Shape -> Shape -> [Shape] # enumFromThenTo :: Shape -> Shape -> Shape -> [Shape] #
Show Shape Source #
Instance details Defined in Game.Labyrinth Methods showsPrec :: Int -> Shape -> ShowS # show :: Shape -> String # showList :: [Shape] -> ShowS #
Eq Shape Source #
Instance details Defined in Game.Labyrinth Methods (==) :: Shape -> Shape -> Bool # (/=) :: Shape -> Shape -> Bool #
Ord Shape Source #
Instance details Defined in Game.Labyrinth Methods compare :: Shape -> Shape -> Ordering # (<) :: Shape -> Shape -> Bool # (<=) :: Shape -> Shape -> Bool # (>) :: Shape -> Shape -> Bool # (>=) :: Shape -> Shape -> Bool # max :: Shape -> Shape -> Shape # min :: Shape -> Shape -> Shape #

type InitTile = (Shape, Maybe Char) Source #

data Rotation Source #

Constructors

R0
R1
R2
R3

Instances

Instances details

Bounded Rotation Source #
Instance details Defined in Game.Labyrinth Methods minBound :: Rotation # maxBound :: Rotation #
Enum Rotation Source #
Instance details Defined in Game.Labyrinth Methods succ :: Rotation -> Rotation # pred :: Rotation -> Rotation # toEnum :: Int -> Rotation # fromEnum :: Rotation -> Int # enumFrom :: Rotation -> [Rotation] # enumFromThen :: Rotation -> Rotation -> [Rotation] # enumFromTo :: Rotation -> Rotation -> [Rotation] # enumFromThenTo :: Rotation -> Rotation -> Rotation -> [Rotation] #
Eq Rotation Source #
Instance details Defined in Game.Labyrinth Methods (==) :: Rotation -> Rotation -> Bool # (/=) :: Rotation -> Rotation -> Bool #
Ord Rotation Source #
Instance details Defined in Game.Labyrinth Methods compare :: Rotation -> Rotation -> Ordering # (<) :: Rotation -> Rotation -> Bool # (<=) :: Rotation -> Rotation -> Bool # (>) :: Rotation -> Rotation -> Bool # (>=) :: Rotation -> Rotation -> Bool # max :: Rotation -> Rotation -> Rotation # min :: Rotation -> Rotation -> Rotation #

dirsFromShape :: Shape -> Directions Bool Source #

defaultBoardDirs :: [[Directions Bool]] Source #

defaultBoard :: Directions Board Source #

randomChoose :: RandomGen g => StateT [a] (State g) a Source #

shuffle :: RandomGen g => State g (InitTile, [InitTile]) Source #

singleCellShape :: (Coord, Coord) -> Shape -> Directions Board Source #

grid :: [a] -> [(a, a)] Source #

layoutMoveableCells :: [InitTile] -> (Directions Board, SymbolMap) Source #

randomBoard :: RandomGen g => State g (InitTile, (Directions Board, SymbolMap)) Source #

shuffleTargets :: RandomGen g => State g [Char] Source #

associateTargets :: T [] Player -> [Char] -> T Seq (Player, T [] Char) Source #

bfsStep :: Directions Board -> Board -> Board Source #

bfs :: Directions Board -> Board -> Board Source #

data Player Source #

Constructors

Player0
Player1
Player2
Player3

Instances

Instances details

Bounded Player Source #
Instance details Defined in Game.Labyrinth Methods minBound :: Player # maxBound :: Player #
Enum Player Source #
Instance details Defined in Game.Labyrinth Methods succ :: Player -> Player # pred :: Player -> Player # toEnum :: Int -> Player # fromEnum :: Player -> Int # enumFrom :: Player -> [Player] # enumFromThen :: Player -> Player -> [Player] # enumFromTo :: Player -> Player -> [Player] # enumFromThenTo :: Player -> Player -> Player -> [Player] #
Show Player Source #
Instance details Defined in Game.Labyrinth Methods showsPrec :: Int -> Player -> ShowS # show :: Player -> String # showList :: [Player] -> ShowS #
Eq Player Source #
Instance details Defined in Game.Labyrinth Methods (==) :: Player -> Player -> Bool # (/=) :: Player -> Player -> Bool #
Ord Player Source #
Instance details Defined in Game.Labyrinth Methods compare :: Player -> Player -> Ordering # (<) :: Player -> Player -> Bool # (<=) :: Player -> Player -> Bool # (>) :: Player -> Player -> Bool # (>=) :: Player -> Player -> Bool # max :: Player -> Player -> Player # min :: Player -> Player -> Player #

playerChar :: Bool -> Player -> Char Source #

moveableSymbols :: [Char] Source #

playerSymbols :: [Char] Source #

fixedSymbols :: [Char] Source #

type SymbolMap = Map (Coord, Coord) Char Source #

fixedSymbolMap :: SymbolMap Source #

randomSymbolMap :: RandomGen g => State g SymbolMap Source #

removeFromMap :: Ord k => k -> Map k a -> (Maybe a, Map k a) Source #

insertMaybeMap :: Ord k => k -> Maybe a -> Map k a -> Map k a Source #

shiftRowLeftMap :: Coord -> (Maybe Char, SymbolMap) -> (Maybe Char, SymbolMap) Source #

shiftRowRightMap :: Coord -> (Maybe Char, SymbolMap) -> (Maybe Char, SymbolMap) Source #

shiftColumnUpMap :: Coord -> (Maybe Char, SymbolMap) -> (Maybe Char, SymbolMap) Source #

shiftColumnDownMap :: Coord -> (Maybe Char, SymbolMap) -> (Maybe Char, SymbolMap) Source #

formatWithSymbols :: BoardState -> Board -> Box Source #

type PlayerMap = EnumMap Player (Coord, Coord) Source #

shiftPlayersGen :: Eq a => (b -> a) -> (b -> b) -> a -> EnumMap k b -> EnumMap k b Source #

shiftRowLeftPlayers :: Coord -> PlayerMap -> PlayerMap Source #

shiftRowRightPlayers :: Coord -> PlayerMap -> PlayerMap Source #

shiftColumnUpPlayers :: Coord -> PlayerMap -> PlayerMap Source #

shiftColumnDownPlayers :: Coord -> PlayerMap -> PlayerMap Source #

data BoardState Source #

Constructors

BoardState
Fields stateBoard :: Directions Board stateSymbolMap :: SymbolMap statePlayerMap :: PlayerMap

type Tile = (Directions Bool, Maybe Char) Source #

cyclicPred :: (Eq a, Enum a, Bounded a) => a -> a Source #

cyclicSucc :: (Eq a, Enum a, Bounded a) => a -> a Source #

shiftStateGen :: (Coord -> (Bool, Board) -> (Bool, Board)) -> (Coord -> (Maybe Char, SymbolMap) -> (Maybe Char, SymbolMap)) -> (Coord -> PlayerMap -> PlayerMap) -> Coord -> (Tile, BoardState) -> (Tile, BoardState) Source #

data Border Source #

Constructors

North
West
South
East

Instances

Instances details

Bounded Border Source #
Instance details Defined in Game.Labyrinth Methods minBound :: Border # maxBound :: Border #
Enum Border Source #
Instance details Defined in Game.Labyrinth Methods succ :: Border -> Border # pred :: Border -> Border # toEnum :: Int -> Border # fromEnum :: Border -> Int # enumFrom :: Border -> [Border] # enumFromThen :: Border -> Border -> [Border] # enumFromTo :: Border -> Border -> [Border] # enumFromThenTo :: Border -> Border -> Border -> [Border] #
Show Border Source #
Instance details Defined in Game.Labyrinth Methods showsPrec :: Int -> Border -> ShowS # show :: Border -> String # showList :: [Border] -> ShowS #
Eq Border Source #
Instance details Defined in Game.Labyrinth Methods (==) :: Border -> Border -> Bool # (/=) :: Border -> Border -> Bool #
Ord Border Source #
Instance details Defined in Game.Labyrinth Methods compare :: Border -> Border -> Ordering # (<) :: Border -> Border -> Bool # (<=) :: Border -> Border -> Bool # (>) :: Border -> Border -> Bool # (>=) :: Border -> Border -> Bool # max :: Border -> Border -> Border # min :: Border -> Border -> Border #