-- 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.6.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 Test.QuickCheck.Arbitrary.Arbitrary1 Data.Char.Block.Block
instance GHC.Base.Applicative Data.Char.Block.Row
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Data.Char.Block.Row a)
instance Test.QuickCheck.Arbitrary.Arbitrary1 Data.Char.Block.Row


-- | 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.Arbitrary1 Data.Char.Braille.Braille
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Data.Char.Braille.Braille6 a)
instance Test.QuickCheck.Arbitrary.Arbitrary1 Data.Char.Braille.Braille6


-- | The <a>1F0A0 code block</a> can be used to work with cards. This
--   module makes working with the three sets of cards more convenient. The
--   first set are cards with a suit (four suits) and a rank (14 ranks),
--   which allows us to generate 56 cards. Next there are three jokes with
--   the colors <i>red</i>, <i>black</i> and <i>white</i>. Finally there
--   are 21 trump cards and the fool card (a tarot card which normally has
--   no number).
--   
--   The module contains pattern synonyms that define common aliasses for
--   these cards.
module Data.Char.Card

-- | A data type for the card suits
data CardSuit

-- | The <i>spades</i> card suit.
Spades :: CardSuit

-- | The <i>hearts</i> card suit.
Hearts :: CardSuit

-- | The <i>diamonds</i> card suit.
Diamonds :: CardSuit

-- | The <i>clubs</i> card suit.
Clubs :: CardSuit

-- | A data type for the rank of the card.
data CardRank

-- | The <i>ace</i> card rank.
Ace :: CardRank

-- | Card rank 2.
R2 :: CardRank

-- | Card rank 3.
R3 :: CardRank

-- | Card rank 4.
R4 :: CardRank

-- | Card rank 5.
R5 :: CardRank

-- | Card rank 6.
R6 :: CardRank

-- | Card rank 7.
R7 :: CardRank

-- | Card rank 8.
R8 :: CardRank

-- | Card rank 9.
R9 :: CardRank

-- | Card rank 10.
R10 :: CardRank

-- | The <i>jack</i> card rank.
Jack :: CardRank

-- | The <i>knight</i> card rank.
Knight :: CardRank

-- | The <i>queen</i> card rank.
Queen :: CardRank

-- | The <i>king</i> card rank.
King :: CardRank

-- | A data type to represent the three colors for which there are jokers:
--   <i>red</i>, <i>black</i> and <i>white</i>.
data JokerColor

-- | The <i>red</i> joker.
Red :: JokerColor

-- | The <i>black</i> joker.
Black :: JokerColor

-- | The <i>white</i> joker.
White :: JokerColor

-- | A data type for the trump cards, often used for <i>tarot</i>.
data Trump

-- | The <i>fool</i> trump card, this tarot card is normally not numbered.
Fool :: Trump

-- | Tarot card <i>I</i>.
Trump1 :: Trump

-- | Tarot card <i>II</i>.
Trump2 :: Trump

-- | Tarot card <i>III</i>.
Trump3 :: Trump

-- | Tarot card <i>IV</i>.
Trump4 :: Trump

-- | Tarot card <i>V</i>.
Trump5 :: Trump

-- | Tarot card <i>VI</i>.
Trump6 :: Trump

-- | Tarot card <i>VII</i>.
Trump7 :: Trump

-- | Tarot card <i>VIII</i>.
Trump8 :: Trump

-- | Tarot card <i>IX</i>.
Trump9 :: Trump

-- | Tarot card <i>X</i>.
Trump10 :: Trump

-- | Tarot card <i>XI</i>.
Trump11 :: Trump

-- | Tarot card <i>XII</i>.
Trump12 :: Trump

-- | Tarot card <i>XIII</i>.
Trump13 :: Trump

-- | Tarot card <i>XIV</i>.
Trump14 :: Trump

-- | Tarot card <i>XV</i>.
Trump15 :: Trump

-- | Tarot card <i>XVI</i>.
Trump16 :: Trump

-- | Tarot card <i>XVII</i>.
Trump17 :: Trump

-- | Tarot card <i>XVIII</i>.
Trump18 :: Trump

-- | Tarot card <i>XIX</i>.
Trump19 :: Trump

-- | Tarot card <i>XX</i>.
Trump20 :: Trump

-- | Tarot card <i>XXI</i>.
Trump21 :: Trump

-- | A data type that represents the possible types of cards for which
--   there is a Unicode characters. This is the back of a card, a card with
--   a suit and rank, three <i>jokers</i>, and the 21 <i>trump</i> cards
--   and the <i>fool</i>.
data Card

-- | The back of the card.
Back :: Card

-- | A card that is a combination of a <a>CardSuit</a> and a
--   <a>CardRank</a>. There are 56 possibilities.
Card :: CardSuit -> CardRank -> Card

-- | Three possible <a>JokerColor</a> cards.
Joker :: JokerColor -> Card
Trump :: Trump -> Card

-- | The unicode character that represents the <i>back</i> of the card.
back :: Char

-- | Convert the given <a>Card</a> object to its unicode equivalent.
card :: Card -> Char

-- | Convert the given <a>CardSuit</a> and <a>CardRank</a> to the
--   equivalent unicode character for this card.
card' :: CardSuit -> CardRank -> Char

-- | Convert the given <a>JokerColor</a> to the unicode character which
--   represents this joker color.
joker :: JokerColor -> Char

-- | Convert the given 't:Trump' value to the unicode equivalent.
trump :: Trump -> Char

-- | <i>Swords</i> is an alias for the <i>spades</i> card suit.
pattern Swords :: CardSuit

-- | <i>Cups</i> is an alias for the <i>hearts</i> card suit.
pattern Cups :: CardSuit

-- | <i>Pentacles</i> is an alias for the <i>diamonds</i> card suit.
pattern Pentacles :: CardSuit

-- | <i>Wands</i> is an alias for the <i>clubs</i> card suit.
pattern Wands :: CardSuit

-- | In France, the <i>jack</i> is sometimes called the <i>valet</i>.
pattern Valet :: CardRank

-- | In Germany, Austria and Switzerland, the <i>jack</i> is sometimes
--   called the <i>bube</i>.
pattern Bube :: CardRank

-- | In Germany and Switzerland, the <i>jack</i> is sometimes called the
--   <i>unter</i>.
pattern Unter :: CardRank

-- | An alternative name for the <i>jack</i> is <i>page</i>.
pattern Page :: CardRank

-- | In Italy, the <i>jack</i> is sometimes called the <i>fante</i>.
pattern Fante :: CardRank

-- | In France, the <i>knight</i> is sometimes called the <i>chevalier</i>.
pattern Chevalier :: CardRank

-- | In Germany, the <i>knight</i> is sometimes called the <i>ober</i>.
pattern Ober :: CardRank

-- | In Germany, the <i>knight</i> is sometimes called the <i>ritter</i>.
pattern Ritter :: CardRank

-- | An alternative name for the <i>jack</i> is <i>cavall</i>.
pattern Cavall :: CardRank

-- | An alternative name for the <i>jack</i> is <i>cavaliere</i>.
pattern Cavaliere :: CardRank

-- | An alternative name for the <i>queen</i> is <i>dame</i>.
pattern Dame :: CardRank

-- | In Germany, the <i>queen</i> is sometimes called the <i>königin</i>.
pattern Königin :: CardRank

-- | In Italy, the <i>queen</i> is sometimes called the <i>regina</i>.
pattern Regina :: CardRank

-- | In France, the <i>king</i> is sometimes called the <i>roi</i>.
pattern Roi :: CardRank

-- | In Germany, the <i>king</i> is sometimes called the <i>könig</i>.
pattern König :: CardRank

-- | In Italy, the <i>queen</i> is sometimes called the <i>re</i>.
pattern Re :: CardRank

-- | The trump card with number <i>II</i> is named <i>childhood</i>.
pattern Childhood :: Trump

-- | The trump card with number <i>III</i> is named <i>youth</i>.
pattern Youth :: Trump

-- | The trump card with number <i>IV</i> is named <i>maturity</i>.
pattern Maturity :: Trump

-- | The trump card with number <i>V</i> is named <i>old age</i>.
pattern OldAge :: Trump

-- | The trump card with number <i>VI</i> is named <i>morning</i>.
pattern Morning :: Trump

-- | The trump card with number <i>VII</i> is named <i>afternoon</i>.
pattern Afternoon :: Trump

-- | The trump card with number <i>VIII</i> is named <i>evening</i>.
pattern Evening :: Trump

-- | The trump card with number <i>IX</i> is named <i>night</i>.
pattern Night :: Trump

-- | The trump card with number <i>X</i> is named <i>earth</i>.
pattern Earth :: Trump

-- | The trump card with number <i>X</i> is named <i>air</i>.
pattern Air :: Trump

-- | The trump card with number <i>XI</i> is named <i>water</i>.
pattern Water :: Trump

-- | The trump card with number <i>XI</i> is named <i>fire</i>.
pattern Fire :: Trump

-- | The trump card with number <i>XII</i> is named <i>dance</i>.
pattern Dance :: Trump

-- | The trump card with number <i>XIII</i> is named <i>shopping</i>.
pattern Shopping :: Trump

-- | The trump card with number <i>XIV</i> is named <i>open air</i>.
pattern OpenAir :: Trump

-- | The trump card with number <i>XV</i> is named <i>visual arts</i>.
pattern VisualArts :: Trump

-- | The trump card with number <i>XVI</i> is named <i>spring</i>.
pattern Spring :: Trump

-- | The trump card with number <i>XVII</i> is named <i>summer</i>.
pattern Summer :: Trump

-- | The trump card with number <i>XVIII</i> is named <i>autumn</i>.
pattern Autumn :: Trump

-- | The trump card with number <i>XIX</i> is named <i>winter</i>.
pattern Winter :: Trump

-- | The trump card with number <i>XX</i> is named the <i>game</i>.
pattern Game :: Trump

-- | The trump card with number <i>XXI</i> is named <i>collective</i>.
pattern Collective :: Trump

-- | The trump card with number <i>I</i> is named <i>individual</i>.
pattern Individual :: Trump
instance GHC.Show.Show Data.Char.Card.Card
instance GHC.Read.Read Data.Char.Card.Card
instance GHC.Classes.Ord Data.Char.Card.Card
instance GHC.Classes.Eq Data.Char.Card.Card
instance GHC.Show.Show Data.Char.Card.Trump
instance GHC.Read.Read Data.Char.Card.Trump
instance GHC.Classes.Ord Data.Char.Card.Trump
instance GHC.Classes.Eq Data.Char.Card.Trump
instance GHC.Enum.Enum Data.Char.Card.Trump
instance GHC.Enum.Bounded Data.Char.Card.Trump
instance GHC.Show.Show Data.Char.Card.JokerColor
instance GHC.Read.Read Data.Char.Card.JokerColor
instance GHC.Classes.Ord Data.Char.Card.JokerColor
instance GHC.Classes.Eq Data.Char.Card.JokerColor
instance GHC.Enum.Enum Data.Char.Card.JokerColor
instance GHC.Enum.Bounded Data.Char.Card.JokerColor
instance GHC.Show.Show Data.Char.Card.CardRank
instance GHC.Read.Read Data.Char.Card.CardRank
instance GHC.Classes.Ord Data.Char.Card.CardRank
instance GHC.Classes.Eq Data.Char.Card.CardRank
instance GHC.Enum.Enum Data.Char.Card.CardRank
instance GHC.Enum.Bounded Data.Char.Card.CardRank
instance GHC.Show.Show Data.Char.Card.CardSuit
instance GHC.Read.Read Data.Char.Card.CardSuit
instance GHC.Classes.Ord Data.Char.Card.CardSuit
instance GHC.Classes.Eq Data.Char.Card.CardSuit
instance GHC.Enum.Enum Data.Char.Card.CardSuit
instance GHC.Enum.Bounded Data.Char.Card.CardSuit
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Card.Card
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Card.Trump
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Card.JokerColor
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Card.CardRank
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Card.CardSuit


-- | This module defines data structures that are used in other modules,
--   for example to rotate the characters.
module Data.Char.Core

-- | The possible orientations of a unicode character, these can be
--   <i>horizontal</i>, or <i>vertical</i>.
data Orientation

-- | <i>Horizontal</i> orientation.
Horizontal :: Orientation

-- | <i>Vertical</i> orientation.
Vertical :: Orientation

-- | Possible rotations of a unicode character if that character can be
--   rotated over 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

-- | A data type that specifies that an item has been given an orientation.
data Oriented a
Oriented :: a -> Orientation -> Oriented a

-- | The object that is oriented.
[oobject] :: Oriented a -> a

-- | The oriented of the oriented object.
[orientation] :: Oriented a -> Orientation

-- | Specify if one should ligate, or not. When litigation is done
--   characters that are normally written in two (or more) characters are
--   combined in one character. For example <tt>Ⅲ</tt> instead of
--   <tt>ⅠⅠⅠ</tt>.
data Ligate

-- | A ligate operation is performed on the characters.
Ligate :: Ligate

-- | No ligate operation is performed on the charaters.
NoLigate :: Ligate

-- | Specify if the given ligate function should be performed on the input,
--   if 'v:Ligate' is passed, and the <i>identity</i> function otherwise.
ligate :: (a -> a) -> Ligate -> a -> a

-- | Specify if the given ligate function is performed over the functor
--   object if 'v:Ligate' is passed, and the <i>identity</i> function
--   otherwise.
ligateF :: Functor f => (a -> a) -> Ligate -> f a -> f a

-- | A data type that lists the possible emphasis of a font. This can be
--   <a>Bold</a> or <a>NoBold</a> the <a>Default</a> is <a>NoBold</a>.
data Emphasis

-- | The characters are not stressed with boldface.
NoBold :: Emphasis

-- | The characters are stressed in boldface.
Bold :: Emphasis

-- | A data type that can be used to specify if an <i>italic</i> character
--   is used. The <a>Default</a> is <a>NoItalic</a>.
data ItalicType

-- | No italic characters are used.
NoItalic :: ItalicType

-- | Italic characters are used.
Italic :: ItalicType

-- | A data type that specifies if the font is with <i>serifs</i> or not.
--   The 'Defaul;t' is <a>Serif</a>.
data FontStyle

-- | The character is a character rendered <i>without</i> serifs.
SansSerif :: FontStyle

-- | The character is a character rendered <i>with</i> serifs.
Serif :: FontStyle

-- | Checks if a character is an <i>alphabetic</i> or <i>numerical</i>
--   character in ASCII. The characters
--   <tt>0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz</tt>
--   satisfy this predicate.
isAsciiAlphaNum :: Char -> Bool

-- | Checks if a charcter is an <i>alphabetic</i> character in ASCII. The
--   characters
--   <tt><a>ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz</a></tt>
--   satisfy this predicate.
isAsciiAlpha :: Char -> Bool
instance GHC.Show.Show Data.Char.Core.Ligate
instance GHC.Read.Read Data.Char.Core.Ligate
instance GHC.Classes.Ord Data.Char.Core.Ligate
instance GHC.Classes.Eq Data.Char.Core.Ligate
instance GHC.Enum.Enum Data.Char.Core.Ligate
instance GHC.Enum.Bounded Data.Char.Core.Ligate
instance GHC.Show.Show Data.Char.Core.FontStyle
instance GHC.Read.Read Data.Char.Core.FontStyle
instance GHC.Classes.Ord Data.Char.Core.FontStyle
instance GHC.Classes.Eq Data.Char.Core.FontStyle
instance GHC.Enum.Enum Data.Char.Core.FontStyle
instance GHC.Enum.Bounded Data.Char.Core.FontStyle
instance GHC.Show.Show Data.Char.Core.ItalicType
instance GHC.Read.Read Data.Char.Core.ItalicType
instance GHC.Classes.Ord Data.Char.Core.ItalicType
instance GHC.Classes.Eq Data.Char.Core.ItalicType
instance GHC.Enum.Enum Data.Char.Core.ItalicType
instance GHC.Enum.Bounded Data.Char.Core.ItalicType
instance GHC.Show.Show Data.Char.Core.Emphasis
instance GHC.Read.Read Data.Char.Core.Emphasis
instance GHC.Classes.Ord Data.Char.Core.Emphasis
instance GHC.Classes.Eq Data.Char.Core.Emphasis
instance GHC.Enum.Enum Data.Char.Core.Emphasis
instance GHC.Enum.Bounded Data.Char.Core.Emphasis
instance GHC.Show.Show Data.Char.Core.Rotate90
instance GHC.Read.Read Data.Char.Core.Rotate90
instance GHC.Classes.Ord Data.Char.Core.Rotate90
instance GHC.Classes.Eq Data.Char.Core.Rotate90
instance GHC.Enum.Enum Data.Char.Core.Rotate90
instance GHC.Enum.Bounded Data.Char.Core.Rotate90
instance Data.Traversable.Traversable Data.Char.Core.Oriented
instance GHC.Show.Show a => GHC.Show.Show (Data.Char.Core.Oriented a)
instance GHC.Read.Read a => GHC.Read.Read (Data.Char.Core.Oriented a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Char.Core.Oriented a)
instance GHC.Base.Functor Data.Char.Core.Oriented
instance Data.Foldable.Foldable Data.Char.Core.Oriented
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Char.Core.Oriented a)
instance GHC.Show.Show Data.Char.Core.Orientation
instance GHC.Read.Read Data.Char.Core.Orientation
instance GHC.Classes.Ord Data.Char.Core.Orientation
instance GHC.Classes.Eq Data.Char.Core.Orientation
instance GHC.Enum.Enum Data.Char.Core.Orientation
instance GHC.Enum.Bounded Data.Char.Core.Orientation
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Core.Ligate
instance Data.Default.Class.Default Data.Char.Core.Ligate
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Core.FontStyle
instance Data.Default.Class.Default Data.Char.Core.FontStyle
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Core.ItalicType
instance Data.Default.Class.Default Data.Char.Core.ItalicType
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Core.Emphasis
instance Data.Default.Class.Default Data.Char.Core.Emphasis
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Core.Rotate90
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Data.Char.Core.Oriented a)
instance Test.QuickCheck.Arbitrary.Arbitrary1 Data.Char.Core.Oriented
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Core.Orientation


-- | 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>king</i> chess piece.
King :: ChessPieceType

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

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

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

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

-- | The <i>pawn</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

-- | 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.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.ChessPieceType
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Chess.ChessColor
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Chess.ChessColorBinary


-- | Unicode has a <a>block</a> named <i>Miscellaneous Symbols</i> that
--   includes unicode characters for dice, this module aims to make it more
--   convenient to render die characters.
module Data.Char.Dice

-- | A data type to store the values of a die.
data DieValue

-- | A die with value <i>one</i>, represented with ⚀.
I :: DieValue

-- | A die with value <i>two</i>, represented with ⚁.
II :: DieValue

-- | A die with value <i>three</i>, represented with ⚂.
III :: DieValue

-- | A die with value <i>four</i>, represented with ⚃.
IV :: DieValue

-- | A die with value <i>five</i>, represented with ⚄.
V :: DieValue

-- | A die with value <i>six</i>, represented with ⚅.
VI :: DieValue

-- | Convert the given integral value to a <a>DieValue</a> that represents
--   the given number. If the number is less than one, or greater than six,
--   <a>Nothing</a> is returned.
toDieValue :: Integral i => i -> Maybe DieValue

-- | Convert the given <a>DieValue</a> to a unicode character that
--   represents a <i>die</i> with that value.
die :: DieValue -> Char
instance GHC.Show.Show Data.Char.Dice.DieValue
instance GHC.Read.Read Data.Char.Dice.DieValue
instance GHC.Classes.Ord Data.Char.Dice.DieValue
instance GHC.Classes.Eq Data.Char.Dice.DieValue
instance GHC.Enum.Enum Data.Char.Dice.DieValue
instance GHC.Enum.Bounded Data.Char.Dice.DieValue
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Dice.DieValue


-- | A module that defines values for domino pieces, and converts these to
--   unicode characters of the <a>1F030 unicode block</a>.
module Data.Char.Domino

-- | A domino piece, which has two items. Depending on the orientation, the
--   items are located at the <i>top</i> and <i>bottom</i>; or <i>left</i>
--   and <i>right</i>.
data Domino a

-- | The front side of the domino piece.
Domino :: a -> a -> Domino a

-- | The part that is located at the <i>left</i> side in case the piece is
--   located <i>horizontally</i>, or at the <i>top</i> in case the piece is
--   located <i>vertically</i>.
[leftTop] :: Domino a -> a

-- | The part that is located at the <i>right</i> side in case the piece is
--   located <i>horizontally</i>, or at the <i>bottom</i> in case the piece
--   is located <i>vertically</i>.
[rightBottom] :: Domino a -> a

-- | The back side of the domino piece.
Back :: Domino a

-- | A pattern synonym that makes it more convenient to write expressions
--   that look like domino's like for example <tt>II :| IV</tt>.
pattern (:|) :: a -> a -> Domino a

-- | A type alias that specifies that <a>OrientedDomino</a> is an
--   <a>Oriented</a> type that wraps a <a>Domino</a> item.
type OrientedDomino a = Oriented (Domino a)

-- | A <a>SimpleDomino</a> is a <a>Domino</a> that contains <a>DieValue</a>
--   objects, it thus can not have an "empty" value.
type SimpleDomino = Domino DieValue

-- | A <a>ComplexDomino</a> is a <a>Domino</a> that contains <a>Maybe</a>
--   values wrapping a <a>DieValue</a>. In case of a <a>Nothing</a>, that
--   side is considered <i>empty</i>.
type ComplexDomino = Domino (Maybe DieValue)

-- | Convert a <a>ComplexDomino</a> value to a unicode character rendering
--   the domino value <i>horizontally</i>.
dominoH :: ComplexDomino -> Char

-- | Convert a <a>SimpleDomino</a> value to a unicode character rendering
--   the domino value <i>horizontally</i>.
dominoH' :: SimpleDomino -> Char

-- | Convert a <a>ComplexDomino</a> value to a unicode character rendering
--   the domino value <i>vertically</i>.
dominoV :: ComplexDomino -> Char

-- | Convert a <a>SimpleDomino</a> value to a unicode character rendering
--   the domino value <i>vertically</i>.
dominoV' :: SimpleDomino -> Char

-- | Convert an <a>OrientedDomino</a> to its unicode equivalent, where the
--   sides of the domino can be empty.
domino :: OrientedDomino (Maybe DieValue) -> Char

-- | Convert an <a>OrientedDomino</a> to its unicode equivalent, where the
--   sides of the domino can <i>not</i> be empty.
domino' :: OrientedDomino DieValue -> Char
instance Data.Traversable.Traversable Data.Char.Domino.Domino
instance GHC.Show.Show a => GHC.Show.Show (Data.Char.Domino.Domino a)
instance GHC.Read.Read a => GHC.Read.Read (Data.Char.Domino.Domino a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Char.Domino.Domino a)
instance GHC.Base.Functor Data.Char.Domino.Domino
instance Data.Foldable.Foldable Data.Char.Domino.Domino
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Char.Domino.Domino a)
instance GHC.Base.Applicative Data.Char.Domino.Domino
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Data.Char.Domino.Domino a)
instance Test.QuickCheck.Arbitrary.Arbitrary1 Data.Char.Domino.Domino


-- | 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 Test.QuickCheck.Arbitrary.Arbitrary1 Data.Char.Frame.Parts
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 Test.QuickCheck.Arbitrary.Arbitrary1 Data.Char.Frame.Vertical
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 Test.QuickCheck.Arbitrary.Arbitrary1 Data.Char.Frame.Horizontal
instance GHC.Base.Applicative Data.Char.Frame.Horizontal


-- | This module aims to make it more convenient to transform mathematical
--   characters to their <i>double struck</i>, <i>fraktur</i>,
--   <i>calligraphic</i>, etc. equivalent.
--   
--   Most of the characters are defined in the <a>1d400</a> unicode block.
module Data.Char.Math

-- | Convert the given character to a mathematical symbol with the given
--   <i>font</i> style, in the given <i>emphasis</i> and in the given
--   <i>italics</i> type wrapped in a <a>Just</a>. If the character is
--   outside the <tt>A</tt>-<tt>Z</tt> and <tt>a</tt>-<tt>z</tt> range,
--   <a>Nothing</a> is returned.
mathAlpha :: FontStyle -> ItalicType -> Emphasis -> Char -> Maybe Char

-- | Convert the given character to a mathematical symbol with the given
--   <i>font</i> style, with a given <i>emphasis</i> and a given
--   <i>italics</i> style. This maps characters an equivalent sansSerif
--   symbol for the <tt>A</tt>-<tt>Z</tt> and <tt>a</tt>-<tt>z</tt> range.
--   For characters outside the range, the behavior is unspecified.
mathAlpha' :: FontStyle -> ItalicType -> Emphasis -> Char -> Char

-- | Convert the given character to a mathematical symbol with serifs, in
--   the given <i>emphasis</i> and in the given <i>italics</i> type wrapped
--   in a <a>Just</a>. If the character is outside the
--   <tt>A</tt>-<tt>Z</tt> and <tt>a</tt>-<tt>z</tt> range, <a>Nothing</a>
--   is returned.
serif :: ItalicType -> Emphasis -> Char -> Maybe Char

-- | Convert the given character to a mathematical symbol with serifs, with
--   a given <i>emphasis</i> and a given <i>italics</i> style. This maps
--   characters an equivalent serif symbol for the <tt>A</tt>-<tt>Z</tt>
--   and <tt>a</tt>-<tt>z</tt> range. For characters outside the range, the
--   behavior is unspecified.
serif' :: ItalicType -> Emphasis -> Char -> Char

-- | Convert the given character to a mathematical symbol with serifs, with
--   no <i>bold</i> and in the given <i>italics</i> type wrapped in a
--   <a>Just</a>. If the character is outside the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range, <a>Nothing</a> is returned.
serifNoBold :: ItalicType -> Char -> Maybe Char

-- | Convert the given character to a mathematical symbol with serifs, not
--   in <i>bold</i> and in a <i>italics</i> type. This maps characters an
--   equivalent serif symbol for the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range. For characters outside the range, the
--   behavior is unspecified.
serifNoBold' :: ItalicType -> Char -> Char

-- | Convert the given character to a mathematical symbol with serifs, in
--   <i>bold</i> with the given <i>italics</i> type wrapped in a
--   <a>Just</a>. If the character is outside the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range, <a>Nothing</a> is returned.
serifBold :: ItalicType -> Char -> Maybe Char

-- | Convert the given character to a mathematical symbol with serifs, in
--   <i>bold</i> and in a <i>italics</i> type. This maps characters an
--   equivalent serif symbol for the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range. For characters outside the range, the
--   behavior is unspecified.
serifBold' :: ItalicType -> Char -> Char

-- | Convert the given character to a mathematical symbol with serifs, in
--   the given <i>emphasis</i> and not in <i>italics</i> wrapped in a
--   <a>Just</a>. If the character is outside the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range, <a>Nothing</a> is returned.
serifNoItalic :: Emphasis -> Char -> Maybe Char

-- | Convert the given character to a mathematical symbol with serifs, with
--   a given <i>emphasis</i> and not in italics. This maps characters an
--   equivalent serif symbol for the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range. For characters outside the range, the
--   behavior is unspecified.
serifNoItalic' :: Emphasis -> Char -> Char

-- | Convert the given character to a mathematical symbol with serifs, in
--   the given <i>emphasis</i> and in <i>italics</i> wrapped in a
--   <a>Just</a>. If the character is outside the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range, <a>Nothing</a> is returned.
serifItalic :: Emphasis -> Char -> Maybe Char

-- | Convert the given character to a mathematical symbol with serifs, with
--   a given <i>emphasis</i> and in italics. This maps characters an
--   equivalent serif symbol for the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range. For characters outside the range, the
--   behavior is unspecified.
serifItalic' :: Emphasis -> Char -> Char

-- | Convert the given character to a mathematical symbol with serifs, with
--   no <i>bold</i>, and no <i>italics</i> wrapped in a <a>Just</a>. If the
--   character is outside the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range, <a>Nothing</a> is returned.
serifNoBoldNoItalic :: Char -> Maybe Char

-- | Convert the given character to a mathematical symbol with serifs, with
--   no <i>bold</i> and no <i>italics</i>. This maps characters to itself
--   for the <tt>A</tt>-<tt>Z</tt> and <tt>a</tt>-<tt>z</tt> range. For
--   characters outside the range, the behavior is unspecified.
serifNoBoldNoItalic' :: Char -> Char

-- | Convert the given character to a mathematical symbol with serifs, in
--   <i>bold</i>, and no <i>italics</i> wrapped in a <a>Just</a>. If the
--   character is outside the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range, <a>Nothing</a> is returned.
serifBoldNoItalic :: Char -> Maybe Char

-- | Convert the given character to a mathematical symbol with serifs, in
--   <i>bold</i> not in <i>italics</i>. This maps characters an equivalent
--   serif symbol for the <tt>A</tt>-<tt>Z</tt> and <tt>a</tt>-<tt>z</tt>
--   range. For characters outside the range, the behavior is unspecified.
serifBoldNoItalic' :: Char -> Char

-- | Convert the given character to a mathematical symbol with serifs, with
--   no <i>bold</i>, and in <i>italics</i> wrapped in a <a>Just</a>. If the
--   character is outside the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range, <a>Nothing</a> is returned.
serifNoBoldItalic :: Char -> Maybe Char

-- | Convert the given character to a mathematical symbol with serifs, with
--   no <i>bold</i> and in <i>italics</i>. This maps characters an
--   equivalent serif symbol for the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range. For characters outside the range, the
--   behavior is unspecified.
serifNoBoldItalic' :: Char -> Char

-- | Convert the given character to a mathematical symbol with serifs, in
--   <i>bold</i>, and in <i>italics</i> wrapped in a <a>Just</a>. If the
--   character is outside the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range, <a>Nothing</a> is returned.
serifBoldItalic :: Char -> Maybe Char

-- | Convert the given character to a mathematical symbol with serifs, with
--   in <i>bold</i> and in <i>italics</i>. This maps characters an
--   equivalent serif symbol for the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range. For characters outside the range, the
--   behavior is unspecified.
serifBoldItalic' :: Char -> Char

-- | Convert the given character to a mathematical symbol without serifs,
--   in the given <i>emphasis</i> and in the given <i>italics</i> type
--   wrapped in a <a>Just</a>. If the character is outside the
--   <tt>A</tt>-<tt>Z</tt> and <tt>a</tt>-<tt>z</tt> range, <a>Nothing</a>
--   is returned.
sansSerif :: ItalicType -> Emphasis -> Char -> Maybe Char

-- | Convert the given character to a mathematical symbol without serifs,
--   with a given <i>emphasis</i> and a given <i>italics</i> style. This
--   maps characters an equivalent sansSerif symbol for the
--   <tt>A</tt>-<tt>Z</tt> and <tt>a</tt>-<tt>z</tt> range. For characters
--   outside the range, the behavior is unspecified.
sansSerif' :: ItalicType -> Emphasis -> Char -> Char

-- | Convert the given character to a mathematical symbol without serifs,
--   with no <i>bold</i> and in the given <i>italics</i> type wrapped in a
--   <a>Just</a>. If the character is outside the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range, <a>Nothing</a> is returned.
sansSerifNoBold :: ItalicType -> Char -> Maybe Char

-- | Convert the given character to a mathematical symbol without serifs,
--   not in <i>bold</i> and in a <i>italics</i> type. This maps characters
--   an equivalent sansSerif symbol for the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range. For characters outside the range, the
--   behavior is unspecified.
sansSerifNoBold' :: ItalicType -> Char -> Char

-- | Convert the given character to a mathematical symbol without serifs,
--   in <i>bold</i> with the given <i>italics</i> type wrapped in a
--   <a>Just</a>. If the character is outside the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range, <a>Nothing</a> is returned.
sansSerifBold :: ItalicType -> Char -> Maybe Char

-- | Convert the given character to a mathematical symbol without serifs,
--   in <i>bold</i> and in a <i>italics</i> type. This maps characters an
--   equivalent sansSerif symbol for the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range. For characters outside the range, the
--   behavior is unspecified.
sansSerifBold' :: ItalicType -> Char -> Char

-- | Convert the given character to a mathematical symbol without serifs,
--   in the given <i>emphasis</i> and not in <i>italics</i> wrapped in a
--   <a>Just</a>. If the character is outside the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range, <a>Nothing</a> is returned.
sansSerifNoItalic :: Emphasis -> Char -> Maybe Char

-- | Convert the given character to a mathematical symbol without serifs,
--   with a given <i>emphasis</i> and not in italics. This maps characters
--   an equivalent sansSerif symbol for the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range. For characters outside the range, the
--   behavior is unspecified.
sansSerifNoItalic' :: Emphasis -> Char -> Char

-- | Convert the given character to a mathematical symbol without serifs,
--   in the given <i>emphasis</i> and in <i>italics</i> wrapped in a
--   <a>Just</a>. If the character is outside the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range, <a>Nothing</a> is returned.
sansSerifItalic :: Emphasis -> Char -> Maybe Char

-- | Convert the given character to a mathematical symbol without serifs,
--   with a given <i>emphasis</i> and in italics. This maps characters an
--   equivalent sansSerif symbol for the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range. For characters outside the range, the
--   behavior is unspecified.
sansSerifItalic' :: Emphasis -> Char -> Char

-- | Convert the given character to a mathematical symbol without serifs,
--   with no <i>bold</i>, and no <i>italics</i> wrapped in a <a>Just</a>.
--   If the character is outside the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range, <a>Nothing</a> is returned.
sansSerifNoBoldNoItalic :: Char -> Maybe Char

-- | Convert the given character to a mathematical symbol without serifs,
--   with no <i>bold</i> and no <i>italics</i>. This maps characters to
--   itself for the <tt>A</tt>-<tt>Z</tt> and <tt>a</tt>-<tt>z</tt> range.
--   For characters outside the range, the behavior is unspecified.
sansSerifNoBoldNoItalic' :: Char -> Char

-- | Convert the given character to a mathematical symbol without serifs,
--   in <i>bold</i>, and no <i>italics</i> wrapped in a <a>Just</a>. If the
--   character is outside the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range, <a>Nothing</a> is returned.
sansSerifBoldNoItalic :: Char -> Maybe Char

-- | Convert the given character to a mathematical symbol without serifs,
--   in <i>bold</i> not in <i>italics</i>. This maps characters an
--   equivalent sansSerif symbol for the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range. For characters outside the range, the
--   behavior is unspecified.
sansSerifBoldNoItalic' :: Char -> Char

-- | Convert the given character to a mathematical symbol without serifs,
--   with no <i>bold</i>, and in <i>italics</i> wrapped in a <a>Just</a>.
--   If the character is outside the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range, <a>Nothing</a> is returned.
sansSerifNoBoldItalic :: Char -> Maybe Char

-- | Convert the given character to a mathematical symbol without serifs,
--   with no <i>bold</i> and in <i>italics</i>. This maps characters an
--   equivalent sansSerif symbol for the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range. For characters outside the range, the
--   behavior is unspecified.
sansSerifNoBoldItalic' :: Char -> Char

-- | Convert the given character to a mathematical symbol without serifs,
--   in <i>bold</i>, and in <i>italics</i> wrapped in a <a>Just</a>. If the
--   character is outside the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range, <a>Nothing</a> is returned.
sansSerifBoldItalic :: Char -> Maybe Char

-- | Convert the given character to a mathematical symbol without serifs,
--   with in <i>bold</i> and in <i>italics</i>. This maps characters an
--   equivalent sansSerif symbol for the <tt>A</tt>-<tt>Z</tt> and
--   <tt>a</tt>-<tt>z</tt> range. For characters outside the range, the
--   behavior is unspecified.
sansSerifBoldItalic' :: Char -> Char

-- | Convert the given digit character (<tt>0</tt>-<tt>9</tt>) to its
--   corresponding character with the given <a>Emphasis</a> in the given
--   <i>font</i> style wrapped in a <a>Just</a> data constructor. For
--   characters outside this range, <a>Nothing</a> is returned.
digit :: FontStyle -> Emphasis -> Char -> Maybe Char

-- | Convert the given digit character (<tt>0</tt>-<tt>9</tt>) to its
--   corresponding character with a given <a>Emphasis</a> in the given
--   <i>font</i> style. The result for characters outside this range is
--   unspecified.
digit' :: FontStyle -> Emphasis -> Char -> Char

-- | Convert the given digit character (<tt>0</tt>-<tt>9</tt>) to its
--   corresponding character with the given <a>Emphasis</a> in sans-serif
--   style wrapped in a <a>Just</a> data constructor. For characters
--   outside this range, <a>Nothing</a> is returned.
digitSansSerif :: Emphasis -> Char -> Maybe Char

-- | Convert the given digit character (<tt>0</tt>-<tt>9</tt>) to its
--   corresponding character with a given <a>Emphasis</a> in sans-serif
--   style. The result for characters outside this range is unspecified.
digitSansSerif' :: Emphasis -> Char -> Char

-- | Convert the given digit character (<tt>0</tt>-<tt>9</tt>) to its
--   corresponding character with the given <a>Emphasis</a> in serif style
--   wrapped in a <a>Just</a> data constructor. For characters outside this
--   range, <a>Nothing</a> is returned.
digitSerif :: Emphasis -> Char -> Maybe Char

-- | Convert the given digit character (<tt>0</tt>-<tt>9</tt>) to its
--   corresponding character with a given <a>Emphasis</a> in serif style.
--   The result for characters outside this range is unspecified.
digitSerif' :: Emphasis -> Char -> Char

-- | Convert the given digit character (<tt>0</tt>-<tt>9</tt>) to its
--   corresponding character in a non-bold serif style wrapped in a
--   <a>Just</a> data constructor. For characters outside this range,
--   <a>Nothing</a> is returned.
digitSerifRegular :: Char -> Maybe Char

-- | Convert the given digit character (<tt>0</tt>-<tt>9</tt>) to its
--   corresponding character in a non-bold serif style. The result for
--   characters outside this range is unspecified.
digitSerifRegular' :: Char -> Char

-- | Convert the given digit character (<tt>0</tt>-<tt>9</tt>) to its
--   corresponding character in a bold serif style wrapped in a <a>Just</a>
--   data constructor. For characters outside this range, <a>Nothing</a> is
--   returned.
digitSerifBold :: Char -> Maybe Char

-- | Convert the given digit character (<tt>0</tt>-<tt>9</tt>) to its
--   corresponding character in a bold serif style. The result for
--   characters outside this range is unspecified.
digitSerifBold' :: Char -> Char

-- | Convert the given digit character (<tt>0</tt>-<tt>9</tt>) to its
--   corresponding character in a non-bold sans-serif style wrapped in a
--   <a>Just</a> data constructor. For characters outside this range,
--   <a>Nothing</a> is returned.
digitSansSerifRegular :: Char -> Maybe Char

-- | Convert the given digit character (<tt>0</tt>-<tt>9</tt>) to its
--   corresponding character in a non-bold sans-serif style. The result for
--   characters outside this range is unspecified.
digitSansSerifRegular' :: Char -> Char

-- | Convert the given digit character (<tt>0</tt>-<tt>9</tt>) to its
--   corresponding character in a bold sans-serif style wrapped in a
--   <a>Just</a> data constructor. For characters outside this range,
--   <a>Nothing</a> is returned.
digitSansSerifBold :: Char -> Maybe Char

-- | Convert the given digit character (<tt>0</tt>-<tt>9</tt>) to its
--   corresponding character in a bold sans-serif style. The result for
--   characters outside this range is unspecified.
digitSansSerifBold' :: Char -> Char

-- | Converts the given digit (<tt>0</tt>-<tt>9</tt>) charcters to its
--   equivalent in <i>monospace</i> style wrapped in a <a>Just</a> data
--   constructor. <a>Nothing</a> for characters outside the range.
digitMonospace :: Char -> Maybe Char

-- | Converts the given digit (<tt>0</tt>-<tt>9</tt>) charcters to its
--   equivalent in <i>monospace</i> style. Unspecified result for
--   characters outside the range.
digitMonospace' :: Char -> Char

-- | Converts the given digit (<tt>0</tt>-<tt>9</tt>) charcters to its
--   equivalent in <i>double-struck</i> style wrapped in a <a>Just</a> data
--   constructor. <a>Nothing</a> for characters outside the range.
digitDoubleStruck :: Char -> Maybe Char

-- | Converts the given digit (<tt>0</tt>-<tt>9</tt>) charcters to its
--   equivalent in <i>double-struck</i> style. Unspecified result for
--   characters outside the range.
digitDoubleStruck' :: Char -> Char

-- | Convert the given number (<tt>0</tt>-<tt>9</tt>) to its corresponding
--   character with the given <a>Emphasis</a> in the given <a>FontStyle</a>
--   wrapped in a <a>Just</a> data constructor. For numbers outside this
--   range, <a>Nothing</a> is returned.
intToDigitChar :: FontStyle -> Emphasis -> Int -> Maybe Char

-- | Convert the given number (<tt>0</tt>-<tt>9</tt>) to its corresponding
--   character with a given <a>Emphasis</a> in the given <a>FontStyle</a>.
--   The result for numbers outside this range is unspecified.
intToDigitChar' :: FontStyle -> Emphasis -> Int -> Char

-- | Convert the given number (<tt>0</tt>-<tt>9</tt>) to its corresponding
--   character with the given <a>Emphasis</a> in serif style wrapped in a
--   <a>Just</a> data constructor. For numbers outside this range,
--   <a>Nothing</a> is returned.
intToDigitSerif :: Emphasis -> Int -> Maybe Char

-- | Convert the given number (<tt>0</tt>-<tt>9</tt>) to its corresponding
--   character with a given <a>Emphasis</a> in serif style. The result for
--   numbers outside this range is unspecified.
intToDigitSerif' :: Emphasis -> Int -> Char

-- | Convert the given number (<tt>0</tt>-<tt>9</tt>) to its corresponding
--   character with the given <a>Emphasis</a> in sans-serif style wrapped
--   in a <a>Just</a> data constructor. For numbers outside this range,
--   <a>Nothing</a> is returned.
intToDigitSansSerif :: Emphasis -> Int -> Maybe Char

-- | Convert the given number (<tt>0</tt>-<tt>9</tt>) to its corresponding
--   character with a given <a>Emphasis</a> in sans-serif style. The result
--   for numbers outside this range is unspecified.
intToDigitSansSerif' :: Emphasis -> Int -> Char

-- | Convert the given number (<tt>0</tt>-<tt>9</tt>) to its corresponding
--   character in a non-bold serif style wrapped in a <a>Just</a> data
--   constructor. For numbers outside this range, <a>Nothing</a> is
--   returned.
intToDigitSerifRegular :: Int -> Maybe Char

-- | Convert the given number (<tt>0</tt>-<tt>9</tt>) to its corresponding
--   character in a non-bold serif style. The result for numbers outside
--   this range is unspecified.
intToDigitSerifRegular' :: Int -> Char

-- | Convert the given number (<tt>0</tt>-<tt>9</tt>) to its corresponding
--   character in a bold serif style wrapped in a <a>Just</a> data
--   constructor. For numbers outside this range, <a>Nothing</a> is
--   returned.
intToDigitSerifBold :: Int -> Maybe Char

-- | Convert the given number (<tt>0</tt>-<tt>9</tt>) to its corresponding
--   character in a bold serif style. The result for numbers outside this
--   range is unspecified.
intToDigitSerifBold' :: Int -> Char

-- | Convert the given number (<tt>0</tt>-<tt>9</tt>) to its corresponding
--   character in a non-bold sans-serif style wrapped in a <a>Just</a> data
--   constructor. For numbers outside this range, <a>Nothing</a> is
--   returned.
intToDigitSansSerifRegular :: Int -> Maybe Char

-- | Convert the given number (<tt>0</tt>-<tt>9</tt>) to its corresponding
--   character in a non-bold sans-serif style. The result for numbers
--   outside this range is unspecified.
intToDigitSansSerifRegular' :: Int -> Char

-- | Convert the given number (<tt>0</tt>-<tt>9</tt>) to its corresponding
--   character in a bold sans-serif style wrapped in a <a>Just</a> data
--   constructor. For numbers outside this range, <a>Nothing</a> is
--   returned.
intToDigitSansSerifBold :: Int -> Maybe Char

-- | Convert the given number (<tt>0</tt>-<tt>9</tt>) to its corresponding
--   character in a bold sans-serif style. The result for numbers outside
--   this range is unspecified.
intToDigitSansSerifBold' :: Int -> Char

-- | Convert the given number (<tt>0</tt>-<tt>9</tt>) to its corresponding
--   character in <i>monospace</i> style wrapped in a <a>Just</a> data
--   constructor. For numbers outside this range, <a>Nothing</a> is
--   returned.
intToDigitMonospace :: Int -> Maybe Char

-- | Convert the given number (<tt>0</tt>-<tt>9</tt>) to its corresponding
--   character in <i>monospace</i> style. Unspecified result for numbers
--   outside this range.
intToDigitMonospace' :: Int -> Char

-- | Convert the given number (<tt>0</tt>-<tt>9</tt>) to its corresponding
--   character in <i>double-struck</i> style wrapped in a <a>Just</a> data
--   constructor. For numbers outside this range, <a>Nothing</a> is
--   returned.
intToDigitDoubleStruck :: Int -> Maybe Char

-- | Convert the given number (<tt>0</tt>-<tt>9</tt>) to its corresponding
--   character in <i>double-struck</i> style. Unspecified result for
--   numbers outside this range.
intToDigitDoubleStruck' :: Int -> Char

-- | Convert the given character to its <i>monospace</i> equivalent for the
--   alphabet and numerical range (<tt>A</tt>-<tt>Z</tt>,
--   <tt>a</tt>-<tt>z</tt>, and <tt>0</tt>-<tt>9</tt>) wrapped in a
--   <a>Just</a> data constructor. For characters outside the range,
--   <a>Nothing</a> is returned.
monospace :: Char -> Maybe Char

-- | Convert the given character to its <i>monospace</i> equivalent for the
--   alphabet and numerical range (<tt>A</tt>-<tt>Z</tt>,
--   <tt>a</tt>-<tt>z</tt>, and <tt>0</tt>-<tt>9</tt>). For characters
--   outside the range, the result is unspecified.
monospace' :: Char -> Char

-- | Obtain the double struck symbol for the given character. The supported
--   range of characters are the alphabet characters
--   (<tt>A</tt>-<tt>Z</tt>, and <tt>a</tt>-<tt>z</tt>), and the numerical
--   characters (<tt>0</tt>-<tt>9</tt>). The symbols are wrapped in the
--   <a>Just</a> data constructor. For characters outside the range,
--   <a>Nothing</a> is returned.
doubleStruck :: Char -> Maybe Char

-- | Obtain the double struck symbol for the given character. The supported
--   range of characters are the alphabet character (<tt>A</tt>-<tt>Z</tt>,
--   and <tt>a</tt>-<tt>z</tt>), and the numerical characters
--   (<tt>0</tt>-<tt>9</tt>). For characters other than these, the
--   behaviour is unspecified.
doubleStruck' :: Char -> Char

-- | Convert the given character to its <i>script</i> or
--   <i>calligraphic</i> symbol wrapped in a <a>Just</a> data constructor.
--   This symbol is <i>not</i> written in the given <a>Emphasis</a> style.
--   If the symbol is outside the alphabet range (<tt>A</tt>-<tt>Z</tt>,
--   and <tt>a-z</tt>), <a>Nothing</a> is returned.
script :: Emphasis -> Char -> Maybe Char

-- | Convert the given character to its <i>script</i> or
--   <i>calligraphic</i> symbol. This symbol is written in the given
--   <a>Emphasis</a> style. If the symbol is outside the alphabet range
--   (<tt>A</tt>-<tt>Z</tt>, and <tt>a-z</tt>), the returned character is
--   unspecified.
script' :: Emphasis -> Char -> Char

-- | Convert the given character to its <i>script</i> or
--   <i>calligraphic</i> symbol wrapped in a <a>Just</a> data constructor.
--   This symbol is <i>not</i> written in boldface. If the symbol is
--   outside the alphabet range (<tt>A</tt>-<tt>Z</tt>, and <tt>a-z</tt>),
--   <a>Nothing</a> is returned.
scriptRegular :: Char -> Maybe Char

-- | Convert the given character to its <i>script</i> or
--   <i>calligraphic</i> symbol. This symbol is <i>not</i> written in
--   boldface. If the symbol is outside the alphabet range
--   (<tt>A</tt>-<tt>Z</tt>, and <tt>a-z</tt>), the returned character is
--   unspecified.
scriptRegular' :: Char -> Char

-- | Convert the given character to its <i>script</i> or
--   <i>calligraphic</i> symbol wrapped in a <a>Just</a> data constructor.
--   This symbol is written in boldface. If the symbol is outside the
--   alphabet range (<tt>A</tt>-<tt>Z</tt>, and <tt>a-z</tt>),
--   <a>Nothing</a> is returned.
scriptBold :: Char -> Maybe Char

-- | Convert the given character to its <i>script</i> or
--   <i>calligraphic</i> symbol. This symbol is written in boldface. If the
--   symbol is outside the alphabet range (<tt>A</tt>-<tt>Z</tt>, and
--   <tt>a-z</tt>), the returned character is unspecified.
scriptBold' :: Char -> Char

-- | Convert the given character to its <i>script</i> or
--   <i>calligraphic</i> symbol wrapped in a <a>Just</a> data constructor.
--   This symbol is <i>not</i> written in the given <a>Emphasis</a> style.
--   If the symbol is outside the alphabet range (<tt>A</tt>-<tt>Z</tt>,
--   and <tt>a-z</tt>), <a>Nothing</a> is returned. This is an alias of
--   <a>script</a>.
calligraphy :: Emphasis -> Char -> Maybe Char

-- | Convert the given character to its <i>script</i> or
--   <i>calligraphic</i> symbol. This symbol is written in the given
--   <a>Emphasis</a> style. If the symbol is outside the alphabet range
--   (<tt>A</tt>-<tt>Z</tt>, and <tt>a-z</tt>), the returned character is
--   unspecified. This is an alias of 'script\''.
calligraphy' :: Emphasis -> Char -> Char

-- | Convert the given character to its <i>script</i> or
--   <i>calligraphic</i> symbol wrapped in a <a>Just</a> data constructor.
--   This symbol is <i>not</i> written in boldface. If the symbol is
--   outside the alphabet range (<tt>A</tt>-<tt>Z</tt>, and <tt>a-z</tt>),
--   <a>Nothing</a> is returned. This is an alias of <a>scriptRegular</a>.
calligraphyRegular :: Char -> Maybe Char

-- | Convert the given character to its <i>script</i> or
--   <i>calligraphic</i> symbol. This symbol is <i>not</i> written in
--   boldface. If the symbol is outside the alphabet range
--   (<tt>A</tt>-<tt>Z</tt>, and <tt>a-z</tt>), the returned character is
--   unspecified. This is an alias of 'scriptRegular\''.
calligraphyRegular' :: Char -> Char

-- | Convert the given character to its <i>script</i> or
--   <i>calligraphic</i> symbol wrapped in a <a>Just</a> data constructor.
--   This symbol is written in boldface. If the symbol is outside the
--   alphabet range (<tt>A</tt>-<tt>Z</tt>, and <tt>a-z</tt>),
--   <a>Nothing</a> is returned. This is an alias of <a>scriptBold</a>.
calligraphyBold :: Char -> Maybe Char

-- | Convert the given character to its <i>script</i> or
--   <i>calligraphic</i> symbol. This symbol is written in boldface. If the
--   symbol is outside the alphabet range (<tt>A</tt>-<tt>Z</tt>, and
--   <tt>a-z</tt>), the returned character is unspecified. This is an alias
--   of 'scriptBold\''.
calligraphyBold' :: Char -> Char

-- | Obtain the fraktur symbol for the given character in the given emphais
--   style. The result is wrapped in a <a>Just</a> data constructor. The
--   range of supported characters are the alphabet characters
--   (<tt>A</tt>-<tt>Z</tt>, and <tt>a</tt>-<tt>z</tt>). In case a
--   character outside the range is passed to the function, <a>Nothing</a>
--   is returned.
fraktur :: Emphasis -> Char -> Maybe Char

-- | Obtain the fraktur symbol for the given character in the given
--   emphasis style. The supported range of characters are the alphabet
--   characters (<tt>A</tt>-<tt>Z</tt>, and <tt>a</tt>-<tt>z</tt>). In case
--   the character is not in this range, it is unspecified what will be
--   returned.
fraktur' :: Emphasis -> Char -> Char

-- | Obtain the fraktur symbol for the given character in a regular (not
--   <i>bold</i> style). The result is wrapped in a <a>Just</a> data
--   constructor. The range of supported characters are the alphabet
--   characters (<tt>A</tt>-<tt>Z</tt>, and <tt>a</tt>-<tt>z</tt>). In case
--   a character outside the range is passed to the function,
--   <a>Nothing</a> is returned.
frakturRegular :: Char -> Maybe Char

-- | Obtain the fraktur symbol for the given character in a regular (not
--   <i>bold</i>) style. The supported range of characters are the alphabet
--   characters (<tt>A</tt>-<tt>Z</tt>, and <tt>a</tt>-<tt>z</tt>). In case
--   the character is not in this range, it is unspecified what will be
--   returned.
frakturRegular' :: Char -> Char

-- | Obtain the fraktur symbol for the given character in a <i>bold</i>.
--   The result is wrapped in a <a>Just</a> data constructor. The range of
--   supported characters are the alphabet characters
--   (<tt>A</tt>-<tt>Z</tt>, and <tt>a</tt>-<tt>z</tt>). In case a
--   character outside the range is passed to the function, <a>Nothing</a>
--   is returned.
frakturBold :: Char -> Maybe Char

-- | Obtain the fraktur symbol for the given character in a <i>bold</i>
--   style. The supported range of characters are the alphabet characters
--   (<tt>A</tt>-<tt>Z</tt>, and <tt>a</tt>-<tt>z</tt>). In case the
--   character is not in this range, it is unspecified what will be
--   returned.
frakturBold' :: Char -> Char


-- | This module aims to convert Roman numerals to a String of unicode
--   characters that represent Roman numerals.
--   
--   One can convert numbers to Roman numerals in uppercase and lowercase,
--   and in <a>Additive</a> and <a>Subtractive</a> style.
module Data.Char.Roman

-- | Roman numerals for which a unicode character exists.
data RomanLiteral

-- | The unicode character for the Roman numeral <i>one</i>: Ⅰ.
I :: RomanLiteral

-- | The unicode character for the Roman numeral <i>two</i>: Ⅱ.
II :: RomanLiteral

-- | The unicode character for the Roman numeral <i>three</i>: Ⅲ.
III :: RomanLiteral

-- | The unicode character for the Roman numeral <i>four</i>: Ⅳ.
IV :: RomanLiteral

-- | The unicode character for the Roman numeral <i>five</i>: Ⅴ.
V :: RomanLiteral

-- | The unicode character for the Roman numeral <i>six</i>: Ⅵ.
VI :: RomanLiteral

-- | The unicode character for the Roman numeral <i>seven</i>: Ⅶ.
VII :: RomanLiteral

-- | The unicode character for the Roman numeral <i>eight</i>: Ⅷ.
VIII :: RomanLiteral

-- | The unicode character for the Roman numeral <i>nine</i>: Ⅸ.
IX :: RomanLiteral

-- | The unicode character for the Roman numeral <i>ten</i>: Ⅹ.
X :: RomanLiteral

-- | The unicode character for the Roman numeral <i>eleven</i>: Ⅺ.
XI :: RomanLiteral

-- | The unicode character for the Roman numeral <i>twelve</i>: Ⅻ.
XII :: RomanLiteral

-- | The unicode character for the Roman numeral <i>fifty</i>: Ⅼ.
L :: RomanLiteral

-- | The unicode character for the Roman numeral <i>hundred</i>: Ⅽ.
C :: RomanLiteral

-- | The unicode character for the Roman numeral <i>five hundred</i>: Ⅾ.
D :: RomanLiteral

-- | The unicode character for the Roman numeral <i>thousand</i>: Ⅿ.
M :: RomanLiteral

-- | The style to convert a number to a Roman numeral.
data RomanStyle

-- | The additive style converts four to ⅠⅠⅠⅠ.
Additive :: RomanStyle

-- | The subtractive style converts four to ⅠⅤ.
Subtractive :: RomanStyle

-- | Convert the given number with the given <a>RomanStyle</a> and
--   <a>Ligate</a> style to a sequence of <a>RomanLiteral</a>s, given the
--   number can be represented with Roman numerals (is strictly larger than
--   zero).
toLiterals :: Integral i => RomanStyle -> Ligate -> i -> Maybe [RomanLiteral]

-- | Convert the given <a>RomanLiteral</a> object to a unicode character in
--   <i>uppercase</i>.
romanLiteral :: RomanLiteral -> Char

-- | Convert the given <a>RomanLiteral</a> object to a unicode character in
--   <i>lowercase</i>.
romanLiteral' :: RomanLiteral -> Char

-- | Convert a sequence of <a>RomanLiteral</a> objects to a <a>Text</a>
--   object that contains a sequence of corresponding Unicode characters
--   which are Roman numberals in <i>uppercase</i>.
romanNumeral :: [RomanLiteral] -> Text

-- | Convert a sequence of <a>RomanLiteral</a> objects to a <a>Text</a>
--   object that contains a sequence of corresponding Unicode characters
--   which are Roman numberals in <i>lowercase</i>.
romanNumeral' :: [RomanLiteral] -> Text

-- | Convert a given number to a <a>Text</a> wrapped in a <a>Just</a> data
--   constructor, given the number can be converted to a Roman numeral,
--   given it can be represented. <a>Nothing</a> in case it can not be
--   represented. The number is written in Roman numerals in
--   <i>uppercase</i>.
romanNumber :: Integral i => RomanStyle -> Ligate -> i -> Maybe Text

-- | Convert a given number to a <a>Text</a> wrapped in a <a>Just</a> data
--   constructor, given the number can be converted to a Roman numeral,
--   given it can be represented. <a>Nothing</a> in case it can not be
--   represented. The number is written in Roman numerals in
--   <i>lowercase</i>.
romanNumber' :: Integral i => RomanStyle -> Ligate -> i -> Maybe Text
instance GHC.Read.Read Data.Char.Roman.RomanLiteral
instance GHC.Show.Show Data.Char.Roman.RomanLiteral
instance GHC.Classes.Eq Data.Char.Roman.RomanLiteral
instance GHC.Enum.Enum Data.Char.Roman.RomanLiteral
instance GHC.Enum.Bounded Data.Char.Roman.RomanLiteral
instance GHC.Read.Read Data.Char.Roman.RomanStyle
instance GHC.Show.Show Data.Char.Roman.RomanStyle
instance GHC.Classes.Eq Data.Char.Roman.RomanStyle
instance GHC.Enum.Enum Data.Char.Roman.RomanStyle
instance GHC.Enum.Bounded Data.Char.Roman.RomanStyle
instance Data.Default.Class.Default Data.Char.Roman.RomanStyle
instance Test.QuickCheck.Arbitrary.Arbitrary Data.Char.Roman.RomanStyle


-- | 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