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


-- | Functions to work with unicode blocks more convenient.
--   
--   A package that makes rendering of frames, blocks, subscript and
--   superscript more convenient.
@package unicode-tricks
@version 0.3.0.0


-- | Unicode has 2-by-2 blocks, this module aims to make it more convenient
--   to render such blocks.
module Data.Char.Block

-- | A data type that determines the state of the <i>row</i> in a block. it
--   determines the left and the right part of the row of the block.
data Row a
Row :: a -> a -> Row a

-- | The left part of a row of the block.
[left] :: Row a -> a

-- | The right part of the row of the block.
[right] :: Row a -> a

-- | A data type that determines the state of the four subparts of the
--   block.
data Block a
Block :: Row a -> Row a -> Block a

-- | The upper part of the block.
[upper] :: Block a -> Row a

-- | The lower part of the block.
[lower] :: Block a -> Row a

-- | Convert the given <a>Block</a> value to a block character in unicode.
--   <a>True</a> means that part is filled, and <a>False</a> means the part
--   is not filled.
filled :: Block Bool -> Char
instance Data.Traversable.Traversable Data.Char.Block.Block
instance GHC.Show.Show a => GHC.Show.Show (Data.Char.Block.Block a)
instance GHC.Read.Read a => GHC.Read.Read (Data.Char.Block.Block a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Char.Block.Block a)
instance GHC.Base.Functor Data.Char.Block.Block
instance Data.Foldable.Foldable Data.Char.Block.Block
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Char.Block.Block a)
instance Data.Traversable.Traversable Data.Char.Block.Row
instance GHC.Show.Show a => GHC.Show.Show (Data.Char.Block.Row a)
instance GHC.Read.Read a => GHC.Read.Read (Data.Char.Block.Row a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Char.Block.Row a)
instance GHC.Base.Functor Data.Char.Block.Row
instance Data.Foldable.Foldable Data.Char.Block.Row
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Char.Block.Row a)
instance GHC.Base.Applicative Data.Char.Block.Block
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Data.Char.Block.Block a)
instance GHC.Base.Applicative Data.Char.Block.Row
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Data.Char.Block.Row a)


-- | Unicode has a Braille segment for Braille with six dot cells, and a
--   segment for Braille with eight dot cells, this module aims to make it
--   more convenient to render such characters.
module Data.Char.Braille

-- | A datastructure to render Braille patterns with six dots cells.
data Braille6 a
Braille6 :: Row a -> Row a -> Row a -> Braille6 a

-- | The state of the top row of the Braille character.
[top] :: Braille6 a -> Row a

-- | The state of the middle row of the Braille character.
[middle] :: Braille6 a -> Row a

-- | The state of the bottom row of the Braille character.
[bottom] :: Braille6 a -> Row a

-- | A datastructure to render Braille patterns with eight dots cells.
data Braille a
Braille :: Row a -> Row a -> Row a -> Row a -> Braille a

-- | The state of the top row of the Braille character.
[row1] :: Braille a -> Row a

-- | The state of the second row of the Braille character.
[row2] :: Braille a -> Row a

-- | The state of the third row of the Braille character.
[row3] :: Braille a -> Row a

-- | The state of the bottom row of the Braille character.
[row4] :: Braille a -> Row a

-- | Convert a <a>Braille6</a> value to a <a>Braille</a> character, by
--   putting in a given value at the two values at the bottom row.
toBraille' :: a -> Braille6 a -> Braille a

-- | Convert a <a>Braille6</a> value to a <a>Braille6</a> character by
--   setting the bottom row with two <a>False</a> values.
toBraille :: Braille6 Bool -> Braille Bool

-- | Convert the given <a>Braille6</a> value to a unicode character
--   representing this Braille value.
braille6 :: Braille6 Bool -> Char

-- | Convert the given <a>Braille</a> value to a unicode character
--   representing this braille value.
braille :: Braille Bool -> Char
instance Data.Traversable.Traversable Data.Char.Braille.Braille
instance GHC.Show.Show a => GHC.Show.Show (Data.Char.Braille.Braille a)
instance GHC.Read.Read a => GHC.Read.Read (Data.Char.Braille.Braille a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Char.Braille.Braille a)
instance GHC.Base.Functor Data.Char.Braille.Braille
instance Data.Foldable.Foldable Data.Char.Braille.Braille
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Char.Braille.Braille a)
instance Data.Traversable.Traversable Data.Char.Braille.Braille6
instance GHC.Show.Show a => GHC.Show.Show (Data.Char.Braille.Braille6 a)
instance GHC.Read.Read a => GHC.Read.Read (Data.Char.Braille.Braille6 a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Char.Braille.Braille6 a)
instance GHC.Base.Functor Data.Char.Braille.Braille6
instance Data.Foldable.Foldable Data.Char.Braille.Braille6
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Char.Braille.Braille6 a)
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Data.Char.Braille.Braille a)
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Data.Char.Braille.Braille6 a)


-- | One can make use of a <a>block 2600</a> and <a>block 1fa00</a> of
--   Unicode characters to render chess characters. One can render chess
--   characters as <i>netral</i>, <i>white</i>, or <i>black</i> 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 <i>equihopper</i>, and
--   special variants like a <i>knight-queen</i>, <i>knight-rook</i>, and
--   <i>knight-bishop</i>.
--   
--   The module contains pattern synonyms for names that are often given to
--   the pieces.
module Data.Char.Chess

-- | The color of a chess piece, this can for most pieces be <a>Black</a>,
--   <a>White</a>, or <a>Neutral</a>.
data ChessColor

-- | <i>White</i> color.
White :: ChessColor

-- | <i>Black</i> color.
Black :: ChessColor

-- | Neutral chess pieces, sometimes depicted half <i>white</i> and half
--   <i>black</i>.
Neutral :: ChessColor

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

-- | <i>White</i> color.
BWhite :: ChessColorBinary

-- | <i>Black</i> color.
BBlack :: ChessColorBinary

-- | The type of chess pieces. Unicode includes an <a>Equihopper</a> as
--   piece as well.
data ChessPieceType

-- | The <i>knight</i> chess piece.
King :: ChessPieceType

-- | The <i>knight</i> chess piece.
Queen :: ChessPieceType

-- | The <i>knight</i> chess piece.
Rook :: ChessPieceType

-- | The <i>knight</i> chess piece.
Bishop :: ChessPieceType

-- | The <i>knight</i> chess piece.
Knight :: ChessPieceType

-- | The <i>knigat</i> chess piece.
Pawn :: ChessPieceType

-- | The <i>equihopper</i> chess piece.
Equihopper :: ChessPieceType

-- | Hybrid chess pieces like the <i>knight-queen</i>, <i>knight-rook</i>
--   and <i>knight-bishop</i>.
data ChessHybridType

-- | The <i>knight-queen</i> chess piece.
KnightQueen :: ChessHybridType

-- | The <i>knight-rook</i> chess piece.
KnightRook :: ChessHybridType

-- | The <i>knight-bishop</i> chess piece.
KnightBishop :: ChessHybridType

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

-- | Standard pieces drawn in <i>black</i>, <i>white</i>, or <i>neutral</i>
--   and with rotation.
Chess90 :: ChessColor -> ChessPieceType -> Rotate90 -> ChessPiece

-- | <i>Knights</i> have unicode characters to render these rotated over
--   <i>45</i>, <i>135</i>, <i>225</i> and <i>315</i> degrees.
Chess45Knight :: ChessColor -> Rotate45 -> ChessPiece

-- | Hybrid chess pieces can only be rendered in <a>BBlack</a> and
--   <a>BWhite</a>.
ChessHybrid :: ChessHybridType -> ChessColorBinary -> ChessPiece

-- | Possible rotations of the pieces. Most pieces can be rotated 0, 90,
--   180, and 270 degrees.
data Rotate90

-- | No rotation.
R0 :: Rotate90

-- | Rotation over <i>90</i> degrees.
R90 :: Rotate90

-- | Rotation over <i>180</i> degrees.
R180 :: Rotate90

-- | Rotation over <i>270</i> degrees.
R270 :: Rotate90

-- | Extra rotations that can be performed for knight chess pieces.
data Rotate45

-- | Rotation over <i>45</i> degrees.
R45 :: Rotate45

-- | Rotation over <i>135</i> degrees.
R135 :: Rotate45

-- | Rotation over <i>225</i> degrees.
R225 :: Rotate45

-- | Rotation over <i>315</i> degrees.
R315 :: Rotate45

-- | Convert the given <a>ChessPiece</a> to the corresponding unicode
--   character.
chessPiece :: ChessPiece -> Char

-- | A <i>grasshopper</i> is a <i>queen</i> rotated over 180 degrees.
pattern Grasshopper :: ChessColor -> ChessPiece

-- | A <i>Nightrider</i> is a <i>knight</i> rotated over 180 degrees.
pattern Nightrider :: ChessColor -> ChessPiece

-- | An <i>amazon</i> is alterative name for a <i>knight-queen</i>.
pattern Amazon :: ChessColorBinary -> ChessPiece

-- | A <i>terror</i> is alterative name for a <i>knight-queen</i>.
pattern Terror :: ChessColorBinary -> ChessPiece

-- | An <i>omnipotent queen</i> is alterative name for a
--   <i>knight-queen</i>.
pattern OmnipotentQueen :: ChessColorBinary -> ChessPiece

-- | A <i>superqueen</i> is alterative name for a <i>knight-queen</i>.
pattern Superqueen :: ChessColorBinary -> ChessPiece

-- | A <i>chancellor</i> is alterative name for a <i>knight-rook</i>.
pattern Chancellor :: ChessColorBinary -> ChessPiece

-- | A <i>marshall</i> is alterative name for a <i>knight-rook</i>.
pattern Marshall :: ChessColorBinary -> ChessPiece

-- | An <i>empress</i> is alterative name for a <i>knight-rook</i>.
pattern Empress :: ChessColorBinary -> ChessPiece

-- | A <i>cardinal</i> is alterative name for a <i>knight-bishop</i>.
pattern Cardinal :: ChessColorBinary -> ChessPiece

-- | A <i>princess</i> is alterative name for a <i>knight-bishop</i>.
pattern Princess :: ChessColorBinary -> ChessPiece
instance GHC.Show.Show Data.Char.Chess.ChessPiece
instance GHC.Read.Read Data.Char.Chess.ChessPiece
instance GHC.Classes.Ord Data.Char.Chess.ChessPiece
instance GHC.Classes.Eq Data.Char.Chess.ChessPiece
instance GHC.Show.Show Data.Char.Chess.ChessHybridType
instance GHC.Read.Read Data.Char.Chess.ChessHybridType
instance GHC.Classes.Ord Data.Char.Chess.ChessHybridType
instance GHC.Classes.Eq Data.Char.Chess.ChessHybridType
instance GHC.Enum.Enum Data.Char.Chess.ChessHybridType
instance GHC.Enum.Bounded Data.Char.Chess.ChessHybridType
instance GHC.Show.Show Data.Char.Chess.Rotate45
instance GHC.Read.Read Data.Char.Chess.Rotate45
instance GHC.Classes.Ord Data.Char.Chess.Rotate45
instance GHC.Classes.Eq Data.Char.Chess.Rotate45
instance GHC.Enum.Enum Data.Char.Chess.Rotate45
instance GHC.Enum.Bounded Data.Char.Chess.Rotate45
instance GHC.Show.Show Data.Char.Chess.Rotate90
instance GHC.Read.Read Data.Char.Chess.Rotate90
instance GHC.Classes.Ord Data.Char.Chess.Rotate90
instance GHC.Classes.Eq Data.Char.Chess.Rotate90
instance GHC.Enum.Enum Data.Char.Chess.Rotate90
instance GHC.Enum.Bounded Data.Char.Chess.Rotate90
instance GHC.Show.Show Data.Char.Chess.ChessPieceType
instance GHC.Read.Read Data.Char.Chess.ChessPieceType
instance GHC.Classes.Ord Data.Char.Chess.ChessPieceType
instance GHC.Classes.Eq Data.Char.Chess.ChessPieceType
instance GHC.Enum.Enum Data.Char.Chess.ChessPieceType
instance GHC.Enum.Bounded Data.Char.Chess.ChessPieceType
instance GHC.Show.Show Data.Char.Chess.ChessColor
instance GHC.Read.Read Data.Char.Chess.ChessColor
instance GHC.Classes.Ord Data.Char.Chess.ChessColor
instance GHC.Classes.Eq Data.Char.Chess.ChessColor
instance GHC.Enum.Enum Data.Char.Chess.ChessColor
instance GHC.Enum.Bounded Data.Char.Chess.ChessColor
instance GHC.Show.Show Data.Char.Chess.ChessColorBinary
instance GHC.Read.Read Data.Char.Chess.ChessColorBinary
instance GHC.Classes.Ord Data.Char.Chess.ChessColorBinary
instance GHC.Classes.Eq Data.Char.Chess.ChessColorBinary
instance GHC.Enum.Enum Data.Char.Chess.ChessColorBinary
instance GHC.Enum.Bounded Data.Char.Chess.ChessColorBinary
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Chess.ChessPiece
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Chess.ChessHybridType
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Chess.Rotate45
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Chess.Rotate90
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Chess.ChessPieceType
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Chess.ChessColor
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Chess.ChessColorBinary


-- | A frame is represented as a pair of horizontal and vertical lines.
--   These can be any items, but currently only booleans and weight objects
--   are covered to convert the item to a corresponding character.
module Data.Char.Frame

-- | The weights of the frame lines, these can be <a>Empty</a>,
--   <a>Light</a> or <a>Heavy</a>.
data Weight

-- | The frame does not contain such line.
Empty :: Weight

-- | The frame contains such line.
Light :: Weight

-- | The frame contains such line, in <i>boldface</i>.
Heavy :: Weight

-- | A data type that determines the state of the <i>horizontal</i> lines
--   of the frame (<a>left</a> and <a>right</a>).
data Horizontal a
Horizontal :: a -> a -> Horizontal a

-- | The state of the left line of the frame.
[left] :: Horizontal a -> a

-- | The state of the right line of the frame.
[right] :: Horizontal a -> a

-- | A data type that determines the state of the <i>vertical</i> lines of
--   the frame (<a>up</a> and <a>down</a>).
data Vertical a
Vertical :: a -> a -> Vertical a

-- | The state of the line in the up direction of the frame.
[up] :: Vertical a -> a

-- | The state of the line in the down direction of the frame.
[down] :: Vertical a -> a

-- | A data type that specifies the four lines that should (not) be drawn
--   for the frame.
data Parts a
Parts :: Vertical a -> Horizontal a -> Parts a

-- | A type synonym that makes it more convenient to work with a
--   <a>Parts</a> object that wraps <a>Bool</a>s. Usually <a>True</a> means
--   it should draw a line, and <a>False</a> that there is no line in that
--   direction.
type Simple = Parts Bool

-- | A type synonym that makes it more convenient to work with a
--   <a>Parts</a> object that wraps <a>Weight</a> objects. These specify
--   the weight .
type Weighted = Parts Weight

-- | A pattern that makes pattern matching and expressions with
--   <a>Parts</a> more convenient.
pattern Frame :: a -> a -> a -> a -> Parts a

-- | Convert a <a>Simple</a> frame to a corresponding <a>Char</a>. Here
--   <a>True</a> is mapped to a <a>Light</a> line.
simple :: Simple -> Char

-- | Convert a <a>Simple</a> frame to a corresponding <a>Char</a>. Here
--   <a>True</a> is mapped to a <a>Heavy</a> line.
simple' :: Simple -> Char

-- | Generate a <a>Char</a> where turns are done with an <i>arc</i> instead
--   of a corner. This can only be done for <a>Light</a> lines.
simpleWithArc :: Simple -> Char

-- | Converts a given <a>Weighted</a> to the char that can be used to
--   render frames.
weighted :: Weighted -> Char

-- | Convert a <a>Simple</a> frame to a <a>Weighted</a> frame by converting
--   <a>True</a> to the given <a>Weight</a> value.
simpleToWeighted :: Weight -> Simple -> Weighted

-- | Convert a <a>Simple</a> frame to a <a>Weighted</a> frame by converting
--   <a>True</a> to <a>Light</a>.
simpleToLight :: Simple -> Weighted

-- | Convert a <a>Simple</a> frame to a <a>Weighted</a> frame by converting
--   <a>True</a> to <a>Heavy</a>.
simpleToHeavy :: Simple -> Weighted
instance GHC.Show.Show Data.Char.Frame.Weight
instance GHC.Read.Read Data.Char.Frame.Weight
instance GHC.Classes.Ord Data.Char.Frame.Weight
instance GHC.Classes.Eq Data.Char.Frame.Weight
instance GHC.Enum.Enum Data.Char.Frame.Weight
instance GHC.Enum.Bounded Data.Char.Frame.Weight
instance Data.Traversable.Traversable Data.Char.Frame.Parts
instance GHC.Show.Show a => GHC.Show.Show (Data.Char.Frame.Parts a)
instance GHC.Read.Read a => GHC.Read.Read (Data.Char.Frame.Parts a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Char.Frame.Parts a)
instance GHC.Base.Functor Data.Char.Frame.Parts
instance Data.Foldable.Foldable Data.Char.Frame.Parts
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Char.Frame.Parts a)
instance Data.Traversable.Traversable Data.Char.Frame.Vertical
instance GHC.Show.Show a => GHC.Show.Show (Data.Char.Frame.Vertical a)
instance GHC.Read.Read a => GHC.Read.Read (Data.Char.Frame.Vertical a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Char.Frame.Vertical a)
instance GHC.Base.Functor Data.Char.Frame.Vertical
instance Data.Foldable.Foldable Data.Char.Frame.Vertical
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Char.Frame.Vertical a)
instance Data.Traversable.Traversable Data.Char.Frame.Horizontal
instance GHC.Show.Show a => GHC.Show.Show (Data.Char.Frame.Horizontal a)
instance GHC.Read.Read a => GHC.Read.Read (Data.Char.Frame.Horizontal a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Char.Frame.Horizontal a)
instance GHC.Base.Functor Data.Char.Frame.Horizontal
instance Data.Foldable.Foldable Data.Char.Frame.Horizontal
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Char.Frame.Horizontal a)
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Frame.Weight
instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Data.Char.Frame.Parts a)
instance GHC.Base.Monoid a => GHC.Base.Monoid (Data.Char.Frame.Parts a)
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Data.Char.Frame.Parts a)
instance GHC.Base.Applicative Data.Char.Frame.Parts
instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Data.Char.Frame.Vertical a)
instance GHC.Base.Monoid a => GHC.Base.Monoid (Data.Char.Frame.Vertical a)
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Data.Char.Frame.Vertical a)
instance GHC.Base.Applicative Data.Char.Frame.Vertical
instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Data.Char.Frame.Horizontal a)
instance GHC.Base.Monoid a => GHC.Base.Monoid (Data.Char.Frame.Horizontal a)
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Data.Char.Frame.Horizontal a)
instance GHC.Base.Applicative Data.Char.Frame.Horizontal


-- | One can make use of a <a>block of Unicode characters</a> to
--   <i>emulate</i> subscript and superscript. Note that the subscript and
--   superscript will be aligned with the <i>baseline</i> and the <i>cap
--   line</i> respectively, and is thus not equivalent to
--   <tt><a>sub</a>...<a>/sub</a></tt> and
--   <tt><a>sup</a>...<a>/sup</a></tt> in HTML. Furthermore only a small
--   subset of characters is supported.
--   
--   This module allows one to map certain characters to their subscript
--   and superscript counterpart, and furthermore makes it more convenient
--   to transform a number (both positive and negative) to a <a>Text</a>
--   that specifies this number in subscript and superscript.
module Data.Char.Small

-- | Convert a set of characters to their subscript counterpart, given that
--   characters exists.
toSub :: Char -> Maybe Char

-- | Convert a set of characters to their superscript counterpart, given
--   that characters exists.
toSup :: Char -> Maybe Char

-- | Convert a number (positive or negative) to a <a>Text</a> that
--   specifies that number in subscript characters.
asSub :: Integral i => i -> Text

-- | Convert a number (positive or negative) to a <a>Text</a> that
--   specifies that number in superscript characters.
asSup :: Integral i => i -> Text

-- | Format a given <a>Ratio</a> object to a <a>Text</a> value that formats
--   the ratio with superscript and subscript.
ratioToUnicode :: Integral i => Ratio i -> Text