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


-- | A compiler front-end generator.
--   
--   The BNF Converter is a compiler construction tool generating a
--   compiler front-end from a Labelled BNF grammar. It was originally
--   written to generate Haskell code, but can also be used for generating
--   Agda, C, C++, Java, Ocaml and XML code.
--   
--   Given a Labelled BNF grammar the tool produces: an abstract syntax as
--   a Haskell, Agda, C, C++, Ocaml module or Java directory, a case
--   skeleton for the abstract syntax in the same language, an Alex, JLex,
--   or Flex lexer generator file, a Happy, CUP, Bison, or Antlr parser
--   generator file, a pretty-printer as a Haskell, Agda, C, C++, Java, or
--   Ocaml module, an XML representation, a LaTeX file containing a
--   readable specification of the language.
@package BNFC3
@version 3.0


-- | The abstract syntax of language BNFC.
module BNFC.Abs
type Grammar = Grammar' BNFC'Position
data Grammar' a
Grammar :: a -> [Def' a] -> Grammar' a
type Def = Def' BNFC'Position
data Def' a
Rule :: a -> Label' a -> Cat' a -> RHS' a -> Def' a
Comment :: a -> String -> Def' a
Comments :: a -> String -> String -> Def' a
Internal :: a -> Label' a -> Cat' a -> RHS' a -> Def' a
Token :: a -> Identifier -> Reg' a -> Def' a
PosToken :: a -> Identifier -> Reg' a -> Def' a
Entryp :: a -> [Cat' a] -> Def' a
Separator :: a -> MinimumSize' a -> Cat' a -> String -> Def' a
Terminator :: a -> MinimumSize' a -> Cat' a -> String -> Def' a
Delimiters :: a -> Cat' a -> String -> String -> Separation' a -> MinimumSize' a -> Def' a
Coercions :: a -> Identifier -> Integer -> Def' a
Rules :: a -> Identifier -> [RHS' a] -> Def' a
Function :: a -> Identifier -> [Arg' a] -> Exp' a -> Def' a
Layout :: a -> [String] -> Def' a
LayoutStop :: a -> [String] -> Def' a
LayoutTop :: a -> Def' a
type Item = Item' BNFC'Position
data Item' a
Terminal :: a -> String -> Item' a
NTerminal :: a -> Cat' a -> Item' a
type Cat = Cat' BNFC'Position
data Cat' a
ListCat :: a -> Cat' a -> Cat' a
IdCat :: a -> Identifier -> Cat' a
type Label = Label' BNFC'Position
data Label' a
Id :: a -> Identifier -> Label' a
Wild :: a -> Label' a
ListEmpty :: a -> Label' a
ListCons :: a -> Label' a
ListOne :: a -> Label' a
type Arg = Arg' BNFC'Position
data Arg' a
Arg :: a -> Identifier -> Arg' a
type Separation = Separation' BNFC'Position
data Separation' a
SepNone :: a -> Separation' a
SepTerm :: a -> String -> Separation' a
SepSepar :: a -> String -> Separation' a
type Exp = Exp' BNFC'Position
data Exp' a
Cons :: a -> Exp' a -> Exp' a -> Exp' a
App :: a -> Identifier -> [Exp' a] -> Exp' a
Var :: a -> Identifier -> Exp' a
LitInteger :: a -> Integer -> Exp' a
LitChar :: a -> Char -> Exp' a
LitString :: a -> String -> Exp' a
LitDouble :: a -> Double -> Exp' a
List :: a -> [Exp' a] -> Exp' a
type RHS = RHS' BNFC'Position
data RHS' a
RHS :: a -> [Item' a] -> RHS' a
type MinimumSize = MinimumSize' BNFC'Position
data MinimumSize' a
MNonEmpty :: a -> MinimumSize' a
MEmpty :: a -> MinimumSize' a
type Reg = Reg' BNFC'Position
data Reg' a
RAlt :: a -> Reg' a -> Reg' a -> Reg' a
RMinus :: a -> Reg' a -> Reg' a -> Reg' a
RSeq :: a -> Reg' a -> Reg' a -> Reg' a
RStar :: a -> Reg' a -> Reg' a
RPlus :: a -> Reg' a -> Reg' a
ROpt :: a -> Reg' a -> Reg' a
REps :: a -> Reg' a
RChar :: a -> Char -> Reg' a
RAlts :: a -> String -> Reg' a
RSeqs :: a -> String -> Reg' a
RDigit :: a -> Reg' a
RLetter :: a -> Reg' a
RUpper :: a -> Reg' a
RLower :: a -> Reg' a
RAny :: a -> Reg' a
newtype Identifier
Identifier :: ((Int, Int), String) -> Identifier

-- | Start position (line, column) of something.
type BNFC'Position = Maybe (Int, Int)
pattern BNFC'NoPosition :: BNFC'Position
pattern BNFC'Position :: Int -> Int -> BNFC'Position

-- | Get the start position of something.
class HasPosition a
hasPosition :: HasPosition a => a -> BNFC'Position
instance Data.Traversable.Traversable BNFC.Abs.Separation'
instance Data.Foldable.Foldable BNFC.Abs.Separation'
instance GHC.Base.Functor BNFC.Abs.Separation'
instance GHC.Read.Read a => GHC.Read.Read (BNFC.Abs.Separation' a)
instance GHC.Show.Show a => GHC.Show.Show (BNFC.Abs.Separation' a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (BNFC.Abs.Separation' a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (BNFC.Abs.Separation' a)
instance Data.Traversable.Traversable BNFC.Abs.MinimumSize'
instance Data.Foldable.Foldable BNFC.Abs.MinimumSize'
instance GHC.Base.Functor BNFC.Abs.MinimumSize'
instance GHC.Read.Read a => GHC.Read.Read (BNFC.Abs.MinimumSize' a)
instance GHC.Show.Show a => GHC.Show.Show (BNFC.Abs.MinimumSize' a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (BNFC.Abs.MinimumSize' a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (BNFC.Abs.MinimumSize' a)
instance Data.Traversable.Traversable BNFC.Abs.Reg'
instance Data.Foldable.Foldable BNFC.Abs.Reg'
instance GHC.Base.Functor BNFC.Abs.Reg'
instance GHC.Read.Read a => GHC.Read.Read (BNFC.Abs.Reg' a)
instance GHC.Show.Show a => GHC.Show.Show (BNFC.Abs.Reg' a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (BNFC.Abs.Reg' a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (BNFC.Abs.Reg' a)
instance GHC.Read.Read BNFC.Abs.Identifier
instance GHC.Show.Show BNFC.Abs.Identifier
instance GHC.Classes.Ord BNFC.Abs.Identifier
instance GHC.Classes.Eq BNFC.Abs.Identifier
instance Data.Traversable.Traversable BNFC.Abs.Exp'
instance Data.Foldable.Foldable BNFC.Abs.Exp'
instance GHC.Base.Functor BNFC.Abs.Exp'
instance GHC.Read.Read a => GHC.Read.Read (BNFC.Abs.Exp' a)
instance GHC.Show.Show a => GHC.Show.Show (BNFC.Abs.Exp' a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (BNFC.Abs.Exp' a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (BNFC.Abs.Exp' a)
instance Data.Traversable.Traversable BNFC.Abs.Arg'
instance Data.Foldable.Foldable BNFC.Abs.Arg'
instance GHC.Base.Functor BNFC.Abs.Arg'
instance GHC.Read.Read a => GHC.Read.Read (BNFC.Abs.Arg' a)
instance GHC.Show.Show a => GHC.Show.Show (BNFC.Abs.Arg' a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (BNFC.Abs.Arg' a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (BNFC.Abs.Arg' a)
instance Data.Traversable.Traversable BNFC.Abs.Label'
instance Data.Foldable.Foldable BNFC.Abs.Label'
instance GHC.Base.Functor BNFC.Abs.Label'
instance GHC.Read.Read a => GHC.Read.Read (BNFC.Abs.Label' a)
instance GHC.Show.Show a => GHC.Show.Show (BNFC.Abs.Label' a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (BNFC.Abs.Label' a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (BNFC.Abs.Label' a)
instance Data.Traversable.Traversable BNFC.Abs.Cat'
instance Data.Foldable.Foldable BNFC.Abs.Cat'
instance GHC.Base.Functor BNFC.Abs.Cat'
instance GHC.Read.Read a => GHC.Read.Read (BNFC.Abs.Cat' a)
instance GHC.Show.Show a => GHC.Show.Show (BNFC.Abs.Cat' a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (BNFC.Abs.Cat' a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (BNFC.Abs.Cat' a)
instance Data.Traversable.Traversable BNFC.Abs.Item'
instance Data.Foldable.Foldable BNFC.Abs.Item'
instance GHC.Base.Functor BNFC.Abs.Item'
instance GHC.Read.Read a => GHC.Read.Read (BNFC.Abs.Item' a)
instance GHC.Show.Show a => GHC.Show.Show (BNFC.Abs.Item' a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (BNFC.Abs.Item' a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (BNFC.Abs.Item' a)
instance Data.Traversable.Traversable BNFC.Abs.RHS'
instance Data.Foldable.Foldable BNFC.Abs.RHS'
instance GHC.Base.Functor BNFC.Abs.RHS'
instance GHC.Read.Read a => GHC.Read.Read (BNFC.Abs.RHS' a)
instance GHC.Show.Show a => GHC.Show.Show (BNFC.Abs.RHS' a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (BNFC.Abs.RHS' a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (BNFC.Abs.RHS' a)
instance Data.Traversable.Traversable BNFC.Abs.Def'
instance Data.Foldable.Foldable BNFC.Abs.Def'
instance GHC.Base.Functor BNFC.Abs.Def'
instance GHC.Read.Read a => GHC.Read.Read (BNFC.Abs.Def' a)
instance GHC.Show.Show a => GHC.Show.Show (BNFC.Abs.Def' a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (BNFC.Abs.Def' a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (BNFC.Abs.Def' a)
instance Data.Traversable.Traversable BNFC.Abs.Grammar'
instance Data.Foldable.Foldable BNFC.Abs.Grammar'
instance GHC.Base.Functor BNFC.Abs.Grammar'
instance GHC.Read.Read a => GHC.Read.Read (BNFC.Abs.Grammar' a)
instance GHC.Show.Show a => GHC.Show.Show (BNFC.Abs.Grammar' a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (BNFC.Abs.Grammar' a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (BNFC.Abs.Grammar' a)
instance BNFC.Abs.HasPosition BNFC.Abs.Grammar
instance BNFC.Abs.HasPosition BNFC.Abs.Def
instance BNFC.Abs.HasPosition BNFC.Abs.Item
instance BNFC.Abs.HasPosition BNFC.Abs.Cat
instance BNFC.Abs.HasPosition BNFC.Abs.Label
instance BNFC.Abs.HasPosition BNFC.Abs.Arg
instance BNFC.Abs.HasPosition BNFC.Abs.Separation
instance BNFC.Abs.HasPosition BNFC.Abs.Exp
instance BNFC.Abs.HasPosition BNFC.Abs.RHS
instance BNFC.Abs.HasPosition BNFC.Abs.MinimumSize
instance BNFC.Abs.HasPosition BNFC.Abs.Reg
instance BNFC.Abs.HasPosition BNFC.Abs.Identifier

module BNFC.Backend.Common.Xml

module BNFC.Backend.CommonInterface.Makefile

module BNFC.Lex
alex_tab_size :: Int
alex_base :: AlexAddr
alex_table :: AlexAddr
alex_check :: AlexAddr
alex_deflt :: AlexAddr
alex_accept :: Array Int (AlexAcc user)
alex_actions :: Array Int (Posn -> String -> Token)
alexIndexInt32OffAddr :: AlexAddr -> Int# -> Int#
quickIndex :: Array Int (AlexAcc (Any :: Type)) -> Int -> AlexAcc (Any :: Type)
data AlexReturn a
AlexEOF :: AlexReturn a
AlexError :: !AlexInput -> AlexReturn a
AlexSkip :: !AlexInput -> !Int -> AlexReturn a
AlexToken :: !AlexInput -> !Int -> a -> AlexReturn a
alexScan :: (Posn, Char, [Byte], String) -> Int -> AlexReturn (Posn -> String -> Token)
alexScanUser :: t -> (Posn, Char, [Byte], String) -> Int -> AlexReturn (Posn -> String -> Token)
alex_scan_tkn :: t1 -> t2 -> Int# -> AlexInput -> Int# -> AlexLastAcc -> (AlexLastAcc, (Posn, Char, [Byte], String))
data AlexLastAcc
AlexNone :: AlexLastAcc
AlexLastAcc :: !Int -> !AlexInput -> !Int -> AlexLastAcc
AlexLastSkip :: !AlexInput -> !Int -> AlexLastAcc
data AlexAcc user
AlexAccNone :: AlexAcc user
AlexAcc :: Int -> AlexAcc user
AlexAccSkip :: AlexAcc user

-- | Create a token with position.
tok :: (String -> Tok) -> Posn -> String -> Token

-- | Token without position.
data Tok

-- | Reserved word or symbol.
TK :: {-# UNPACK #-} !TokSymbol -> Tok

-- | String literal.
TL :: !String -> Tok

-- | Integer literal.
TI :: !String -> Tok

-- | Identifier.
TV :: !String -> Tok

-- | Float literal.
TD :: !String -> Tok

-- | Character literal.
TC :: !String -> Tok
T_Identifier :: !String -> Tok

-- | Smart constructor for <a>Tok</a> for the sake of backwards
--   compatibility.
pattern TS :: String -> Int -> Tok

-- | Keyword or symbol tokens have a unique ID.
data TokSymbol
TokSymbol :: String -> !Int -> TokSymbol

-- | Keyword or symbol text.
[tsText] :: TokSymbol -> String

-- | Unique ID.
[tsID] :: TokSymbol -> !Int

-- | Token with position.
data Token
PT :: Posn -> Tok -> Token
Err :: Posn -> Token

-- | Pretty print a position.
printPosn :: Posn -> String

-- | Pretty print the position of the first token in the list.
tokenPos :: [Token] -> String

-- | Get the position of a token.
tokenPosn :: Token -> Posn

-- | Get line and column of a token.
tokenLineCol :: Token -> (Int, Int)

-- | Get line and column of a position.
posLineCol :: Posn -> (Int, Int)

-- | Convert a token into "position token" form.
mkPosToken :: Token -> ((Int, Int), String)

-- | Convert a token to its text.
tokenText :: Token -> String

-- | Convert a token to a string.
prToken :: Token -> String

-- | Finite map from text to token organized as binary search tree.
data BTree

-- | Nil (leaf).
N :: BTree

-- | Binary node.
B :: String -> Tok -> BTree -> BTree -> BTree

-- | Convert potential keyword into token or use fallback conversion.
eitherResIdent :: (String -> Tok) -> String -> Tok

-- | The keywords and symbols of the language organized as binary search
--   tree.
resWords :: BTree

-- | Unquote string literal.
unescapeInitTail :: String -> String
data Posn
Pn :: !Int -> !Int -> !Int -> Posn
alexStartPos :: Posn
alexMove :: Posn -> Char -> Posn
type Byte = Word8
type AlexInput = (Posn, Char, [Byte], String)
tokens :: String -> [Token]
alexGetByte :: AlexInput -> Maybe (Byte, AlexInput)
alexInputPrevChar :: AlexInput -> Char

-- | Encode a Haskell String to a list of Word8 values, in UTF8 format.
utf8Encode :: Char -> [Word8]
alex_action_3 :: Posn -> String -> Token
alex_action_4 :: Posn -> String -> Token
alex_action_5 :: Posn -> String -> Token
alex_action_6 :: Posn -> String -> Token
alex_action_7 :: Posn -> String -> Token
alex_action_8 :: Posn -> String -> Token
alex_action_9 :: Posn -> String -> Token
data AlexAddr
AlexA# :: Addr# -> AlexAddr
alexIndexInt16OffAddr :: AlexAddr -> Int# -> Int#
instance GHC.Show.Show BNFC.Lex.TokSymbol
instance GHC.Classes.Ord BNFC.Lex.Tok
instance GHC.Show.Show BNFC.Lex.Tok
instance GHC.Classes.Eq BNFC.Lex.Tok
instance GHC.Show.Show BNFC.Lex.BTree
instance GHC.Classes.Ord BNFC.Lex.Posn
instance GHC.Show.Show BNFC.Lex.Posn
instance GHC.Classes.Eq BNFC.Lex.Posn
instance GHC.Classes.Ord BNFC.Lex.Token
instance GHC.Show.Show BNFC.Lex.Token
instance GHC.Classes.Eq BNFC.Lex.Token
instance GHC.Classes.Eq BNFC.Lex.TokSymbol
instance GHC.Classes.Ord BNFC.Lex.TokSymbol

module BNFC.License
license :: String

module BNFC.Par
happyError :: [Token] -> Err a
myLexer :: String -> [Token]
pGrammar :: [Token] -> Err Grammar
pListDef :: [Token] -> Err [Def]
pDef :: [Token] -> Err Def
pItem :: [Token] -> Err Item
pListItem :: [Token] -> Err [Item]
pCat :: [Token] -> Err Cat
pListCat :: [Token] -> Err [Cat]
pLabel :: [Token] -> Err Label
pArg :: [Token] -> Err Arg
pListArg :: [Token] -> Err [Arg]
pSeparation :: [Token] -> Err Separation
pListString :: [Token] -> Err [String]
pExp :: [Token] -> Err Exp
pExp1 :: [Token] -> Err Exp
pExp2 :: [Token] -> Err Exp
pListExp :: [Token] -> Err [Exp]
pListExp2 :: [Token] -> Err [Exp]
pRHS :: [Token] -> Err RHS
pListRHS :: [Token] -> Err [RHS]
pMinimumSize :: [Token] -> Err MinimumSize
pReg :: [Token] -> Err Reg
pReg1 :: [Token] -> Err Reg
pReg2 :: [Token] -> Err Reg
pReg3 :: [Token] -> Err Reg


-- | Pretty-printer for BNFC. Generated by the BNF converter.
module BNFC.Print

-- | The top-level printing method.
printTree :: Print a => a -> String
type Doc = [ShowS] -> [ShowS]
doc :: ShowS -> Doc
render :: Doc -> String
parenth :: Doc -> Doc
concatS :: [ShowS] -> ShowS
concatD :: [Doc] -> Doc
replicateS :: Int -> ShowS -> ShowS

-- | The printer class does the job.
class Print a
prt :: Print a => Int -> a -> Doc
printString :: String -> Doc
mkEsc :: Char -> Char -> ShowS
prPrec :: Int -> Int -> Doc -> Doc
instance BNFC.Print.Print a => BNFC.Print.Print [a]
instance BNFC.Print.Print GHC.Types.Char
instance BNFC.Print.Print GHC.Base.String
instance BNFC.Print.Print GHC.Integer.Type.Integer
instance BNFC.Print.Print GHC.Types.Double
instance BNFC.Print.Print BNFC.Abs.Identifier
instance BNFC.Print.Print (BNFC.Abs.Grammar' a)
instance BNFC.Print.Print [BNFC.Abs.Def' a]
instance BNFC.Print.Print (BNFC.Abs.Def' a)
instance BNFC.Print.Print (BNFC.Abs.Item' a)
instance BNFC.Print.Print [BNFC.Abs.Item' a]
instance BNFC.Print.Print (BNFC.Abs.Cat' a)
instance BNFC.Print.Print [BNFC.Abs.Cat' a]
instance BNFC.Print.Print (BNFC.Abs.Label' a)
instance BNFC.Print.Print (BNFC.Abs.Arg' a)
instance BNFC.Print.Print [BNFC.Abs.Arg' a]
instance BNFC.Print.Print (BNFC.Abs.Separation' a)
instance BNFC.Print.Print [GHC.Base.String]
instance BNFC.Print.Print (BNFC.Abs.Exp' a)
instance BNFC.Print.Print [BNFC.Abs.Exp' a]
instance BNFC.Print.Print (BNFC.Abs.RHS' a)
instance BNFC.Print.Print [BNFC.Abs.RHS' a]
instance BNFC.Print.Print (BNFC.Abs.MinimumSize' a)
instance BNFC.Print.Print (BNFC.Abs.Reg' a)


module BNFC.Utils.Decoration

-- | A decoration is a functor that is traversable into any functor.
--   
--   The <a>Functor</a> superclass is given because of the limitations of
--   the Haskell class system. <tt>traverseF</tt> actually implies
--   functoriality.
--   
--   Minimal complete definition: <tt>traverseF</tt> or
--   <tt>distributeF</tt>.
class Functor t => Decoration t

-- | <tt>traverseF</tt> is the defining property.
traverseF :: (Decoration t, Functor m) => (a -> m b) -> t a -> m (t b)

-- | Decorations commute into any functor.
distributeF :: (Decoration t, Functor m) => t (m a) -> m (t a)
traverseF2 :: (Decoration t, Bifunctor m) => (a -> m b c) -> t a -> m (t b) (t c)

-- | Decorations commute into any bifunctor.
distributeF2 :: (Decoration t, Bifunctor m) => t (m a b) -> m (t a) (t b)

-- | Any decoration is traversable with <tt>traverse = traverseF</tt>. Just
--   like any <a>Traversable</a> is a functor, so is any decoration, given
--   by just <tt>traverseF</tt>, a functor.
dmap :: Decoration t => (a -> b) -> t a -> t b

-- | Any decoration is a lens. <tt>set</tt> is a special case of
--   <tt>dmap</tt>.
dget :: Decoration t => t a -> a

-- | A proper name for a generic decoration.
data DecorationT d a
DecorationT :: d -> a -> DecorationT d a
[decoration] :: DecorationT d a -> d
[decorated] :: DecorationT d a -> a
instance Data.Traversable.Traversable (BNFC.Utils.Decoration.DecorationT d)
instance Data.Foldable.Foldable (BNFC.Utils.Decoration.DecorationT d)
instance GHC.Base.Functor (BNFC.Utils.Decoration.DecorationT d)
instance (GHC.Show.Show d, GHC.Show.Show a) => GHC.Show.Show (BNFC.Utils.Decoration.DecorationT d a)
instance (GHC.Classes.Ord d, GHC.Classes.Ord a) => GHC.Classes.Ord (BNFC.Utils.Decoration.DecorationT d a)
instance (GHC.Classes.Eq d, GHC.Classes.Eq a) => GHC.Classes.Eq (BNFC.Utils.Decoration.DecorationT d a)
instance BNFC.Utils.Decoration.Decoration (BNFC.Utils.Decoration.DecorationT d)
instance BNFC.Utils.Decoration.Decoration Data.Functor.Identity.Identity
instance (BNFC.Utils.Decoration.Decoration d, BNFC.Utils.Decoration.Decoration t) => BNFC.Utils.Decoration.Decoration (Data.Functor.Compose.Compose d t)
instance BNFC.Utils.Decoration.Decoration ((,) a)


-- | Non-empty lists.
--   
--   Better name <tt>List1</tt> for non-empty lists, plus missing
--   functionality.
--   
--   Import: @
--   
--   {-# LANGUAGE PatternSynonyms #-}
--   
--   import BNFC.Utils.List1 (List1, pattern (:|)) import qualified
--   BNFC.Utils.List1 as List1
--   
--   @
module BNFC.Utils.List1

-- | Non-empty <a>String</a>.
type String1 = List1 Char

-- | Non-empty list. TODO change to newtype?
type List1 = NonEmpty
trim1 :: String -> Maybe String1

-- | Return the last element and the rest.
initLast :: List1 a -> ([a], a)

-- | Build a list with one element.
singleton :: a -> List1 a

-- | Append a list to a non-empty list.
appendList :: List1 a -> [a] -> List1 a

-- | Prepend a list to a non-empty list.
prependList :: [a] -> List1 a -> List1 a

-- | More precise type for <tt>snoc</tt>.
snoc :: [a] -> a -> List1 a

-- | Concatenate one or more non-empty lists.
concat :: [List1 a] -> [a]

-- | Like <a>union</a>. Duplicates in the first list are not removed.
--   O(nm).
union :: Eq a => List1 a -> List1 a -> List1 a
ifNull :: [a] -> b -> (List1 a -> b) -> b
ifNotNull :: [a] -> (List1 a -> b) -> b -> b

-- | Checks if all the elements in the list are equal. Assumes that the
--   <a>Eq</a> instance stands for an equivalence relation. O(n).
allEqual :: Eq a => List1 a -> Bool

-- | Like <a>catMaybes</a>.
catMaybes :: List1 (Maybe a) -> [a]

-- | Like <a>filter</a>.
mapMaybe :: (a -> Maybe b) -> List1 a -> [b]

-- | Like <a>partitionEithers</a>.
partitionEithers :: List1 (Either a b) -> ([a], [b])

-- | Like <a>lefts</a>.
lefts :: List1 (Either a b) -> [a]

-- | Like <a>rights</a>.
rights :: List1 (Either a b) -> [b]

-- | Like <a>zipWithM</a>.
zipWithM :: Applicative m => (a -> b -> m c) -> List1 a -> List1 b -> m (List1 c)

-- | Like <a>zipWithM</a>.
zipWithM_ :: Applicative m => (a -> b -> m c) -> List1 a -> List1 b -> m ()

-- | <a>sortWith</a> for <a>NonEmpty</a>, behaves the same as:
--   
--   <pre>
--   sortBy . comparing
--   </pre>
sortWith :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty a

-- | <a>sortBy</a> for <a>NonEmpty</a>, behaves the same as <a>sortBy</a>
sortBy :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a

-- | <a>transpose</a> for <a>NonEmpty</a>, behaves the same as
--   <a>transpose</a> The rows/columns need not be the same length, in
--   which case &gt; transpose . transpose /= id
transpose :: NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)

-- | The <a>nubBy</a> function behaves just like <a>nub</a>, except it uses
--   a user-supplied equality predicate instead of the overloaded <a>==</a>
--   function.
nubBy :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty a

-- | The <a>nub</a> function removes duplicate elements from a list. In
--   particular, it keeps only the first occurrence of each element. (The
--   name <a>nub</a> means 'essence'.) It is a special case of
--   <a>nubBy</a>, which allows the programmer to supply their own
--   inequality test.
nub :: Eq a => NonEmpty a -> NonEmpty a

-- | The <a>unzip</a> function is the inverse of the <a>zip</a> function.
unzip :: Functor f => f (a, b) -> (f a, f b)

-- | The <a>zipWith</a> function generalizes <a>zip</a>. Rather than
--   tupling the elements, the elements are combined using the function
--   passed as the first argument.
zipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c

-- | The <a>zip</a> function takes two streams and returns a stream of
--   corresponding pairs.
zip :: NonEmpty a -> NonEmpty b -> NonEmpty (a, b)

-- | <tt>xs !! n</tt> returns the element of the stream <tt>xs</tt> at
--   index <tt>n</tt>. Note that the head of the stream has index 0.
--   
--   <i>Beware</i>: a negative or out-of-bounds index will cause an error.
(!!) :: NonEmpty a -> Int -> a
infixl 9 !!

-- | The <a>isPrefixOf</a> function returns <a>True</a> if the first
--   argument is a prefix of the second.
isPrefixOf :: Eq a => [a] -> NonEmpty a -> Bool

-- | <a>groupAllWith1</a> is to <a>groupWith1</a> as <a>groupAllWith</a> is
--   to <a>groupWith</a>
groupAllWith1 :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)

-- | <a>groupWith1</a> is to <a>group1</a> as <a>groupWith</a> is to
--   <a>group</a>
groupWith1 :: Eq b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)

-- | <a>groupBy1</a> is to <a>group1</a> as <a>groupBy</a> is to
--   <a>group</a>.
groupBy1 :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)

-- | <a>group1</a> operates like <a>group</a>, but uses the knowledge that
--   its input is non-empty to produce guaranteed non-empty output.
group1 :: Eq a => NonEmpty a -> NonEmpty (NonEmpty a)

-- | <a>groupAllWith</a> operates like <a>groupWith</a>, but sorts the list
--   first so that each equivalence class has, at most, one list in the
--   output
groupAllWith :: Ord b => (a -> b) -> [a] -> [NonEmpty a]

-- | <a>groupWith</a> operates like <a>group</a>, but uses the provided
--   projection when comparing for equality
groupWith :: (Foldable f, Eq b) => (a -> b) -> f a -> [NonEmpty a]

-- | <a>groupBy</a> operates like <a>group</a>, but uses the provided
--   equality predicate instead of <a>==</a>.
groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a]

-- | The <a>group</a> function takes a stream and returns a list of streams
--   such that flattening the resulting list is equal to the argument.
--   Moreover, each stream in the resulting list contains only equal
--   elements. For example, in list notation:
--   
--   <pre>
--   'group' $ 'cycle' "Mississippi"
--     = "M" : "i" : "ss" : "i" : "ss" : "i" : "pp" : "i" : "M" : "i" : ...
--   </pre>
group :: (Foldable f, Eq a) => f a -> [NonEmpty a]

-- | The <a>partition</a> function takes a predicate <tt>p</tt> and a
--   stream <tt>xs</tt>, and returns a pair of lists. The first list
--   corresponds to the elements of <tt>xs</tt> for which <tt>p</tt> holds;
--   the second corresponds to the elements of <tt>xs</tt> for which
--   <tt>p</tt> does not hold.
--   
--   <pre>
--   'partition' p xs = ('filter' p xs, 'filter' (not . p) xs)
--   </pre>
partition :: (a -> Bool) -> NonEmpty a -> ([a], [a])

-- | <tt><a>filter</a> p xs</tt> removes any elements from <tt>xs</tt> that
--   do not satisfy <tt>p</tt>.
filter :: (a -> Bool) -> NonEmpty a -> [a]

-- | The <tt><a>break</a> p</tt> function is equivalent to <tt><a>span</a>
--   (not . p)</tt>.
break :: (a -> Bool) -> NonEmpty a -> ([a], [a])

-- | <tt><a>span</a> p xs</tt> returns the longest prefix of <tt>xs</tt>
--   that satisfies <tt>p</tt>, together with the remainder of the stream.
--   
--   <pre>
--   'span' p xs == ('takeWhile' p xs, 'dropWhile' p xs)
--   xs == ys ++ zs where (ys, zs) = 'span' p xs
--   </pre>
span :: (a -> Bool) -> NonEmpty a -> ([a], [a])

-- | <tt><a>dropWhile</a> p xs</tt> returns the suffix remaining after
--   <tt><a>takeWhile</a> p xs</tt>.
dropWhile :: (a -> Bool) -> NonEmpty a -> [a]

-- | <tt><a>takeWhile</a> p xs</tt> returns the longest prefix of the
--   stream <tt>xs</tt> for which the predicate <tt>p</tt> holds.
takeWhile :: (a -> Bool) -> NonEmpty a -> [a]

-- | <tt><a>splitAt</a> n xs</tt> returns a pair consisting of the prefix
--   of <tt>xs</tt> of length <tt>n</tt> and the remaining stream
--   immediately following this prefix.
--   
--   <pre>
--   'splitAt' n xs == ('take' n xs, 'drop' n xs)
--   xs == ys ++ zs where (ys, zs) = 'splitAt' n xs
--   </pre>
splitAt :: Int -> NonEmpty a -> ([a], [a])

-- | <tt><a>drop</a> n xs</tt> drops the first <tt>n</tt> elements off the
--   front of the sequence <tt>xs</tt>.
drop :: Int -> NonEmpty a -> [a]

-- | <tt><a>take</a> n xs</tt> returns the first <tt>n</tt> elements of
--   <tt>xs</tt>.
take :: Int -> NonEmpty a -> [a]

-- | <tt><a>repeat</a> x</tt> returns a constant stream, where all elements
--   are equal to <tt>x</tt>.
repeat :: a -> NonEmpty a

-- | <a>reverse</a> a finite NonEmpty stream.
reverse :: NonEmpty a -> NonEmpty a

-- | <tt><a>cycle</a> xs</tt> returns the infinite repetition of
--   <tt>xs</tt>:
--   
--   <pre>
--   cycle (1 :| [2,3]) = 1 :| [2,3,1,2,3,...]
--   </pre>
cycle :: NonEmpty a -> NonEmpty a

-- | <tt><a>iterate</a> f x</tt> produces the infinite sequence of repeated
--   applications of <tt>f</tt> to <tt>x</tt>.
--   
--   <pre>
--   iterate f x = x :| [f x, f (f x), ..]
--   </pre>
iterate :: (a -> a) -> a -> NonEmpty a

-- | 'intersperse x xs' alternates elements of the list with copies of
--   <tt>x</tt>.
--   
--   <pre>
--   intersperse 0 (1 :| [2,3]) == 1 :| [0,2,0,3]
--   </pre>
intersperse :: a -> NonEmpty a -> NonEmpty a

-- | <a>scanr1</a> is a variant of <a>scanr</a> that has no starting value
--   argument.
scanr1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a

-- | <a>scanl1</a> is a variant of <a>scanl</a> that has no starting value
--   argument:
--   
--   <pre>
--   scanl1 f [x1, x2, ...] == x1 :| [x1 `f` x2, x1 `f` (x2 `f` x3), ...]
--   </pre>
scanl1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a

-- | <a>scanr</a> is the right-to-left dual of <a>scanl</a>. Note that
--   
--   <pre>
--   head (scanr f z xs) == foldr f z xs.
--   </pre>
scanr :: Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b

-- | <a>scanl</a> is similar to <a>foldl</a>, but returns a stream of
--   successive reduced values from the left:
--   
--   <pre>
--   scanl f z [x1, x2, ...] == z :| [z `f` x1, (z `f` x1) `f` x2, ...]
--   </pre>
--   
--   Note that
--   
--   <pre>
--   last (scanl f z xs) == foldl f z xs.
--   </pre>
scanl :: Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b

-- | <tt><a>some1</a> x</tt> sequences <tt>x</tt> one or more times.
some1 :: Alternative f => f a -> f (NonEmpty a)

-- | <tt><a>insert</a> x xs</tt> inserts <tt>x</tt> into the last position
--   in <tt>xs</tt> where it is still less than or equal to the next
--   element. In particular, if the list is sorted beforehand, the result
--   will also be sorted.
insert :: (Foldable f, Ord a) => a -> f a -> NonEmpty a

-- | The <a>tails</a> function takes a stream <tt>xs</tt> and returns all
--   the suffixes of <tt>xs</tt>.
tails :: Foldable f => f a -> NonEmpty [a]

-- | The <a>inits</a> function takes a stream <tt>xs</tt> and returns all
--   the finite prefixes of <tt>xs</tt>.
inits :: Foldable f => f a -> NonEmpty [a]

-- | Map a function over a <a>NonEmpty</a> stream.
map :: (a -> b) -> NonEmpty a -> NonEmpty b

-- | Convert a stream to a normal list efficiently.
toList :: NonEmpty a -> [a]

-- | Converts a normal list to a <a>NonEmpty</a> stream.
--   
--   Raises an error if given an empty list.
fromList :: [a] -> NonEmpty a

-- | Sort a stream.
sort :: Ord a => NonEmpty a -> NonEmpty a

-- | Synonym for <a>&lt;|</a>.
cons :: a -> NonEmpty a -> NonEmpty a

-- | Prepend an element to the stream.
(<|) :: a -> NonEmpty a -> NonEmpty a
infixr 5 <|

-- | Extract everything except the last element of the stream.
init :: NonEmpty a -> [a]

-- | Extract the last element of the stream.
last :: NonEmpty a -> a

-- | Extract the possibly-empty tail of the stream.
tail :: NonEmpty a -> [a]

-- | Extract the first element of the stream.
head :: NonEmpty a -> a

-- | The <a>unfoldr</a> function is analogous to <a>Data.List</a>'s
--   <a>unfoldr</a> operation.
unfoldr :: (a -> (b, Maybe a)) -> a -> NonEmpty b

-- | <a>uncons</a> produces the first element of the stream, and a stream
--   of the remaining elements, if any.
uncons :: NonEmpty a -> (a, Maybe (NonEmpty a))

-- | <a>nonEmpty</a> efficiently turns a normal list into a <a>NonEmpty</a>
--   stream, producing <a>Nothing</a> if the input is empty.
nonEmpty :: [a] -> Maybe (NonEmpty a)

-- | <a>unfold</a> produces a new stream by repeatedly applying the
--   unfolding function to the seed value to produce an element of type
--   <tt>b</tt> and a new seed value. When the unfolding function returns
--   <a>Nothing</a> instead of a new seed value, the stream ends.
unfold :: (a -> (b, Maybe a)) -> a -> NonEmpty b

-- | Compute n-ary logic exclusive OR operation on <a>NonEmpty</a> list.
xor :: NonEmpty Bool -> Bool

-- | Number of elements in <a>NonEmpty</a> list.
length :: NonEmpty a -> Int
pattern (:|) :: () => a -> [a] -> NonEmpty a
infixr 5 :|
instance Data.String.IsString BNFC.Utils.List1.String1


-- | Lists of length at least 2.
--   
--   Import as: <tt> import BNFC.Utils.List2 (List2(List2)) import
--   qualified BNFC.Utils.List2 as List2 </tt>
module BNFC.Utils.List2

-- | Lists of length ≥2.
data List2 a
List2 :: a -> a -> [a] -> List2 a
type List1 = NonEmpty
cons :: a -> List2 a -> List2 a
snoc :: List2 a -> a -> List2 a

-- | Safe.
head :: List2 a -> a

-- | Safe.
tail :: List2 a -> [a]

-- | Safe.
tail1 :: List2 a -> List1 a
toList1 :: List2 a -> List1 a

-- | Unsafe!
fromList :: [a] -> List2 a

-- | Unsafe!
fromList1 :: List1 a -> List2 a
break :: (a -> Bool) -> List2 a -> ([a], [a])

-- | The <a>toList</a> function extracts a list of <tt>Item l</tt> from the
--   structure <tt>l</tt>. It should satisfy fromList . toList = id.
toList :: IsList l => l -> [Item l]
instance Data.Traversable.Traversable BNFC.Utils.List2.List2
instance Data.Foldable.Foldable BNFC.Utils.List2.List2
instance GHC.Base.Functor BNFC.Utils.List2.List2
instance GHC.Show.Show a => GHC.Show.Show (BNFC.Utils.List2.List2 a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (BNFC.Utils.List2.List2 a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (BNFC.Utils.List2.List2 a)
instance GHC.Base.Semigroup (BNFC.Utils.List2.List2 a)
instance GHC.Exts.IsList (BNFC.Utils.List2.List2 a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (BNFC.Utils.List2.List2 a)

module BNFC.Utils.Panic
panic :: HasCallStack => String -> a
panicPositionNothing :: HasCallStack => a
panicEmptyIdentifier :: HasCallStack => a


-- | Constructing singleton collections.
module BNFC.Utils.Singleton

-- | A create-only possibly empty collection is a monoid with the
--   possibility to inject elements.
class (Semigroup coll, Monoid coll, Singleton el coll) => Collection el coll | coll -> el
fromList :: Collection el coll => [el] -> coll

-- | Overloaded <tt>singleton</tt> constructor for collections.
class Singleton el coll | coll -> el
singleton :: Singleton el coll => el -> coll
instance BNFC.Utils.Singleton.Collection a [a]
instance BNFC.Utils.Singleton.Collection a ([a] -> [a])
instance GHC.Classes.Ord a => BNFC.Utils.Singleton.Collection a (Data.Set.Internal.Set a)
instance GHC.Classes.Ord k => BNFC.Utils.Singleton.Collection (k, a) (Data.Map.Internal.Map k a)
instance BNFC.Utils.Singleton.Singleton a (GHC.Maybe.Maybe a)
instance BNFC.Utils.Singleton.Singleton a [a]
instance BNFC.Utils.Singleton.Singleton a ([a] -> [a])
instance BNFC.Utils.Singleton.Singleton a (GHC.Base.NonEmpty a)
instance BNFC.Utils.Singleton.Singleton a (Data.Set.Internal.Set a)
instance BNFC.Utils.Singleton.Singleton (k, a) (Data.Map.Internal.Map k a)


-- | Extension to the '<tt>Prelude'</tt>.
module BNFC.Prelude

-- | Append two lists, i.e.,
--   
--   <pre>
--   [x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
--   [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]
--   </pre>
--   
--   If the first list is not finite, the result is the first list.
(++) :: [a] -> [a] -> [a]
infixr 5 ++

-- | The value of <tt>seq a b</tt> is bottom if <tt>a</tt> is bottom, and
--   otherwise equal to <tt>b</tt>. In other words, it evaluates the first
--   argument <tt>a</tt> to weak head normal form (WHNF). <tt>seq</tt> is
--   usually introduced to improve performance by avoiding unneeded
--   laziness.
--   
--   A note on evaluation order: the expression <tt>seq a b</tt> does
--   <i>not</i> guarantee that <tt>a</tt> will be evaluated before
--   <tt>b</tt>. The only guarantee given by <tt>seq</tt> is that the both
--   <tt>a</tt> and <tt>b</tt> will be evaluated before <tt>seq</tt>
--   returns a value. In particular, this means that <tt>b</tt> may be
--   evaluated before <tt>a</tt>. If you need to guarantee a specific order
--   of evaluation, you must use the function <tt>pseq</tt> from the
--   "parallel" package.
seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b
infixr 0 `seq`

-- | &lt;math&gt;. <a>filter</a>, applied to a predicate and a list,
--   returns the list of those elements that satisfy the predicate; i.e.,
--   
--   <pre>
--   filter p xs = [ x | x &lt;- xs, p x]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; filter odd [1, 2, 3]
--   [1,3]
--   </pre>
filter :: (a -> Bool) -> [a] -> [a]

-- | &lt;math&gt;. <a>zip</a> takes two lists and returns a list of
--   corresponding pairs.
--   
--   <pre>
--   zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]
--   </pre>
--   
--   If one input list is short, excess elements of the longer list are
--   discarded:
--   
--   <pre>
--   zip [1] ['a', 'b'] = [(1, 'a')]
--   zip [1, 2] ['a'] = [(1, 'a')]
--   </pre>
--   
--   <a>zip</a> is right-lazy:
--   
--   <pre>
--   zip [] _|_ = []
--   zip _|_ [] = _|_
--   </pre>
--   
--   <a>zip</a> is capable of list fusion, but it is restricted to its
--   first list argument and its resulting list.
zip :: [a] -> [b] -> [(a, b)]

-- | The <a>print</a> function outputs a value of any printable type to the
--   standard output device. Printable types are those that are instances
--   of class <a>Show</a>; <a>print</a> converts values to strings for
--   output using the <a>show</a> operation and adds a newline.
--   
--   For example, a program to print the first 20 integers and their powers
--   of 2 could be written as:
--   
--   <pre>
--   main = print ([(n, 2^n) | n &lt;- [0..19]])
--   </pre>
print :: Show a => a -> IO ()

-- | Extract the first component of a pair.
fst :: (a, b) -> a

-- | Extract the second component of a pair.
snd :: (a, b) -> b

-- | <a>otherwise</a> is defined as the value <a>True</a>. It helps to make
--   guards more readable. eg.
--   
--   <pre>
--   f x | x &lt; 0     = ...
--       | otherwise = ...
--   </pre>
otherwise :: Bool

-- | &lt;math&gt;. <a>map</a> <tt>f xs</tt> is the list obtained by
--   applying <tt>f</tt> to each element of <tt>xs</tt>, i.e.,
--   
--   <pre>
--   map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn]
--   map f [x1, x2, ...] == [f x1, f x2, ...]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; map (+1) [1, 2, 3]
--   </pre>
map :: (a -> b) -> [a] -> [b]

-- | Application operator. This operator is redundant, since ordinary
--   application <tt>(f x)</tt> means the same as <tt>(f <a>$</a> x)</tt>.
--   However, <a>$</a> has low, right-associative binding precedence, so it
--   sometimes allows parentheses to be omitted; for example:
--   
--   <pre>
--   f $ g $ h x  =  f (g (h x))
--   </pre>
--   
--   It is also useful in higher-order situations, such as <tt><a>map</a>
--   (<a>$</a> 0) xs</tt>, or <tt><a>zipWith</a> (<a>$</a>) fs xs</tt>.
--   
--   Note that <tt>(<a>$</a>)</tt> is levity-polymorphic in its result
--   type, so that <tt>foo <a>$</a> True</tt> where <tt>foo :: Bool -&gt;
--   Int#</tt> is well-typed.
($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
infixr 0 $

-- | general coercion from integral types
fromIntegral :: (Integral a, Num b) => a -> b

-- | general coercion to fractional types
realToFrac :: (Real a, Fractional b) => a -> b

-- | The <a>Bounded</a> class is used to name the upper and lower limits of
--   a type. <a>Ord</a> is not a superclass of <a>Bounded</a> since types
--   that are not totally ordered may also have upper and lower bounds.
--   
--   The <a>Bounded</a> class may be derived for any enumeration type;
--   <a>minBound</a> is the first constructor listed in the <tt>data</tt>
--   declaration and <a>maxBound</a> is the last. <a>Bounded</a> may also
--   be derived for single-constructor datatypes whose constituent types
--   are in <a>Bounded</a>.
class Bounded a
minBound :: Bounded a => a
maxBound :: Bounded a => a

-- | Class <a>Enum</a> defines operations on sequentially ordered types.
--   
--   The <tt>enumFrom</tt>... methods are used in Haskell's translation of
--   arithmetic sequences.
--   
--   Instances of <a>Enum</a> may be derived for any enumeration type
--   (types whose constructors have no fields). The nullary constructors
--   are assumed to be numbered left-to-right by <a>fromEnum</a> from
--   <tt>0</tt> through <tt>n-1</tt>. See Chapter 10 of the <i>Haskell
--   Report</i> for more details.
--   
--   For any type that is an instance of class <a>Bounded</a> as well as
--   <a>Enum</a>, the following should hold:
--   
--   <ul>
--   <li>The calls <tt><a>succ</a> <a>maxBound</a></tt> and <tt><a>pred</a>
--   <a>minBound</a></tt> should result in a runtime error.</li>
--   <li><a>fromEnum</a> and <a>toEnum</a> should give a runtime error if
--   the result value is not representable in the result type. For example,
--   <tt><a>toEnum</a> 7 :: <a>Bool</a></tt> is an error.</li>
--   <li><a>enumFrom</a> and <a>enumFromThen</a> should be defined with an
--   implicit bound, thus:</li>
--   </ul>
--   
--   <pre>
--   enumFrom     x   = enumFromTo     x maxBound
--   enumFromThen x y = enumFromThenTo x y bound
--     where
--       bound | fromEnum y &gt;= fromEnum x = maxBound
--             | otherwise                = minBound
--   </pre>
class Enum a

-- | the successor of a value. For numeric types, <a>succ</a> adds 1.
succ :: Enum a => a -> a

-- | the predecessor of a value. For numeric types, <a>pred</a> subtracts
--   1.
pred :: Enum a => a -> a

-- | Convert from an <a>Int</a>.
toEnum :: Enum a => Int -> a

-- | Convert to an <a>Int</a>. It is implementation-dependent what
--   <a>fromEnum</a> returns when applied to a value that is too large to
--   fit in an <a>Int</a>.
fromEnum :: Enum a => a -> Int

-- | Used in Haskell's translation of <tt>[n..]</tt> with <tt>[n..] =
--   enumFrom n</tt>, a possible implementation being <tt>enumFrom n = n :
--   enumFrom (succ n)</tt>. For example:
--   
--   <ul>
--   <li><pre>enumFrom 4 :: [Integer] = [4,5,6,7,...]</pre></li>
--   <li><pre>enumFrom 6 :: [Int] = [6,7,8,9,...,maxBound ::
--   Int]</pre></li>
--   </ul>
enumFrom :: Enum a => a -> [a]

-- | Used in Haskell's translation of <tt>[n,n'..]</tt> with <tt>[n,n'..] =
--   enumFromThen n n'</tt>, a possible implementation being
--   <tt>enumFromThen n n' = n : n' : worker (f x) (f x n')</tt>,
--   <tt>worker s v = v : worker s (s v)</tt>, <tt>x = fromEnum n' -
--   fromEnum n</tt> and <tt>f n y | n &gt; 0 = f (n - 1) (succ y) | n &lt;
--   0 = f (n + 1) (pred y) | otherwise = y</tt> For example:
--   
--   <ul>
--   <li><pre>enumFromThen 4 6 :: [Integer] = [4,6,8,10...]</pre></li>
--   <li><pre>enumFromThen 6 2 :: [Int] = [6,2,-2,-6,...,minBound ::
--   Int]</pre></li>
--   </ul>
enumFromThen :: Enum a => a -> a -> [a]

-- | Used in Haskell's translation of <tt>[n..m]</tt> with <tt>[n..m] =
--   enumFromTo n m</tt>, a possible implementation being <tt>enumFromTo n
--   m | n &lt;= m = n : enumFromTo (succ n) m | otherwise = []</tt>. For
--   example:
--   
--   <ul>
--   <li><pre>enumFromTo 6 10 :: [Int] = [6,7,8,9,10]</pre></li>
--   <li><pre>enumFromTo 42 1 :: [Integer] = []</pre></li>
--   </ul>
enumFromTo :: Enum a => a -> a -> [a]

-- | Used in Haskell's translation of <tt>[n,n'..m]</tt> with <tt>[n,n'..m]
--   = enumFromThenTo n n' m</tt>, a possible implementation being
--   <tt>enumFromThenTo n n' m = worker (f x) (c x) n m</tt>, <tt>x =
--   fromEnum n' - fromEnum n</tt>, <tt>c x = bool (&gt;=) (<a>(x</a>
--   0)</tt> <tt>f n y | n &gt; 0 = f (n - 1) (succ y) | n &lt; 0 = f (n +
--   1) (pred y) | otherwise = y</tt> and <tt>worker s c v m | c v m = v :
--   worker s c (s v) m | otherwise = []</tt> For example:
--   
--   <ul>
--   <li><pre>enumFromThenTo 4 2 -6 :: [Integer] =
--   [4,2,0,-2,-4,-6]</pre></li>
--   <li><pre>enumFromThenTo 6 8 2 :: [Int] = []</pre></li>
--   </ul>
enumFromThenTo :: Enum a => a -> a -> a -> [a]

-- | The <a>Eq</a> class defines equality (<a>==</a>) and inequality
--   (<a>/=</a>). All the basic datatypes exported by the <a>Prelude</a>
--   are instances of <a>Eq</a>, and <a>Eq</a> may be derived for any
--   datatype whose constituents are also instances of <a>Eq</a>.
--   
--   The Haskell Report defines no laws for <a>Eq</a>. However, <a>==</a>
--   is customarily expected to implement an equivalence relationship where
--   two values comparing equal are indistinguishable by "public"
--   functions, with a "public" function being one not allowing to see
--   implementation details. For example, for a type representing
--   non-normalised natural numbers modulo 100, a "public" function doesn't
--   make the difference between 1 and 201. It is expected to have the
--   following properties:
--   
--   <ul>
--   <li><i><b>Reflexivity</b></i> <tt>x == x</tt> = <a>True</a></li>
--   <li><i><b>Symmetry</b></i> <tt>x == y</tt> = <tt>y == x</tt></li>
--   <li><i><b>Transitivity</b></i> if <tt>x == y &amp;&amp; y == z</tt> =
--   <a>True</a>, then <tt>x == z</tt> = <a>True</a></li>
--   <li><i><b>Substitutivity</b></i> if <tt>x == y</tt> = <a>True</a> and
--   <tt>f</tt> is a "public" function whose return type is an instance of
--   <a>Eq</a>, then <tt>f x == f y</tt> = <a>True</a></li>
--   <li><i><b>Negation</b></i> <tt>x /= y</tt> = <tt>not (x ==
--   y)</tt></li>
--   </ul>
--   
--   Minimal complete definition: either <a>==</a> or <a>/=</a>.
class Eq a
(==) :: Eq a => a -> a -> Bool
(/=) :: Eq a => a -> a -> Bool
infix 4 ==
infix 4 /=

-- | Trigonometric and hyperbolic functions and related functions.
--   
--   The Haskell Report defines no laws for <a>Floating</a>. However,
--   <tt>(<a>+</a>)</tt>, <tt>(<a>*</a>)</tt> and <a>exp</a> are
--   customarily expected to define an exponential field and have the
--   following properties:
--   
--   <ul>
--   <li><tt>exp (a + b)</tt> = <tt>exp a * exp b</tt></li>
--   <li><tt>exp (fromInteger 0)</tt> = <tt>fromInteger 1</tt></li>
--   </ul>
class Fractional a => Floating a
pi :: Floating a => a
log :: Floating a => a -> a
sqrt :: Floating a => a -> a
(**) :: Floating a => a -> a -> a
logBase :: Floating a => a -> a -> a
sin :: Floating a => a -> a
cos :: Floating a => a -> a
tan :: Floating a => a -> a
asin :: Floating a => a -> a
acos :: Floating a => a -> a
atan :: Floating a => a -> a
sinh :: Floating a => a -> a
cosh :: Floating a => a -> a
tanh :: Floating a => a -> a
asinh :: Floating a => a -> a
acosh :: Floating a => a -> a
atanh :: Floating a => a -> a
infixr 8 **

-- | Fractional numbers, supporting real division.
--   
--   The Haskell Report defines no laws for <a>Fractional</a>. However,
--   <tt>(<a>+</a>)</tt> and <tt>(<a>*</a>)</tt> are customarily expected
--   to define a division ring and have the following properties:
--   
--   <ul>
--   <li><i><b><a>recip</a> gives the multiplicative inverse</b></i> <tt>x
--   * recip x</tt> = <tt>recip x * x</tt> = <tt>fromInteger 1</tt></li>
--   </ul>
--   
--   Note that it <i>isn't</i> customarily expected that a type instance of
--   <a>Fractional</a> implement a field. However, all instances in
--   <tt>base</tt> do.
class Num a => Fractional a

-- | Fractional division.
(/) :: Fractional a => a -> a -> a

-- | Reciprocal fraction.
recip :: Fractional a => a -> a

-- | Conversion from a <a>Rational</a> (that is <tt><a>Ratio</a>
--   <a>Integer</a></tt>). A floating literal stands for an application of
--   <a>fromRational</a> to a value of type <a>Rational</a>, so such
--   literals have type <tt>(<a>Fractional</a> a) =&gt; a</tt>.
fromRational :: Fractional a => Rational -> a
infixl 7 /

-- | Integral numbers, supporting integer division.
--   
--   The Haskell Report defines no laws for <a>Integral</a>. However,
--   <a>Integral</a> instances are customarily expected to define a
--   Euclidean domain and have the following properties for the
--   <a>div</a>/<a>mod</a> and <a>quot</a>/<a>rem</a> pairs, given suitable
--   Euclidean functions <tt>f</tt> and <tt>g</tt>:
--   
--   <ul>
--   <li><tt>x</tt> = <tt>y * quot x y + rem x y</tt> with <tt>rem x y</tt>
--   = <tt>fromInteger 0</tt> or <tt>g (rem x y)</tt> &lt; <tt>g
--   y</tt></li>
--   <li><tt>x</tt> = <tt>y * div x y + mod x y</tt> with <tt>mod x y</tt>
--   = <tt>fromInteger 0</tt> or <tt>f (mod x y)</tt> &lt; <tt>f
--   y</tt></li>
--   </ul>
--   
--   An example of a suitable Euclidean function, for <a>Integer</a>'s
--   instance, is <a>abs</a>.
class (Real a, Enum a) => Integral a

-- | integer division truncated toward zero
quot :: Integral a => a -> a -> a

-- | integer remainder, satisfying
--   
--   <pre>
--   (x `quot` y)*y + (x `rem` y) == x
--   </pre>
rem :: Integral a => a -> a -> a

-- | integer division truncated toward negative infinity
div :: Integral a => a -> a -> a

-- | integer modulus, satisfying
--   
--   <pre>
--   (x `div` y)*y + (x `mod` y) == x
--   </pre>
mod :: Integral a => a -> a -> a

-- | simultaneous <a>quot</a> and <a>rem</a>
quotRem :: Integral a => a -> a -> (a, a)

-- | simultaneous <a>div</a> and <a>mod</a>
divMod :: Integral a => a -> a -> (a, a)

-- | conversion to <a>Integer</a>
toInteger :: Integral a => a -> Integer
infixl 7 `mod`
infixl 7 `div`
infixl 7 `rem`
infixl 7 `quot`

-- | The <a>Monad</a> class defines the basic operations over a
--   <i>monad</i>, a concept from a branch of mathematics known as
--   <i>category theory</i>. From the perspective of a Haskell programmer,
--   however, it is best to think of a monad as an <i>abstract datatype</i>
--   of actions. Haskell's <tt>do</tt> expressions provide a convenient
--   syntax for writing monadic expressions.
--   
--   Instances of <a>Monad</a> should satisfy the following:
--   
--   <ul>
--   <li><i>Left identity</i> <tt><a>return</a> a <a>&gt;&gt;=</a> k = k
--   a</tt></li>
--   <li><i>Right identity</i> <tt>m <a>&gt;&gt;=</a> <a>return</a> =
--   m</tt></li>
--   <li><i>Associativity</i> <tt>m <a>&gt;&gt;=</a> (\x -&gt; k x
--   <a>&gt;&gt;=</a> h) = (m <a>&gt;&gt;=</a> k) <a>&gt;&gt;=</a>
--   h</tt></li>
--   </ul>
--   
--   Furthermore, the <a>Monad</a> and <a>Applicative</a> operations should
--   relate as follows:
--   
--   <ul>
--   <li><pre><a>pure</a> = <a>return</a></pre></li>
--   <li><pre>m1 <a>&lt;*&gt;</a> m2 = m1 <a>&gt;&gt;=</a> (x1 -&gt; m2
--   <a>&gt;&gt;=</a> (x2 -&gt; <a>return</a> (x1 x2)))</pre></li>
--   </ul>
--   
--   The above laws imply:
--   
--   <ul>
--   <li><pre><a>fmap</a> f xs = xs <a>&gt;&gt;=</a> <a>return</a> .
--   f</pre></li>
--   <li><pre>(<a>&gt;&gt;</a>) = (<a>*&gt;</a>)</pre></li>
--   </ul>
--   
--   and that <a>pure</a> and (<a>&lt;*&gt;</a>) satisfy the applicative
--   functor laws.
--   
--   The instances of <a>Monad</a> for lists, <a>Maybe</a> and <a>IO</a>
--   defined in the <a>Prelude</a> satisfy these laws.
class Applicative m => Monad (m :: Type -> Type)

-- | Sequentially compose two actions, passing any value produced by the
--   first as an argument to the second.
--   
--   '<tt>as <a>&gt;&gt;=</a> bs</tt>' can be understood as the <tt>do</tt>
--   expression
--   
--   <pre>
--   do a &lt;- as
--      bs a
--   </pre>
(>>=) :: Monad m => m a -> (a -> m b) -> m b

-- | Sequentially compose two actions, discarding any value produced by the
--   first, like sequencing operators (such as the semicolon) in imperative
--   languages.
--   
--   '<tt>as <a>&gt;&gt;</a> bs</tt>' can be understood as the <tt>do</tt>
--   expression
--   
--   <pre>
--   do as
--      bs
--   </pre>
(>>) :: Monad m => m a -> m b -> m b

-- | Inject a value into the monadic type.
return :: Monad m => a -> m a
infixl 1 >>=
infixl 1 >>

-- | A type <tt>f</tt> is a Functor if it provides a function <tt>fmap</tt>
--   which, given any types <tt>a</tt> and <tt>b</tt> lets you apply any
--   function from <tt>(a -&gt; b)</tt> to turn an <tt>f a</tt> into an
--   <tt>f b</tt>, preserving the structure of <tt>f</tt>. Furthermore
--   <tt>f</tt> needs to adhere to the following:
--   
--   <ul>
--   <li><i>Identity</i> <tt><a>fmap</a> <a>id</a> == <a>id</a></tt></li>
--   <li><i>Composition</i> <tt><a>fmap</a> (f . g) == <a>fmap</a> f .
--   <a>fmap</a> g</tt></li>
--   </ul>
--   
--   Note, that the second law follows from the free theorem of the type
--   <a>fmap</a> and the first law, so you need only check that the former
--   condition holds.
class Functor (f :: Type -> Type)

-- | Using <tt>ApplicativeDo</tt>: '<tt><a>fmap</a> f as</tt>' can be
--   understood as the <tt>do</tt> expression
--   
--   <pre>
--   do a &lt;- as
--      pure (f a)
--   </pre>
--   
--   with an inferred <tt>Functor</tt> constraint.
fmap :: Functor f => (a -> b) -> f a -> f b

-- | Replace all locations in the input with the same value. The default
--   definition is <tt><a>fmap</a> . <a>const</a></tt>, but this may be
--   overridden with a more efficient version.
--   
--   Using <tt>ApplicativeDo</tt>: '<tt>a <a>&lt;$</a> bs</tt>' can be
--   understood as the <tt>do</tt> expression
--   
--   <pre>
--   do bs
--      pure a
--   </pre>
--   
--   with an inferred <tt>Functor</tt> constraint.
(<$) :: Functor f => a -> f b -> f a
infixl 4 <$

-- | Basic numeric class.
--   
--   The Haskell Report defines no laws for <a>Num</a>. However,
--   <tt>(<a>+</a>)</tt> and <tt>(<a>*</a>)</tt> are customarily expected
--   to define a ring and have the following properties:
--   
--   <ul>
--   <li><i><b>Associativity of <tt>(<a>+</a>)</tt></b></i> <tt>(x + y) +
--   z</tt> = <tt>x + (y + z)</tt></li>
--   <li><i><b>Commutativity of <tt>(<a>+</a>)</tt></b></i> <tt>x + y</tt>
--   = <tt>y + x</tt></li>
--   <li><i><b><tt><a>fromInteger</a> 0</tt> is the additive
--   identity</b></i> <tt>x + fromInteger 0</tt> = <tt>x</tt></li>
--   <li><i><b><a>negate</a> gives the additive inverse</b></i> <tt>x +
--   negate x</tt> = <tt>fromInteger 0</tt></li>
--   <li><i><b>Associativity of <tt>(<a>*</a>)</tt></b></i> <tt>(x * y) *
--   z</tt> = <tt>x * (y * z)</tt></li>
--   <li><i><b><tt><a>fromInteger</a> 1</tt> is the multiplicative
--   identity</b></i> <tt>x * fromInteger 1</tt> = <tt>x</tt> and
--   <tt>fromInteger 1 * x</tt> = <tt>x</tt></li>
--   <li><i><b>Distributivity of <tt>(<a>*</a>)</tt> with respect to
--   <tt>(<a>+</a>)</tt></b></i> <tt>a * (b + c)</tt> = <tt>(a * b) + (a *
--   c)</tt> and <tt>(b + c) * a</tt> = <tt>(b * a) + (c * a)</tt></li>
--   </ul>
--   
--   Note that it <i>isn't</i> customarily expected that a type instance of
--   both <a>Num</a> and <a>Ord</a> implement an ordered ring. Indeed, in
--   <tt>base</tt> only <a>Integer</a> and <a>Rational</a> do.
class Num a
(+) :: Num a => a -> a -> a
(-) :: Num a => a -> a -> a
(*) :: Num a => a -> a -> a

-- | Unary negation.
negate :: Num a => a -> a

-- | Absolute value.
abs :: Num a => a -> a

-- | Sign of a number. The functions <a>abs</a> and <a>signum</a> should
--   satisfy the law:
--   
--   <pre>
--   abs x * signum x == x
--   </pre>
--   
--   For real numbers, the <a>signum</a> is either <tt>-1</tt> (negative),
--   <tt>0</tt> (zero) or <tt>1</tt> (positive).
signum :: Num a => a -> a

-- | Conversion from an <a>Integer</a>. An integer literal represents the
--   application of the function <a>fromInteger</a> to the appropriate
--   value of type <a>Integer</a>, so such literals have type
--   <tt>(<a>Num</a> a) =&gt; a</tt>.
fromInteger :: Num a => Integer -> a
infixl 6 -
infixl 6 +
infixl 7 *

-- | The <a>Ord</a> class is used for totally ordered datatypes.
--   
--   Instances of <a>Ord</a> can be derived for any user-defined datatype
--   whose constituent types are in <a>Ord</a>. The declared order of the
--   constructors in the data declaration determines the ordering in
--   derived <a>Ord</a> instances. The <a>Ordering</a> datatype allows a
--   single comparison to determine the precise ordering of two objects.
--   
--   The Haskell Report defines no laws for <a>Ord</a>. However,
--   <a>&lt;=</a> is customarily expected to implement a non-strict partial
--   order and have the following properties:
--   
--   <ul>
--   <li><i><b>Transitivity</b></i> if <tt>x &lt;= y &amp;&amp; y &lt;=
--   z</tt> = <a>True</a>, then <tt>x &lt;= z</tt> = <a>True</a></li>
--   <li><i><b>Reflexivity</b></i> <tt>x &lt;= x</tt> = <a>True</a></li>
--   <li><i><b>Antisymmetry</b></i> if <tt>x &lt;= y &amp;&amp; y &lt;=
--   x</tt> = <a>True</a>, then <tt>x == y</tt> = <a>True</a></li>
--   </ul>
--   
--   Note that the following operator interactions are expected to hold:
--   
--   <ol>
--   <li><tt>x &gt;= y</tt> = <tt>y &lt;= x</tt></li>
--   <li><tt>x &lt; y</tt> = <tt>x &lt;= y &amp;&amp; x /= y</tt></li>
--   <li><tt>x &gt; y</tt> = <tt>y &lt; x</tt></li>
--   <li><tt>x &lt; y</tt> = <tt>compare x y == LT</tt></li>
--   <li><tt>x &gt; y</tt> = <tt>compare x y == GT</tt></li>
--   <li><tt>x == y</tt> = <tt>compare x y == EQ</tt></li>
--   <li><tt>min x y == if x &lt;= y then x else y</tt> = <a>True</a></li>
--   <li><tt>max x y == if x &gt;= y then x else y</tt> = <a>True</a></li>
--   </ol>
--   
--   Note that (7.) and (8.) do <i>not</i> require <a>min</a> and
--   <a>max</a> to return either of their arguments. The result is merely
--   required to <i>equal</i> one of the arguments in terms of <a>(==)</a>.
--   
--   Minimal complete definition: either <a>compare</a> or <a>&lt;=</a>.
--   Using <a>compare</a> can be more efficient for complex types.
class Eq a => Ord a
compare :: Ord a => a -> a -> Ordering
(<) :: Ord a => a -> a -> Bool
(<=) :: Ord a => a -> a -> Bool
(>) :: Ord a => a -> a -> Bool
(>=) :: Ord a => a -> a -> Bool
max :: Ord a => a -> a -> a
min :: Ord a => a -> a -> a
infix 4 <
infix 4 <=
infix 4 >
infix 4 >=

-- | Parsing of <a>String</a>s, producing values.
--   
--   Derived instances of <a>Read</a> make the following assumptions, which
--   derived instances of <a>Show</a> obey:
--   
--   <ul>
--   <li>If the constructor is defined to be an infix operator, then the
--   derived <a>Read</a> instance will parse only infix applications of the
--   constructor (not the prefix form).</li>
--   <li>Associativity is not used to reduce the occurrence of parentheses,
--   although precedence may be.</li>
--   <li>If the constructor is defined using record syntax, the derived
--   <a>Read</a> will parse only the record-syntax form, and furthermore,
--   the fields must be given in the same order as the original
--   declaration.</li>
--   <li>The derived <a>Read</a> instance allows arbitrary Haskell
--   whitespace between tokens of the input string. Extra parentheses are
--   also allowed.</li>
--   </ul>
--   
--   For example, given the declarations
--   
--   <pre>
--   infixr 5 :^:
--   data Tree a =  Leaf a  |  Tree a :^: Tree a
--   </pre>
--   
--   the derived instance of <a>Read</a> in Haskell 2010 is equivalent to
--   
--   <pre>
--   instance (Read a) =&gt; Read (Tree a) where
--   
--           readsPrec d r =  readParen (d &gt; app_prec)
--                            (\r -&gt; [(Leaf m,t) |
--                                    ("Leaf",s) &lt;- lex r,
--                                    (m,t) &lt;- readsPrec (app_prec+1) s]) r
--   
--                         ++ readParen (d &gt; up_prec)
--                            (\r -&gt; [(u:^:v,w) |
--                                    (u,s) &lt;- readsPrec (up_prec+1) r,
--                                    (":^:",t) &lt;- lex s,
--                                    (v,w) &lt;- readsPrec (up_prec+1) t]) r
--   
--             where app_prec = 10
--                   up_prec = 5
--   </pre>
--   
--   Note that right-associativity of <tt>:^:</tt> is unused.
--   
--   The derived instance in GHC is equivalent to
--   
--   <pre>
--   instance (Read a) =&gt; Read (Tree a) where
--   
--           readPrec = parens $ (prec app_prec $ do
--                                    Ident "Leaf" &lt;- lexP
--                                    m &lt;- step readPrec
--                                    return (Leaf m))
--   
--                        +++ (prec up_prec $ do
--                                    u &lt;- step readPrec
--                                    Symbol ":^:" &lt;- lexP
--                                    v &lt;- step readPrec
--                                    return (u :^: v))
--   
--             where app_prec = 10
--                   up_prec = 5
--   
--           readListPrec = readListPrecDefault
--   </pre>
--   
--   Why do both <a>readsPrec</a> and <a>readPrec</a> exist, and why does
--   GHC opt to implement <a>readPrec</a> in derived <a>Read</a> instances
--   instead of <a>readsPrec</a>? The reason is that <a>readsPrec</a> is
--   based on the <a>ReadS</a> type, and although <a>ReadS</a> is mentioned
--   in the Haskell 2010 Report, it is not a very efficient parser data
--   structure.
--   
--   <a>readPrec</a>, on the other hand, is based on a much more efficient
--   <a>ReadPrec</a> datatype (a.k.a "new-style parsers"), but its
--   definition relies on the use of the <tt>RankNTypes</tt> language
--   extension. Therefore, <a>readPrec</a> (and its cousin,
--   <a>readListPrec</a>) are marked as GHC-only. Nevertheless, it is
--   recommended to use <a>readPrec</a> instead of <a>readsPrec</a>
--   whenever possible for the efficiency improvements it brings.
--   
--   As mentioned above, derived <a>Read</a> instances in GHC will
--   implement <a>readPrec</a> instead of <a>readsPrec</a>. The default
--   implementations of <a>readsPrec</a> (and its cousin, <a>readList</a>)
--   will simply use <a>readPrec</a> under the hood. If you are writing a
--   <a>Read</a> instance by hand, it is recommended to write it like so:
--   
--   <pre>
--   instance <a>Read</a> T where
--     <a>readPrec</a>     = ...
--     <a>readListPrec</a> = <a>readListPrecDefault</a>
--   </pre>
class Read a

-- | attempts to parse a value from the front of the string, returning a
--   list of (parsed value, remaining string) pairs. If there is no
--   successful parse, the returned list is empty.
--   
--   Derived instances of <a>Read</a> and <a>Show</a> satisfy the
--   following:
--   
--   <ul>
--   <li><tt>(x,"")</tt> is an element of <tt>(<a>readsPrec</a> d
--   (<a>showsPrec</a> d x ""))</tt>.</li>
--   </ul>
--   
--   That is, <a>readsPrec</a> parses the string produced by
--   <a>showsPrec</a>, and delivers the value that <a>showsPrec</a> started
--   with.
readsPrec :: Read a => Int -> ReadS a

-- | The method <a>readList</a> is provided to allow the programmer to give
--   a specialised way of parsing lists of values. For example, this is
--   used by the predefined <a>Read</a> instance of the <a>Char</a> type,
--   where values of type <a>String</a> should be are expected to use
--   double quotes, rather than square brackets.
readList :: Read a => ReadS [a]
class (Num a, Ord a) => Real a

-- | the rational equivalent of its real argument with full precision
toRational :: Real a => a -> Rational

-- | Efficient, machine-independent access to the components of a
--   floating-point number.
class (RealFrac a, Floating a) => RealFloat a

-- | a constant function, returning the radix of the representation (often
--   <tt>2</tt>)
floatRadix :: RealFloat a => a -> Integer

-- | a constant function, returning the number of digits of
--   <a>floatRadix</a> in the significand
floatDigits :: RealFloat a => a -> Int

-- | a constant function, returning the lowest and highest values the
--   exponent may assume
floatRange :: RealFloat a => a -> (Int, Int)

-- | The function <a>decodeFloat</a> applied to a real floating-point
--   number returns the significand expressed as an <a>Integer</a> and an
--   appropriately scaled exponent (an <a>Int</a>). If
--   <tt><a>decodeFloat</a> x</tt> yields <tt>(m,n)</tt>, then <tt>x</tt>
--   is equal in value to <tt>m*b^^n</tt>, where <tt>b</tt> is the
--   floating-point radix, and furthermore, either <tt>m</tt> and
--   <tt>n</tt> are both zero or else <tt>b^(d-1) &lt;= <a>abs</a> m &lt;
--   b^d</tt>, where <tt>d</tt> is the value of <tt><a>floatDigits</a>
--   x</tt>. In particular, <tt><a>decodeFloat</a> 0 = (0,0)</tt>. If the
--   type contains a negative zero, also <tt><a>decodeFloat</a> (-0.0) =
--   (0,0)</tt>. <i>The result of</i> <tt><a>decodeFloat</a> x</tt> <i>is
--   unspecified if either of</i> <tt><a>isNaN</a> x</tt> <i>or</i>
--   <tt><a>isInfinite</a> x</tt> <i>is</i> <a>True</a>.
decodeFloat :: RealFloat a => a -> (Integer, Int)

-- | <a>encodeFloat</a> performs the inverse of <a>decodeFloat</a> in the
--   sense that for finite <tt>x</tt> with the exception of <tt>-0.0</tt>,
--   <tt><a>uncurry</a> <a>encodeFloat</a> (<a>decodeFloat</a> x) = x</tt>.
--   <tt><a>encodeFloat</a> m n</tt> is one of the two closest
--   representable floating-point numbers to <tt>m*b^^n</tt> (or
--   <tt>±Infinity</tt> if overflow occurs); usually the closer, but if
--   <tt>m</tt> contains too many bits, the result may be rounded in the
--   wrong direction.
encodeFloat :: RealFloat a => Integer -> Int -> a

-- | <a>exponent</a> corresponds to the second component of
--   <a>decodeFloat</a>. <tt><a>exponent</a> 0 = 0</tt> and for finite
--   nonzero <tt>x</tt>, <tt><a>exponent</a> x = snd (<a>decodeFloat</a> x)
--   + <a>floatDigits</a> x</tt>. If <tt>x</tt> is a finite floating-point
--   number, it is equal in value to <tt><a>significand</a> x * b ^^
--   <a>exponent</a> x</tt>, where <tt>b</tt> is the floating-point radix.
--   The behaviour is unspecified on infinite or <tt>NaN</tt> values.
exponent :: RealFloat a => a -> Int

-- | The first component of <a>decodeFloat</a>, scaled to lie in the open
--   interval (<tt>-1</tt>,<tt>1</tt>), either <tt>0.0</tt> or of absolute
--   value <tt>&gt;= 1/b</tt>, where <tt>b</tt> is the floating-point
--   radix. The behaviour is unspecified on infinite or <tt>NaN</tt>
--   values.
significand :: RealFloat a => a -> a

-- | multiplies a floating-point number by an integer power of the radix
scaleFloat :: RealFloat a => Int -> a -> a

-- | <a>True</a> if the argument is an IEEE "not-a-number" (NaN) value
isNaN :: RealFloat a => a -> Bool

-- | <a>True</a> if the argument is an IEEE infinity or negative infinity
isInfinite :: RealFloat a => a -> Bool

-- | <a>True</a> if the argument is too small to be represented in
--   normalized format
isDenormalized :: RealFloat a => a -> Bool

-- | <a>True</a> if the argument is an IEEE negative zero
isNegativeZero :: RealFloat a => a -> Bool

-- | <a>True</a> if the argument is an IEEE floating point number
isIEEE :: RealFloat a => a -> Bool

-- | a version of arctangent taking two real floating-point arguments. For
--   real floating <tt>x</tt> and <tt>y</tt>, <tt><a>atan2</a> y x</tt>
--   computes the angle (from the positive x-axis) of the vector from the
--   origin to the point <tt>(x,y)</tt>. <tt><a>atan2</a> y x</tt> returns
--   a value in the range [<tt>-pi</tt>, <tt>pi</tt>]. It follows the
--   Common Lisp semantics for the origin when signed zeroes are supported.
--   <tt><a>atan2</a> y 1</tt>, with <tt>y</tt> in a type that is
--   <a>RealFloat</a>, should return the same value as <tt><a>atan</a>
--   y</tt>. A default definition of <a>atan2</a> is provided, but
--   implementors can provide a more accurate implementation.
atan2 :: RealFloat a => a -> a -> a

-- | Extracting components of fractions.
class (Real a, Fractional a) => RealFrac a

-- | The function <a>properFraction</a> takes a real fractional number
--   <tt>x</tt> and returns a pair <tt>(n,f)</tt> such that <tt>x =
--   n+f</tt>, and:
--   
--   <ul>
--   <li><tt>n</tt> is an integral number with the same sign as <tt>x</tt>;
--   and</li>
--   <li><tt>f</tt> is a fraction with the same type and sign as
--   <tt>x</tt>, and with absolute value less than <tt>1</tt>.</li>
--   </ul>
--   
--   The default definitions of the <a>ceiling</a>, <a>floor</a>,
--   <a>truncate</a> and <a>round</a> functions are in terms of
--   <a>properFraction</a>.
properFraction :: (RealFrac a, Integral b) => a -> (b, a)

-- | <tt><a>truncate</a> x</tt> returns the integer nearest <tt>x</tt>
--   between zero and <tt>x</tt>
truncate :: (RealFrac a, Integral b) => a -> b

-- | <tt><a>round</a> x</tt> returns the nearest integer to <tt>x</tt>; the
--   even integer if <tt>x</tt> is equidistant between two integers
round :: (RealFrac a, Integral b) => a -> b

-- | <tt><a>ceiling</a> x</tt> returns the least integer not less than
--   <tt>x</tt>
ceiling :: (RealFrac a, Integral b) => a -> b

-- | <tt><a>floor</a> x</tt> returns the greatest integer not greater than
--   <tt>x</tt>
floor :: (RealFrac a, Integral b) => a -> b

-- | Conversion of values to readable <a>String</a>s.
--   
--   Derived instances of <a>Show</a> have the following properties, which
--   are compatible with derived instances of <a>Read</a>:
--   
--   <ul>
--   <li>The result of <a>show</a> is a syntactically correct Haskell
--   expression containing only constants, given the fixity declarations in
--   force at the point where the type is declared. It contains only the
--   constructor names defined in the data type, parentheses, and spaces.
--   When labelled constructor fields are used, braces, commas, field
--   names, and equal signs are also used.</li>
--   <li>If the constructor is defined to be an infix operator, then
--   <a>showsPrec</a> will produce infix applications of the
--   constructor.</li>
--   <li>the representation will be enclosed in parentheses if the
--   precedence of the top-level constructor in <tt>x</tt> is less than
--   <tt>d</tt> (associativity is ignored). Thus, if <tt>d</tt> is
--   <tt>0</tt> then the result is never surrounded in parentheses; if
--   <tt>d</tt> is <tt>11</tt> it is always surrounded in parentheses,
--   unless it is an atomic expression.</li>
--   <li>If the constructor is defined using record syntax, then
--   <a>show</a> will produce the record-syntax form, with the fields given
--   in the same order as the original declaration.</li>
--   </ul>
--   
--   For example, given the declarations
--   
--   <pre>
--   infixr 5 :^:
--   data Tree a =  Leaf a  |  Tree a :^: Tree a
--   </pre>
--   
--   the derived instance of <a>Show</a> is equivalent to
--   
--   <pre>
--   instance (Show a) =&gt; Show (Tree a) where
--   
--          showsPrec d (Leaf m) = showParen (d &gt; app_prec) $
--               showString "Leaf " . showsPrec (app_prec+1) m
--            where app_prec = 10
--   
--          showsPrec d (u :^: v) = showParen (d &gt; up_prec) $
--               showsPrec (up_prec+1) u .
--               showString " :^: "      .
--               showsPrec (up_prec+1) v
--            where up_prec = 5
--   </pre>
--   
--   Note that right-associativity of <tt>:^:</tt> is ignored. For example,
--   
--   <ul>
--   <li><tt><a>show</a> (Leaf 1 :^: Leaf 2 :^: Leaf 3)</tt> produces the
--   string <tt>"Leaf 1 :^: (Leaf 2 :^: Leaf 3)"</tt>.</li>
--   </ul>
class Show a

-- | Convert a value to a readable <a>String</a>.
--   
--   <a>showsPrec</a> should satisfy the law
--   
--   <pre>
--   showsPrec d x r ++ s  ==  showsPrec d x (r ++ s)
--   </pre>
--   
--   Derived instances of <a>Read</a> and <a>Show</a> satisfy the
--   following:
--   
--   <ul>
--   <li><tt>(x,"")</tt> is an element of <tt>(<a>readsPrec</a> d
--   (<a>showsPrec</a> d x ""))</tt>.</li>
--   </ul>
--   
--   That is, <a>readsPrec</a> parses the string produced by
--   <a>showsPrec</a>, and delivers the value that <a>showsPrec</a> started
--   with.
showsPrec :: Show a => Int -> a -> ShowS

-- | A specialised variant of <a>showsPrec</a>, using precedence context
--   zero, and returning an ordinary <a>String</a>.
show :: Show a => a -> String

-- | The method <a>showList</a> is provided to allow the programmer to give
--   a specialised way of showing lists of values. For example, this is
--   used by the predefined <a>Show</a> instance of the <a>Char</a> type,
--   where values of type <a>String</a> should be shown in double quotes,
--   rather than between square brackets.
showList :: Show a => [a] -> ShowS

-- | When a value is bound in <tt>do</tt>-notation, the pattern on the left
--   hand side of <tt>&lt;-</tt> might not match. In this case, this class
--   provides a function to recover.
--   
--   A <a>Monad</a> without a <a>MonadFail</a> instance may only be used in
--   conjunction with pattern that always match, such as newtypes, tuples,
--   data types with only a single data constructor, and irrefutable
--   patterns (<tt>~pat</tt>).
--   
--   Instances of <a>MonadFail</a> should satisfy the following law:
--   <tt>fail s</tt> should be a left zero for <a>&gt;&gt;=</a>,
--   
--   <pre>
--   fail s &gt;&gt;= f  =  fail s
--   </pre>
--   
--   If your <a>Monad</a> is also <a>MonadPlus</a>, a popular definition is
--   
--   <pre>
--   fail _ = mzero
--   </pre>
class Monad m => MonadFail (m :: Type -> Type)
fail :: MonadFail m => String -> m a

-- | A functor with application, providing operations to
--   
--   <ul>
--   <li>embed pure expressions (<a>pure</a>), and</li>
--   <li>sequence computations and combine their results (<a>&lt;*&gt;</a>
--   and <a>liftA2</a>).</li>
--   </ul>
--   
--   A minimal complete definition must include implementations of
--   <a>pure</a> and of either <a>&lt;*&gt;</a> or <a>liftA2</a>. If it
--   defines both, then they must behave the same as their default
--   definitions:
--   
--   <pre>
--   (<a>&lt;*&gt;</a>) = <a>liftA2</a> <a>id</a>
--   </pre>
--   
--   <pre>
--   <a>liftA2</a> f x y = f <a>&lt;$&gt;</a> x <a>&lt;*&gt;</a> y
--   </pre>
--   
--   Further, any definition must satisfy the following:
--   
--   <ul>
--   <li><i>Identity</i> <pre><a>pure</a> <a>id</a> <a>&lt;*&gt;</a> v =
--   v</pre></li>
--   <li><i>Composition</i> <pre><a>pure</a> (.) <a>&lt;*&gt;</a> u
--   <a>&lt;*&gt;</a> v <a>&lt;*&gt;</a> w = u <a>&lt;*&gt;</a> (v
--   <a>&lt;*&gt;</a> w)</pre></li>
--   <li><i>Homomorphism</i> <pre><a>pure</a> f <a>&lt;*&gt;</a>
--   <a>pure</a> x = <a>pure</a> (f x)</pre></li>
--   <li><i>Interchange</i> <pre>u <a>&lt;*&gt;</a> <a>pure</a> y =
--   <a>pure</a> (<a>$</a> y) <a>&lt;*&gt;</a> u</pre></li>
--   </ul>
--   
--   The other methods have the following default definitions, which may be
--   overridden with equivalent specialized implementations:
--   
--   <ul>
--   <li><pre>u <a>*&gt;</a> v = (<a>id</a> <a>&lt;$</a> u)
--   <a>&lt;*&gt;</a> v</pre></li>
--   <li><pre>u <a>&lt;*</a> v = <a>liftA2</a> <a>const</a> u v</pre></li>
--   </ul>
--   
--   As a consequence of these laws, the <a>Functor</a> instance for
--   <tt>f</tt> will satisfy
--   
--   <ul>
--   <li><pre><a>fmap</a> f x = <a>pure</a> f <a>&lt;*&gt;</a> x</pre></li>
--   </ul>
--   
--   It may be useful to note that supposing
--   
--   <pre>
--   forall x y. p (q x y) = f x . g y
--   </pre>
--   
--   it follows from the above that
--   
--   <pre>
--   <a>liftA2</a> p (<a>liftA2</a> q u v) = <a>liftA2</a> f u . <a>liftA2</a> g v
--   </pre>
--   
--   If <tt>f</tt> is also a <a>Monad</a>, it should satisfy
--   
--   <ul>
--   <li><pre><a>pure</a> = <a>return</a></pre></li>
--   <li><pre>m1 <a>&lt;*&gt;</a> m2 = m1 <a>&gt;&gt;=</a> (x1 -&gt; m2
--   <a>&gt;&gt;=</a> (x2 -&gt; <a>return</a> (x1 x2)))</pre></li>
--   <li><pre>(<a>*&gt;</a>) = (<a>&gt;&gt;</a>)</pre></li>
--   </ul>
--   
--   (which implies that <a>pure</a> and <a>&lt;*&gt;</a> satisfy the
--   applicative functor laws).
class Functor f => Applicative (f :: Type -> Type)

-- | Lift a value.
pure :: Applicative f => a -> f a

-- | Sequential application.
--   
--   A few functors support an implementation of <a>&lt;*&gt;</a> that is
--   more efficient than the default one.
--   
--   Using <tt>ApplicativeDo</tt>: '<tt>fs <a>&lt;*&gt;</a> as</tt>' can be
--   understood as the <tt>do</tt> expression
--   
--   <pre>
--   do f &lt;- fs
--      a &lt;- as
--      pure (f a)
--   </pre>
(<*>) :: Applicative f => f (a -> b) -> f a -> f b

-- | Sequence actions, discarding the value of the first argument.
--   
--   '<tt>as <a>*&gt;</a> bs</tt>' can be understood as the <tt>do</tt>
--   expression
--   
--   <pre>
--   do as
--      bs
--   </pre>
--   
--   This is a tad complicated for our <tt>ApplicativeDo</tt> extension
--   which will give it a <tt>Monad</tt> constraint. For an
--   <tt>Applicative</tt> constraint we write it of the form
--   
--   <pre>
--   do _ &lt;- as
--      b &lt;- bs
--      pure b
--   </pre>
(*>) :: Applicative f => f a -> f b -> f b

-- | Sequence actions, discarding the value of the second argument.
--   
--   Using <tt>ApplicativeDo</tt>: '<tt>as <a>&lt;*</a> bs</tt>' can be
--   understood as the <tt>do</tt> expression
--   
--   <pre>
--   do a &lt;- as
--      bs
--      pure a
--   </pre>
(<*) :: Applicative f => f a -> f b -> f a
infixl 4 <*
infixl 4 *>
infixl 4 <*>

-- | Data structures that can be folded.
--   
--   For example, given a data type
--   
--   <pre>
--   data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)
--   </pre>
--   
--   a suitable instance would be
--   
--   <pre>
--   instance Foldable Tree where
--      foldMap f Empty = mempty
--      foldMap f (Leaf x) = f x
--      foldMap f (Node l k r) = foldMap f l `mappend` f k `mappend` foldMap f r
--   </pre>
--   
--   This is suitable even for abstract types, as the monoid is assumed to
--   satisfy the monoid laws. Alternatively, one could define
--   <tt>foldr</tt>:
--   
--   <pre>
--   instance Foldable Tree where
--      foldr f z Empty = z
--      foldr f z (Leaf x) = f x z
--      foldr f z (Node l k r) = foldr f (f k (foldr f z r)) l
--   </pre>
--   
--   <tt>Foldable</tt> instances are expected to satisfy the following
--   laws:
--   
--   <pre>
--   foldr f z t = appEndo (foldMap (Endo . f) t ) z
--   </pre>
--   
--   <pre>
--   foldl f z t = appEndo (getDual (foldMap (Dual . Endo . flip f) t)) z
--   </pre>
--   
--   <pre>
--   fold = foldMap id
--   </pre>
--   
--   <pre>
--   length = getSum . foldMap (Sum . const  1)
--   </pre>
--   
--   <tt>sum</tt>, <tt>product</tt>, <tt>maximum</tt>, and <tt>minimum</tt>
--   should all be essentially equivalent to <tt>foldMap</tt> forms, such
--   as
--   
--   <pre>
--   sum = getSum . foldMap Sum
--   </pre>
--   
--   but may be less defined.
--   
--   If the type is also a <a>Functor</a> instance, it should satisfy
--   
--   <pre>
--   foldMap f = fold . fmap f
--   </pre>
--   
--   which implies that
--   
--   <pre>
--   foldMap f . fmap g = foldMap (f . g)
--   </pre>
class Foldable (t :: Type -> Type)

-- | Map each element of the structure to a monoid, and combine the
--   results.
foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m

-- | Right-associative fold of a structure.
--   
--   In the case of lists, <a>foldr</a>, when applied to a binary operator,
--   a starting value (typically the right-identity of the operator), and a
--   list, reduces the list using the binary operator, from right to left:
--   
--   <pre>
--   foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)
--   </pre>
--   
--   Note that, since the head of the resulting expression is produced by
--   an application of the operator to the first element of the list,
--   <a>foldr</a> can produce a terminating expression from an infinite
--   list.
--   
--   For a general <a>Foldable</a> structure this should be semantically
--   identical to,
--   
--   <pre>
--   foldr f z = <a>foldr</a> f z . <a>toList</a>
--   </pre>
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b

-- | Left-associative fold of a structure.
--   
--   In the case of lists, <a>foldl</a>, when applied to a binary operator,
--   a starting value (typically the left-identity of the operator), and a
--   list, reduces the list using the binary operator, from left to right:
--   
--   <pre>
--   foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn
--   </pre>
--   
--   Note that to produce the outermost application of the operator the
--   entire input list must be traversed. This means that <a>foldl'</a>
--   will diverge if given an infinite list.
--   
--   Also note that if you want an efficient left-fold, you probably want
--   to use <a>foldl'</a> instead of <a>foldl</a>. The reason for this is
--   that latter does not force the "inner" results (e.g. <tt>z `f` x1</tt>
--   in the above example) before applying them to the operator (e.g. to
--   <tt>(`f` x2)</tt>). This results in a thunk chain &lt;math&gt;
--   elements long, which then must be evaluated from the outside-in.
--   
--   For a general <a>Foldable</a> structure this should be semantically
--   identical to,
--   
--   <pre>
--   foldl f z = <a>foldl</a> f z . <a>toList</a>
--   </pre>
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b

-- | A variant of <a>foldr</a> that has no base case, and thus may only be
--   applied to non-empty structures.
--   
--   <pre>
--   <a>foldr1</a> f = <a>foldr1</a> f . <a>toList</a>
--   </pre>
foldr1 :: Foldable t => (a -> a -> a) -> t a -> a

-- | A variant of <a>foldl</a> that has no base case, and thus may only be
--   applied to non-empty structures.
--   
--   <pre>
--   <a>foldl1</a> f = <a>foldl1</a> f . <a>toList</a>
--   </pre>
foldl1 :: Foldable t => (a -> a -> a) -> t a -> a

-- | Test whether the structure is empty. The default implementation is
--   optimized for structures that are similar to cons-lists, because there
--   is no general way to do better.
null :: Foldable t => t a -> Bool

-- | Returns the size/length of a finite structure as an <a>Int</a>. The
--   default implementation is optimized for structures that are similar to
--   cons-lists, because there is no general way to do better.
length :: Foldable t => t a -> Int

-- | Does the element occur in the structure?
elem :: (Foldable t, Eq a) => a -> t a -> Bool

-- | The largest element of a non-empty structure.
maximum :: (Foldable t, Ord a) => t a -> a

-- | The least element of a non-empty structure.
minimum :: (Foldable t, Ord a) => t a -> a

-- | The <a>sum</a> function computes the sum of the numbers of a
--   structure.
sum :: (Foldable t, Num a) => t a -> a

-- | The <a>product</a> function computes the product of the numbers of a
--   structure.
product :: (Foldable t, Num a) => t a -> a
infix 4 `elem`

-- | Functors representing data structures that can be traversed from left
--   to right.
--   
--   A definition of <a>traverse</a> must satisfy the following laws:
--   
--   <ul>
--   <li><i>Naturality</i> <tt>t . <a>traverse</a> f = <a>traverse</a> (t .
--   f)</tt> for every applicative transformation <tt>t</tt></li>
--   <li><i>Identity</i> <tt><a>traverse</a> <a>Identity</a> =
--   <a>Identity</a></tt></li>
--   <li><i>Composition</i> <tt><a>traverse</a> (<a>Compose</a> .
--   <a>fmap</a> g . f) = <a>Compose</a> . <a>fmap</a> (<a>traverse</a> g)
--   . <a>traverse</a> f</tt></li>
--   </ul>
--   
--   A definition of <a>sequenceA</a> must satisfy the following laws:
--   
--   <ul>
--   <li><i>Naturality</i> <tt>t . <a>sequenceA</a> = <a>sequenceA</a> .
--   <a>fmap</a> t</tt> for every applicative transformation
--   <tt>t</tt></li>
--   <li><i>Identity</i> <tt><a>sequenceA</a> . <a>fmap</a> <a>Identity</a>
--   = <a>Identity</a></tt></li>
--   <li><i>Composition</i> <tt><a>sequenceA</a> . <a>fmap</a>
--   <a>Compose</a> = <a>Compose</a> . <a>fmap</a> <a>sequenceA</a> .
--   <a>sequenceA</a></tt></li>
--   </ul>
--   
--   where an <i>applicative transformation</i> is a function
--   
--   <pre>
--   t :: (Applicative f, Applicative g) =&gt; f a -&gt; g a
--   </pre>
--   
--   preserving the <a>Applicative</a> operations, i.e.
--   
--   <pre>
--   t (<a>pure</a> x) = <a>pure</a> x
--   t (f <a>&lt;*&gt;</a> x) = t f <a>&lt;*&gt;</a> t x
--   </pre>
--   
--   and the identity functor <a>Identity</a> and composition functors
--   <a>Compose</a> are from <a>Data.Functor.Identity</a> and
--   <a>Data.Functor.Compose</a>.
--   
--   A result of the naturality law is a purity law for <a>traverse</a>
--   
--   <pre>
--   <a>traverse</a> <a>pure</a> = <a>pure</a>
--   </pre>
--   
--   (The naturality law is implied by parametricity and thus so is the
--   purity law [1, p15].)
--   
--   Instances are similar to <a>Functor</a>, e.g. given a data type
--   
--   <pre>
--   data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)
--   </pre>
--   
--   a suitable instance would be
--   
--   <pre>
--   instance Traversable Tree where
--      traverse f Empty = pure Empty
--      traverse f (Leaf x) = Leaf &lt;$&gt; f x
--      traverse f (Node l k r) = Node &lt;$&gt; traverse f l &lt;*&gt; f k &lt;*&gt; traverse f r
--   </pre>
--   
--   This is suitable even for abstract types, as the laws for
--   <a>&lt;*&gt;</a> imply a form of associativity.
--   
--   The superclass instances should satisfy the following:
--   
--   <ul>
--   <li>In the <a>Functor</a> instance, <a>fmap</a> should be equivalent
--   to traversal with the identity applicative functor
--   (<a>fmapDefault</a>).</li>
--   <li>In the <a>Foldable</a> instance, <a>foldMap</a> should be
--   equivalent to traversal with a constant applicative functor
--   (<a>foldMapDefault</a>).</li>
--   </ul>
--   
--   References: [1] The Essence of the Iterator Pattern, Jeremy Gibbons
--   and Bruno C. d. S. Oliveira
class (Functor t, Foldable t) => Traversable (t :: Type -> Type)

-- | Map each element of a structure to an action, evaluate these actions
--   from left to right, and collect the results. For a version that
--   ignores the results see <a>traverse_</a>.
traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)

-- | Evaluate each action in the structure from left to right, and collect
--   the results. For a version that ignores the results see
--   <a>sequenceA_</a>.
sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)

-- | Map each element of a structure to a monadic action, evaluate these
--   actions from left to right, and collect the results. For a version
--   that ignores the results see <a>mapM_</a>.
mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)

-- | Evaluate each monadic action in the structure from left to right, and
--   collect the results. For a version that ignores the results see
--   <a>sequence_</a>.
sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)

-- | The class of semigroups (types with an associative binary operation).
--   
--   Instances should satisfy the following:
--   
--   <ul>
--   <li><i>Associativity</i> <tt>x <a>&lt;&gt;</a> (y <a>&lt;&gt;</a> z) =
--   (x <a>&lt;&gt;</a> y) <a>&lt;&gt;</a> z</tt></li>
--   </ul>
class Semigroup a

-- | An associative operation.
--   
--   <pre>
--   &gt;&gt;&gt; [1,2,3] &lt;&gt; [4,5,6]
--   [1,2,3,4,5,6]
--   </pre>
(<>) :: Semigroup a => a -> a -> a
infixr 6 <>

-- | The class of monoids (types with an associative binary operation that
--   has an identity). Instances should satisfy the following:
--   
--   <ul>
--   <li><i>Right identity</i> <tt>x <a>&lt;&gt;</a> <a>mempty</a> =
--   x</tt></li>
--   <li><i>Left identity</i> <tt><a>mempty</a> <a>&lt;&gt;</a> x =
--   x</tt></li>
--   <li><i>Associativity</i> <tt>x <a>&lt;&gt;</a> (y <a>&lt;&gt;</a> z) =
--   (x <a>&lt;&gt;</a> y) <a>&lt;&gt;</a> z</tt> (<a>Semigroup</a>
--   law)</li>
--   <li><i>Concatenation</i> <tt><a>mconcat</a> = <a>foldr</a>
--   (<a>&lt;&gt;</a>) <a>mempty</a></tt></li>
--   </ul>
--   
--   The method names refer to the monoid of lists under concatenation, but
--   there are many other instances.
--   
--   Some types can be viewed as a monoid in more than one way, e.g. both
--   addition and multiplication on numbers. In such cases we often define
--   <tt>newtype</tt>s and make those instances of <a>Monoid</a>, e.g.
--   <a>Sum</a> and <a>Product</a>.
--   
--   <b>NOTE</b>: <a>Semigroup</a> is a superclass of <a>Monoid</a> since
--   <i>base-4.11.0.0</i>.
class Semigroup a => Monoid a

-- | Identity of <a>mappend</a>
--   
--   <pre>
--   &gt;&gt;&gt; "Hello world" &lt;&gt; mempty
--   "Hello world"
--   </pre>
mempty :: Monoid a => a

-- | An associative operation
--   
--   <b>NOTE</b>: This method is redundant and has the default
--   implementation <tt><a>mappend</a> = (<a>&lt;&gt;</a>)</tt> since
--   <i>base-4.11.0.0</i>. Should it be implemented manually, since
--   <a>mappend</a> is a synonym for (<a>&lt;&gt;</a>), it is expected that
--   the two functions are defined the same way. In a future GHC release
--   <a>mappend</a> will be removed from <a>Monoid</a>.
mappend :: Monoid a => a -> a -> a

-- | Fold a list using the monoid.
--   
--   For most types, the default definition for <a>mconcat</a> will be
--   used, but the function is included in the class definition so that an
--   optimized version can be provided for specific types.
--   
--   <pre>
--   &gt;&gt;&gt; mconcat ["Hello", " ", "Haskell", "!"]
--   "Hello Haskell!"
--   </pre>
mconcat :: Monoid a => [a] -> a
data Bool
False :: Bool
True :: Bool

-- | The character type <a>Char</a> is an enumeration whose values
--   represent Unicode (or equivalently ISO/IEC 10646) code points (i.e.
--   characters, see <a>http://www.unicode.org/</a> for details). This set
--   extends the ISO 8859-1 (Latin-1) character set (the first 256
--   characters), which is itself an extension of the ASCII character set
--   (the first 128 characters). A character literal in Haskell has type
--   <a>Char</a>.
--   
--   To convert a <a>Char</a> to or from the corresponding <a>Int</a> value
--   defined by Unicode, use <a>toEnum</a> and <a>fromEnum</a> from the
--   <a>Enum</a> class respectively (or equivalently <a>ord</a> and
--   <a>chr</a>).
data Char

-- | Double-precision floating point numbers. It is desirable that this
--   type be at least equal in range and precision to the IEEE
--   double-precision type.
data Double

-- | Single-precision floating point numbers. It is desirable that this
--   type be at least equal in range and precision to the IEEE
--   single-precision type.
data Float

-- | A fixed-precision integer type with at least the range <tt>[-2^29 ..
--   2^29-1]</tt>. The exact range for a given implementation can be
--   determined by using <a>minBound</a> and <a>maxBound</a> from the
--   <a>Bounded</a> class.
data Int

-- | Arbitrary precision integers. In contrast with fixed-size integral
--   types such as <a>Int</a>, the <a>Integer</a> type represents the
--   entire infinite range of integers.
--   
--   For more information about this type's representation, see the
--   comments in its implementation.
data Integer

-- | The <a>Maybe</a> type encapsulates an optional value. A value of type
--   <tt><a>Maybe</a> a</tt> either contains a value of type <tt>a</tt>
--   (represented as <tt><a>Just</a> a</tt>), or it is empty (represented
--   as <a>Nothing</a>). Using <a>Maybe</a> is a good way to deal with
--   errors or exceptional cases without resorting to drastic measures such
--   as <a>error</a>.
--   
--   The <a>Maybe</a> type is also a monad. It is a simple kind of error
--   monad, where all errors are represented by <a>Nothing</a>. A richer
--   error monad can be built using the <a>Either</a> type.
data Maybe a
Nothing :: Maybe a
Just :: a -> Maybe a
data Ordering
LT :: Ordering
EQ :: Ordering
GT :: Ordering

-- | Arbitrary-precision rational numbers, represented as a ratio of two
--   <a>Integer</a> values. A rational number may be constructed using the
--   <a>%</a> operator.
type Rational = Ratio Integer

-- | A value of type <tt><a>IO</a> a</tt> is a computation which, when
--   performed, does some I/O before returning a value of type <tt>a</tt>.
--   
--   There is really only one way to "perform" an I/O action: bind it to
--   <tt>Main.main</tt> in your program. When your program is run, the I/O
--   will be performed. It isn't possible to perform I/O from an arbitrary
--   function, unless that function is itself in the <a>IO</a> monad and
--   called at some point, directly or indirectly, from <tt>Main.main</tt>.
--   
--   <a>IO</a> is a monad, so <a>IO</a> actions can be combined using
--   either the do-notation or the <a>&gt;&gt;</a> and <a>&gt;&gt;=</a>
--   operations from the <a>Monad</a> class.
data IO a

-- | A <a>Word</a> is an unsigned integral type, with the same size as
--   <a>Int</a>.
data Word

-- | The <a>Either</a> type represents values with two possibilities: a
--   value of type <tt><a>Either</a> a b</tt> is either <tt><a>Left</a>
--   a</tt> or <tt><a>Right</a> b</tt>.
--   
--   The <a>Either</a> type is sometimes used to represent a value which is
--   either correct or an error; by convention, the <a>Left</a> constructor
--   is used to hold an error value and the <a>Right</a> constructor is
--   used to hold a correct value (mnemonic: "right" also means "correct").
--   
--   <h4><b>Examples</b></h4>
--   
--   The type <tt><a>Either</a> <a>String</a> <a>Int</a></tt> is the type
--   of values which can be either a <a>String</a> or an <a>Int</a>. The
--   <a>Left</a> constructor can be used only on <a>String</a>s, and the
--   <a>Right</a> constructor can be used only on <a>Int</a>s:
--   
--   <pre>
--   &gt;&gt;&gt; let s = Left "foo" :: Either String Int
--   
--   &gt;&gt;&gt; s
--   Left "foo"
--   
--   &gt;&gt;&gt; let n = Right 3 :: Either String Int
--   
--   &gt;&gt;&gt; n
--   Right 3
--   
--   &gt;&gt;&gt; :type s
--   s :: Either String Int
--   
--   &gt;&gt;&gt; :type n
--   n :: Either String Int
--   </pre>
--   
--   The <a>fmap</a> from our <a>Functor</a> instance will ignore
--   <a>Left</a> values, but will apply the supplied function to values
--   contained in a <a>Right</a>:
--   
--   <pre>
--   &gt;&gt;&gt; let s = Left "foo" :: Either String Int
--   
--   &gt;&gt;&gt; let n = Right 3 :: Either String Int
--   
--   &gt;&gt;&gt; fmap (*2) s
--   Left "foo"
--   
--   &gt;&gt;&gt; fmap (*2) n
--   Right 6
--   </pre>
--   
--   The <a>Monad</a> instance for <a>Either</a> allows us to chain
--   together multiple actions which may fail, and fail overall if any of
--   the individual steps failed. First we'll write a function that can
--   either parse an <a>Int</a> from a <a>Char</a>, or fail.
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Char ( digitToInt, isDigit )
--   
--   &gt;&gt;&gt; :{
--       let parseEither :: Char -&gt; Either String Int
--           parseEither c
--             | isDigit c = Right (digitToInt c)
--             | otherwise = Left "parse error"
--   
--   &gt;&gt;&gt; :}
--   </pre>
--   
--   The following should work, since both <tt>'1'</tt> and <tt>'2'</tt>
--   can be parsed as <a>Int</a>s.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--       let parseMultiple :: Either String Int
--           parseMultiple = do
--             x &lt;- parseEither '1'
--             y &lt;- parseEither '2'
--             return (x + y)
--   
--   &gt;&gt;&gt; :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; parseMultiple
--   Right 3
--   </pre>
--   
--   But the following should fail overall, since the first operation where
--   we attempt to parse <tt>'m'</tt> as an <a>Int</a> will fail:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--       let parseMultiple :: Either String Int
--           parseMultiple = do
--             x &lt;- parseEither 'm'
--             y &lt;- parseEither '2'
--             return (x + y)
--   
--   &gt;&gt;&gt; :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; parseMultiple
--   Left "parse error"
--   </pre>
data Either a b
Left :: a -> Either a b
Right :: b -> Either a b

-- | The <a>readIO</a> function is similar to <a>read</a> except that it
--   signals parse failure to the <a>IO</a> monad instead of terminating
--   the program.
readIO :: Read a => String -> IO a

-- | The <a>readLn</a> function combines <a>getLine</a> and <a>readIO</a>.
readLn :: Read a => IO a

-- | The computation <a>appendFile</a> <tt>file str</tt> function appends
--   the string <tt>str</tt>, to the file <tt>file</tt>.
--   
--   Note that <a>writeFile</a> and <a>appendFile</a> write a literal
--   string to a file. To write a value of any printable type, as with
--   <a>print</a>, use the <a>show</a> function to convert the value to a
--   string first.
--   
--   <pre>
--   main = appendFile "squares" (show [(x,x*x) | x &lt;- [0,0.1..2]])
--   </pre>
appendFile :: FilePath -> String -> IO ()

-- | The computation <a>writeFile</a> <tt>file str</tt> function writes the
--   string <tt>str</tt>, to the file <tt>file</tt>.
writeFile :: FilePath -> String -> IO ()

-- | The <a>readFile</a> function reads a file and returns the contents of
--   the file as a string. The file is read lazily, on demand, as with
--   <a>getContents</a>.
readFile :: FilePath -> IO String

-- | The <a>interact</a> function takes a function of type
--   <tt>String-&gt;String</tt> as its argument. The entire input from the
--   standard input device is passed to this function as its argument, and
--   the resulting string is output on the standard output device.
interact :: (String -> String) -> IO ()

-- | The <a>getContents</a> operation returns all user input as a single
--   string, which is read lazily as it is needed (same as
--   <a>hGetContents</a> <a>stdin</a>).
getContents :: IO String

-- | Read a line from the standard input device (same as <a>hGetLine</a>
--   <a>stdin</a>).
getLine :: IO String

-- | Read a character from the standard input device (same as
--   <a>hGetChar</a> <a>stdin</a>).
getChar :: IO Char

-- | The same as <a>putStr</a>, but adds a newline character.
putStrLn :: String -> IO ()

-- | Write a string to the standard output device (same as <a>hPutStr</a>
--   <a>stdout</a>).
putStr :: String -> IO ()

-- | Write a character to the standard output device (same as
--   <a>hPutChar</a> <a>stdout</a>).
putChar :: Char -> IO ()

-- | Raise an <a>IOError</a> in the <a>IO</a> monad.
ioError :: IOError -> IO a

-- | File and directory names are values of type <a>String</a>, whose
--   precise meaning is operating system dependent. Files can be opened,
--   yielding a handle which can then be used to operate on the contents of
--   that file.
type FilePath = String

-- | Construct an <a>IOError</a> value with a string describing the error.
--   The <tt>fail</tt> method of the <a>IO</a> instance of the <a>Monad</a>
--   class raises a <a>userError</a>, thus:
--   
--   <pre>
--   instance Monad IO where
--     ...
--     fail s = ioError (userError s)
--   </pre>
userError :: String -> IOError

-- | The Haskell 2010 type for exceptions in the <a>IO</a> monad. Any I/O
--   operation may raise an <a>IOError</a> instead of returning a result.
--   For a more general type of exception, including also those that arise
--   in pure code, see <a>Exception</a>.
--   
--   In Haskell 2010, this is an opaque type.
type IOError = IOException

-- | <a>notElem</a> is the negation of <a>elem</a>.
notElem :: (Foldable t, Eq a) => a -> t a -> Bool
infix 4 `notElem`

-- | Determines whether all elements of the structure satisfy the
--   predicate.
all :: Foldable t => (a -> Bool) -> t a -> Bool

-- | Determines whether any element of the structure satisfies the
--   predicate.
any :: Foldable t => (a -> Bool) -> t a -> Bool

-- | <a>or</a> returns the disjunction of a container of Bools. For the
--   result to be <a>False</a>, the container must be finite; <a>True</a>,
--   however, results from a <a>True</a> value finitely far from the left
--   end.
or :: Foldable t => t Bool -> Bool

-- | <a>and</a> returns the conjunction of a container of Bools. For the
--   result to be <a>True</a>, the container must be finite; <a>False</a>,
--   however, results from a <a>False</a> value finitely far from the left
--   end.
and :: Foldable t => t Bool -> Bool

-- | Map a function over all the elements of a container and concatenate
--   the resulting lists.
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]

-- | The concatenation of all the elements of a container of lists.
concat :: Foldable t => t [a] -> [a]

-- | Evaluate each monadic action in the structure from left to right, and
--   ignore the results. For a version that doesn't ignore the results see
--   <a>sequence</a>.
--   
--   As of base 4.8.0.0, <a>sequence_</a> is just <a>sequenceA_</a>,
--   specialized to <a>Monad</a>.
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()

-- | Map each element of a structure to a monadic action, evaluate these
--   actions from left to right, and ignore the results. For a version that
--   doesn't ignore the results see <a>mapM</a>.
--   
--   As of base 4.8.0.0, <a>mapM_</a> is just <a>traverse_</a>, specialized
--   to <a>Monad</a>.
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()

-- | <a>unwords</a> is an inverse operation to <a>words</a>. It joins words
--   with separating spaces.
--   
--   <pre>
--   &gt;&gt;&gt; unwords ["Lorem", "ipsum", "dolor"]
--   "Lorem ipsum dolor"
--   </pre>
unwords :: [String] -> String

-- | <a>words</a> breaks a string up into a list of words, which were
--   delimited by white space.
--   
--   <pre>
--   &gt;&gt;&gt; words "Lorem ipsum\ndolor"
--   ["Lorem","ipsum","dolor"]
--   </pre>
words :: String -> [String]

-- | <a>unlines</a> is an inverse operation to <a>lines</a>. It joins
--   lines, after appending a terminating newline to each.
--   
--   <pre>
--   &gt;&gt;&gt; unlines ["Hello", "World", "!"]
--   "Hello\nWorld\n!\n"
--   </pre>
unlines :: [String] -> String

-- | <a>lines</a> breaks a string up into a list of strings at newline
--   characters. The resulting strings do not contain newlines.
--   
--   Note that after splitting the string at newline characters, the last
--   part of the string is considered a line even if it doesn't end with a
--   newline. For example,
--   
--   <pre>
--   &gt;&gt;&gt; lines ""
--   []
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lines "\n"
--   [""]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lines "one"
--   ["one"]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lines "one\n"
--   ["one"]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lines "one\n\n"
--   ["one",""]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lines "one\ntwo"
--   ["one","two"]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lines "one\ntwo\n"
--   ["one","two"]
--   </pre>
--   
--   Thus <tt><a>lines</a> s</tt> contains at least as many elements as
--   newlines in <tt>s</tt>.
lines :: String -> [String]

-- | The <a>read</a> function reads input from a string, which must be
--   completely consumed by the input process. <a>read</a> fails with an
--   <a>error</a> if the parse is unsuccessful, and it is therefore
--   discouraged from being used in real applications. Use <a>readMaybe</a>
--   or <a>readEither</a> for safe alternatives.
--   
--   <pre>
--   &gt;&gt;&gt; read "123" :: Int
--   123
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; read "hello" :: Int
--   *** Exception: Prelude.read: no parse
--   </pre>
read :: Read a => String -> a

-- | equivalent to <a>readsPrec</a> with a precedence of 0.
reads :: Read a => ReadS a

-- | Case analysis for the <a>Either</a> type. If the value is
--   <tt><a>Left</a> a</tt>, apply the first function to <tt>a</tt>; if it
--   is <tt><a>Right</a> b</tt>, apply the second function to <tt>b</tt>.
--   
--   <h4><b>Examples</b></h4>
--   
--   We create two values of type <tt><a>Either</a> <a>String</a>
--   <a>Int</a></tt>, one using the <a>Left</a> constructor and another
--   using the <a>Right</a> constructor. Then we apply "either" the
--   <a>length</a> function (if we have a <a>String</a>) or the "times-two"
--   function (if we have an <a>Int</a>):
--   
--   <pre>
--   &gt;&gt;&gt; let s = Left "foo" :: Either String Int
--   
--   &gt;&gt;&gt; let n = Right 3 :: Either String Int
--   
--   &gt;&gt;&gt; either length (*2) s
--   3
--   
--   &gt;&gt;&gt; either length (*2) n
--   6
--   </pre>
either :: (a -> c) -> (b -> c) -> Either a b -> c

-- | The <a>lex</a> function reads a single lexeme from the input,
--   discarding initial white space, and returning the characters that
--   constitute the lexeme. If the input string contains only white space,
--   <a>lex</a> returns a single successful `lexeme' consisting of the
--   empty string. (Thus <tt><a>lex</a> "" = [("","")]</tt>.) If there is
--   no legal lexeme at the beginning of the input string, <a>lex</a> fails
--   (i.e. returns <tt>[]</tt>).
--   
--   This lexer is not completely faithful to the Haskell lexical syntax in
--   the following respects:
--   
--   <ul>
--   <li>Qualified names are not handled properly</li>
--   <li>Octal and hexadecimal numerics are not recognized as a single
--   token</li>
--   <li>Comments are not treated properly</li>
--   </ul>
lex :: ReadS String

-- | <tt><a>readParen</a> <a>True</a> p</tt> parses what <tt>p</tt> parses,
--   but surrounded with parentheses.
--   
--   <tt><a>readParen</a> <a>False</a> p</tt> parses what <tt>p</tt>
--   parses, but optionally surrounded with parentheses.
readParen :: Bool -> ReadS a -> ReadS a

-- | A parser for a type <tt>a</tt>, represented as a function that takes a
--   <a>String</a> and returns a list of possible parses as
--   <tt>(a,<a>String</a>)</tt> pairs.
--   
--   Note that this kind of backtracking parser is very inefficient;
--   reading a large structure may be quite slow (cf <a>ReadP</a>).
type ReadS a = String -> [(a, String)]

-- | <tt><a>lcm</a> x y</tt> is the smallest positive integer that both
--   <tt>x</tt> and <tt>y</tt> divide.
lcm :: Integral a => a -> a -> a

-- | <tt><a>gcd</a> x y</tt> is the non-negative factor of both <tt>x</tt>
--   and <tt>y</tt> of which every common factor of <tt>x</tt> and
--   <tt>y</tt> is also a factor; for example <tt><a>gcd</a> 4 2 = 2</tt>,
--   <tt><a>gcd</a> (-4) 6 = 2</tt>, <tt><a>gcd</a> 0 4</tt> = <tt>4</tt>.
--   <tt><a>gcd</a> 0 0</tt> = <tt>0</tt>. (That is, the common divisor
--   that is "greatest" in the divisibility preordering.)
--   
--   Note: Since for signed fixed-width integer types, <tt><a>abs</a>
--   <a>minBound</a> &lt; 0</tt>, the result may be negative if one of the
--   arguments is <tt><a>minBound</a></tt> (and necessarily is if the other
--   is <tt>0</tt> or <tt><a>minBound</a></tt>) for such types.
gcd :: Integral a => a -> a -> a

-- | raise a number to an integral power
(^^) :: (Fractional a, Integral b) => a -> b -> a
infixr 8 ^^

-- | raise a number to a non-negative integral power
(^) :: (Num a, Integral b) => a -> b -> a
infixr 8 ^
odd :: Integral a => a -> Bool
even :: Integral a => a -> Bool

-- | utility function that surrounds the inner show function with
--   parentheses when the <a>Bool</a> parameter is <a>True</a>.
showParen :: Bool -> ShowS -> ShowS

-- | utility function converting a <a>String</a> to a show function that
--   simply prepends the string unchanged.
showString :: String -> ShowS

-- | utility function converting a <a>Char</a> to a show function that
--   simply prepends the character unchanged.
showChar :: Char -> ShowS

-- | equivalent to <a>showsPrec</a> with a precedence of 0.
shows :: Show a => a -> ShowS

-- | The <tt>shows</tt> functions return a function that prepends the
--   output <a>String</a> to an existing <a>String</a>. This allows
--   constant-time concatenation of results using function composition.
type ShowS = String -> String

-- | The <a>unzip3</a> function takes a list of triples and returns three
--   lists, analogous to <a>unzip</a>.
unzip3 :: [(a, b, c)] -> ([a], [b], [c])

-- | <a>unzip</a> transforms a list of pairs into a list of first
--   components and a list of second components.
unzip :: [(a, b)] -> ([a], [b])

-- | The <a>zipWith3</a> function takes a function which combines three
--   elements, as well as three lists and returns a list of their
--   point-wise combination, analogous to <a>zipWith</a>. It is capable of
--   list fusion, but it is restricted to its first list argument and its
--   resulting list.
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]

-- | &lt;math&gt;. <a>zipWith</a> generalises <a>zip</a> by zipping with
--   the function given as the first argument, instead of a tupling
--   function. For example, <tt><a>zipWith</a> (+)</tt> is applied to two
--   lists to produce the list of corresponding sums:
--   
--   <pre>
--   &gt;&gt;&gt; zipWith (+) [1, 2, 3] [4, 5, 6]
--   [5,7,9]
--   </pre>
--   
--   <a>zipWith</a> is right-lazy:
--   
--   <pre>
--   zipWith f [] _|_ = []
--   </pre>
--   
--   <a>zipWith</a> is capable of list fusion, but it is restricted to its
--   first list argument and its resulting list.
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

-- | <a>zip3</a> takes three lists and returns a list of triples, analogous
--   to <a>zip</a>. It is capable of list fusion, but it is restricted to
--   its first list argument and its resulting list.
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]

-- | List index (subscript) operator, starting from 0. It is an instance of
--   the more general <a>genericIndex</a>, which takes an index of any
--   integral type.
(!!) :: [a] -> Int -> a
infixl 9 !!

-- | &lt;math&gt;. <a>lookup</a> <tt>key assocs</tt> looks up a key in an
--   association list.
--   
--   <pre>
--   &gt;&gt;&gt; lookup 2 [(1, "first"), (2, "second"), (3, "third")]
--   Just "second"
--   </pre>
lookup :: Eq a => a -> [(a, b)] -> Maybe b

-- | <a>reverse</a> <tt>xs</tt> returns the elements of <tt>xs</tt> in
--   reverse order. <tt>xs</tt> must be finite.
reverse :: [a] -> [a]

-- | <a>break</a>, applied to a predicate <tt>p</tt> and a list
--   <tt>xs</tt>, returns a tuple where first element is longest prefix
--   (possibly empty) of <tt>xs</tt> of elements that <i>do not satisfy</i>
--   <tt>p</tt> and second element is the remainder of the list:
--   
--   <pre>
--   break (&gt; 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4])
--   break (&lt; 9) [1,2,3] == ([],[1,2,3])
--   break (&gt; 9) [1,2,3] == ([1,2,3],[])
--   </pre>
--   
--   <a>break</a> <tt>p</tt> is equivalent to <tt><a>span</a> (<a>not</a> .
--   p)</tt>.
break :: (a -> Bool) -> [a] -> ([a], [a])

-- | <a>span</a>, applied to a predicate <tt>p</tt> and a list <tt>xs</tt>,
--   returns a tuple where first element is longest prefix (possibly empty)
--   of <tt>xs</tt> of elements that satisfy <tt>p</tt> and second element
--   is the remainder of the list:
--   
--   <pre>
--   span (&lt; 3) [1,2,3,4,1,2,3,4] == ([1,2],[3,4,1,2,3,4])
--   span (&lt; 9) [1,2,3] == ([1,2,3],[])
--   span (&lt; 0) [1,2,3] == ([],[1,2,3])
--   </pre>
--   
--   <a>span</a> <tt>p xs</tt> is equivalent to <tt>(<a>takeWhile</a> p xs,
--   <a>dropWhile</a> p xs)</tt>
span :: (a -> Bool) -> [a] -> ([a], [a])

-- | <a>splitAt</a> <tt>n xs</tt> returns a tuple where first element is
--   <tt>xs</tt> prefix of length <tt>n</tt> and second element is the
--   remainder of the list:
--   
--   <pre>
--   splitAt 6 "Hello World!" == ("Hello ","World!")
--   splitAt 3 [1,2,3,4,5] == ([1,2,3],[4,5])
--   splitAt 1 [1,2,3] == ([1],[2,3])
--   splitAt 3 [1,2,3] == ([1,2,3],[])
--   splitAt 4 [1,2,3] == ([1,2,3],[])
--   splitAt 0 [1,2,3] == ([],[1,2,3])
--   splitAt (-1) [1,2,3] == ([],[1,2,3])
--   </pre>
--   
--   It is equivalent to <tt>(<a>take</a> n xs, <a>drop</a> n xs)</tt> when
--   <tt>n</tt> is not <tt>_|_</tt> (<tt>splitAt _|_ xs = _|_</tt>).
--   <a>splitAt</a> is an instance of the more general
--   <a>genericSplitAt</a>, in which <tt>n</tt> may be of any integral
--   type.
splitAt :: Int -> [a] -> ([a], [a])

-- | <a>drop</a> <tt>n xs</tt> returns the suffix of <tt>xs</tt> after the
--   first <tt>n</tt> elements, or <tt>[]</tt> if <tt>n &gt; <a>length</a>
--   xs</tt>:
--   
--   <pre>
--   drop 6 "Hello World!" == "World!"
--   drop 3 [1,2,3,4,5] == [4,5]
--   drop 3 [1,2] == []
--   drop 3 [] == []
--   drop (-1) [1,2] == [1,2]
--   drop 0 [1,2] == [1,2]
--   </pre>
--   
--   It is an instance of the more general <a>genericDrop</a>, in which
--   <tt>n</tt> may be of any integral type.
drop :: Int -> [a] -> [a]

-- | <a>take</a> <tt>n</tt>, applied to a list <tt>xs</tt>, returns the
--   prefix of <tt>xs</tt> of length <tt>n</tt>, or <tt>xs</tt> itself if
--   <tt>n &gt; <a>length</a> xs</tt>:
--   
--   <pre>
--   take 5 "Hello World!" == "Hello"
--   take 3 [1,2,3,4,5] == [1,2,3]
--   take 3 [1,2] == [1,2]
--   take 3 [] == []
--   take (-1) [1,2] == []
--   take 0 [1,2] == []
--   </pre>
--   
--   It is an instance of the more general <a>genericTake</a>, in which
--   <tt>n</tt> may be of any integral type.
take :: Int -> [a] -> [a]

-- | <a>dropWhile</a> <tt>p xs</tt> returns the suffix remaining after
--   <a>takeWhile</a> <tt>p xs</tt>:
--   
--   <pre>
--   dropWhile (&lt; 3) [1,2,3,4,5,1,2,3] == [3,4,5,1,2,3]
--   dropWhile (&lt; 9) [1,2,3] == []
--   dropWhile (&lt; 0) [1,2,3] == [1,2,3]
--   </pre>
dropWhile :: (a -> Bool) -> [a] -> [a]

-- | <a>takeWhile</a>, applied to a predicate <tt>p</tt> and a list
--   <tt>xs</tt>, returns the longest prefix (possibly empty) of
--   <tt>xs</tt> of elements that satisfy <tt>p</tt>:
--   
--   <pre>
--   takeWhile (&lt; 3) [1,2,3,4,1,2,3,4] == [1,2]
--   takeWhile (&lt; 9) [1,2,3] == [1,2,3]
--   takeWhile (&lt; 0) [1,2,3] == []
--   </pre>
takeWhile :: (a -> Bool) -> [a] -> [a]

-- | <a>cycle</a> ties a finite list into a circular one, or equivalently,
--   the infinite repetition of the original list. It is the identity on
--   infinite lists.
cycle :: [a] -> [a]

-- | <a>replicate</a> <tt>n x</tt> is a list of length <tt>n</tt> with
--   <tt>x</tt> the value of every element. It is an instance of the more
--   general <a>genericReplicate</a>, in which <tt>n</tt> may be of any
--   integral type.
replicate :: Int -> a -> [a]

-- | <a>repeat</a> <tt>x</tt> is an infinite list, with <tt>x</tt> the
--   value of every element.
repeat :: a -> [a]

-- | <a>iterate</a> <tt>f x</tt> returns an infinite list of repeated
--   applications of <tt>f</tt> to <tt>x</tt>:
--   
--   <pre>
--   iterate f x == [x, f x, f (f x), ...]
--   </pre>
--   
--   Note that <a>iterate</a> is lazy, potentially leading to thunk
--   build-up if the consumer doesn't force each iterate. See
--   <a>iterate'</a> for a strict variant of this function.
iterate :: (a -> a) -> a -> [a]

-- | &lt;math&gt;. <a>scanr1</a> is a variant of <a>scanr</a> that has no
--   starting value argument.
scanr1 :: (a -> a -> a) -> [a] -> [a]

-- | &lt;math&gt;. <a>scanr</a> is the right-to-left dual of <a>scanl</a>.
--   Note that
--   
--   <pre>
--   head (scanr f z xs) == foldr f z xs.
--   </pre>
scanr :: (a -> b -> b) -> b -> [a] -> [b]

-- | &lt;math&gt;. <a>scanl1</a> is a variant of <a>scanl</a> that has no
--   starting value argument:
--   
--   <pre>
--   scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]
--   </pre>
scanl1 :: (a -> a -> a) -> [a] -> [a]

-- | &lt;math&gt;. <a>scanl</a> is similar to <a>foldl</a>, but returns a
--   list of successive reduced values from the left:
--   
--   <pre>
--   scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]
--   </pre>
--   
--   Note that
--   
--   <pre>
--   last (scanl f z xs) == foldl f z xs.
--   </pre>
scanl :: (b -> a -> b) -> b -> [a] -> [b]

-- | &lt;math&gt;. Return all the elements of a list except the last one.
--   The list must be non-empty.
init :: [a] -> [a]

-- | &lt;math&gt;. Extract the last element of a list, which must be finite
--   and non-empty.
last :: [a] -> a

-- | &lt;math&gt;. Extract the elements after the head of a list, which
--   must be non-empty.
tail :: [a] -> [a]

-- | &lt;math&gt;. Extract the first element of a list, which must be
--   non-empty.
head :: [a] -> a

-- | The <a>maybe</a> function takes a default value, a function, and a
--   <a>Maybe</a> value. If the <a>Maybe</a> value is <a>Nothing</a>, the
--   function returns the default value. Otherwise, it applies the function
--   to the value inside the <a>Just</a> and returns the result.
--   
--   <h4><b>Examples</b></h4>
--   
--   Basic usage:
--   
--   <pre>
--   &gt;&gt;&gt; maybe False odd (Just 3)
--   True
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; maybe False odd Nothing
--   False
--   </pre>
--   
--   Read an integer from a string using <a>readMaybe</a>. If we succeed,
--   return twice the integer; that is, apply <tt>(*2)</tt> to it. If
--   instead we fail to parse an integer, return <tt>0</tt> by default:
--   
--   <pre>
--   &gt;&gt;&gt; import Text.Read ( readMaybe )
--   
--   &gt;&gt;&gt; maybe 0 (*2) (readMaybe "5")
--   10
--   
--   &gt;&gt;&gt; maybe 0 (*2) (readMaybe "")
--   0
--   </pre>
--   
--   Apply <a>show</a> to a <tt>Maybe Int</tt>. If we have <tt>Just n</tt>,
--   we want to show the underlying <a>Int</a> <tt>n</tt>. But if we have
--   <a>Nothing</a>, we return the empty string instead of (for example)
--   "Nothing":
--   
--   <pre>
--   &gt;&gt;&gt; maybe "" show (Just 5)
--   "5"
--   
--   &gt;&gt;&gt; maybe "" show Nothing
--   ""
--   </pre>
maybe :: b -> (a -> b) -> Maybe a -> b

-- | An infix synonym for <a>fmap</a>.
--   
--   The name of this operator is an allusion to <a>$</a>. Note the
--   similarities between their types:
--   
--   <pre>
--    ($)  ::              (a -&gt; b) -&gt;   a -&gt;   b
--   (&lt;$&gt;) :: Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
--   </pre>
--   
--   Whereas <a>$</a> is function application, <a>&lt;$&gt;</a> is function
--   application lifted over a <a>Functor</a>.
--   
--   <h4><b>Examples</b></h4>
--   
--   Convert from a <tt><a>Maybe</a> <a>Int</a></tt> to a <tt><a>Maybe</a>
--   <a>String</a></tt> using <a>show</a>:
--   
--   <pre>
--   &gt;&gt;&gt; show &lt;$&gt; Nothing
--   Nothing
--   
--   &gt;&gt;&gt; show &lt;$&gt; Just 3
--   Just "3"
--   </pre>
--   
--   Convert from an <tt><a>Either</a> <a>Int</a> <a>Int</a></tt> to an
--   <tt><a>Either</a> <a>Int</a></tt> <a>String</a> using <a>show</a>:
--   
--   <pre>
--   &gt;&gt;&gt; show &lt;$&gt; Left 17
--   Left 17
--   
--   &gt;&gt;&gt; show &lt;$&gt; Right 17
--   Right "17"
--   </pre>
--   
--   Double each element of a list:
--   
--   <pre>
--   &gt;&gt;&gt; (*2) &lt;$&gt; [1,2,3]
--   [2,4,6]
--   </pre>
--   
--   Apply <a>even</a> to the second element of a pair:
--   
--   <pre>
--   &gt;&gt;&gt; even &lt;$&gt; (2,2)
--   (2,True)
--   </pre>
(<$>) :: Functor f => (a -> b) -> f a -> f b
infixl 4 <$>

-- | <a>uncurry</a> converts a curried function to a function on pairs.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; uncurry (+) (1,2)
--   3
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; uncurry ($) (show, 1)
--   "1"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; map (uncurry max) [(1,2), (3,4), (6,8)]
--   [2,4,8]
--   </pre>
uncurry :: (a -> b -> c) -> (a, b) -> c

-- | <a>curry</a> converts an uncurried function to a curried function.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; curry fst 1 2
--   1
--   </pre>
curry :: ((a, b) -> c) -> a -> b -> c

-- | the same as <tt><a>flip</a> (<a>-</a>)</tt>.
--   
--   Because <tt>-</tt> is treated specially in the Haskell grammar,
--   <tt>(-</tt> <i>e</i><tt>)</tt> is not a section, but an application of
--   prefix negation. However, <tt>(<a>subtract</a></tt>
--   <i>exp</i><tt>)</tt> is equivalent to the disallowed section.
subtract :: Num a => a -> a -> a

-- | <a>asTypeOf</a> is a type-restricted version of <a>const</a>. It is
--   usually used as an infix operator, and its typing forces its first
--   argument (which is usually overloaded) to have the same type as the
--   second.
asTypeOf :: a -> a -> a

-- | <tt><a>until</a> p f</tt> yields the result of applying <tt>f</tt>
--   until <tt>p</tt> holds.
until :: (a -> Bool) -> (a -> a) -> a -> a

-- | Strict (call-by-value) application operator. It takes a function and
--   an argument, evaluates the argument to weak head normal form (WHNF),
--   then calls the function with that value.
($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
infixr 0 $!

-- | <tt><a>flip</a> f</tt> takes its (first) two arguments in the reverse
--   order of <tt>f</tt>.
--   
--   <pre>
--   &gt;&gt;&gt; flip (++) "hello" "world"
--   "worldhello"
--   </pre>
flip :: (a -> b -> c) -> b -> a -> c

-- | Function composition.
(.) :: (b -> c) -> (a -> b) -> a -> c
infixr 9 .

-- | <tt>const x</tt> is a unary function which evaluates to <tt>x</tt> for
--   all inputs.
--   
--   <pre>
--   &gt;&gt;&gt; const 42 "hello"
--   42
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; map (const 42) [0..3]
--   [42,42,42,42]
--   </pre>
const :: a -> b -> a

-- | Identity function.
--   
--   <pre>
--   id x = x
--   </pre>
id :: a -> a

-- | Same as <a>&gt;&gt;=</a>, but with the arguments interchanged.
(=<<) :: Monad m => (a -> m b) -> m a -> m b
infixr 1 =<<

-- | A <a>String</a> is a list of characters. String constants in Haskell
--   are values of type <a>String</a>.
--   
--   See <a>Data.List</a> for operations on lists.
type String = [Char]

-- | A special case of <a>error</a>. It is expected that compilers will
--   recognize this and insert error messages which are more appropriate to
--   the context in which <a>undefined</a> appears.
undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a

-- | A variant of <a>error</a> that does not produce a stack trace.
errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a

-- | <a>error</a> stops execution and displays an error message.
error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a

-- | Boolean "and", lazy in the second argument
(&&) :: Bool -> Bool -> Bool
infixr 3 &&

-- | Boolean "or", lazy in the second argument
(||) :: Bool -> Bool -> Bool
infixr 2 ||

-- | Boolean "not"
not :: Bool -> Bool

-- | Prepend an element to the stream.
(<|) :: a -> NonEmpty a -> NonEmpty a
infixr 5 <|

-- | <a>nonEmpty</a> efficiently turns a normal list into a <a>NonEmpty</a>
--   stream, producing <a>Nothing</a> if the input is empty.
nonEmpty :: [a] -> Maybe (NonEmpty a)
pattern (:|) :: () => a -> [a] -> NonEmpty a
infixr 5 :|

-- | Non-empty <a>String</a>.
type String1 = List1 Char

-- | Non-empty list. TODO change to newtype?
type List1 = NonEmpty
trim1 :: String -> Maybe String1

-- | Lists of length ≥2.
data List2 a
List2 :: a -> a -> [a] -> List2 a

-- | A monad transformer that adds exceptions to other monads.
--   
--   <tt>ExceptT</tt> constructs a monad parameterized over two things:
--   
--   <ul>
--   <li>e - The exception type.</li>
--   <li>m - The inner monad.</li>
--   </ul>
--   
--   The <a>return</a> function yields a computation that produces the
--   given value, while <tt>&gt;&gt;=</tt> sequences two subcomputations,
--   exiting on the first exception.
newtype ExceptT e (m :: Type -> Type) a
ExceptT :: m (Either e a) -> ExceptT e (m :: Type -> Type) a

-- | The strategy of combining computations that can throw exceptions by
--   bypassing bound functions from the point an exception is thrown to the
--   point that it is handled.
--   
--   Is parameterized over the type of error information and the monad type
--   constructor. It is common to use <tt><a>Either</a> String</tt> as the
--   monad type constructor for an error monad in which error descriptions
--   take the form of strings. In that case and many other common cases the
--   resulting monad is already defined as an instance of the
--   <a>MonadError</a> class. You can also define your own error type
--   and/or use a monad type constructor other than <tt><a>Either</a>
--   <tt>String</tt></tt> or <tt><a>Either</a> <tt>IOError</tt></tt>. In
--   these cases you will have to explicitly define instances of the
--   <a>MonadError</a> class. (If you are using the deprecated
--   <a>Control.Monad.Error</a> or <a>Control.Monad.Trans.Error</a>, you
--   may also have to define an <a>Error</a> instance.)
class Monad m => MonadError e (m :: Type -> Type) | m -> e

-- | Is used within a monadic computation to begin exception processing.
throwError :: MonadError e m => e -> m a

-- | A handler function to handle previous errors and return to normal
--   execution. A common idiom is:
--   
--   <pre>
--   do { action1; action2; action3 } `catchError` handler
--   </pre>
--   
--   where the <tt>action</tt> functions can call <a>throwError</a>. Note
--   that <tt>handler</tt> and the do-block must have the same return type.
catchError :: MonadError e m => m a -> (e -> m a) -> m a

-- | The inverse of <a>ExceptT</a>.
runExceptT :: ExceptT e m a -> m (Either e a)

-- | Retrieves a function of the current environment.
asks :: MonadReader r m => (r -> a) -> m a

-- | See examples in <a>Control.Monad.Reader</a>. Note, the partially
--   applied function type <tt>(-&gt;) r</tt> is a simple reader monad. See
--   the <tt>instance</tt> declaration below.
class Monad m => MonadReader r (m :: Type -> Type) | m -> r

-- | Retrieves the monad environment.
ask :: MonadReader r m => m r

-- | Executes a computation in a modified environment.
local :: MonadReader r m => (r -> r) -> m a -> m a

-- | Retrieves a function of the current environment.
reader :: MonadReader r m => (r -> a) -> m a

-- | The reader monad transformer, which adds a read-only environment to
--   the given monad.
--   
--   The <a>return</a> function ignores the environment, while
--   <tt>&gt;&gt;=</tt> passes the inherited environment to both
--   subcomputations.
newtype ReaderT r (m :: Type -> Type) a
ReaderT :: (r -> m a) -> ReaderT r (m :: Type -> Type) a
[runReaderT] :: ReaderT r (m :: Type -> Type) a -> r -> m a

-- | Transform the computation inside a <tt>ReaderT</tt>.
--   
--   <ul>
--   <li><pre><a>runReaderT</a> (<a>mapReaderT</a> f m) = f .
--   <a>runReaderT</a> m</pre></li>
--   </ul>
mapReaderT :: (m a -> n b) -> ReaderT r m a -> ReaderT r n b

-- | Monadic state transformer.
--   
--   Maps an old state to a new state inside a state monad. The old state
--   is thrown away.
--   
--   <pre>
--   Main&gt; :t modify ((+1) :: Int -&gt; Int)
--   modify (...) :: (MonadState Int a) =&gt; a ()
--   </pre>
--   
--   This says that <tt>modify (+1)</tt> acts over any Monad that is a
--   member of the <tt>MonadState</tt> class, with an <tt>Int</tt> state.
modify :: MonadState s m => (s -> s) -> m ()

-- | Gets specific component of the state, using a projection function
--   supplied.
gets :: MonadState s m => (s -> a) -> m a

-- | Minimal definition is either both of <tt>get</tt> and <tt>put</tt> or
--   just <tt>state</tt>
class Monad m => MonadState s (m :: Type -> Type) | m -> s

-- | Return the state from the internals of the monad.
get :: MonadState s m => m s

-- | Replace the state inside the monad.
put :: MonadState s m => s -> m ()

-- | Embed a simple state action into the monad.
state :: MonadState s m => (s -> (a, s)) -> m a

-- | A state transformer monad parameterized by:
--   
--   <ul>
--   <li><tt>s</tt> - The state.</li>
--   <li><tt>m</tt> - The inner monad.</li>
--   </ul>
--   
--   The <a>return</a> function leaves the state unchanged, while
--   <tt>&gt;&gt;=</tt> uses the final state of the first computation as
--   the initial state of the second.
newtype StateT s (m :: Type -> Type) a
StateT :: (s -> m (a, s)) -> StateT s (m :: Type -> Type) a
[runStateT] :: StateT s (m :: Type -> Type) a -> s -> m (a, s)

-- | Evaluate a state computation with the given initial state and return
--   the final value, discarding the final state.
--   
--   <ul>
--   <li><pre><a>evalStateT</a> m s = <a>liftM</a> <a>fst</a>
--   (<a>runStateT</a> m s)</pre></li>
--   </ul>
evalStateT :: Monad m => StateT s m a -> s -> m a

-- | Evaluate a state computation with the given initial state and return
--   the final state, discarding the final value.
--   
--   <ul>
--   <li><pre><a>execStateT</a> m s = <a>liftM</a> <a>snd</a>
--   (<a>runStateT</a> m s)</pre></li>
--   </ul>
execStateT :: Monad m => StateT s m a -> s -> m s

-- | The class of monad transformers. Instances should satisfy the
--   following laws, which state that <a>lift</a> is a monad
--   transformation:
--   
--   <ul>
--   <li><pre><a>lift</a> . <a>return</a> = <a>return</a></pre></li>
--   <li><pre><a>lift</a> (m &gt;&gt;= f) = <a>lift</a> m &gt;&gt;=
--   (<a>lift</a> . f)</pre></li>
--   </ul>
class MonadTrans (t :: Type -> Type -> Type -> Type)

-- | Lift a computation from the argument monad to the constructed monad.
lift :: (MonadTrans t, Monad m) => m a -> t m a

-- | Transform an action in <tt>t m</tt> using a transformer that operates
--   on the underlying monad <tt>m</tt>
liftThrough :: (MonadTransControl t, Monad (t m), Monad m) => (m (StT t a) -> m (StT t b)) -> t m a -> t m b

-- | Monadic state of <tt>t</tt>.
--   
--   The monadic state of a monad transformer is the result type of its
--   <tt>run</tt> function, e.g.:
--   
--   <pre>
--   <a>runReaderT</a> :: <a>ReaderT</a> r m a -&gt; r -&gt; m a
--   <a>StT</a> (<a>ReaderT</a> r) a ~ a
--   
--   <a>runStateT</a> :: <a>StateT</a> s m a -&gt; s -&gt; m (a, s)
--   <a>StT</a> (<a>StateT</a> s) a ~ (a, s)
--   
--   <a>runMaybeT</a> :: <a>MaybeT</a> m a -&gt; m (<a>Maybe</a> a)
--   <a>StT</a> <a>MaybeT</a> a ~ <a>Maybe</a> a
--   </pre>
--   
--   Provided type instances:
--   
--   <pre>
--   StT <a>IdentityT</a>    a ~ a
--   StT <a>MaybeT</a>       a ~ <a>Maybe</a> a
--   StT (<a>ErrorT</a> e)   a ~ <a>Error</a> e =&gt; <a>Either</a> e a
--   StT (<a>ExceptT</a> e)  a ~ <a>Either</a> e a
--   StT <a>ListT</a>        a ~ [a]
--   StT (<a>ReaderT</a> r)  a ~ a
--   StT (<a>StateT</a> s)   a ~ (a, s)
--   StT (<a>WriterT</a> w)  a ~ <a>Monoid</a> w =&gt; (a, w)
--   StT (<a>RWST</a> r w s) a ~ <a>Monoid</a> w =&gt; (a, s, w)
--   </pre>
type family StT (t :: Type -> Type -> Type -> Type) a

-- | The <tt>MonadTransControl</tt> type class is a stronger version of
--   <tt><a>MonadTrans</a></tt>:
--   
--   Instances of <tt><a>MonadTrans</a></tt> know how to
--   <tt><tt>lift</tt></tt> actions in the base monad to the transformed
--   monad. These lifted actions, however, are completely unaware of the
--   monadic state added by the transformer.
--   
--   <tt><a>MonadTransControl</a></tt> instances are aware of the monadic
--   state of the transformer and allow to save and restore this state.
--   
--   This allows to lift functions that have a monad transformer in both
--   positive and negative position. Take, for example, the function
--   
--   <pre>
--   withFile :: FilePath -&gt; IOMode -&gt; (Handle -&gt; IO r) -&gt; IO r
--   </pre>
--   
--   <tt><a>MonadTrans</a></tt> instances can only lift the return type of
--   the <tt>withFile</tt> function:
--   
--   <pre>
--   withFileLifted :: MonadTrans t =&gt; FilePath -&gt; IOMode -&gt; (Handle -&gt; IO r) -&gt; t IO r
--   withFileLifted file mode action = lift (withFile file mode action)
--   </pre>
--   
--   However, <tt><a>MonadTrans</a></tt> is not powerful enough to make
--   <tt>withFileLifted</tt> accept a function that returns <tt>t IO</tt>.
--   The reason is that we need to take away the transformer layer in order
--   to pass the function to <tt><tt>withFile</tt></tt>.
--   <tt><a>MonadTransControl</a></tt> allows us to do this:
--   
--   <pre>
--   withFileLifted' :: (Monad (t IO), MonadTransControl t) =&gt; FilePath -&gt; IOMode -&gt; (Handle -&gt; t IO r) -&gt; t IO r
--   withFileLifted' file mode action = liftWith (\run -&gt; withFile file mode (run . action)) &gt;&gt;= restoreT . return
--   </pre>
class MonadTrans t => MonadTransControl (t :: Type -> Type -> Type -> Type) where {
    
    -- | Monadic state of <tt>t</tt>.
    --   
    --   The monadic state of a monad transformer is the result type of its
    --   <tt>run</tt> function, e.g.:
    --   
    --   <pre>
    --   <a>runReaderT</a> :: <a>ReaderT</a> r m a -&gt; r -&gt; m a
    --   <a>StT</a> (<a>ReaderT</a> r) a ~ a
    --   
    --   <a>runStateT</a> :: <a>StateT</a> s m a -&gt; s -&gt; m (a, s)
    --   <a>StT</a> (<a>StateT</a> s) a ~ (a, s)
    --   
    --   <a>runMaybeT</a> :: <a>MaybeT</a> m a -&gt; m (<a>Maybe</a> a)
    --   <a>StT</a> <a>MaybeT</a> a ~ <a>Maybe</a> a
    --   </pre>
    --   
    --   Provided type instances:
    --   
    --   <pre>
    --   StT <a>IdentityT</a>    a ~ a
    --   StT <a>MaybeT</a>       a ~ <a>Maybe</a> a
    --   StT (<a>ErrorT</a> e)   a ~ <a>Error</a> e =&gt; <a>Either</a> e a
    --   StT (<a>ExceptT</a> e)  a ~ <a>Either</a> e a
    --   StT <a>ListT</a>        a ~ [a]
    --   StT (<a>ReaderT</a> r)  a ~ a
    --   StT (<a>StateT</a> s)   a ~ (a, s)
    --   StT (<a>WriterT</a> w)  a ~ <a>Monoid</a> w =&gt; (a, w)
    --   StT (<a>RWST</a> r w s) a ~ <a>Monoid</a> w =&gt; (a, s, w)
    --   </pre>
    type family StT (t :: Type -> Type -> Type -> Type) a;
}

-- | <tt>liftWith</tt> is similar to <tt>lift</tt> in that it lifts a
--   computation from the argument monad to the constructed monad.
--   
--   Instances should satisfy similar laws as the <a>MonadTrans</a> laws:
--   
--   <pre>
--   liftWith (\_ -&gt; return a) = return a
--   </pre>
--   
--   <pre>
--   liftWith (\_ -&gt; m &gt;&gt;= f)  =  liftWith (\_ -&gt; m) &gt;&gt;= (\a -&gt; liftWith (\_ -&gt; f a))
--   </pre>
--   
--   The difference with <tt>lift</tt> is that before lifting the
--   <tt>m</tt> computation <tt>liftWith</tt> captures the state of
--   <tt>t</tt>. It then provides the <tt>m</tt> computation with a
--   <a>Run</a> function that allows running <tt>t n</tt> computations in
--   <tt>n</tt> (for all <tt>n</tt>) on the captured state, e.g.
--   
--   <pre>
--   withFileLifted :: (Monad (t IO), MonadTransControl t) =&gt; FilePath -&gt; IOMode -&gt; (Handle -&gt; t IO r) -&gt; t IO r
--   withFileLifted file mode action = liftWith (\run -&gt; withFile file mode (run . action)) &gt;&gt;= restoreT . return
--   </pre>
--   
--   If the <tt>Run</tt> function is ignored, <tt>liftWith</tt> coincides
--   with <tt>lift</tt>:
--   
--   <pre>
--   lift f = liftWith (\_ -&gt; f)
--   </pre>
--   
--   Implementations use the <tt><a>Run</a></tt> function associated with a
--   transformer:
--   
--   <pre>
--   liftWith :: <a>Monad</a> m =&gt; ((<a>Monad</a> n =&gt; <a>ReaderT</a> r n b -&gt; n b) -&gt; m a) -&gt; <a>ReaderT</a> r m a
--   liftWith f = <a>ReaderT</a> (\r -&gt; f (\action -&gt; <a>runReaderT</a> action r))
--   
--   liftWith :: <a>Monad</a> m =&gt; ((<a>Monad</a> n =&gt; <a>StateT</a> s n b -&gt; n (b, s)) -&gt; m a) -&gt; <a>StateT</a> s m a
--   liftWith f = <a>StateT</a> (\s -&gt; <a>liftM</a> (\x -&gt; (x, s)) (f (\action -&gt; <a>runStateT</a> action s)))
--   
--   liftWith :: <a>Monad</a> m =&gt; ((<a>Monad</a> n =&gt; <a>MaybeT</a> n b -&gt; n (<a>Maybe</a> b)) -&gt; m a) -&gt; <a>MaybeT</a> m a
--   liftWith f = <a>MaybeT</a> (<a>liftM</a> <tt>Just</tt> (f <a>runMaybeT</a>))
--   </pre>
liftWith :: (MonadTransControl t, Monad m) => (Run t -> m a) -> t m a

-- | Construct a <tt>t</tt> computation from the monadic state of
--   <tt>t</tt> that is returned from a <a>Run</a> function.
--   
--   Instances should satisfy:
--   
--   <pre>
--   liftWith (\run -&gt; run t) &gt;&gt;= restoreT . return = t
--   </pre>
--   
--   <tt>restoreT</tt> is usually implemented through the constructor of
--   the monad transformer:
--   
--   <pre>
--   <a>ReaderT</a>  :: (r -&gt; m a) -&gt; <a>ReaderT</a> r m a
--   restoreT ::       m a  -&gt; <a>ReaderT</a> r m a
--   restoreT action = <a>ReaderT</a> { runReaderT = <a>const</a> action }
--   
--   <a>StateT</a>   :: (s -&gt; m (a, s)) -&gt; <a>StateT</a> s m a
--   restoreT ::       m (a, s)  -&gt; <a>StateT</a> s m a
--   restoreT action = <a>StateT</a> { runStateT = <a>const</a> action }
--   
--   <a>MaybeT</a>   :: m (<a>Maybe</a> a) -&gt; <a>MaybeT</a> m a
--   restoreT :: m (<a>Maybe</a> a) -&gt; <a>MaybeT</a> m a
--   restoreT action = <a>MaybeT</a> action
--   </pre>
--   
--   Example type signatures:
--   
--   <pre>
--   restoreT :: <a>Monad</a> m             =&gt; m a            -&gt; <a>IdentityT</a> m a
--   restoreT :: <a>Monad</a> m             =&gt; m (<a>Maybe</a> a)    -&gt; <a>MaybeT</a> m a
--   restoreT :: (<a>Monad</a> m, <a>Error</a> e)  =&gt; m (<a>Either</a> e a) -&gt; <a>ErrorT</a> e m a
--   restoreT :: <a>Monad</a> m             =&gt; m (<a>Either</a> e a) -&gt; <a>ExceptT</a> e m a
--   restoreT :: <a>Monad</a> m             =&gt; m [a]          -&gt; <a>ListT</a> m a
--   restoreT :: <a>Monad</a> m             =&gt; m a            -&gt; <a>ReaderT</a> r m a
--   restoreT :: <a>Monad</a> m             =&gt; m (a, s)       -&gt; <a>StateT</a> s m a
--   restoreT :: (<a>Monad</a> m, <a>Monoid</a> w) =&gt; m (a, w)       -&gt; <a>WriterT</a> w m a
--   restoreT :: (<a>Monad</a> m, <a>Monoid</a> w) =&gt; m (a, s, w)    -&gt; <a>RWST</a> r w s m a
--   </pre>
restoreT :: (MonadTransControl t, Monad m) => m (StT t a) -> t m a

-- | A writer monad parameterized by:
--   
--   <ul>
--   <li><tt>w</tt> - the output to accumulate.</li>
--   <li><tt>m</tt> - The inner monad.</li>
--   </ul>
--   
--   The <a>return</a> function produces the output <a>mempty</a>, while
--   <tt>&gt;&gt;=</tt> combines the outputs of the subcomputations using
--   <a>mappend</a>.
newtype WriterT w (m :: Type -> Type) a
WriterT :: m (a, w) -> WriterT w (m :: Type -> Type) a
[runWriterT] :: WriterT w (m :: Type -> Type) a -> m (a, w)
class (Monoid w, Monad m) => MonadWriter w (m :: Type -> Type) | m -> w

-- | <tt><a>writer</a> (a,w)</tt> embeds a simple writer action.
writer :: MonadWriter w m => (a, w) -> m a

-- | <tt><a>tell</a> w</tt> is an action that produces the output
--   <tt>w</tt>.
tell :: MonadWriter w m => w -> m ()

-- | <tt><a>listen</a> m</tt> is an action that executes the action
--   <tt>m</tt> and adds its output to the value of the computation.
listen :: MonadWriter w m => m a -> m (a, w)

-- | <tt><a>pass</a> m</tt> is an action that executes the action
--   <tt>m</tt>, which returns a value and a function, and returns the
--   value, applying the function to the output.
pass :: MonadWriter w m => m (a, w -> w) -> m a

-- | A writer monad parameterized by the type <tt>w</tt> of output to
--   accumulate.
--   
--   The <a>return</a> function produces the output <a>mempty</a>, while
--   <tt>&gt;&gt;=</tt> combines the outputs of the subcomputations using
--   <a>mappend</a>.
type Writer w = WriterT w Identity

-- | Unwrap a writer computation as a (result, output) pair. (The inverse
--   of <a>writer</a>.)
runWriter :: Writer w a -> (a, w)

-- | &lt;math&gt;. The <tt>nubOrd</tt> function removes duplicate elements
--   from a list. In particular, it keeps only the first occurrence of each
--   element. By using a <a>Set</a> internally it has better asymptotics
--   than the standard <a>nub</a> function.
--   
--   <h4>Strictness</h4>
--   
--   <tt>nubOrd</tt> is strict in the elements of the list.
--   
--   <h4>Efficiency note</h4>
--   
--   When applicable, it is almost always better to use <a>nubInt</a> or
--   <a>nubIntOn</a> instead of this function, although it can be a little
--   worse in certain pathological cases. For example, to nub a list of
--   characters, use
--   
--   <pre>
--   nubIntOn fromEnum xs
--   </pre>
nubOrd :: Ord a => [a] -> [a]

-- | List of elements of a structure, from left to right.
toList :: Foldable t => t a -> [a]

-- | Determines whether all elements of the structure satisfy the
--   predicate.
all :: Foldable t => (a -> Bool) -> t a -> Bool

-- | <tt><a>on</a> b u x y</tt> runs the binary function <tt>b</tt>
--   <i>on</i> the results of applying unary function <tt>u</tt> to two
--   arguments <tt>x</tt> and <tt>y</tt>. From the opposite perspective, it
--   transforms two inputs and combines the outputs.
--   
--   <pre>
--   ((+) `<a>on</a>` f) x y = f x + f y
--   </pre>
--   
--   Typical usage: <tt><a>sortBy</a> (<a>compare</a> `on`
--   <a>fst</a>)</tt>.
--   
--   Algebraic properties:
--   
--   <ul>
--   <li><pre>(*) `on` <a>id</a> = (*) -- (if (*) ∉ {⊥, <a>const</a>
--   ⊥})</pre></li>
--   <li><pre>((*) `on` f) `on` g = (*) `on` (f . g)</pre></li>
--   <li><pre><a>flip</a> on f . <a>flip</a> on g = <a>flip</a> on (g .
--   f)</pre></li>
--   </ul>
on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
infixl 0 `on`

-- | The class of semigroups (types with an associative binary operation).
--   
--   Instances should satisfy the following:
--   
--   <ul>
--   <li><i>Associativity</i> <tt>x <a>&lt;&gt;</a> (y <a>&lt;&gt;</a> z) =
--   (x <a>&lt;&gt;</a> y) <a>&lt;&gt;</a> z</tt></li>
--   </ul>
class Semigroup a

-- | An associative operation.
--   
--   <pre>
--   &gt;&gt;&gt; [1,2,3] &lt;&gt; [4,5,6]
--   [1,2,3,4,5,6]
--   </pre>
(<>) :: Semigroup a => a -> a -> a

-- | Reduce a non-empty list with <a>&lt;&gt;</a>
--   
--   The default definition should be sufficient, but this can be
--   overridden for efficiency.
--   
--   <pre>
--   &gt;&gt;&gt; import Data.List.NonEmpty
--   
--   &gt;&gt;&gt; sconcat $ "Hello" :| [" ", "Haskell", "!"]
--   "Hello Haskell!"
--   </pre>
sconcat :: Semigroup a => NonEmpty a -> a

-- | Repeat a value <tt>n</tt> times.
--   
--   Given that this works on a <a>Semigroup</a> it is allowed to fail if
--   you request 0 or fewer repetitions, and the default definition will do
--   so.
--   
--   By making this a member of the class, idempotent semigroups and
--   monoids can upgrade this to execute in &lt;math&gt; by picking
--   <tt>stimes = <a>stimesIdempotent</a></tt> or <tt>stimes =
--   <a>stimesIdempotentMonoid</a></tt> respectively.
--   
--   <pre>
--   &gt;&gt;&gt; stimes 4 [1]
--   [1,1,1,1]
--   </pre>
stimes :: (Semigroup a, Integral b) => b -> a -> a
infixr 6 <>

-- | Prepend an element to the stream.
(<|) :: a -> NonEmpty a -> NonEmpty a
infixr 5 <|

-- | <a>nonEmpty</a> efficiently turns a normal list into a <a>NonEmpty</a>
--   stream, producing <a>Nothing</a> if the input is empty.
nonEmpty :: [a] -> Maybe (NonEmpty a)
pattern (:|) :: () => a -> [a] -> NonEmpty a
infixr 5 :|

-- | A Map from keys <tt>k</tt> to values <tt>a</tt>.
--   
--   The <a>Semigroup</a> operation for <a>Map</a> is <a>union</a>, which
--   prefers values from the left operand. If <tt>m1</tt> maps a key
--   <tt>k</tt> to a value <tt>a1</tt>, and <tt>m2</tt> maps the same key
--   to a different value <tt>a2</tt>, then their union <tt>m1 &lt;&gt;
--   m2</tt> maps <tt>k</tt> to <tt>a1</tt>.
data Map k a

-- | A set of values <tt>a</tt>.
data Set a

-- | <tt>spanEnd p l == reverse (span p (reverse l))</tt>.
--   
--   Invariant: <tt>l == front ++ end where (end, front) = spanEnd p l</tt>
--   
--   (From package ghc, module Util.)
spanEnd :: (a -> Bool) -> [a] -> ([a], [a])
forMM_ :: (Monad m, Foldable t) => m (t a) -> (a -> m ()) -> m ()


-- | Tools to manipulate regular expressions.
module BNFC.Types.Regex

-- | Regular expressions are constructed over character classes.
--   
--   Use smart constructors to ensure invariants.
data Regex

-- | Atomic regular expression.
RChar :: CharClass -> Regex

-- | Alternative/sum: List free of duplicates and <tt>RAlt</tt>. We use
--   list instead of set to preserve the order given by the user. Empty
--   list would mean empty language, but this is instead represented by the
--   empty character class.
RAlts :: List2 Regex -> Regex

-- | Difference. Most lexer generators do not support difference in
--   general, only at the level of character classes. LBNF has general
--   difference, so it is represented here.
RMinus :: Regex -> Regex -> Regex

-- | Language of the empty word (empty sequence).
REps :: Regex

-- | Sequence/product. List free of <tt>RSeq</tt>. Empty list is
--   <tt>eps</tt> (language of the empty word).
RSeqs :: List2 Regex -> Regex

-- | 0 or more repetitions. <a>Regex</a> isn't <a>RStar</a>, <a>RPlus</a>,
--   <a>ROpt</a>, <tt><a>RAlts</a> []</tt> nor <a>REps</a>.
RStar :: Regex -> Regex

-- | 1 or more repetitions. <a>Regex</a> isn't <a>RStar</a>, <a>RPlus</a>,
--   <a>ROpt</a>, <tt><a>RAlts</a> []</tt> nor <a>REps</a>.
RPlus :: Regex -> Regex

-- | 0 or 1 repetitions. <a>Regex</a> isn't <a>RStar</a>, <a>RPlus</a>,
--   <a>ROpt</a>, <tt><a>RAlts</a> []</tt> nor <a>REps</a>.
ROpt :: Regex -> Regex
pattern REmpty :: Regex
pattern RAlt :: Regex -> Regex -> Regex
pattern RSeq :: Regex -> Regex -> Regex

-- | Check if a regular expression is nullable (accepts the empty string).
nullable :: Regex -> Bool

-- | Check if a regular expression matches at least one word.
--   
--   For differences, this check may err on the positive side.
class Satisfiable a
satisfiable :: Satisfiable a => a -> Bool

-- | Character classes are regular expressions that recognize character
--   sequences of length exactly one. These are often distinguished from
--   arbitrary regular expressions in lexer generators, e.g. in
--   <tt>alex</tt>.
--   
--   We represent character classes as a difference of unions of atomic
--   character classes.
--   
--   Semantics: <tt>⟦ CMinus ccYes ccNo ⟧ = ⟦ ccYes ⟧ ⟦ ccNo ⟧</tt>
data CharClass
CMinus :: CharClassUnion -> CharClassUnion -> CharClass

-- | Character in question must be in one of these character classes.
[ccYes] :: CharClass -> CharClassUnion

-- | Character in question must not be in one of these character classes.
--   Must be empty if <a>ccYes</a> is empty.
[ccNo] :: CharClass -> CharClassUnion
pattern CEmpty :: CharClass
pattern CC :: CharClassUnion -> CharClass

-- | Possibly overlapping union of character classes.
data CharClassUnion

-- | Any character, LBNF <tt>char</tt>.
CAny :: CharClassUnion

-- | Any of the given (≥0) alternatives. List is free of duplicates.
CAlt :: [CharClassAtom] -> CharClassUnion
pattern CCEmpty :: CharClassUnion

-- | Atomic character class.
data CharClassAtom

-- | A single character.
CChar :: Char -> CharClassAtom

-- | <tt>0-9</tt>, LBNF <tt>digit</tt>.
CDigit :: CharClassAtom

-- | Lower case character, LBNF <tt>lower</tt>.
CLower :: CharClassAtom

-- | Upper case character, LBNF <tt>upper</tt>.
CUpper :: CharClassAtom
rChar :: Char -> Regex

-- | Simplifications included, but no distributivity.
rSeq :: Regex -> Regex -> Regex
rSeqs :: [Regex] -> Regex
rAlt :: Regex -> Regex -> Regex
rAlts :: [Regex] -> Regex
rMinus :: Regex -> Regex -> Regex
rStar :: Regex -> Regex
rPlus :: Regex -> Regex
rOpt :: Regex -> Regex

-- | Disjunction of two character classes is either a character class again
--   (<a>RChar</a>) or simply the disjunction (<a>RAlt</a>).
--   
--   <tt>(p1 m1) ∪ (p2 m2) = (p1 ∪ p2) (m1 ∪ m2)</tt> if <tt>p1 ⊥ m2</tt>
--   and <tt>p2 ⊥ m1</tt>
cAlt :: CharClass -> CharClass -> Regex

-- | Disjunction of two character classes is either a character class again
--   (<a>RChar</a>) or simply the disjunction (<a>RMinus</a>).
--   
--   <tt>(p1 m1) (0 m2) = p1 m1</tt> <tt>(p1 m1) (p2 m2) = p1 (m1 ∪
--   p2)</tt> if <tt>p1 m2 = p1</tt>
cMinus :: CharClass -> CharClass -> Regex

-- | Match given characters.
cChar :: Char -> CharClass

-- | Match any of the given characters.
cAlts :: [Char] -> CharClass
cDigit :: CharClass
cLower :: CharClass
cUpper :: CharClass
cLetter :: CharClass
cAny :: CharClass
cAtom :: CharClassAtom -> CharClass

-- | Smart constructor for <tt>CharClass</tt> from difference..
--   
--   Mutually reduce: <tt>(A - B) = (A B) - (B A)</tt>
ccuMinus :: CharClassUnion -> CharClassUnion -> Either CharClass CharClassUnion
onlyOneChar :: CharClassUnion -> Bool
isEmpty :: CharClassUnion -> Bool
instance GHC.Show.Show BNFC.Types.Regex.CharClassAtom
instance GHC.Classes.Ord BNFC.Types.Regex.CharClassAtom
instance GHC.Classes.Eq BNFC.Types.Regex.CharClassAtom
instance GHC.Show.Show BNFC.Types.Regex.CharClassUnion
instance GHC.Classes.Ord BNFC.Types.Regex.CharClassUnion
instance GHC.Show.Show BNFC.Types.Regex.CharClass
instance GHC.Classes.Ord BNFC.Types.Regex.CharClass
instance GHC.Classes.Eq BNFC.Types.Regex.CharClass
instance GHC.Show.Show BNFC.Types.Regex.Regex
instance GHC.Classes.Ord BNFC.Types.Regex.Regex
instance GHC.Classes.Eq BNFC.Types.Regex.Regex
instance BNFC.Types.Regex.Satisfiable BNFC.Types.Regex.Regex
instance BNFC.Types.Regex.Satisfiable BNFC.Types.Regex.CharClass
instance BNFC.Types.Regex.Satisfiable BNFC.Types.Regex.CharClassUnion
instance GHC.Classes.Eq BNFC.Types.Regex.CharClassUnion
instance GHC.Base.Semigroup BNFC.Types.Regex.CharClassUnion
instance GHC.Base.Monoid BNFC.Types.Regex.CharClassUnion

module BNFC.Types.Position
data WithPosition a
WithPosition :: !Position -> a -> WithPosition a
[wpPos] :: WithPosition a -> !Position
[wpThing] :: WithPosition a -> a
data WithPosition' a
WithPosition' :: !Position' -> a -> WithPosition' a
[wpPos'] :: WithPosition' a -> !Position'
[wpThing'] :: WithPosition' a -> a
type Position' = Maybe Position
data Position
Position :: !Int -> !Int -> Position

-- | Starting at line, counting from 1. (0 for invalid line.)
[posLine] :: Position -> !Int

-- | Starting at column, counting from 1. (0 for invalid column.)
[posCol] :: Position -> !Int

-- | Something that can be parsed into a <a>Position</a>.
class ToPosition p
toPosition :: ToPosition p => p -> Position

-- | Something that can be parsed into a <a>Position'</a>.
class ToPosition' p
toPosition' :: ToPosition' p => p -> Position'
instance GHC.Show.Show BNFC.Types.Position.Position
instance GHC.Classes.Ord BNFC.Types.Position.Position
instance GHC.Classes.Eq BNFC.Types.Position.Position
instance Data.Traversable.Traversable BNFC.Types.Position.WithPosition'
instance Data.Foldable.Foldable BNFC.Types.Position.WithPosition'
instance GHC.Base.Functor BNFC.Types.Position.WithPosition'
instance GHC.Show.Show a => GHC.Show.Show (BNFC.Types.Position.WithPosition' a)
instance Data.Traversable.Traversable BNFC.Types.Position.WithPosition
instance Data.Foldable.Foldable BNFC.Types.Position.WithPosition
instance GHC.Base.Functor BNFC.Types.Position.WithPosition
instance GHC.Show.Show a => GHC.Show.Show (BNFC.Types.Position.WithPosition a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (BNFC.Types.Position.WithPosition a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (BNFC.Types.Position.WithPosition a)
instance BNFC.Types.Position.ToPosition' BNFC.Types.Position.Position'
instance BNFC.Types.Position.ToPosition' BNFC.Types.Position.Position
instance BNFC.Types.Position.ToPosition' (GHC.Types.Int, GHC.Types.Int)
instance BNFC.Types.Position.ToPosition' (GHC.Maybe.Maybe (GHC.Types.Int, GHC.Types.Int))
instance BNFC.Types.Position.ToPosition BNFC.Types.Position.Position
instance BNFC.Types.Position.ToPosition (GHC.Types.Int, GHC.Types.Int)
instance BNFC.Utils.Decoration.Decoration BNFC.Types.Position.WithPosition
instance BNFC.Utils.Decoration.Decoration BNFC.Types.Position.WithPosition'
instance GHC.Enum.Bounded BNFC.Types.Position.Position

module BNFC.Options.Target

-- | Target languages
data TargetLanguage
TargetAgda :: TargetLanguage
TargetC :: TargetLanguage
TargetCpp :: TargetLanguage
TargetCppNoStl :: TargetLanguage
TargetHaskell :: TargetLanguage
TargetLatex :: TargetLanguage
TargetJava :: TargetLanguage
TargetOCaml :: TargetLanguage
TargetPygments :: TargetLanguage
TargetTxt2Tags :: TargetLanguage
TargetCheck :: TargetLanguage
instance GHC.Classes.Ord BNFC.Options.Target.TargetLanguage
instance GHC.Enum.Enum BNFC.Options.Target.TargetLanguage
instance GHC.Enum.Bounded BNFC.Options.Target.TargetLanguage
instance GHC.Classes.Eq BNFC.Options.Target.TargetLanguage
instance GHC.Show.Show BNFC.Options.Target.TargetLanguage


-- | Global options parser.
module BNFC.Options.GlobalOptions

-- | Global options.
data GlobalOptions
GlobalOptions :: Bool -> Bool -> Bool -> Maybe FilePath -> Bool -> FilePath -> GlobalOptions
[optVerbose] :: GlobalOptions -> Bool
[optDryRun] :: GlobalOptions -> Bool
[optForce] :: GlobalOptions -> Bool
[optOutDir] :: GlobalOptions -> Maybe FilePath
[optMakeFile] :: GlobalOptions -> Bool
[optInput] :: GlobalOptions -> FilePath

-- | Global options parser.
globalOptionsParser :: Parser GlobalOptions
instance GHC.Show.Show BNFC.Options.GlobalOptions.GlobalOptions

module BNFC.Backend.Latex.State
newtype LatexBackendState
LatexSt :: GlobalOptions -> LatexBackendState
[globalOpt] :: LatexBackendState -> GlobalOptions

module BNFC.Lexing

-- | Create regex for multiline comments.
--   
--   <pre>
--   &gt;&gt;&gt; debugPrint $ mkRegMultilineComment "&lt;" "&gt;"
--   '&lt;'(char-'&gt;')*'&gt;'
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; debugPrint $ mkRegMultilineComment "/*" "*/"
--   {"/*"}(char-'*')*'*'((char-["*/"])(char-'*')*'*'|'*')*'/'
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; debugPrint $ mkRegMultilineComment "&lt;!--" "--&gt;"
--   {"&lt;!--"}(char-'-')*'-'((char-'-')+'-')*'-'((char-["-&gt;"])(char-'-')*'-'((char-'-')+'-')*'-'|'-')*'&gt;'
--   </pre>
mkRegMultilineComment :: String -> String -> Regex


-- | Converting back to and forth from LBNF regular regular expression.
module BNFC.Check.Regex

-- | Convert LBNF regular expression into internal format.
normRegex :: Reg -> Regex

-- | Convert from internal format to LBNF regular expression.
class ReifyRegex a
reifyRegex :: ReifyRegex a => a -> Reg
instance BNFC.Check.Regex.ReifyRegex BNFC.Types.Regex.CharClassUnion
instance BNFC.Check.Regex.ReifyRegex BNFC.Types.Regex.Regex
instance BNFC.Check.Regex.ReifyRegex BNFC.Types.Regex.CharClass

module BNFC.Backend.Txt2Tags.Options
newtype Txt2TagsBackendOptions
TxtOpts :: String -> Txt2TagsBackendOptions
[target] :: Txt2TagsBackendOptions -> String
txt2tagsOptionsParser :: Parser Txt2TagsBackendOptions

module BNFC.Backend.Txt2Tags.State
data Txt2TagsBackendState
Txt2TagsSt :: GlobalOptions -> Txt2TagsBackendOptions -> Txt2TagsBackendState
[globalOpt] :: Txt2TagsBackendState -> GlobalOptions
[txtOpts] :: Txt2TagsBackendState -> Txt2TagsBackendOptions

module BNFC.Backend.Txt2Tags.InitState
txt2tagsInitState :: GlobalOptions -> Txt2TagsBackendOptions -> Except String Txt2TagsBackendState

module BNFC.Backend.Latex.InitState
latexInitState :: GlobalOptions -> Except String LatexBackendState


-- | Haskell's reserved words.
module BNFC.Backend.Haskell.Utilities.ReservedWords
hsReservedWords :: [String]

-- | Modifier to avoid clashes in definition.
avoidReservedWords :: String -> String
avoidReservedWordsArgs :: String -> String
avoidReservedWords' :: String1 -> String
avoidReservedWordsArgs' :: String1 -> String
avoidReservedWords1 :: String1 -> String1

module BNFC.Backend.Haskell.Options
data HaskellBackendOptions
HaskellOpts :: Maybe String -> Bool -> TokenText -> Bool -> Bool -> Bool -> Bool -> Bool -> HaskellBackendOptions
[nameSpace] :: HaskellBackendOptions -> Maybe String
[inDir] :: HaskellBackendOptions -> Bool
[tokenText] :: HaskellBackendOptions -> TokenText
[functor] :: HaskellBackendOptions -> Bool
[generic] :: HaskellBackendOptions -> Bool
[xml] :: HaskellBackendOptions -> Bool
[xmlt] :: HaskellBackendOptions -> Bool
[gadt] :: HaskellBackendOptions -> Bool
haskellOptionsParser :: Parser HaskellBackendOptions
tokenTextReader :: ReadM TokenText
showTokenText :: TokenText -> String

-- | How to represent token content in the Haskell backend?
data TokenText

-- | Represent strings as <tt>String</tt>.
StringToken :: TokenText

-- | Represent strings as <tt>Data.Text</tt>.
TextToken :: TokenText
isStringToken :: TokenText -> Bool
isTextToken :: TokenText -> Bool
printHaskellOptions :: HaskellBackendOptions -> String
instance GHC.Show.Show BNFC.Backend.Haskell.Options.TokenText
instance GHC.Classes.Ord BNFC.Backend.Haskell.Options.TokenText
instance GHC.Classes.Eq BNFC.Backend.Haskell.Options.TokenText
instance GHC.Enum.Enum BNFC.Backend.Haskell.Options.TokenText
instance GHC.Enum.Bounded BNFC.Backend.Haskell.Options.TokenText

module BNFC.Backend.Common.Utils

-- | The name of a module, e.g. <a>Foo.Abs</a>, <a>Foo.Print</a> etc.
type ModuleName = String

-- | Generalization of <a>unless</a>.
unless :: Monoid m => Bool -> m -> m

-- | Generalization of <a>when</a>.
when :: Monoid m => Bool -> m -> m
prPrec :: Int -> Int -> Doc () -> Doc ()
docToString :: LayoutOptions -> Doc () -> String

-- | Replace all occurences of a value by another value
replace :: (Eq a, Functor f) => a -> a -> f a -> f a

module BNFC.Backend.Haskell.GADT.ComposOp
composOp :: ModuleName -> String
composOpDoc :: ModuleName -> Doc ()

module BNFC.Backend.Common.StringUtils

-- | Helper function that escapes characters in strings &gt;&gt;&gt;
--   escapeChars "\" "\\" &gt;&gt;&gt; escapeChars """ "\"" &gt;&gt;&gt;
--   escapeChars "'" "\'"
escapeChars :: String -> String
fstCharUpper :: String -> String
fstCharLower :: String -> String


-- | The internal representation of LBNF grammars.
--   
--   Pragmas have been desugared as far as possible.
module BNFC.CF

-- | The internal representation of a LBNF grammar.
--   
--   The name is an abbreviation of Context-Free (Grammar).
--   
--   Rules are stored in:
--   
--   <ol>
--   <li>The signature: a map from rule names to their type (Id labels
--   only). The signature is used for type-checking definitions and special
--   rules (lists).</li>
--   <li>The AST rules: a map from categories to labels to rhss. This
--   representation is useful for generating the abstract syntax and the
--   printer. Keywords are not trimmed here to allow the extra whitespace
--   to be printed (see BNFC/bnfc#70).</li>
--   <li>The parser rules: a map from categories to rhss to labels.
--   <tt>internal</tt> rules are not contained in this map. This
--   representation expresses that each parseable BNF rule can have at most
--   one label. It is useful for detecting overlapping rules, e.g. coming
--   from proper rules and list/coercion pragmas. The parser generation
--   should start with these rules. Keywords are trimmed since
--   BNFC-generated parsers are not whitespace-sensitive.</li>
--   </ol>
data LBNF
LBNF :: Signature -> Functions -> ASTRules -> ASTRulesAP -> UsedBuiltins -> ParserRules -> UsedBuiltins -> EntryPoints -> TokenDefs -> KeywordUses -> SymbolUses -> SymbolsKeywords -> LineComments -> BlockComments -> LayoutKeywords -> LayoutKeywords -> Maybe Position -> LBNF

-- | Type for each AST constructor and defined function.
[_lbnfSignature] :: LBNF -> Signature

-- | Checked functions from <tt>define</tt> pragmas.
[_lbnfFunctions] :: LBNF -> Functions

-- | Per category, its rules ordered by label.
[_lbnfASTRules] :: LBNF -> ASTRules

-- | AST rules used to generate abstract syntax and printer. Per type
--   (category without precedence), its rules non terminals and a map from
--   category precedence to rhs, ordered by label.
[_lbnfASTRulesAP] :: LBNF -> ASTRulesAP

-- | Builtin categories <tt>Char, Integer, ...</tt> (non-overwritten)
--   mentioned in the AST. (Includes builtin categories only mentioned in
--   <a>Internal</a> rules.)
[_lbnfASTBuiltins] :: LBNF -> UsedBuiltins

-- | Per category, its <a>Parseable</a> rules ordered by <a>RHS</a>.
[_lbnfParserRules] :: LBNF -> ParserRules

-- | Builtin categories <tt>Char, Integer, ...</tt> mentioned in the
--   <a>Parseable</a> rules. (and not overwritten).
[_lbnfParserBuiltins] :: LBNF -> UsedBuiltins

-- | Collection of entry points for parser, each with the position(s) where
--   it was declared entry point.
[_lbnfEntryPoints] :: LBNF -> EntryPoints

-- | User-defined token categories.
[_lbnfTokenDefs] :: LBNF -> TokenDefs

-- | Keywords and their occurrences in rhss. Computed by pass 1.
[_lbnfKeywords] :: LBNF -> KeywordUses

-- | Symbols and their occurrences in rhss. Computed by pass 1.
[_lbnfSymbols] :: LBNF -> SymbolUses

-- | Symbols and keywords used in lexer and parser specifications
[_lbnfSymbolsKeywords] :: LBNF -> SymbolsKeywords

-- | Line comment pragmas by position, e.g. <tt>comment "--"</tt>.
[_lbnfLineComments] :: LBNF -> LineComments

-- | Block comment pragmas by position, e.g. <tt>comment "{-" "-}"</tt>.
[_lbnfBlockComments] :: LBNF -> BlockComments

-- | <tt>layout</tt> start keywords with the pragma position. Keywords are
--   members of <a>_lbnfKeywords</a>.
[_lbnfLayoutStart] :: LBNF -> LayoutKeywords

-- | <tt>layout stop</tt> keywords with the pragma position. Disjoint from
--   <tt>_lbnfLayout</tt>. Keywords are members of <a>_lbnfKeywords</a>.
[_lbnfLayoutStop] :: LBNF -> LayoutKeywords

-- | <a>Position</a> of <tt>layout toplevel</tt>, if present.
[_lbnfLayoutTop] :: LBNF -> Maybe Position
type Signature = Map LabelName (WithPosition FunType)
type Functions = Map LabelName (WithPosition Function)
type ASTRules = Map Cat (Map Label (WithPosition ARuleRHS))
type ASTRulesAP = Map Type (Map Label ([Type], (Integer, WithPosition ARHS)))
type ParserRules = Map Cat (Map RHS (WithPosition RuleLabel))
type EntryPoints = Map Cat (List1 Position)
type UsedBuiltins = Map BuiltinCat (List1 Position)
type TokenDefs = Map CatName (WithPosition TokenDef)
type KeywordUses = Map Keyword (List1 Position)
type SymbolUses = Map Symbol (List1 Position)
type SymbolsKeywords = Map String1 Int
type LineComments = Map Position LineComment
type BlockComments = Map Position BlockComment
type LayoutKeywords = Map Keyword Position
initLBNF :: LBNF

-- | A token category is defined by a regular expression.
data TokenDef
TokenDef :: PositionToken -> Regex -> Bool -> TokenDef

-- | Is it a <tt>position token</tt>?
[positionToken] :: TokenDef -> PositionToken

-- | The defining regular expression.
[regexToken] :: TokenDef -> Regex

-- | Is it the <tt>Ident</tt> token?
[isIdent] :: TokenDef -> Bool

-- | Keywords are non-empty <tt>trim</tt>med strings. Trimming happens
--   since LBNF is a whitespace-insensitive formalism. Should a future
--   version of BNFC become whitespace sensitive, we have to abstain from
--   <tt>trim</tt>ming keywords by default.
newtype Keyword
Keyword :: List1 Char -> Keyword
[theKeyword] :: Keyword -> List1 Char
newtype Symbol
Symbol :: List1 Char -> Symbol
[theSymbol] :: Symbol -> List1 Char
newtype LineComment
LineComment :: String1 -> LineComment
data BlockComment
BlockComment :: String1 -> String1 -> BlockComment
type CatName = String1
type Cat = Cat' BaseCat

-- | Categories (non-terminals).
data Cat' a

-- | Base category, e.g. <tt>Ident</tt>, <tt>Exp</tt>.
Cat :: a -> Cat' a

-- | List non-terminals, e.g., <tt>[Ident]</tt>, <tt>[Exp]</tt>,
--   <tt>[Exp1]</tt>.
ListCat :: Cat' a -> Cat' a

-- | E.g. <tt>Exp1</tt>, <tt>Exp2</tt>.
CoerceCat :: CatName -> Integer -> Cat' a
data BaseCat

-- | <tt>Char</tt>, <tt>Double</tt>, <tt>Integer</tt>, <tt>String</tt>.
BuiltinCat :: BuiltinCat -> BaseCat

-- | <pre>
--   Ident
--   </pre>
IdentCat :: IdentCat -> BaseCat

-- | User-defined <tt>token</tt> category.
TokenCat :: CatName -> BaseCat

-- | Base category defined by CFG, like <tt>Exp</tt>.
BaseCat :: CatName -> BaseCat

-- | Built-in token categories with special token representation.
data BuiltinCat

-- | <pre>
--   Char
--   </pre>
BChar :: BuiltinCat

-- | <pre>
--   Double
--   </pre>
BDouble :: BuiltinCat

-- | <pre>
--   Integer
--   </pre>
BInteger :: BuiltinCat

-- | <pre>
--   String
--   </pre>
BString :: BuiltinCat

-- | Built-in token Ident, treated as a string.
data IdentCat

-- | <pre>
--   Ident
--   </pre>
BIdent :: IdentCat

-- | Types are categories without the precedences (<a>CoerceCat</a>).
data Type

-- | Base category.
BaseType :: BaseCat -> Type

-- | List category.
ListType :: Type -> Type

-- | Function type <tt>t(t₁,...,tₙ)</tt> or <tt>t₁ → ... → tₙ → t</tt>.
data FunType
FunType :: Type -> [Type] -> FunType

-- | Result type.
[targetType] :: FunType -> Type

-- | Types of parameters, left to right.
[argTypes] :: FunType -> [Type]

-- | Bodies of <a>Function</a>. For convenience, these are fully typed.
data Exp

-- | (Possibly defined) label with its type applied to the correct number
--   of expressions.
App :: Label -> FunType -> [Exp] -> Exp

-- | Use of function parameter.
Var :: Parameter -> Exp
LitInteger :: Integer -> Exp
LitDouble :: Double -> Exp
LitChar :: Char -> Exp
LitString :: String -> Exp

-- | Bound variable.
data Parameter
Parameter :: VarName -> Type -> Parameter
[paramName] :: Parameter -> VarName
[paramType] :: Parameter -> Type
type VarName = String1

-- | Definition body of a constructor.
data Function
Function :: [Parameter] -> Exp -> Type -> Function
[funPars] :: Function -> [Parameter]
[funBody] :: Function -> Exp
[funType] :: Function -> Type

-- | Label names are nonempty strings.
type LabelName = String1

-- | LBNF rule label (AST constructor).
data Label

-- | ordinary rule label (uppercase)
LId :: LabelName -> Label

-- | defined label (lowercase) No representation in AST:
LDef :: LabelName -> Label

-- | coercion <tt>_</tt> List labels, mapped to the list constructors of
--   the target language.
LWild :: Label

-- | empty list <tt>[]</tt>
LNil :: Label

-- | singleton list <tt>(:[])</tt> ("robot gorilla")
LSg :: Label

-- | list constructor <tt>(:)</tt>
LCons :: Label

-- | Element of a rule right hand side (rhs).
data Item' a

-- | Keyword or symbol (not represented in AST).
Terminal :: a -> Item' a

-- | Category (represented in AST).
NTerminal :: Cat -> Item' a
type AItem = Item' String1 " AST/printer flavor."
type Item = Item' Keyword " Parser flavor."

-- | The bare rhs of a rule.
type RHS' a = [Item' a]
type ARHS = RHS' String1
type RHS = RHS' Keyword

-- | The origin of a rule.
data RuleOrigin

-- | Ordinary LBNF rule.
FromOrdinary :: RuleOrigin

-- | Expanded from <tt>rules</tt> pragma.
FromRules :: RuleOrigin

-- | Expanded from <tt>coercions</tt> pragma.
FromCoercions :: RuleOrigin

-- | Expanded from list pragma: <tt>separator</tt> or <tt>terminator</tt>.
FromList :: RuleOrigin

-- | The AST-flavor representation of the rule rhs with meta information.
data ARuleRHS
ARuleRHS :: RuleOrigin -> Parseable -> ARHS -> ARuleRHS

-- | A rule can also originate from pragmas.
[aruleOrigin] :: ARuleRHS -> RuleOrigin

-- | <tt>internal</tt> or parseable?
[aruleParseable] :: ARuleRHS -> Parseable

-- | Right hand side.
[aruleRHS] :: ARuleRHS -> ARHS

-- | The parser-flavor representation of the rule label with meta
--   information.
data RuleLabel
RuleLabel :: RuleOrigin -> Label -> RuleLabel

-- | A rule can also originate from pragmas.
[ruleOrigin] :: RuleLabel -> RuleOrigin

-- | The name of the rule.
[ruleLabel] :: RuleLabel -> Label
data Separator' a

-- | E.g. <tt>separator _ ","</tt>.
Separator :: a -> Separator' a

-- | E.g. <tt>terminator _ ";"</tt>. The last case is better represented as
--   <tt>Nothing</tt>. -- | NoSeparator -- -- ^ E.g. <tt>separator _
--   ""</tt> or <tt>terminator _ ""</tt>.
Terminator :: a -> Separator' a
type ASeparator = Separator' String1
type Separator = Separator' Keyword

-- | Is a rule relevant for the parser or only for the AST/printer?
data Parseable

-- | <tt>internal</tt> rule (only for AST &amp; printer)
Internal :: Parseable

-- | ordinary rule (also for parser)
Parseable :: Parseable

-- | Does a token category carry position information?
data PositionToken

-- | from 'position token' pragma
PositionToken :: PositionToken

-- | from ordinary <tt>token</tt> pragma
NoPositionToken :: PositionToken
lbnfTokenDefs :: Lens' LBNF TokenDefs
lbnfSymbolsKeywords :: Lens' LBNF SymbolsKeywords
lbnfSymbols :: Lens' LBNF SymbolUses
lbnfSignature :: Lens' LBNF Signature
lbnfParserRules :: Lens' LBNF ParserRules
lbnfParserBuiltins :: Lens' LBNF UsedBuiltins
lbnfLineComments :: Lens' LBNF LineComments
lbnfLayoutTop :: Lens' LBNF (Maybe Position)
lbnfLayoutStop :: Lens' LBNF LayoutKeywords
lbnfLayoutStart :: Lens' LBNF LayoutKeywords
lbnfKeywords :: Lens' LBNF KeywordUses
lbnfFunctions :: Lens' LBNF Functions
lbnfEntryPoints :: Lens' LBNF EntryPoints
lbnfBlockComments :: Lens' LBNF BlockComments
lbnfASTRulesAP :: Lens' LBNF ASTRulesAP
lbnfASTRules :: Lens' LBNF ASTRules
lbnfASTBuiltins :: Lens' LBNF UsedBuiltins

-- | Convert <a>Cat</a> to <a>Type</a>, converting <a>CoerceCat</a> to
--   <a>BaseCat</a>.
catToType :: Cat -> Type
catToIdentifier :: Cat -> String1
baseCatToIdentifier :: BaseCat -> String1

-- | Print <tt>CatName</tt> from <tt>Cat</tt> in AST generator.
printCatName :: Cat -> String
printCatNamePrec :: Cat -> String
printCatNamePrec' :: Cat -> String
catToString :: Cat -> String
printBaseCatName :: BaseCat -> String

-- | is <tt>Cat</tt> coerced?
isCatCoerced :: Cat -> Bool

-- | is <tt>Cat</tt> list category?
isCatList :: Cat -> Bool

-- | is <tt>Cat</tt> between used builtins.
isCatBuiltin :: Cat -> Bool

-- | get <tt>Cat</tt> coercion number, returns 0 if <tt>Cat</tt> is not
--   coerced.
getCatPrec :: Cat -> Integer

-- | When given a list Cat, i.e. '[C]', it removes the square brackets, and
--   adds the prefix List, i.e. <tt>ListC</tt>. (for Happy and Latex)
identCat :: Cat -> String
isBuiltin :: BaseCat -> Bool
isIdentifier :: BaseCat -> Bool
isToken :: BaseCat -> Bool
builtinCats :: [(BuiltinCat, String1)]
printBuiltinCat :: BuiltinCat -> String1
printIdentCat :: IdentCat -> String1
parseBuiltinCat :: String1 -> Maybe (Either IdentCat BuiltinCat)
identBuiltinCats :: [(Either IdentCat BuiltinCat, String1)]
tChar :: Type
tDouble :: Type
tInteger :: Type
tString :: Type
printTypeName :: Type -> String

-- | When given a list Type, i.e. '[C]', it removes the square brackets,
--   and adds the prefix List, i.e. <tt>ListC</tt>. (for Happy and Latex)
identType :: Type -> String
isListType :: Type -> Bool
isBuiltinType :: Type -> Bool
isIdentType :: Type -> Bool
isTokenType :: Type -> Bool
labelFromIdentifier :: LabelName -> Label

-- | Print <tt>Label</tt> name.
printLabelName :: Label -> String
printRuleName :: Label -> String
isDef :: Label -> Bool
isCoercion :: Label -> Bool
isList :: Label -> Bool
isALabel :: Label -> Bool
isPLabel :: Label -> Bool

-- | Filter <tt>Label</tt>s that will be printed in the AST datatypes.
filterLabelsAST :: [String] -> [(Label, ([Type], (Integer, ARHS)))] -> [(Label, ([Type], (Integer, ARHS)))]

-- | Filter <tt>Label</tt>s that will be printed in the Pretty printer.
filterLabelsPrinter :: [String] -> [(Label, ([Type], (Integer, ARHS)))] -> [(Label, ([Type], (Integer, ARHS)))]

-- | Print names of <tt>Cat</tt> in a rhs.
printRhsCats :: [Item' a] -> [String]

-- | Print rhs <tt>Item</tt>s, both non terminals and terminals.
printRHS :: [Item' Keyword] -> [String]

-- | Get <tt>Cat</tt>s in a rhs.
getRhsCats :: [Item' a] -> [Cat]
printItemName :: Item' String1 -> String
isNTerminal :: Item' a -> Bool
isItemListCat :: Item' a -> Bool
isItemBuiltin :: Item' a -> Bool

-- | Get the non-terminals of a rhs in left-to-right order.
rhsCats :: RHS' a -> [Cat]

-- | Get the types of a rhs.
rhsType :: RHS' a -> [Type]

-- | does a token definition contain a no position token.
isNoPositionToken :: WithPosition TokenDef -> Bool

-- | does a token definition contain (with position) a position token.
isPositionToken :: WithPosition TokenDef -> Bool

-- | does a token definition contain a position token.
isPosToken :: TokenDef -> Bool
hasIdentifier :: TokenDefs -> Bool

-- | Print <tt>Exp</tt> (function body in define pragma).
printExp :: Bool -> String -> Exp -> String
printExp1 :: Exp -> String
printExp2 :: String -> Exp -> String
isApp1 :: Exp -> Bool
isApp2 :: Exp -> Bool

-- | All-whitespace strings (in particular, empty strings) give
--   <a>Nothing</a>.
getKeyword :: Separator -> Keyword
parseKeyword :: String -> Maybe Keyword
parseASeparator :: Separator' String -> Maybe ASeparator
trimSeparator :: ASeparator -> Maybe Separator
lookupRHS :: Cat -> RHS -> ParserRules -> Maybe (WithPosition RuleLabel)
layoutsAreUsed :: LBNF -> Bool
instance GHC.Classes.Ord BNFC.CF.Keyword
instance GHC.Classes.Eq BNFC.CF.Keyword
instance GHC.Classes.Ord BNFC.CF.Symbol
instance GHC.Classes.Eq BNFC.CF.Symbol
instance GHC.Show.Show BNFC.CF.LineComment
instance GHC.Show.Show BNFC.CF.BlockComment
instance GHC.Show.Show a => GHC.Show.Show (BNFC.CF.Cat' a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (BNFC.CF.Cat' a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (BNFC.CF.Cat' a)
instance GHC.Enum.Enum BNFC.CF.BuiltinCat
instance GHC.Enum.Bounded BNFC.CF.BuiltinCat
instance GHC.Show.Show BNFC.CF.BuiltinCat
instance GHC.Classes.Ord BNFC.CF.BuiltinCat
instance GHC.Classes.Eq BNFC.CF.BuiltinCat
instance GHC.Show.Show BNFC.CF.IdentCat
instance GHC.Classes.Ord BNFC.CF.IdentCat
instance GHC.Classes.Eq BNFC.CF.IdentCat
instance GHC.Show.Show BNFC.CF.BaseCat
instance GHC.Classes.Ord BNFC.CF.BaseCat
instance GHC.Classes.Eq BNFC.CF.BaseCat
instance GHC.Show.Show BNFC.CF.Type
instance GHC.Classes.Ord BNFC.CF.Type
instance GHC.Classes.Eq BNFC.CF.Type
instance GHC.Show.Show BNFC.CF.FunType
instance GHC.Classes.Eq BNFC.CF.FunType
instance GHC.Show.Show BNFC.CF.Parameter
instance GHC.Show.Show BNFC.CF.Label
instance GHC.Classes.Ord BNFC.CF.Label
instance GHC.Classes.Eq BNFC.CF.Label
instance GHC.Show.Show BNFC.CF.Exp
instance GHC.Show.Show BNFC.CF.Function
instance Data.Traversable.Traversable BNFC.CF.Item'
instance Data.Foldable.Foldable BNFC.CF.Item'
instance GHC.Base.Functor BNFC.CF.Item'
instance GHC.Show.Show a => GHC.Show.Show (BNFC.CF.Item' a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (BNFC.CF.Item' a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (BNFC.CF.Item' a)
instance GHC.Show.Show BNFC.CF.RuleOrigin
instance GHC.Classes.Ord BNFC.CF.RuleOrigin
instance GHC.Classes.Eq BNFC.CF.RuleOrigin
instance GHC.Show.Show BNFC.CF.RuleLabel
instance GHC.Classes.Eq BNFC.CF.RuleLabel
instance Data.Traversable.Traversable BNFC.CF.Separator'
instance Data.Foldable.Foldable BNFC.CF.Separator'
instance GHC.Base.Functor BNFC.CF.Separator'
instance GHC.Show.Show a => GHC.Show.Show (BNFC.CF.Separator' a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (BNFC.CF.Separator' a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (BNFC.CF.Separator' a)
instance GHC.Show.Show BNFC.CF.Parseable
instance GHC.Classes.Ord BNFC.CF.Parseable
instance GHC.Classes.Eq BNFC.CF.Parseable
instance GHC.Show.Show BNFC.CF.ARuleRHS
instance GHC.Classes.Eq BNFC.CF.ARuleRHS
instance GHC.Show.Show BNFC.CF.PositionToken
instance GHC.Classes.Ord BNFC.CF.PositionToken
instance GHC.Classes.Eq BNFC.CF.PositionToken
instance GHC.Show.Show BNFC.CF.TokenDef
instance GHC.Show.Show BNFC.CF.LBNF
instance GHC.Show.Show BNFC.CF.Symbol
instance GHC.Show.Show BNFC.CF.Keyword


-- | The checker monad.
--   
--   Responsible for throwing errors and accumulating warnings.
module BNFC.Check.Monad

-- | Monad for error reporting and warnings.
class Monad m => MonadCheck m
fatalError :: MonadCheck m => FatalError -> m a
recoverableError :: MonadCheck m => RecoverableError -> m ()
warn :: MonadCheck m => Warning -> m ()

-- | Set the file position for subsequent errors.
atPosition :: (MonadCheck m, ToPosition' p) => p -> m a -> m a

-- | Retrieve the stored position.
askPosition :: MonadCheck m => m Position'
fatalError :: (MonadCheck m, MonadTrans t, MonadCheck n, t n ~ m) => FatalError -> m a
recoverableError :: (MonadCheck m, MonadTrans t, MonadCheck n, t n ~ m) => RecoverableError -> m ()
warn :: (MonadCheck m, MonadTrans t, MonadCheck n, t n ~ m) => Warning -> m ()

-- | Set the file position for subsequent errors.
atPosition :: (MonadCheck m, MonadTransControl t, MonadCheck n, t n ~ m) => ToPosition' p => p -> m a -> m a

-- | Retrieve the stored position.
askPosition :: (MonadCheck m, MonadTrans t, MonadCheck n, t n ~ m) => m Position'

-- | Fatal errors (check cannot continue).
data FatalError
FatalError :: FatalError

-- | The given label isn't contained in the <a>Signature</a>.
UndefinedLabel :: LabelName -> FatalError

-- | A list expression was found at the given type, which isn't a
--   <a>ListType</a>.
ListsDontInhabitType :: Type -> FatalError

-- | Any of these errors allows to continue BNFC, but may result in
--   undesired/illformed output.
data RecoverableError

-- | The pragma <tt>delimiters</tt> has been removed in BNFC 2.9. Pragma is
--   ignored.
DelimitersNotSupported :: RecoverableError

-- | E.g. trying to mix ordinary rules with list pragmas or <tt>token</tt>
--   definitions. Redefinition is ignored.
IncompatibleDefinition :: ICat -> Position -> RecoverableError

-- | Trying to apply <tt>coercions</tt> pragma to a <a>CoerceCat</a>, e.g.
--   <tt>coercions Exp3 2</tt>. Pragma is ignored. Pass 2 errors
CoercionsOfCoerceCat :: RecoverableError

-- | Trying to apply <tt>coercions</tt> pragma to a <a>BuiltinCat</a>, e.g.
--   <tt>coercions Integer 2</tt>. Pragma is ignored.
CoercionsOfBuiltinCat :: RecoverableError

-- | Trying to apply <tt>coercions</tt> pragma to a <a>IdentCat</a>, e.g.
--   <tt>coercions Ident 2</tt>. Pragma is ignored.
CoercionsOfIdentCat :: RecoverableError

-- | Trying to apply <tt>coercions</tt> pragma to a <a>TokenCat</a>, e.g.
--   <tt>coercions Id 2</tt>. Pragma is ignored.
CoercionsOfTokenCat :: RecoverableError

-- | This base category is not defined.
UnknownCatName :: CatName -> RecoverableError

-- | Tried to make a precedence variant of a builtin category, like
--   <tt>Char3</tt>.
CoerceBuiltinCat :: BuiltinCat -> RecoverableError

-- | Tried to make a precedence variant of an ident category, like
--   <tt>Ident3</tt>.
CoerceIdentCat :: IdentCat -> RecoverableError

-- | Tried to make a precedence variant of a list category, like
--   <tt>[Arg3]</tt>.
CoerceListCat :: CatName -> RecoverableError

-- | Tried to make a precedence variant of a token category, like
--   <tt>Id3</tt>.
CoerceTokenCat :: CatName -> RecoverableError

-- | The label <a>LabelName</a> has been defined already, at
--   <a>Position</a>.
DuplicateLabel :: LabelName -> Position -> RecoverableError

-- | The same BNF rule already exists, at <a>Position</a>.
DuplicateRHS :: Position -> RecoverableError

-- | Cannot use ordinary or defined labels to construct a list category.
InvalidListRule :: LabelName -> RecoverableError

-- | List label to construct non-list category.
InvalidListLabel :: Type -> RecoverableError

-- | Invalid type for label <tt>[]</tt>.
InvalidLabelNil :: FunType -> RecoverableError

-- | Invalid type for label <tt>(:)</tt>.
InvalidLabelCons :: FunType -> RecoverableError

-- | Invalid type for label <tt>(:[])</tt>.
InvalidLabelSg :: FunType -> RecoverableError

-- | Invalid type for label <tt>_</tt>.
InvalidLabelWild :: FunType -> RecoverableError

-- | <tt>define</tt> pragma with unused label is skipped, since we don't
--   have its type.
IgnoringUndeclaredFunction :: RecoverableError

-- | Type checker added missing parameters in a <tt>define</tt>.
NotEnoughParameters :: List1 String1 -> RecoverableError

-- | These parameters were ignored since they are too many, according to
--   the type.
DroppingSpuriousParameters :: List1 Arg -> RecoverableError

-- | A constructor/function misses arguments of the given types.
MissingArguments :: LabelName -> List1 Type -> RecoverableError

-- | A constructor/function was given (these) more arguments than needed.
DroppingSpuriousArguments :: LabelName -> List1 Exp -> RecoverableError

-- | An expression of the first type was expected, but it has the second
--   type.
ExpectedVsInferredType :: Type -> Type -> RecoverableError

-- | Defined <tt>token</tt> category matches the empty string. Such a token
--   can be produced by the lexer when nothing else can be produced, but
--   then it can be produced infinitely often without making progress. This
--   may result in a loop in the lexer. Token definition is kept.
NullableToken :: CatName -> Regex -> RecoverableError

-- | One of the delimiters of a block comment is empty.
IllformedBlockComment :: RecoverableError

-- | A keyword appears both in <tt>layout</tt> and <tt>layout stop</tt>.
--   The redefinition is ignored. Final checks
ConflictingUsesOfLayoutKeyword :: Keyword -> Position -> RecoverableError

-- | No entrypoints have been defined. This is an error that does not block
--   any other checks, so it is "recoverable". But it makes flags failure
--   of the check phase, because later phases (e.g. parser generation) will
--   crash.
EmptyGrammar :: RecoverableError

-- | Any of these warnings drops the useless or redundant definition.
data Warning
FooWarning :: Warning

-- | The label <a>LabelName</a> clashes with a category of the same name
--   defined at <a>Position</a>.
LabelClashesWithCategory :: LabelName -> Position -> Warning

-- | <tt>coercions _ 0</tt> does not add any rules.
IgnoringNullCoercions :: Warning

-- | A list rule with different coercion levels of the base category.
--   Cannot implement faithful printer for such rules.
NonUniformListRule :: Cat -> [Cat] -> Warning

-- | Grammar permits upper case parameters, but this isn't Haskell-style
--   (which is the model for BNFC's expression syntax otherwise).
ParameterShouldBeLowerCase :: VarName -> Warning

-- | A parameter shadows a previous one.
ShadowingParameter :: VarName -> Warning

-- | The given label is shadowed by a parameter, which looks confusing.
ShadowedByParameter :: VarName -> Warning

-- | Defined <tt>token</tt> category may not match anything.
EmptyToken :: CatName -> Regex -> Warning

-- | <tt>comment ""</tt> is ignored.
IgnoringEmptyLineComment :: Warning

-- | <tt>comment "" ""</tt> is ignored.
IgnoringEmptyBlockComment :: Warning

-- | <tt>layout [stop] ""</tt> is simply ignored
EmptyLayoutKeyword :: Warning

-- | <tt>layout [stop] kw</tt> but <tt>kw</tt> is not mentioned in the
--   grammar.
UndefinedLayoutKeyword :: Keyword -> Warning

-- | This layout keyword already occurred in a pragma of the same kind.
DuplicateLayoutKeyword :: Keyword -> Position -> Warning

-- | <tt>layout toplevel</tt> already appeared at <a>Position</a>.
DuplicateLayoutTop :: Position -> Warning

-- | Intermediated form of categories. (No builtins/token types recognized
--   yet.)
type ICat = Cat' CatName
type PFatalError = WithPosition' FatalError
type PRecoverableError = WithPosition' RecoverableError
type PWarning = WithPosition' Warning
type PWarnErr = WithPosition' (Either RecoverableError Warning)
type RecoverableErrors = [PRecoverableError]
type Warnings = [PWarning]
type WarnErrs = [PWarnErr]

-- | The LBNF checker monad.
newtype Check a
Check :: ReaderT Position' (ExceptT PFatalError (Writer WarnErrs)) a -> Check a
[unCheck] :: Check a -> ReaderT Position' (ExceptT PFatalError (Writer WarnErrs)) a
runCheck :: Check a -> (Warnings, RecoverableErrors, Either PFatalError a)
instance GHC.Show.Show BNFC.Check.Monad.FatalError
instance GHC.Show.Show BNFC.Check.Monad.Warning
instance GHC.Show.Show BNFC.Check.Monad.RecoverableError
instance GHC.Base.Monad BNFC.Check.Monad.Check
instance GHC.Base.Applicative BNFC.Check.Monad.Check
instance GHC.Base.Functor BNFC.Check.Monad.Check
instance BNFC.Check.Monad.MonadCheck BNFC.Check.Monad.Check
instance BNFC.Check.Monad.MonadCheck m => BNFC.Check.Monad.MonadCheck (Control.Monad.Trans.Except.ExceptT e m)
instance BNFC.Check.Monad.MonadCheck m => BNFC.Check.Monad.MonadCheck (Control.Monad.Trans.Reader.ReaderT r m)
instance BNFC.Check.Monad.MonadCheck m => BNFC.Check.Monad.MonadCheck (Control.Monad.Trans.State.Lazy.StateT s m)


-- | First pass of processing a LBNF file.
--   
--   <ul>
--   <li>Find all the categories defined in a LBNF grammar.</li>
--   <li>Complain about duplicate categories, e.g. defined both by rules
--   and <tt>list</tt> or <tt>token</tt> pragmas.</li>
--   <li>Drops errorneous definitions, returning a list of errors. It is
--   possible to continue into pass 2 with the remaining definitions,
--   should the user desire so (switch <tt>--force</tt>).</li>
--   <li>Produces a map whose keys are the grammar categories parsed into
--   <a>ICat</a> intermediate format and whose values are their first
--   defining occurrences plus kind information.</li>
--   </ul>
--   
--   This pass does not transform the list of parsed definitions into an
--   intermediate format, e.g. for saving the translations of category
--   names to <a>ICat</a>. This could be done, but the translation is cheap
--   and deterministic, so it can be repeated in pass 2.
module BNFC.Check.Pass1

-- | The state and result of pass1.
data Pass1
Pass1 :: DefinedICats -> Map ICat (List1 (WithPosition Parseable)) -> Map Keyword (List1 Position) -> Pass1

-- | The categories defined by the grammar.
[_stDefinedCats] :: Pass1 -> DefinedICats

-- | The categories referenced (used) in the grammar. Occurrences in
--   <tt>internal</tt> rules will be labeled <a>Internal</a>.
[_stUsedCats] :: Pass1 -> Map ICat (List1 (WithPosition Parseable))

-- | The keywords used in the grammar.
[_stKeywords] :: Pass1 -> Map Keyword (List1 Position)
type DefinedICats = Map ICat PCatKind

-- | The kind of a category definition.
data CatKind

-- | given by rules and/or <tt>rules</tt> pragma
KRules :: List1 RuleKind -> CatKind

-- | given by <tt>separator</tt> or <tt>terminator</tt> pragma
KList :: CatKind

-- | given by <tt>token</tt> pragma
KToken :: PositionToken -> CatKind
type PCatKind = WithPosition CatKind

-- | The kind of a rule definition.
data RuleKind

-- | ordinary or <tt>internal</tt> rule
ROrdinary :: Parseable -> RuleKind

-- | <tt>rules</tt> pragma
RRules :: RuleKind

-- | <tt>coercion</tt> pragma
RCoercion :: RuleKind
stUsedCats :: Lens' Pass1 (Map ICat (List1 (WithPosition Parseable)))
stKeywords :: Lens' Pass1 (Map Keyword (List1 Position))
stDefinedCats :: Lens' Pass1 DefinedICats

-- | Entry point for pass 1.
checkLBNF :: Grammar -> Check (Grammar, Pass1)

-- | The monad for pass 1, manipulates <a>Pass1</a>.
type M = StateT Pass1 Check

-- | Check a whole grammar, swallowing errorneous definitions.
checkGrammar :: Grammar -> M Grammar

-- | Check a definition. Swallow it if it produces a recoverable error.
checkDef :: Def -> M (Maybe Def)
useCats :: AddCategories a => a -> M ()
useCatsInternal :: AddCategories a => a -> M ()

-- | Collect categories used in something.
class AddCategories a
addCategories :: AddCategories a => a -> ReaderT Parseable M ()
class AddKeywords a
addKeywords :: AddKeywords a => a -> M ()
ruleKind :: RuleKind -> CatKind
mergeKind :: CatKind -> CatKind -> Either () CatKind
parseCat :: Cat -> ICat
parseCoerceCat :: String -> ICat
identifierToCat :: Identifier -> Cat

-- | Resolve category.
parseICat :: ICat -> ReaderT DefinedICats Check Cat
data WithDefinition a
WithDefinition :: Def -> a -> WithDefinition a
[wdDef] :: WithDefinition a -> Def
[wdThing] :: WithDefinition a -> a
type PCatOrigin = WithPosition CatOrigin
data CatOrigin

-- | ordinary or <tt>internal</tt> rule
ORule :: CatOrigin

-- | <tt>rules</tt> pragma
ORules :: CatOrigin

-- | <tt>separator</tt> or <tt>terminator</tt> pragma
OList :: CatOrigin

-- | <tt>token</tt> definition (exclusive)
OToken :: CatOrigin
type PDCatKind = WithPosition (WithDefinition CatKind)
data CatInfo
CatInfo :: Parseable -> [PCatOrigin] -> CatInfo

-- | Does this category have at least one parseable rule?
[_catParsable] :: CatInfo -> Parseable

-- | Where is this category defined? For ordinary categories, list of
--   definitions that populate the category.
[_catOrigins] :: CatInfo -> [PCatOrigin]
catParsable :: Lens' CatInfo Parseable
catOrigins :: Lens' CatInfo [PCatOrigin]
instance Data.Traversable.Traversable BNFC.Check.Pass1.WithDefinition
instance Data.Foldable.Foldable BNFC.Check.Pass1.WithDefinition
instance GHC.Base.Functor BNFC.Check.Pass1.WithDefinition
instance GHC.Show.Show a => GHC.Show.Show (BNFC.Check.Pass1.WithDefinition a)
instance GHC.Show.Show BNFC.Check.Pass1.CatOrigin
instance GHC.Classes.Ord BNFC.Check.Pass1.CatOrigin
instance GHC.Classes.Eq BNFC.Check.Pass1.CatOrigin
instance GHC.Show.Show BNFC.Check.Pass1.CatInfo
instance BNFC.Types.Position.ToPosition p => BNFC.Check.Pass1.AddKeywords (p, GHC.Base.String)
instance BNFC.Check.Pass1.AddKeywords a => BNFC.Check.Pass1.AddKeywords [a]
instance BNFC.Check.Pass1.AddKeywords BNFC.Abs.RHS
instance BNFC.Check.Pass1.AddKeywords BNFC.Abs.Item
instance BNFC.Check.Pass1.AddCategories (BNFC.Types.Position.WithPosition BNFC.Check.Monad.ICat)
instance BNFC.Check.Pass1.AddCategories BNFC.Abs.Cat
instance BNFC.Check.Pass1.AddCategories a => BNFC.Check.Pass1.AddCategories [a]
instance BNFC.Check.Pass1.AddCategories BNFC.Abs.RHS
instance BNFC.Check.Pass1.AddCategories BNFC.Abs.Item
instance GHC.Show.Show BNFC.Check.Pass1.RuleKind
instance GHC.Show.Show BNFC.Check.Pass1.CatKind
instance GHC.Show.Show BNFC.Check.Pass1.Pass1


-- | Check definition bodies.
--   
--   Simple first-order type-checking for the bodies of <tt>define</tt>d
--   constructors.
module BNFC.Check.Expressions

-- | Entry point to check contents of a <a>Function</a>.
checkFunction :: Position -> Signature -> LabelName -> [Arg] -> Exp -> FunType -> Check Function
instance GHC.Show.Show BNFC.Check.Expressions.Env


-- | Second pass of processing a LBNF file.
module BNFC.Check.Pass2

-- | Entry point for pass 2.
checkLBNF :: Grammar -> Pass1 -> Check LBNF
filterParseable :: List1 (WithPosition Parseable) -> Maybe (List1 Position)

-- | The monad for pass2.
type M = ReaderT Pass1 (StateT LBNF Check)
checkGrammar :: Grammar -> M ()

-- | If no entrypoints are given explicitly, take the first non-terminal.
--   If no non-terminal is defined, raise an error
checkEntryPoints :: M ()
checkDef :: Def -> M ()
parseICat :: ICat -> M Cat

-- | Check that a category is defined and convert it into internal
--   representation
checkCat :: Cat -> M (WithPosition Cat)

-- | Convert a LBNF label into internal representation.
parseLabel :: Label -> WithPosition Label

-- | Convert an LBNF item (terminal or non-terminal) to internal
--   representation.
checkItem :: Item -> M (Maybe (WithPosition AItem))

-- | Check that (1) ordinary labels define ordinary types (not list types),
--   (2) coercions are have identity type, and (3) list constructors have
--   their respective types.
checkLabel :: WithPosition Label -> FunType -> M ()

-- | Check list rules for uniform indexing. This flags rules like <tt>(:).
--   [Exp] ::= Exp1 [Exp]</tt>. Such rules make sense in the abstract
--   syntax and the parser, but may lead to non-faithful printers.
checkListLabelForUniformity :: WithPosition Label -> Cat -> [Cat] -> M ()

-- | Add label to signature, if it does not exist there yet. Otherwise,
--   throw error.
addSig :: LabelName -> WithPosition FunType -> M ()
checkRHS :: RHS -> M ARHS
trimRHS :: ARHS -> RHS

-- | Check a LBNF rule and convert it into internal form.
checkRule :: Position -> Parseable -> Label -> Cat -> RHS -> M ()

-- | Add a well-typed rule to <tt>lnbfASTRules</tt>, <a>lbnfASTRulesAP</a>
--   and, if it is <a>Parseable</a>, to <a>lbnfParserRules</a>.
addRule :: Position -> RuleOrigin -> Parseable -> Cat -> Label -> ARHS -> M ()

-- | Add rules from list pragma.
checkList :: Position -> MinimumSize -> Cat -> Separator' String -> M ()

-- | Add rules from <tt>coercion</tt> pragma.
--   
--   E.g. <tt>coercions Exp 3</tt> will add the following rules:
--   
--   <pre>
--   _. Exp  ::= Exp1;
--   _. Exp1 ::= Exp2;
--   _. Exp2 ::= Exp3;
--   _. Exp3 ::= "(" Exp ")";
--   </pre>
checkCoercions :: Position -> Identifier -> Integer -> M ()

-- | Add rules from <tt>rules</tt> pragma.
checkRules :: Position -> Identifier -> [RHS] -> M ()
checkDefine :: Position -> Identifier -> [Arg] -> Exp -> M ()

-- | Add a token category (position carrying or not) defined by a regular
--   expression.
addTokenDef :: Position -> Identifier -> PositionToken -> Reg -> M ()

-- | Add a keyword that starts or stops layout.
addLayoutKeyword :: Lens' LBNF LayoutKeywords -> Lens' LBNF LayoutKeywords -> Position -> String -> M ()

-- | Add line comment delimiter, unless empty.
addLineComment :: Position -> String -> M ()

-- | Add block comment delimiters if both are non-empty.
addBlockComment :: Position -> String -> String -> M ()


-- | Entrypoint for the LBNF checker.
module BNFC.Check.Run
checkGrammar :: Grammar -> (Warnings, RecoverableErrors, Either PFatalError LBNF)


-- | Utilies for the Haskell pretty printer.
module BNFC.Backend.Haskell.Utilities.Printer
cats :: [Type] -> [String]
listcats :: [Type] -> [String]
toks :: LBNF -> [String]
keywords :: LBNF -> [String]
data Literal
LitChar :: Literal
LitString :: Literal
LitInteger :: Literal
LitDouble :: Literal
literalDoc :: Doc ()
tokenDoc :: [String] -> Doc ()
catDoc :: [String] -> Doc ()
listcatDoc :: [String] -> Doc ()
annDoc :: Doc ()

-- | Annotate keywords with Magenta color.
annotateKeyword :: Doc ()

-- | Annotate literals with Cyan color.
annotateLiteral :: Doc ()

-- | Annotate tokens with Green color.
annotateToken :: Doc ()
annotateCategory :: Doc ()
annotateListCategory :: Doc ()
printAnn :: [String] -> [String] -> [String] -> Doc ()
parseType :: Type -> Doc ()
parseTokenName :: CatName -> Doc ()
annotations :: [Item' String1] -> [String]
annToAnsiStyle :: Doc ()
renderFunction :: Doc ()

module BNFC.Backend.Haskell.Utilities.Parser
tokenName :: Doc ()
parserCatName :: Cat -> Doc ()
generateP :: Bool -> Cat -> Doc ()
qualify :: String -> String -> String

-- | Generate patterns and a set of metavariables (de Bruijn indices)
--   indicating where in the pattern the non-terminals are locate.
--   
--   <pre>
--   &gt;&gt;&gt; generatePatterns False [ NTerminal (Cat' (BaseCat 'E':|"xp")), Terminal (Keyword ('+':|[])), NTerminal (Cat' (BaseCat 'E':|"xp")) ]
--   ("Exp '+' Exp",["$1","$3"])
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; generatePatterns True [ NTerminal (Cat' (BaseCat 'E':|"xp")), Terminal (Keyword ('+':|[])), NTerminal (Cat' (BaseCat 'E':|"xp")) ]
--   ("Exp '+' Exp",["(snd $1)","(snd $3)"])
--   </pre>
generatePatterns :: Bool -> RHS -> (String, [String])

module BNFC.Backend.CommonInterface.OOAbstractSyntax
data Abs
Abs :: [String] -> [String] -> [String] -> [String] -> Signature -> Functions -> Abs
[posTokens] :: Abs -> [String]
[noPosTokens] :: Abs -> [String]
[catClasses] :: Abs -> [String]
[labelClasses] :: Abs -> [String]
[signatures] :: Abs -> Signature
[defineds] :: Abs -> Functions
lbnf2abs :: LBNF -> Abs
allClasses :: LBNF -> [String]
allNonClasses :: LBNF -> [String]
basetypes :: [([Char], [Char])]
classVar :: String -> String
pointerIf :: Bool -> String -> String

module BNFC.Backend.CommonInterface.NamedVariables
type IVar = (String, Int)

-- | Converts a list of categories into their types to be used as instance
--   variables. If a category appears only once, it is given the number 0,
--   if it appears more than once, its occurrences are numbered from 1. ex:
--   
--   <pre>
--   &gt;&gt;&gt; getVars [Cat "A", Cat "B", Cat "A"]
--   [("A",1),("B",0),("A",2)]
--   </pre>
getVars :: [Cat] -> [IVar]

-- | Anotate the right hand side of a rule with variable names for the
--   non-terminals. &gt;&gt;&gt; numVars [Left (Cat <a>A</a>), Right "+",
--   Left (Cat <a>B</a>)] [Left (A,a_),Right "+",Left (B,b_)] &gt;&gt;&gt;
--   numVars [Left (Cat <a>A</a>), Left (Cat <a>A</a>), Right ";"] [Left
--   (A,a_1),Left (A,a_2),Right ";"]
numVars :: [Either Cat a] -> [Either (Cat, Doc ()) a]
fixCoersions :: ASTRules -> ASTRules
varName :: [Char] -> [Char]
showNum :: (Eq a, Num a, Show a) => a -> [Char]
firstLowerCase :: String -> String

module BNFC.Backend.CommonInterface.Backend
type Result = [(FilePath, String)]
type Log = Writer String
type Output = WriterT Result Log ()

-- | Backend typeclass.
class Backend (target :: TargetLanguage) where {
    type family BackendOptions target;
    type family BackendState target;
}
parseOpts :: Backend target => Parser (BackendOptions target)
initState :: Backend target => LBNF -> GlobalOptions -> BackendOptions target -> Except String (BackendState target)
abstractSyntax :: Backend target => LBNF -> State (BackendState target) Result
printer :: Backend target => LBNF -> State (BackendState target) Result
lexer :: Backend target => LBNF -> State (BackendState target) Result
parser :: Backend target => LBNF -> State (BackendState target) Result
parserTest :: Backend target => LBNF -> State (BackendState target) Result
makefile :: Backend target => LBNF -> State (BackendState target) Result
runBackend :: forall target. Backend target => GlobalOptions -> BackendOptions target -> LBNF -> Except String Result

module BNFC.Backend.Txt2Tags.Txt2Tags
txt2tags :: LBNF -> State Txt2TagsBackendState Result
cf2string :: LBNF -> String -> String
cf2doc :: LBNF -> String -> Doc ()
introduction :: String -> Doc ()
printTerminals :: LBNF -> String -> Doc ()
printBuiltin :: BuiltinCat -> Doc ()
reservedWords :: Doc ()
printKeywords :: String -> [String] -> Doc ()
printSymbols :: String -> [String] -> Doc ()
printComments :: [String] -> [(String, String)] -> Doc ()
printToken :: (CatName, WithPosition TokenDef) -> Doc ()
printGrammar :: LBNF -> String -> Doc ()
printRule :: (Cat, [ARHS]) -> Doc ()
printARHS :: ARHS -> Doc ()
printItem :: Item' String1 -> Doc ()
printCat :: Cat -> String
printRegTxt2Tags :: Regex -> Doc ()
class Print a
prt :: Print a => Int -> a -> Doc ()
instance BNFC.Backend.Txt2Tags.Txt2Tags.Print a => BNFC.Backend.Txt2Tags.Txt2Tags.Print [a]
instance BNFC.Backend.Txt2Tags.Txt2Tags.Print GHC.Types.Char
instance BNFC.Backend.Txt2Tags.Txt2Tags.Print BNFC.Types.Regex.Regex
instance BNFC.Backend.Txt2Tags.Txt2Tags.Print BNFC.Types.Regex.CharClassUnion
instance BNFC.Backend.Txt2Tags.Txt2Tags.Print BNFC.Types.Regex.CharClassAtom

module BNFC.Backend.Txt2Tags.Makefile
txt2tagsmakefile :: LBNF -> State Txt2TagsBackendState Result
makefileString :: String -> String -> String
makefileDoc :: String -> String -> Doc ()

module BNFC.Backend.Txt2Tags
instance BNFC.Backend.CommonInterface.Backend.Backend 'BNFC.Options.Target.TargetTxt2Tags

module BNFC.Backend.OCaml
newtype OcamlBackendOptions
OcamlOpts :: Bool -> OcamlBackendOptions
ocamlOptionsParser :: Parser OcamlBackendOptions
data OcamlBackendState
instance BNFC.Backend.CommonInterface.Backend.Backend 'BNFC.Options.Target.TargetOCaml

module BNFC.Backend.Latex.Makefile
latexmakefile :: LBNF -> State LatexBackendState Result
makefileString :: String -> String
makefileDoc :: String -> Doc ()

module BNFC.Backend.Latex.Latex
latex :: LBNF -> State LatexBackendState Result
cf2string :: LBNF -> String -> String
cf2doc :: LBNF -> String -> Doc ()
beginning :: String -> Doc ()
macros :: Doc ()
printTerminals :: LBNF -> String -> Doc ()
printBuiltin :: BuiltinCat -> Doc ()
printToken :: (CatName, WithPosition TokenDef) -> Doc ()
reservedWords :: Doc ()
tabular :: Doc () -> Doc ()
printKeywords :: String -> [String] -> Doc ()
reserved :: String -> Doc ()
printSymbols :: String -> [String] -> Doc ()
symbol :: String -> Doc ()
printEscape :: String -> String
printComments :: [String] -> [(String, String)] -> Doc ()
printGrammar :: LBNF -> String -> Doc ()
printRule :: (Cat, [ARHS]) -> Doc ()
terminal :: String1 -> Doc ()
nonterminal :: Cat -> Doc ()
printItem :: Item' String1 -> Doc ()
printARHS :: ARHS -> Doc ()
printRegLatex :: Regex -> Doc ()
class Print a
prt :: Print a => Int -> a -> Doc ()
instance BNFC.Backend.Latex.Latex.Print a => BNFC.Backend.Latex.Latex.Print [a]
instance BNFC.Backend.Latex.Latex.Print GHC.Types.Char
instance BNFC.Backend.Latex.Latex.Print BNFC.Types.Regex.Regex
instance BNFC.Backend.Latex.Latex.Print BNFC.Types.Regex.CharClassUnion
instance BNFC.Backend.Latex.Latex.Print BNFC.Types.Regex.CharClassAtom

module BNFC.Backend.Latex
data LatexBackendOptions
LatexOpts :: LatexBackendOptions
latexOptionsParser :: Parser LatexBackendOptions
instance BNFC.Backend.CommonInterface.Backend.Backend 'BNFC.Options.Target.TargetLatex

module BNFC.Backend.Java
data JavaBackendOptions
JavaOpts :: Bool -> Maybe String -> Bool -> Bool -> Bool -> JavaBackendOptions
[lineNumbers] :: JavaBackendOptions -> Bool
[nameSpace] :: JavaBackendOptions -> Maybe String
[jlex] :: JavaBackendOptions -> Bool
[jflex] :: JavaBackendOptions -> Bool
[antlr4] :: JavaBackendOptions -> Bool
javaOptionsParser :: Parser JavaBackendOptions
data JavaBackendState
instance BNFC.Backend.CommonInterface.Backend.Backend 'BNFC.Options.Target.TargetJava


-- | Backend write module.
--   
--   Defines useful functions to write the backend output to files.
module BNFC.Backend.CommonInterface.Write
writeFiles :: FilePath -> Result -> IO ()

module BNFC.Backend.CommonInterface.Types

module BNFC.Backend.Haskell.Utilities.Utils

-- | Token data type for lexer and parser specification generation.
data Token
Builtin :: BuiltinCat -> Token
Identifier :: Token
UserDefined :: CatName -> Token
printTokenName :: Token -> String
tokenTextImport :: TokenText -> Doc ()
tokenTextType :: TokenText -> Doc ()
tokenTextPack :: TokenText -> String -> String
tokenTextPackParens :: TokenText -> String -> Doc ()
tokenTextUnpack :: TokenText -> String -> Doc ()

-- | Make a variable name for a category.
catToVarName :: Cat -> String

-- | Turn (non-terminal) items into indexed variables.
indexVars :: [Item' String1] -> [(String, Integer)]
printArgs :: ARHS -> [Doc ()]
posType :: String
posConstr :: String
noPosConstr :: String

-- | Make directory of generated files.
mkDir :: Bool -> Maybe String -> String -> String -> String

-- | Relative filepath where to write generated components.
mkFilePath :: Bool -> Maybe String -> String -> String -> String -> FilePath

-- | Make module name of generated files.
mkModule :: Bool -> Maybe String -> String -> String -> String
instance GHC.Show.Show BNFC.Backend.Haskell.Utilities.Utils.Token


-- | Utilies for the Haskell lexer specification.
module BNFC.Backend.Haskell.Utilities.Lexer
tokenName :: Token -> Doc ()
tokenComment :: Token -> Doc ()
isUserDefined :: Token -> Bool
unicodeAndSymbols :: LBNF -> [String]
asciiKeywords :: LBNF -> [String]


-- | Utilies for Haskell state initialitation.
module BNFC.Backend.Haskell.Utilities.InitState

-- | Get grammar tokens for lexer specification generation.
getTokens :: LBNF -> [Token]

-- | Sort functions (define pragma) and avoid reserved words.
processFunctions :: Functions -> [(LabelName, Function)]

-- | Sort parser rules and avoid reserved words.
processParserRules :: ParserRules -> [(Cat, Map RHS RuleLabel)]

-- | Process AST rules to generate Abstract Syntax and Printer.
processRules :: ASTRulesAP -> [(Type, [(Label, ([Type], (Integer, ARHS)))])]

-- | Sort tokens (token pragma) according to their definition order in the
--   .cf file.
sortTokens :: TokenDefs -> [(CatName, TokenDef)]

module BNFC.Backend.Haskell.State
data HaskellBackendState
HaskellSt :: GlobalOptions -> HaskellBackendOptions -> [Token] -> [(Type, [(Label, ([Type], (Integer, ARHS)))])] -> [(Cat, Map RHS RuleLabel)] -> [(LabelName, Function)] -> [(CatName, TokenDef)] -> HaskellBackendState
[globalOpt] :: HaskellBackendState -> GlobalOptions
[haskellOpts] :: HaskellBackendState -> HaskellBackendOptions
[lexerParserTokens] :: HaskellBackendState -> [Token]
[astRules] :: HaskellBackendState -> [(Type, [(Label, ([Type], (Integer, ARHS)))])]
[parserRules] :: HaskellBackendState -> [(Cat, Map RHS RuleLabel)]
[functions] :: HaskellBackendState -> [(LabelName, Function)]
[tokens] :: HaskellBackendState -> [(CatName, TokenDef)]

module BNFC.Backend.Haskell.Test
haskellParserTest :: LBNF -> State HaskellBackendState Result
cf2test :: LBNF -> String -> TokenText -> Bool -> Maybe String -> String
cf2doc :: LBNF -> String -> TokenText -> Bool -> Maybe String -> Doc ()

module BNFC.Backend.Haskell.Template
haskellTemplate :: LBNF -> State HaskellBackendState Result
cf2template :: [(Type, [(Label, ([Type], (Integer, ARHS)))])] -> [CatName] -> String -> Bool -> Maybe String -> Bool -> String
cf2doc :: [(Type, [(Label, ([Type], (Integer, ARHS)))])] -> [CatName] -> String -> Bool -> Maybe String -> Bool -> Doc ()
prologue :: ModuleName -> ModuleName -> Bool -> Bool -> Doc ()
printTokens :: ModuleName -> [CatName] -> Doc ()
printToken :: ModuleName -> CatName -> Doc ()
printDatas :: ModuleName -> Bool -> [(Type, [(Label, ([Type], (Integer, ARHS)))])] -> Doc ()
printData :: ModuleName -> Bool -> Type -> [(Label, ([Type], (Integer, ARHS)))] -> Doc ()
printCase :: ModuleName -> Bool -> (Label, ARHS) -> Doc ()

module BNFC.Backend.Haskell.InitState
haskellInitState :: LBNF -> GlobalOptions -> HaskellBackendOptions -> Except String HaskellBackendState

-- | Checks specific of the Haskell language.
hsChecks :: LBNF -> Except String ()

module BNFC.Backend.Haskell.Printer
haskellPrinter :: LBNF -> State HaskellBackendState Result
cf2printer :: LBNF -> String -> Bool -> Maybe String -> Bool -> [(Type, [(Label, ([Type], (Integer, ARHS)))])] -> [(CatName, TokenDef)] -> Bool -> TokenText -> String
cf2doc :: LBNF -> String -> Bool -> Maybe String -> Bool -> [(Type, [(Label, ([Type], (Integer, ARHS)))])] -> [(CatName, TokenDef)] -> Bool -> TokenText -> Doc ()
printPrologue :: LBNF -> String -> Bool -> Maybe String -> Bool -> ModuleName -> [(Type, [(Label, ([Type], (Integer, ARHS)))])] -> Doc ()

-- | Print tokens instances for the printer.
printTokenInstances :: ModuleName -> TokenText -> [(CatName, TokenDef)] -> Doc ()
printTokenInstance :: ModuleName -> TokenText -> (CatName, TokenDef) -> Doc ()

-- | Print cateries instances for the printer.
printCatInstances :: ModuleName -> Bool -> [(Type, [(Label, ([Type], (Integer, ARHS)))])] -> Doc ()
printCatInstance :: ModuleName -> Bool -> Type -> [(Label, ([Type], (Integer, ARHS)))] -> Doc ()
printCase :: Doc () -> Bool -> (Label, (Integer, ARHS)) -> (Integer, Doc ())
rhsToPrint :: ARHS -> [Doc ()]

module BNFC.Backend.Haskell.Layout
cf2layout :: LBNF -> String -> Bool -> Maybe String -> String
haskellLayout :: LBNF -> State HaskellBackendState Result

module BNFC.Backend.Haskell.GADT.Utils
isTreeType :: (Label, ARHS) -> Bool

module BNFC.Backend.Haskell.GADT.Template
haskellGADTTemplate :: LBNF -> State HaskellBackendState Result

module BNFC.Backend.Haskell.AbstractSyntax
cf2abs :: LBNF -> String -> Bool -> Maybe String -> [(Type, [(Label, ([Type], (Integer, ARHS)))])] -> [(LabelName, Function)] -> [(CatName, TokenDef)] -> Bool -> Bool -> Bool -> TokenText -> String
haskellAbstractSyntax :: LBNF -> State HaskellBackendState Result

-- | Print functions given by the define pragma.
printFunctions :: Bool -> [(LabelName, Function)] -> Doc ()

module BNFC.Backend.Haskell.GADT.AbstractSyntax
haskellAbstractSyntaxGADT :: LBNF -> State HaskellBackendState Result
cf2abs :: LBNF -> String -> Bool -> Maybe String -> [(Type, [(Label, ([Type], (Integer, ARHS)))])] -> [(LabelName, Function)] -> [(CatName, TokenDef)] -> TokenText -> String
cf2doc :: LBNF -> String -> Bool -> Maybe String -> [(Type, [(Label, ([Type], (Integer, ARHS)))])] -> [(LabelName, Function)] -> [(CatName, TokenDef)] -> TokenText -> Doc ()
prologue :: ModuleName -> ModuleName -> Bool -> [String] -> TokenText -> Bool -> Doc ()
pragmas :: Bool -> Doc ()
imports :: ModuleName -> Bool -> TokenText -> Doc ()
printData :: [String] -> Doc ()
printTree :: [String] -> TokenText -> [(Type, [(Label, ([Type], (Integer, ARHS)))])] -> [(CatName, TokenDef)] -> Doc ()
composInstances :: [(Label, ARHS)] -> Doc ()
showInstances :: [(Label, ARHS)] -> [(CatName, TokenDef)] -> Doc ()
eqInstance :: Doc ()
ordInstance :: Doc ()
johnMajorEq :: [(Label, ARHS)] -> [(CatName, TokenDef)] -> Doc ()
indexes :: [(Label, [Type])] -> [String] -> Doc ()
compareSame :: [(Label, ARHS)] -> [(CatName, TokenDef)] -> Doc ()

module BNFC.Backend.Haskell.Parser
haskellParser :: LBNF -> State HaskellBackendState Result
cf2parser :: LBNF -> [(Cat, Map RHS RuleLabel)] -> String -> Bool -> Maybe String -> TokenText -> [Token] -> Bool -> String
cf2doc :: LBNF -> [(Cat, Map RHS RuleLabel)] -> String -> Bool -> Maybe String -> TokenText -> [Token] -> Bool -> Doc ()
header :: ModuleName -> ModuleName -> ModuleName -> TokenText -> [Cat] -> Doc ()

-- | The declarations of a happy file. &gt;&gt;&gt; declarations False [Cat
--   <a>A</a>, Cat <a>B</a>, ListCat (Cat <a>B</a>)] %name pA A %name pB B
--   %name pListB ListB -- no lexer declaration %monad { Err } {
--   (&gt;&gt;=) } { return } %tokentype {Token}
--   
--   <pre>
--   &gt;&gt;&gt; declarations True [Cat "A", Cat "B", ListCat (Cat "B")]
--   %name pA_internal A
--   %name pB_internal B
--   %name pListB_internal ListB
--   -- no lexer declaration
--   %monad { Err } { (&gt;&gt;=) } { return }
--   %tokentype {Token}
--   </pre>
declarations :: Bool -> [Cat] -> Doc ()

-- | Generate the list of tokens and their identifiers.
tokensList :: LBNF -> [Token] -> Bool -> Doc ()
specialRules :: LBNF -> ModuleName -> TokenText -> Bool -> [Token] -> Doc ()
specialRule :: LBNF -> ModuleName -> TokenText -> Bool -> Token -> Doc ()
happyRules :: ModuleName -> Bool -> [(Cat, Map RHS RuleLabel)] -> Doc ()
printRule :: ModuleName -> Bool -> Cat -> Map RHS RuleLabel -> Doc ()
constructRule :: Bool -> ModuleName -> (RHS, RuleLabel) -> Doc ()
footer :: ModuleName -> [String] -> TokenText -> Bool -> [Cat] -> Doc ()

module BNFC.Backend.Haskell.Lexer
haskellLexer :: LBNF -> State HaskellBackendState Result
cf2lexer :: LBNF -> String -> Bool -> Maybe String -> TokenText -> [Token] -> String
cf2doc :: LBNF -> String -> Bool -> Maybe String -> TokenText -> [Token] -> Doc ()
prelude :: String -> Bool -> Maybe String -> TokenText -> Doc ()

-- | Character class definitions.
cMacros :: Doc ()

-- | Regular expressions and lex actions.
rMacros :: LBNF -> Doc ()
restOfAlex :: TokenText -> [Token] -> LBNF -> Doc ()
printRegAlex :: Regex -> Doc ()
class Print a
prt :: Print a => Int -> a -> Doc ()
instance BNFC.Backend.Haskell.Lexer.Print a => BNFC.Backend.Haskell.Lexer.Print [a]
instance BNFC.Backend.Haskell.Lexer.Print GHC.Types.Char
instance BNFC.Backend.Haskell.Lexer.Print BNFC.Types.Regex.Regex
instance BNFC.Backend.Haskell.Lexer.Print BNFC.Types.Regex.CharClassUnion
instance BNFC.Backend.Haskell.Lexer.Print BNFC.Types.Regex.CharClassAtom

module BNFC.Backend.Common.Makefile

-- | Creates a Makefile rule.
--   
--   <pre>
--   &gt;&gt;&gt; mkRule "main" ["file1","file2"] ["do something"]
--   main : file1 file2
--        do something
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; mkRule "main" ["program.exe"] []
--   main : program.exe
--   </pre>
mkRule :: String -> [String] -> String -> Doc ()

-- | Variable assignment.
--   
--   <pre>
--   &gt;&gt;&gt; mkVar "FOO" "bar"
--   FOO=bar
--   </pre>
mkVar :: String -> String -> Doc ()

-- | Variable referencing.
--   
--   <pre>
--   &gt;&gt;&gt; refVar "FOO"
--   "${FOO}"
--   </pre>
refVar :: String -> Doc ()

module BNFC.Backend.Haskell.Makefile
haskellmakefile :: LBNF -> State HaskellBackendState Result
cf2makefile :: LBNF -> HaskellBackendOptions -> Bool -> String -> Maybe FilePath -> FilePath -> String
makefileDoc :: LBNF -> HaskellBackendOptions -> Bool -> String -> Maybe FilePath -> FilePath -> Doc ()

module BNFC.Backend.Haskell
instance BNFC.Backend.CommonInterface.Backend.Backend 'BNFC.Options.Target.TargetHaskell

module BNFC.Backend.CPP
data CppBackendOptions
CppOpts :: Bool -> Maybe String -> CppBackendOptions
[lineNumbers] :: CppBackendOptions -> Bool
[nameSpace] :: CppBackendOptions -> Maybe String
cppOptionsParser :: Parser CppBackendOptions
data CppBackendState
instance BNFC.Backend.CommonInterface.Backend.Backend 'BNFC.Options.Target.TargetCpp

module BNFC.Backend.C
newtype CBackendOptions
COpts :: Bool -> CBackendOptions
cOptionsParser :: Parser CBackendOptions
data CBackendState
instance BNFC.Backend.CommonInterface.Backend.Backend 'BNFC.Options.Target.TargetC

module BNFC.Backend.Agda.Utilities.Utils

-- | Import the builtin numeric types (content of some token categories)?
data ImportNumeric

-- | Import the numeric types.
YesImportNumeric :: ImportNumeric

-- | Don't import the numeric types.
NoImportNumeric :: ImportNumeric
imports :: ImportNumeric -> Bool -> Bool -> Bool -> Doc ()
importPragmas :: Bool -> [ModuleName] -> Doc ()
sanitize :: String -> String

-- | How to print the types of constructors in Agda?
data ConstructorStyle

-- | Simply typed, like <tt>E → S → S → S</tt>.
UnnamedArg :: ConstructorStyle

-- | Dependently typed, like <tt>(e : E) (s₁ s₂ : S) → S</tt>.
NamedArg :: ConstructorStyle

-- | Suggest the name of a bound variable of the given category.
--   
--   <pre>
--   &gt;&gt;&gt; map nameSuggestion
--   [ ListType (BaseType (BaseCat 'S':|"tm")), BaseType (TokenCat 'V':|"ar"), (BaseType (BaseCat 'E':|"xp") ]
--   ["ss","x","e"]
--   </pre>
nameSuggestion :: Type -> String

-- | Suggest the name of a bound variable of the given base category.
--   
--   <pre>
--   &gt;&gt;&gt; map nameFor ["Stm","ABC","#String"]
--   ["s","a","s"]
--   </pre>
nameFor :: String1 -> String

-- | Number duplicate elements in a list consecutively, starting with 1.
--   
--   <pre>
--   &gt;&gt;&gt; numberUniquely ["a", "b", "a", "a", "c", "b"]
--   [(Just 1,"a"),(Just 1,"b"),(Just 2,"a"),(Just 3,"a"),(Nothing,"c"),(Just 2,"b")]
--   </pre>
numberUniquely :: forall a. Ord a => [a] -> [(Maybe Int, a)]

-- | A frequency map.
--   
--   NB: this type synonym should be local to <a>numberUniquely</a>, but
--   Haskell lacks local type synonyms.
--   <a>https://gitlab.haskell.org/ghc/ghc/issues/4020</a>
type Frequency a = Map a Int

-- | Increase the frequency of the given key.
incr :: Ord a => a -> Frequency a -> Frequency a
uArrow :: String
instance GHC.Classes.Eq BNFC.Backend.Agda.Utilities.Utils.ImportNumeric

module BNFC.Backend.Agda.Utilities.ReservedWords

-- | A list of Agda keywords that would clash with generated names.
agdaReservedWords :: [String]

-- | Turn identifier to non-capital identifier. Needed, since in Agda a
--   constructor cannot overload a data type with the same name.
--   
--   <pre>
--   &gt;&gt;&gt; map agdaLower ["SFun","foo","ABC","HelloWorld","module","Type_int","C1"]
--   ["sFun","foo","aBC","helloWorld","module'","type-int","c1"]
--   </pre>
agdaLower :: String1 -> String1

-- | Avoid Agda reserved words.
avoidAgdaReservedWords :: String1 -> String1

-- | Apply agdaLower function to AST rhs types.
avoidResWordsASTRulesAgda :: [(Type, [(Label, [Type])])] -> [(Type, [(Label, [Type])])]
lowerLabel :: Label -> Label
avoidResWordsType :: Type -> Type
avoidResWordsCat :: Cat -> Cat
avoidResWordsBaseCat :: BaseCat -> BaseCat
processFunctionsAgda :: [(LabelName, Function)] -> [(LabelName, Function)]
checkFun :: Function -> Function
checkPars :: [Parameter] -> [Parameter]
checkPar :: Parameter -> Parameter
checkBody :: Exp -> Exp

module BNFC.Backend.Agda.Options
data AgdaBackendOptions
AgdaOpts :: Maybe String -> Bool -> Bool -> Bool -> AgdaBackendOptions
[nameSpace] :: AgdaBackendOptions -> Maybe String
[inDir] :: AgdaBackendOptions -> Bool
[functor] :: AgdaBackendOptions -> Bool
[generic] :: AgdaBackendOptions -> Bool
agdaOptionsParser :: Parser AgdaBackendOptions
printAgdaOptions :: AgdaBackendOptions -> String


-- | Commands Subparsers.
module BNFC.Options.Commands

-- | subcommands parser.
commandsParser :: Parser Command
data Command
Agda :: AgdaBackendOptions -> Command
C :: CBackendOptions -> Command
Cpp :: CppBackendOptions -> Command
Haskell :: HaskellBackendOptions -> Command
Java :: JavaBackendOptions -> Command
Latex :: LatexBackendOptions -> Command
OCaml :: OcamlBackendOptions -> Command
Txt2Tags :: Txt2TagsBackendOptions -> Command
Check :: Command

module BNFC.Backend.Agda.State
data AgdaBackendState
AgdaSt :: GlobalOptions -> AgdaBackendOptions -> [Token] -> [(Type, [(Label, ([Type], (Integer, ARHS)))])] -> [(Type, [(Label, [Type])])] -> [(Cat, Map RHS RuleLabel)] -> [(LabelName, Function)] -> [(LabelName, Function)] -> [(CatName, TokenDef)] -> AgdaBackendState
[globalOpt] :: AgdaBackendState -> GlobalOptions
[agdaOpts] :: AgdaBackendState -> AgdaBackendOptions
[lexerParserTokens] :: AgdaBackendState -> [Token]
[hsAstRules] :: AgdaBackendState -> [(Type, [(Label, ([Type], (Integer, ARHS)))])]
[agdaAstRules] :: AgdaBackendState -> [(Type, [(Label, [Type])])]
[parserRules] :: AgdaBackendState -> [(Cat, Map RHS RuleLabel)]
[hsFunctions] :: AgdaBackendState -> [(LabelName, Function)]
[agdaFunctions] :: AgdaBackendState -> [(LabelName, Function)]
[tokens] :: AgdaBackendState -> [(CatName, TokenDef)]

module BNFC.Backend.Agda.Test
agdaParserTest :: LBNF -> State AgdaBackendState Result

module BNFC.Backend.Agda.Template
agdaTemplate :: LBNF -> State AgdaBackendState Result

module BNFC.Backend.Agda.Printer
agdaPrinter :: LBNF -> State AgdaBackendState Result

module BNFC.Backend.Agda.Parser
agdaParser :: LBNF -> State AgdaBackendState Result

module BNFC.Backend.Agda.Makefile
agdaMakefile :: LBNF -> State AgdaBackendState Result
cf2makefile :: LBNF -> AgdaBackendOptions -> Bool -> String -> Maybe FilePath -> FilePath -> String
makefileDoc :: LBNF -> AgdaBackendOptions -> Bool -> String -> Maybe FilePath -> FilePath -> Doc ()

module BNFC.Backend.Agda.Main
agdaMain :: LBNF -> State AgdaBackendState Result

module BNFC.Backend.Agda.Lexer
agdaLexer :: LBNF -> State AgdaBackendState Result

module BNFC.Backend.Agda.InitState
agdaInitState :: LBNF -> GlobalOptions -> AgdaBackendOptions -> Except String AgdaBackendState
processASTRulesAgda :: [String] -> [(Type, [(Label, ([Type], (Integer, ARHS)))])] -> [(Type, [(Label, [Type])])]
toAgdaRules :: (Type, [(Label, ([Type], (Integer, ARHS)))]) -> (Type, [(Label, [Type])])
filterRules :: [String] -> [(Type, [(Label, [Type])])] -> [(Type, [(Label, [Type])])]

-- | Filter <tt>Label</tt>s that will be printed in the Agda AST datatypes.
filterLabelsAgdaAST :: [String] -> [(Label, [Type])] -> [(Label, [Type])]

module BNFC.Backend.Agda.IOLib
agdaIOLib :: State AgdaBackendState Result

module BNFC.Backend.Agda.AbstractSyntax
agdaAbstractSyntax :: LBNF -> State AgdaBackendState Result
cf2AST :: LBNF -> String -> Bool -> Maybe String -> [(Type, [(Label, [Type])])] -> [(LabelName, Function)] -> [(CatName, TokenDef)] -> [CatName] -> Bool -> String
cf2doc :: LBNF -> String -> Bool -> Maybe String -> [(Type, [(Label, [Type])])] -> [(LabelName, Function)] -> [(CatName, TokenDef)] -> [CatName] -> Bool -> Doc ()

-- | Print Agda types for user defined tokens.
prTokens :: ModuleName -> [(CatName, TokenDef)] -> Doc ()
prToken :: ModuleName -> (CatName, TokenDef) -> Doc ()

-- | Print Agda types for categories in AST rules.
prDatas :: Bool -> ModuleName -> ConstructorStyle -> [(Type, [(Label, [Type])])] -> Doc ()

-- | Pretty-print Agda data types and pragmas for AST.
prData :: Bool -> ModuleName -> ConstructorStyle -> (Type, [(Label, [Type])]) -> Doc ()

-- | Pretty-print Agda data types and pragmas.
prData' :: ModuleName -> ConstructorStyle -> Doc () -> Doc () -> [(Label, [Type])] -> Doc ()

-- | Pretty-print AST definition in Agda syntax.
prettyData :: ConstructorStyle -> Doc () -> [(Label, [Type])] -> Doc ()
printCase :: ConstructorStyle -> Doc () -> (Label, [Type]) -> Doc ()
printConstructorArgs :: ConstructorStyle -> [Type] -> Doc ()
prettyType :: Type -> String
compilePragma :: ModuleName -> Doc () -> Doc () -> [Doc ()] -> Doc ()

-- | Generate Haskell/Agda code for the <tt>define</tt>d constructors.
prFunctions :: Bool -> [(LabelName, Function)] -> Doc ()
prFunction :: Bool -> (LabelName, Function) -> Doc ()
printerBindings :: ModuleName -> [Type] -> [BuiltinCat] -> [CatName] -> Doc ()
prPrinterBindings :: [(Doc (), Doc ())] -> Doc ()
prPrinterBinding :: (Doc (), Doc ()) -> Doc ()
prPrinterPragmas :: [(Doc (), (Doc (), Doc ()))] -> Doc ()
prPrinterPragma :: (Doc (), (Doc (), Doc ())) -> Doc ()

module BNFC.Backend.Agda
instance BNFC.Backend.CommonInterface.Backend.Backend 'BNFC.Options.Target.TargetAgda

module Paths_BNFC3
version :: Version
getBinDir :: IO FilePath
getLibDir :: IO FilePath
getDynLibDir :: IO FilePath
getDataDir :: IO FilePath
getLibexecDir :: IO FilePath
getDataFileName :: FilePath -> IO FilePath
getSysconfDir :: IO FilePath

module BNFC.Options.Version

-- | The program version obtained from the cabal file.
version :: String


-- | Info options.
module BNFC.Options.InfoOptions
self :: String
versionOption :: Parser (a -> a)
versionWords :: [String]
numericVersionOption :: Parser (a -> a)
licenseOption :: Parser (a -> a)

module BNFC.Options
data Options
Options :: GlobalOptions -> Command -> Options
[globalOptions] :: Options -> GlobalOptions
[command] :: Options -> Command
programOptions :: Parser Options
getOptInput :: Options -> FilePath
options :: IO Options
options' :: [String] -> IO Options
type Target = Maybe FilePath

-- | Like <a>execParser</a>, but parse given argument list rather than
--   those from <a>getArgs</a>.
execParser' :: [String] -> ParserInfo a -> IO a

-- | Run a program description with custom preferences.
customExecParser' :: ParserPrefs -> [String] -> ParserInfo a -> IO a

module BNFC.Main
type Err = Either String

-- | BNFC main.
bnfc :: IO ()

-- | Entrypoint with argument vector.
bnfcArgs :: [String] -> IO ()

-- | Entrypoint with parsed options.
bnfcOptions :: Options -> IO ()

-- | Entrypoint with parsed options and parsed grammar.
bnfcGrammar :: Options -> Grammar -> IO ()
type Msgs = [String]
execRun :: ((Maybe Result, Maybe FilePath), Msgs) -> IO ()

-- | Entrypoint with argument vector.
runBnfcArgs :: [String] -> IO ((Maybe Result, Maybe FilePath), Msgs)

-- | Entrypoint with parsed options.
runBnfcOptions :: Options -> IO ((Maybe Result, Maybe FilePath), Msgs)

-- | Entrypoint with parsed options and grammar.
runBnfcGrammar :: Options -> Grammar -> ((Maybe Result, Maybe FilePath), Msgs)

-- | Write to files.
writeResult :: Maybe FilePath -> Result -> IO ()
getAbs :: LBNF -> String
parseFile :: FilePath -> IO Grammar
dieIfError :: Err a -> IO a