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


-- | Haskell Utrecht Tools Library
--   
--   Fast Parser Combinators and Pretty Printing Combinators
@package uulib
@version 0.9.21

module UU.Util.Utils
newtype Id x
Id :: x -> Id x
cross :: (a -> c) -> (b -> d) -> (a, b) -> (c, d)
split :: (a -> b) -> (a -> c) -> a -> (b, c)
fst3 :: (a, b, c) -> a
snd3 :: (a, b, c) -> b
thd3 :: (a, b, c) -> c

module UU.Util.PermTree
data Perms p a
Choice :: (Maybe a) -> [Branch p a] -> Perms p a
data Branch p a
Br :: (p x) -> (Perms p (x -> a)) -> Branch p a
add :: Maybe a -> p a -> Perms p (a -> b) -> Perms p b
empty :: a -> Perms p a
(<$$>) :: (a -> b) -> p a -> Perms p b
(<$?>) :: (a -> b) -> (a, p a) -> Perms p b
(<||>) :: Perms p (a -> b) -> p a -> Perms p b
(<|?>) :: Perms p (a -> b) -> (a, p a) -> Perms p b
instance GHC.Base.Functor (UU.Util.PermTree.Perms p)
instance GHC.Base.Functor (UU.Util.PermTree.Branch p)

module UU.Util.BinaryTrees
data BinSearchTree av
Node :: (BinSearchTree av) -> av -> (BinSearchTree av) -> BinSearchTree av
Nil :: BinSearchTree av
tab2tree :: [av] -> BinSearchTree av
btFind :: (a -> b -> Ordering) -> BinSearchTree (a, c) -> b -> Maybe c
btLocateIn :: (a -> b -> Ordering) -> BinSearchTree a -> b -> Maybe a
btLookup :: (a -> b) -> (a -> c) -> (b -> d -> Ordering) -> BinSearchTree a -> d -> Maybe c

module UU.Pretty.Basic
class Show a => PP a where pp = text . show ppList as = if null as then empty else foldr (>|<) empty . map pp $ as
pp :: PP a => a -> PP_Doc
ppList :: PP a => [a] -> PP_Doc
data PP_Doc
data PP_Exp
empty :: PP_Doc
text :: String -> PP_Doc
indent :: PP a => Int -> a -> PP_Doc
(>|<) :: (PP a, PP b) => a -> b -> PP_Doc
(>-<) :: (PP a, PP b) => a -> b -> PP_Doc
fill :: PP a => [a] -> PP_Doc
fillblock :: PP a => Int -> [a] -> PP_Doc
(>//<) :: (PP a, PP b) => a -> b -> PP_Doc
join :: PP_Doc -> PP_Doc
par :: PP_Exp
(>>$<) :: PP a => PP_Exp -> [a] -> PP_Doc
eindent :: Int -> PP_Exp -> PP_Exp
(>>|<<) :: PP_Exp -> PP_Exp -> PP_Exp
(>>-<<) :: PP_Exp -> PP_Exp -> PP_Exp
(>>//<<) :: PP_Exp -> PP_Exp -> PP_Exp
ejoin :: PP_Exp -> PP_Exp
(>>$<<) :: PP_Exp -> [PP_Exp] -> PP_Exp
render :: PP_Doc -> Int -> IO ()
renderAll :: PP_Doc -> Int -> IO ()
disp :: PP_Doc -> Int -> ShowS
c2e :: PP a => a -> PP_Exp
element_h1 :: PP_Doc -> PP_Doc
eelement_h1 :: PP_Exp -> PP_Exp
vcenter :: PP a => [a] -> PP_Doc
invisible :: PP_Doc -> PP_Doc
fpar :: PP_Exp
spar :: PP_Exp
instance GHC.Classes.Eq UU.Pretty.Basic.T_Frame
instance UU.Pretty.Basic.PP UU.Pretty.Basic.PP_Doc
instance UU.Pretty.Basic.PP GHC.Types.Char
instance UU.Pretty.Basic.PP a => UU.Pretty.Basic.PP [a]
instance GHC.Show.Show UU.Pretty.Basic.PP_Doc
instance GHC.Classes.Ord UU.Pretty.Basic.T_Frame
instance GHC.Classes.Eq UU.Pretty.Basic.Format
instance GHC.Classes.Ord UU.Pretty.Basic.Format

module UU.Pretty.Ext
(>^<) :: (PP a, PP b) => a -> b -> PP_Doc
(>>^<<) :: PP_Exp -> PP_Exp -> PP_Exp
(>#<) :: (PP a, PP b) => a -> b -> PP_Doc
(>>#<<) :: PP_Exp -> PP_Exp -> PP_Exp
wide_text :: Int -> String -> PP_Doc
vlist :: PP a => [a] -> PP_Doc
hlist :: PP a => [a] -> PP_Doc
hlist_sp :: PP a => [a] -> PP_Doc
list_h1 :: [PP_Doc] -> [PP_Doc]
hlist_h1 :: [PP_Doc] -> PP_Doc
(>|<<) :: PP a => a -> PP_Exp -> PP_Exp
(>-<<) :: PP a => a -> PP_Exp -> PP_Exp
(>>|<) :: PP a => PP_Exp -> a -> PP_Exp
(>>-<) :: PP a => PP_Exp -> a -> PP_Exp
pp_es :: (Foldable t, PP (t a)) => t a -> PP_Doc
vdisp :: Int -> [PP_Doc] -> ShowS
pp_wrap :: PP a => a -> a -> PP_Doc -> PP_Doc
pp_quotes :: PP_Doc -> PP_Doc
pp_doubleQuotes :: PP_Doc -> PP_Doc
pp_parens :: PP_Doc -> PP_Doc
pp_brackets :: PP_Doc -> PP_Doc
pp_braces :: PP_Doc -> PP_Doc
hv :: PP a => [a] -> PP_Doc
hv_sp :: PP a => [a] -> PP_Doc
pp_block :: (Foldable t, Foldable t1, Foldable t2, PP (t a), PP (t1 a1), PP (t2 a2)) => t1 a1 -> t a -> t2 a2 -> [PP_Doc] -> PP_Doc
pp_ite :: (PP a, PP b, PP a1, PP b1, PP a2, PP b2, PP a3) => a -> a1 -> a2 -> a3 -> b -> b1 -> b2 -> PP_Doc
pp_list :: Int -> String -> String -> String -> [PP_Doc] -> PP_Doc
pp_slist :: Int -> String -> String -> String -> [PP_Doc] -> PP_Doc
pp_parens_list :: Int -> [PP_Doc] -> PP_Doc
instance UU.Pretty.Basic.PP GHC.Types.Int
instance UU.Pretty.Basic.PP GHC.Types.Float

module UU.Pretty


module UU.PPrint
data Doc
class Pretty a where prettyList = list . map pretty
pretty :: Pretty a => a -> Doc

-- | A specialised variant of <a>showsPrec</a>, using precedence context
--   zero, and returning an ordinary <a>String</a>.
show :: Show a => a -> String
putDoc :: Doc -> IO ()
hPutDoc :: Handle -> Doc -> IO ()
(<>) :: Doc -> Doc -> Doc
(<+>) :: Doc -> Doc -> Doc
(</>) :: Doc -> Doc -> Doc
(<//>) :: Doc -> Doc -> Doc
(<$>) :: Doc -> Doc -> Doc
(<$$>) :: Doc -> Doc -> Doc
sep :: [Doc] -> Doc
fillSep :: [Doc] -> Doc
hsep :: [Doc] -> Doc
vsep :: [Doc] -> Doc
cat :: [Doc] -> Doc
fillCat :: [Doc] -> Doc
hcat :: [Doc] -> Doc
vcat :: [Doc] -> Doc
punctuate :: Doc -> [Doc] -> [Doc]
align :: Doc -> Doc
hang :: Int -> Doc -> Doc
indent :: Int -> Doc -> Doc
fill :: Int -> Doc -> Doc
fillBreak :: Int -> Doc -> Doc
list :: [Doc] -> Doc
tupled :: [Doc] -> Doc
semiBraces :: [Doc] -> Doc
encloseSep :: Doc -> Doc -> Doc -> [Doc] -> Doc
angles :: Doc -> Doc
langle :: Doc
rangle :: Doc
parens :: Doc -> Doc
lparen :: Doc
rparen :: Doc
braces :: Doc -> Doc
lbrace :: Doc
rbrace :: Doc
brackets :: Doc -> Doc
lbracket :: Doc
rbracket :: Doc
dquotes :: Doc -> Doc
dquote :: Doc
squotes :: Doc -> Doc
squote :: Doc
comma :: Doc
space :: Doc
dot :: Doc
backslash :: Doc
semi :: Doc
colon :: Doc
equals :: Doc
string :: [Char] -> Doc
bool :: Bool -> Doc
int :: Int -> Doc
integer :: Integer -> Doc
float :: Float -> Doc
double :: Double -> Doc
rational :: Rational -> Doc
softline :: Doc
softbreak :: Doc
empty :: Doc
char :: Char -> Doc
text :: [Char] -> Doc
line :: Doc
linebreak :: Doc
nest :: Int -> Doc -> Doc
group :: Doc -> Doc
column :: (Int -> Doc) -> Doc
nesting :: (Int -> Doc) -> Doc
width :: Doc -> (Int -> Doc) -> Doc
data SimpleDoc
SEmpty :: SimpleDoc
SChar :: Char -> SimpleDoc -> SimpleDoc
SText :: !Int -> String -> SimpleDoc -> SimpleDoc
SLine :: !Int -> SimpleDoc -> SimpleDoc
renderPretty :: Float -> Int -> Doc -> SimpleDoc
renderCompact :: Doc -> SimpleDoc
displayS :: SimpleDoc -> ShowS
displayIO :: Handle -> SimpleDoc -> IO ()
instance UU.PPrint.Pretty a => UU.PPrint.Pretty [a]
instance UU.PPrint.Pretty UU.PPrint.Doc
instance UU.PPrint.Pretty ()
instance UU.PPrint.Pretty GHC.Types.Bool
instance UU.PPrint.Pretty GHC.Types.Char
instance UU.PPrint.Pretty GHC.Types.Int
instance UU.PPrint.Pretty GHC.Integer.Type.Integer
instance UU.PPrint.Pretty GHC.Types.Float
instance UU.PPrint.Pretty GHC.Types.Double
instance (UU.PPrint.Pretty a, UU.PPrint.Pretty b) => UU.PPrint.Pretty (a, b)
instance (UU.PPrint.Pretty a, UU.PPrint.Pretty b, UU.PPrint.Pretty c) => UU.PPrint.Pretty (a, b, c)
instance UU.PPrint.Pretty a => UU.PPrint.Pretty (GHC.Base.Maybe a)
instance GHC.Show.Show UU.PPrint.Doc

module UU.Parsing.MachineInterface

-- | The <a>InputState</a> class contains the interface that the AnaParser
--   parsers expect for the input. A minimal complete instance definition
--   consists of <a>splitStateE</a>, <a>splitState</a> and
--   <a>getPosition</a>.
class InputState state s pos | state -> s, state -> pos where reportError _ = id insertSymbol _ = id deleteSymbol _ = id

-- | Splits the state in a strict variant of <a>Either</a>, with
--   <a>Left'</a> if a symbol can be split off and <a>Right'</a> if none
--   can
splitStateE :: InputState state s pos => state -> Either' state s

-- | Splits the state in the first symbol and the remaining state
splitState :: InputState state s pos => state -> (# s, state #)

-- | Gets the current position in the input
getPosition :: InputState state s pos => state -> pos

-- | Reports an error
reportError :: InputState state s pos => Message s pos -> state -> state

-- | Modify the state as the result of inserting a symbol <tt>s</tt> in the
--   input. The symbol that has already been considered as having been
--   inserted is passed. It should normally not be added to the state.
insertSymbol :: InputState state s pos => s -> state -> state

-- | Modify the state as the result of deleting a symbol <tt>s</tt> from
--   the input. The symbol that has already been deleted from the input
--   state is passed. It should normally not be deleted from the state.
deleteSymbol :: InputState state s pos => s -> state -> state
class OutputState r
acceptR :: OutputState r => v -> rest -> r v rest
nextR :: OutputState r => (a -> rest -> rest') -> (b -> a) -> (r b rest) -> rest'
class Symbol s where deleteCost b = 5# symBefore = error "You should have made your token type an instance of the Class Symbol. eg by defining symBefore = pred" symAfter = error "You should have made your token type an instance of the Class Symbol. eg by defining symAfter  = succ"
deleteCost :: Symbol s => s -> Int#
symBefore :: Symbol s => s -> s
symAfter :: Symbol s => s -> s
data Either' state s
Left' :: !s -> (state) -> Either' state s
Right' :: (state) -> Either' state s
data Steps val s p
OkVal :: (a -> val) -> (Steps a s p) -> Steps val s p
Ok :: Steps val s p -> Steps val s p
[rest] :: Steps val s p -> Steps val s p
Cost :: Int# -> Steps val s p -> Steps val s p
[costing] :: Steps val s p -> Int#
[rest] :: Steps val s p -> Steps val s p
StRepair :: Int# -> !(Message s p) -> Steps val s p -> Steps val s p
[costing] :: Steps val s p -> Int#
[m] :: Steps val s p -> !(Message s p)
[rest] :: Steps val s p -> Steps val s p
Best :: (Steps val s p) -> (Steps val s p) -> (Steps val s p) -> Steps val s p
NoMoreSteps :: val -> Steps val s p
data Action s
Insert :: s -> Action s
Delete :: s -> Action s
Other :: String -> Action s
val :: (a -> b) -> Steps a s p -> Steps b s p
evalSteps :: Steps a s p -> a
getMsgs :: Steps a s p -> [Message s p]
data Message sym pos
Msg :: (Expecting sym) -> !pos -> (Action sym) -> Message sym pos
data Expecting s
ESym :: (SymbolR s) -> Expecting s
EStr :: String -> Expecting s
EOr :: [Expecting s] -> Expecting s
ESeq :: [Expecting s] -> Expecting s
data SymbolR s
Range :: !s -> !s -> SymbolR s
EmptyR :: SymbolR s
mk_range :: Ord s => s -> s -> SymbolR s
symInRange :: Ord a => SymbolR a -> a -> Bool
symRS :: Ord a => SymbolR a -> a -> Ordering
except :: (Ord s, Foldable t, Symbol s) => SymbolR s -> t s -> [SymbolR s]
usererror :: [Char] -> t
systemerror :: [Char] -> [Char] -> t
instance GHC.Classes.Eq s => GHC.Classes.Eq (UU.Parsing.MachineInterface.Expecting s)
instance GHC.Classes.Ord s => GHC.Classes.Ord (UU.Parsing.MachineInterface.Expecting s)
instance GHC.Classes.Ord s => GHC.Classes.Ord (UU.Parsing.MachineInterface.SymbolR s)
instance GHC.Classes.Eq s => GHC.Classes.Eq (UU.Parsing.MachineInterface.SymbolR s)
instance (GHC.Classes.Eq s, GHC.Show.Show s) => GHC.Show.Show (UU.Parsing.MachineInterface.Expecting s)
instance (GHC.Classes.Eq s, GHC.Show.Show s, GHC.Show.Show p) => GHC.Show.Show (UU.Parsing.MachineInterface.Message s p)
instance GHC.Show.Show s => GHC.Show.Show (UU.Parsing.MachineInterface.Action s)
instance (GHC.Classes.Eq s, GHC.Show.Show s) => GHC.Show.Show (UU.Parsing.MachineInterface.SymbolR s)

module UU.Parsing.Machine
pDynE :: ParsRec state result s p a -> AnaParser state result s p a
pDynL :: ParsRec state result s p a -> AnaParser state result s p a
newtype RealParser state s p a
P :: (forall r' r''. (a -> r'' -> r') -> (state -> Steps r'' s p) -> state -> Steps r' s p) -> RealParser state s p a
newtype RealRecogn state s p
R :: (forall r. (state -> Steps r s p) -> state -> Steps r s p) -> RealRecogn state s p
newtype RealAccept state result s p a
A :: (forall r. (state -> Steps r s p) -> state -> Steps (result a r) s p) -> RealAccept state result s p a
newtype ParsRec state result s p a
PR :: (RealParser state s p a, RealRecogn state s p, RealAccept state result s p a) -> ParsRec state result s p a
mkPR :: OutputState result => (RealParser t s p a, RealRecogn t s p) -> ParsRec t result s p a
unP :: RealParser t t1 t2 t3 -> (t3 -> r'' -> r') -> (t -> Steps r'' t1 t2) -> t -> Steps r' t1 t2
unR :: RealRecogn t t1 t2 -> (t -> Steps r t1 t2) -> t -> Steps r t1 t2
parseRecbasic :: (inp -> Steps (out c d) sym pos) -> ParsRec inp out sym pos a -> inp -> Steps (out a (out c d)) sym pos
parsebasic :: (inp -> Steps (out c d) sym pos) -> AnaParser inp out sym pos a -> inp -> Steps (out a (out c d)) sym pos
libAccept :: (OutputState a, InputState b s p) => ParsRec b a s p s
libInsert :: (OutputState result, InputState t s p) => Int# -> s -> Expecting s -> ParsRec t result s p s
libSucceed :: OutputState result => a -> ParsRec t result s p a
libSeq :: (OutputState t1, OutputState result) => ParsRec t3 t s p (t2 -> a) -> ParsRec t3 t1 s p t2 -> ParsRec t3 result s p a
libDollar :: OutputState result => (t2 -> a) -> ParsRec t t1 s p t2 -> ParsRec t result s p a
libDollarL :: OutputState result => a -> ParsRec t2 t s p t1 -> ParsRec t2 result s p a
libDollarR :: OutputState result => t -> ParsRec t1 t2 s p a -> ParsRec t1 result s p a
libSeqL :: OutputState result => ParsRec t3 t s p a -> ParsRec t3 t1 s p t2 -> ParsRec t3 result s p a
libSeqR :: OutputState result => ParsRec t3 t s p t1 -> ParsRec t3 t2 s p a -> ParsRec t3 result s p a
libOr :: (Ord s, OutputState result) => ParsRec t2 t s p a -> ParsRec t2 t1 s p a -> ParsRec t2 result s p a
libFail :: OutputState a => ParsRec b a c p d
starting :: Steps a s p -> Expecting s
hasSuccess :: Steps a s p -> Bool
getStart :: Message t t1 -> Expecting t
addToMessage :: Ord sym => Message sym pos -> Expecting sym -> Message sym pos
addexpecting :: Ord s => Expecting s -> Steps val s p -> Steps val s p
eor :: Ord a => Expecting a -> Expecting a -> Expecting a
libBest :: Ord s => Steps b s p -> Steps b s p -> Steps b s p
libBest' :: Ord s => Steps b s p -> Steps c s p -> (b -> d) -> (c -> d) -> Steps d s p
isTrue :: Int# -> Bool
lib_correct :: Ord s => (b -> c -> Steps d s p) -> (b -> c -> Steps d s p) -> b -> c -> Steps d s p
libCorrect :: Ord s => Steps a s p -> Steps c s p -> (a -> d) -> (c -> d) -> Steps d s p
data ToBeat a
ToBeat :: Int# -> a -> ToBeat a
traverse :: ToBeat (Steps a s p) -> (Steps v s p -> Steps a s p, Steps v s p) -> Int# -> Int# -> ToBeat (Steps a s p)
data AnaParser state result s p a
AnaParser :: ParsRec state result s p a -> Nat -> Maybe (Bool, Either a (ParsRec state result s p a)) -> OneDescr state result s p a -> AnaParser state result s p a
[pars] :: AnaParser state result s p a -> ParsRec state result s p a
[leng] :: AnaParser state result s p a -> Nat
[zerop] :: AnaParser state result s p a -> Maybe (Bool, Either a (ParsRec state result s p a))
[onep] :: AnaParser state result s p a -> OneDescr state result s p a
data OneDescr state result s p a
OneDescr :: Expecting s -> [(SymbolR s, TableEntry state result s p a)] -> OneDescr state result s p a
[firsts] :: OneDescr state result s p a -> Expecting s
[table] :: OneDescr state result s p a -> [(SymbolR s, TableEntry state result s p a)]
data TableEntry state result s p a
TableEntry :: (ParsRec state result s p a) -> (Expecting s -> ParsRec state result s p a) -> TableEntry state result s p a
anaFail :: OutputState a => AnaParser b a c p d
noOneParser :: OneDescr state result s p a
pEmpty :: ParsRec state result s p a -> (Bool, Either a (ParsRec state result s p a)) -> AnaParser state result s p a
anaSucceed :: OutputState result => a -> AnaParser state result s p a
anaLow :: OutputState result => a -> AnaParser state result s p a
anaDynE :: ParsRec state result s p a -> AnaParser state result s p a
anaDynL :: ParsRec state result s p a -> AnaParser state result s p a
anaOr :: (Ord s, Symbol s, OutputState result, InputState state s p) => AnaParser state result s p a -> AnaParser state result s p a -> AnaParser state result s p a
anaSeq :: (Ord s, Symbol s, OutputState t1, OutputState result, InputState state s p) => (t7 -> ParsRec t t1 s t2 t3 -> ParsRec state result s p a) -> (ParsRec t4 t5 s t6 t7 -> ParsRec t t1 s t2 t3 -> ParsRec state result s p a) -> (t7 -> t3 -> a) -> AnaParser t4 t5 s t6 t7 -> AnaParser t t1 s t2 t3 -> AnaParser state result s p a
seqZeroZero :: OutputState result => Maybe (Bool, Either t t1) -> Maybe (Bool, Either a1 (ParsRec t2 result s p a1)) -> (t -> ParsRec t2 result s p a1 -> b) -> (t1 -> ParsRec t2 result s p a1 -> b) -> (t -> a1 -> a) -> Maybe (Bool, Either a b)
orOneOneDescr :: Ord s => OneDescr state result s p a -> OneDescr state result s p a -> Bool -> OneDescr state result s p a
anaCostRange :: (Ord d, Symbol d, OutputState a, InputState b d p) => Int# -> d -> SymbolR d -> AnaParser b a d p d
anaGetFirsts :: AnaParser state result s p a -> Expecting s
anaSetFirsts :: (Ord s, Symbol s, OutputState result, InputState state s p) => Expecting s -> AnaParser state result s p a -> AnaParser state result s p a
mapOnePars :: (ParsRec t t1 s t2 t3 -> ParsRec state result s p a) -> OneDescr t t1 s t2 t3 -> OneDescr state result s p a
mkParser :: (InputState state s p, Symbol s, Ord s, OutputState result) => Nat -> Maybe (Bool, Either a (ParsRec state result s p a)) -> OneDescr state result s p a -> AnaParser state result s p a
data Nat
Zero :: Nat
Succ :: Nat -> Nat
Infinite :: Nat
nat_le :: Nat -> Nat -> Bool
nat_min :: Nat -> Nat -> (Nat, (b -> b -> c) -> b -> b -> c)
nat_add :: Nat -> Nat -> Nat
mergeTables :: (Ord s, Ord a1, Symbol a1, OutputState t) => [(SymbolR a1, ParsRec t1 t s p a)] -> [(SymbolR a1, ParsRec t1 t s p a)] -> [(SymbolR a1, ParsRec t1 t s p a)]
libMap :: OutputState result => (forall r r''. (b -> r -> r'') -> state -> Steps (a, r) s p -> (state, Steps r'' s p)) -> (forall r. state -> Steps (r) s p -> (state, Steps r s p)) -> ParsRec state result s p a -> ParsRec state result s p b
pMap :: OutputState result => (forall r r''. (b -> r -> r'') -> state -> Steps (a, r) s p -> (state, Steps r'' s p)) -> (forall r. state -> Steps (r) s p -> (state, Steps r s p)) -> AnaParser state result s p a -> AnaParser state result s p b
libWrap :: OutputState result => (forall r r''. (b -> r -> r'') -> state -> Steps (a, r) s p -> (state -> Steps r s p) -> (state, Steps r'' s p, state -> Steps r s p)) -> (forall r. state -> Steps r s p -> (state -> Steps r s p) -> (state, Steps r s p, state -> Steps r s p)) -> ParsRec state result s p a -> ParsRec state result s p b
pWrap :: OutputState result => (forall r r''. (b -> r -> r'') -> state -> Steps (a, r) s p -> (state -> Steps r s p) -> (state, Steps r'' s p, state -> Steps r s p)) -> (forall r. state -> Steps r s p -> (state -> Steps r s p) -> (state, Steps r s p, state -> Steps r s p)) -> AnaParser state result s p a -> AnaParser state result s p b
lookupSym :: Ord a => BinSearchTree (SymbolR a, b) -> a -> Maybe b
instance GHC.Show.Show UU.Parsing.Machine.Nat
instance GHC.Classes.Eq UU.Parsing.Machine.Nat

module UU.Parsing.StateParser
class StateParser p st | p -> st where set x = change (const x) get = change id
change :: StateParser p st => (st -> st) -> p st
set :: StateParser p st => st -> p st
get :: StateParser p st => p st
instance UU.Parsing.MachineInterface.InputState inp s p => UU.Parsing.MachineInterface.InputState (inp, state) s p
instance (UU.Parsing.MachineInterface.InputState inp s p, UU.Parsing.MachineInterface.OutputState out) => UU.Parsing.StateParser.StateParser (UU.Parsing.Machine.AnaParser (inp, st) out s p) st

module UU.Scanner.Position
type Line = Int
type Column = Int
type Filename = String
class Position p
line :: Position p => p -> Line
column :: Position p => p -> Column
file :: Position p => p -> Filename
data Pos
Pos :: !Line -> !Column -> Filename -> Pos
initPos :: FilePath -> Pos
noPos :: Pos
advl :: Line -> Pos -> Pos
advc :: Column -> Pos -> Pos
adv :: Pos -> Char -> Pos
updPos :: Char -> Pos -> Pos
tab :: Pos -> Pos
newl :: Pos -> Pos
tabWidth :: Column -> Int
updPos' :: Char -> Pos -> (Pos -> a) -> a
advc' :: Int -> Pos -> (Pos -> a) -> a
tab' :: Pos -> (Pos -> a) -> a
newl' :: Pos -> (Pos -> a) -> a
instance UU.Scanner.Position.Position UU.Scanner.Position.Pos
instance GHC.Show.Show UU.Scanner.Position.Pos

module UU.Scanner.GenToken
data GenToken key tp val
Reserved :: !key -> !Pos -> GenToken key tp val
ValToken :: !tp -> val -> !Pos -> GenToken key tp val
position :: GenToken k t v -> Pos

module UU.Scanner.GenTokenOrd
instance (GHC.Classes.Eq key, GHC.Classes.Eq tp) => GHC.Classes.Eq (UU.Scanner.GenToken.GenToken key tp val)
instance (GHC.Classes.Ord key, GHC.Classes.Ord tp) => GHC.Classes.Ord (UU.Scanner.GenToken.GenToken key tp val)

module UU.Scanner.GenTokenSymbol
instance UU.Parsing.MachineInterface.Symbol (UU.Scanner.GenToken.GenToken key tp val)

module UU.Scanner.Token
type Token = GenToken String EnumValToken String
data EnumValToken
TkVarid :: EnumValToken
TkConid :: EnumValToken
TkString :: EnumValToken
TkChar :: EnumValToken
TkInteger8 :: EnumValToken
TkInteger10 :: EnumValToken
TkInteger16 :: EnumValToken
TkFraction :: EnumValToken
TkTextnm :: EnumValToken
TkTextln :: EnumValToken
TkOp :: EnumValToken
TkConOp :: EnumValToken
TkError :: EnumValToken
reserved :: String -> Pos -> Token
valueToken :: EnumValToken -> String -> Pos -> Token
errToken :: String -> Pos -> Token
instance GHC.Classes.Ord UU.Scanner.Token.EnumValToken
instance GHC.Classes.Eq UU.Scanner.Token.EnumValToken

module UU.Scanner.Scanner
scanFile :: [String] -> [String] -> String -> String -> FilePath -> IO [Token]
scan :: [String] -> [String] -> String -> String -> Pos -> String -> [Token]
lexNest :: (Pos -> String -> [Token]) -> Pos -> String -> [Token]
scanString :: String -> (String, Int, String)
scanChar :: [Char] -> (Maybe Char, Int, [Char])
getchar :: [Char] -> (Maybe Char, Int, [Char])
getEscChar :: [Char] -> (Maybe Char, Int, [Char])
readn :: Int -> [Char] -> Int
getNumber :: [Char] -> (EnumValToken, [Char], Int, [Char])
isHexaDigit :: Char -> Bool
isOctalDigit :: Char -> Bool
value :: Char -> Int

module UU.Scanner.TokenShow
instance GHC.Show.Show UU.Scanner.Token.Token
instance GHC.Show.Show UU.Scanner.Token.EnumValToken

module UU.Parsing.Interface
data AnaParser state result s p a
pWrap :: OutputState result => (forall r r''. (b -> r -> r'') -> state -> Steps (a, r) s p -> (state -> Steps r s p) -> (state, Steps r'' s p, state -> Steps r s p)) -> (forall r. state -> Steps r s p -> (state -> Steps r s p) -> (state, Steps r s p, state -> Steps r s p)) -> AnaParser state result s p a -> AnaParser state result s p b
pMap :: OutputState result => (forall r r''. (b -> r -> r'') -> state -> Steps (a, r) s p -> (state, Steps r'' s p)) -> (forall r. state -> Steps (r) s p -> (state, Steps r s p)) -> AnaParser state result s p a -> AnaParser state result s p b
type Parser s = AnaParser [s] Pair s (Maybe s)

-- | The <a>IsParser</a> class contains the base combinators with which to
--   write parsers. A minimal complete instance definition consists of
--   definitions for '(<a>*</a>)', '(<a>|</a>)', <a>pSucceed</a>,
--   <a>pLow</a>, <a>pFail</a>, <a>pCostRange</a>, <a>pCostSym</a>,
--   <a>getfirsts</a>, <a>setfirsts</a>, and <a>getzerop</a>. All operators
--   available through <a>Applicative</a>, 'Functor", and
--   <a>Alternative</a> have the same names suffixed with <tt>:</tt>.
class (Applicative p, Alternative p, Functor p) => IsParser p s | p -> s where pSucceed = pure pFail = empty pSym a = pCostSym 5# a a pRange = pCostRange 5#

-- | Two variants of the parser for empty strings. <a>pSucceed</a> parses
--   the empty string, and fully counts as an alternative parse. It returns
--   the value passed to it.
pSucceed :: IsParser p s => a -> p a

-- | <a>pLow</a> parses the empty string, but alternatives to pLow are
--   always preferred over <a>pLow</a> parsing the empty string.
pLow :: IsParser p s => a -> p a

-- | This parser always fails, and never returns any value at all.
pFail :: IsParser p s => p a

-- | Parses a range of symbols with an associated cost and the symbol to
--   insert if no symbol in the range is present. Returns the actual symbol
--   parsed.
pCostRange :: IsParser p s => Int# -> s -> SymbolR s -> p s

-- | Parses a symbol with an associated cost and the symbol to insert if
--   the symbol to parse isn't present. Returns either the symbol parsed or
--   the symbol inserted.
pCostSym :: IsParser p s => Int# -> s -> s -> p s

-- | Parses a symbol. Returns the symbol parsed.
pSym :: IsParser p s => s -> p s
pRange :: IsParser p s => s -> SymbolR s -> p s

-- | Get the firsts set from the parser, i.e. the symbols it expects.
getfirsts :: IsParser p s => p v -> Expecting s

-- | Set the firsts set in the parser.
setfirsts :: IsParser p s => Expecting s -> p v -> p v

-- | <a>getzerop</a> returns <tt>Nothing</tt> if the parser can not parse
--   the empty string, and returns <tt>Just p</tt> with <tt>p</tt> a parser
--   that parses the empty string and returns the appropriate value.
getzerop :: IsParser p s => p v -> Maybe (p v)

-- | <a>getonep</a> returns <tt>Nothing</tt> if the parser can only parse
--   the empty string, and returns <tt>Just p</tt> with <tt>p</tt> a parser
--   that does not parse any empty string.
getonep :: IsParser p s => p v -> Maybe (p v)

-- | The fast <a>AnaParser</a> instance of the <a>IsParser</a> class. Note
--   that this requires a functioning <a>Ord</a> for the symbol type s, as
--   tokens are often compared using the <a>compare</a> function in
--   <a>Ord</a> rather than always using <a>==</a> rom <a>Eq</a>. The two
--   do need to be consistent though, that is for any two <tt>x1</tt>,
--   <tt>x2</tt> such that <tt>x1 == x2</tt> you must have <tt>compare x1
--   x2 == EQ</tt>.
pCost :: (OutputState out, InputState inp sym pos, Symbol sym, Ord sym) => Int# -> AnaParser inp out sym pos ()
getInputState :: (InputState a c d, Symbol c, Ord c, OutputState b) => AnaParser a b c d a
handleEof :: (Symbol s, InputState a s p) => a -> Steps (Pair a ()) s p
parse :: (Symbol s, InputState inp s pos) => AnaParser inp Pair s pos a -> inp -> Steps (Pair a (Pair inp ())) s pos
parseIOMessage :: (Symbol s, InputState inp s p) => (Message s p -> String) -> AnaParser inp Pair s p a -> inp -> IO a
parseIOMessageN :: (Symbol s, InputState inp s p) => (Message s p -> String) -> Int -> AnaParser inp Pair s p a -> inp -> IO a
data Pair a r
Pair :: a -> r -> Pair a r
evalStepsIO :: (Message s p -> String) -> Steps b s p -> IO b
evalStepsIO' :: (Message s p -> String) -> Int -> Steps b s p -> IO b

-- | Sequential application.
(<*>) :: Applicative f => forall a b. f (a -> b) -> f a -> f b

-- | Sequence actions, discarding the value of the second argument.
(<*) :: Applicative f => forall a b. f a -> f b -> f a

-- | Sequence actions, discarding the value of the first argument.
(*>) :: Applicative f => forall a b. f a -> f b -> f b

-- | An infix synonym for <a>fmap</a>.
--   
--   <h4><b>Examples</b></h4>
--   
--   Convert from a <tt><tt>Maybe</tt> <tt>Int</tt></tt> to a
--   <tt><tt>Maybe</tt> <tt>String</tt></tt> using <tt>show</tt>:
--   
--   <pre>
--   &gt;&gt;&gt; show &lt;$&gt; Nothing
--   Nothing
--   
--   &gt;&gt;&gt; show &lt;$&gt; Just 3
--   Just "3"
--   </pre>
--   
--   Convert from an <tt><tt>Either</tt> <tt>Int</tt> <tt>Int</tt></tt> to
--   an <tt><tt>Either</tt> <tt>Int</tt></tt> <tt>String</tt> using
--   <tt>show</tt>:
--   
--   <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 <tt>even</tt> 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

-- | 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.
(<$) :: Functor f => forall a b. a -> f b -> f a

-- | An associative binary operation
(<|>) :: Alternative f => forall a. f a -> f a -> f a
instance (GHC.Classes.Ord s, UU.Parsing.MachineInterface.Symbol s, UU.Parsing.MachineInterface.InputState state s p, UU.Parsing.MachineInterface.OutputState result) => UU.Parsing.Interface.IsParser (UU.Parsing.Machine.AnaParser state result s p) s
instance (GHC.Classes.Ord s, UU.Parsing.MachineInterface.Symbol s, UU.Parsing.MachineInterface.InputState state s p, UU.Parsing.MachineInterface.OutputState result) => GHC.Base.Applicative (UU.Parsing.Machine.AnaParser state result s p)
instance (GHC.Classes.Ord s, UU.Parsing.MachineInterface.Symbol s, UU.Parsing.MachineInterface.InputState state s p, UU.Parsing.MachineInterface.OutputState result) => GHC.Base.Alternative (UU.Parsing.Machine.AnaParser state result s p)
instance (GHC.Classes.Ord s, UU.Parsing.MachineInterface.Symbol s, UU.Parsing.MachineInterface.InputState state s p, UU.Parsing.MachineInterface.OutputState result, GHC.Base.Applicative (UU.Parsing.Machine.AnaParser state result s p)) => GHC.Base.Functor (UU.Parsing.Machine.AnaParser state result s p)
instance UU.Parsing.MachineInterface.InputState [s] s (GHC.Base.Maybe s)
instance UU.Parsing.MachineInterface.OutputState UU.Parsing.Interface.Pair

module UU.Parsing.Derived

-- | Checks if the parser accepts epsilon.
acceptsepsilon :: (IsParser p s) => p v -> Bool
mnz :: (IsParser p s) => p v -> t -> String -> t

-- | Parses the specified range, see also <a>pRange</a>.
--   
--   Example:
--   
--   <pre>
--   pDig = 'a' &lt;..&gt; 'z'
--   </pre>
(<..>) :: (IsParser p s) => s -> s -> p s
pExcept :: (IsParser p s, Symbol s, Ord s, Eq (SymbolR s)) => (s, s, s) -> [s] -> p s

-- | Optionally recognize parser <tt>p</tt>.
--   
--   If <tt>p</tt> can be recognized, the return value of <tt>p</tt> is
--   used. Otherwise, the value <tt>v</tt> is used. Note that opt is
--   greedy, if you do not want this use <tt>... <a>|</a> pSucceed v</tt>
--   instead. Furthermore, <tt>p</tt> should not recognise the empty
--   string.
opt :: (IsParser p s) => p a -> a -> p a
asList :: (IsParser p s) => Expecting s -> p v -> p v
asList1 :: (IsParser p s) => Expecting s -> p v -> p v
asOpt :: (IsParser p s) => Expecting s -> p v -> p v

-- | Parses the sequence of <tt>pa</tt> and <tt>pb</tt>, and combines them
--   as a tuple.
(<+>) :: (IsParser p s) => p a -> p b -> p (a, b)

-- | A variant of <a>&lt;*&gt;</a> with the arguments reversed.
(<**>) :: Applicative f => f a -> f (a -> b) -> f b
(<$$>) :: (IsParser p s) => (a -> b -> c) -> p b -> p (a -> c)
(<??>) :: (IsParser p s) => p a -> p (a -> a) -> p a
(<?>) :: (IsParser p s) => p v -> String -> p v

-- | This can be used to parse <tt>x</tt> surrounded by <tt>l</tt> and
--   <tt>r</tt>.
--   
--   Example:
--   
--   <pre>
--   pParens = pPacked pOParen pCParen
--   </pre>
pPacked :: (IsParser p s) => p a -> p b1 -> p b -> p b
pFoldr_ng :: (IsParser p s) => (a -> a1 -> a1, a1) -> p a -> p a1
pFoldr_gr :: (IsParser p s) => (a -> b -> b, b) -> p a -> p b
pFoldr :: (IsParser p s) => (a -> b -> b, b) -> p a -> p b
pFoldr1_ng :: (IsParser p s) => (v -> b -> b, b) -> p v -> p b
pFoldr1_gr :: (IsParser p s) => (v -> b -> b, b) -> p v -> p b
pFoldr1 :: (IsParser p s) => (v -> b -> b, b) -> p v -> p b
pFoldrSep_ng :: (IsParser p s) => (v -> b -> b, b) -> p a -> p v -> p b
pFoldrSep_gr :: (IsParser p s) => (v -> b -> b, b) -> p a -> p v -> p b
pFoldrSep :: (IsParser p s) => (v -> b -> b, b) -> p a -> p v -> p b
pFoldr1Sep_ng :: (IsParser p s) => (a -> b -> b, b) -> p a1 -> p a -> p b
pFoldr1Sep_gr :: (IsParser p s) => (a -> b -> b, b) -> p a1 -> p a -> p b
pFoldr1Sep :: (IsParser p s) => (a -> b -> b, b) -> p a1 -> p a -> p b
pList_ng :: (IsParser p s) => p a -> p [a]
pList_gr :: (IsParser p s) => p a -> p [a]
pList :: (IsParser p s) => p a -> p [a]
pList1_ng :: (IsParser p s) => p a -> p [a]
pList1_gr :: (IsParser p s) => p a -> p [a]
pList1 :: (IsParser p s) => p a -> p [a]
pListSep_ng :: (IsParser p s) => p a1 -> p a -> p [a]
pListSep_gr :: (IsParser p s) => p a1 -> p a -> p [a]
pListSep :: (IsParser p s) => p a -> p a1 -> p [a1]
pList1Sep_ng :: (IsParser p s) => p a1 -> p a -> p [a]
pList1Sep_gr :: (IsParser p s) => p a1 -> p a -> p [a]
pList1Sep :: (IsParser p s) => p a -> p a1 -> p [a1]
pChainr_ng :: (IsParser p s) => p (a -> a -> a) -> p a -> p a
pChainr_gr :: (IsParser p s) => p (c -> c -> c) -> p c -> p c
pChainr :: (IsParser p s) => p (c -> c -> c) -> p c -> p c
pChainl_ng :: (IsParser p s) => p (c -> c -> c) -> p c -> p c
pChainl_gr :: (IsParser p s) => p (c -> c -> c) -> p c -> p c
pChainl :: (IsParser p s) => p (c -> c -> c) -> p c -> p c

-- | Parses using any of the parsers in the list <tt>l</tt>.
--   
--   Warning: <tt>l</tt> may not be an empty list.
pAny :: (IsParser p s) => (a -> p a1) -> [a] -> p a1

-- | Parses any of the symbols in <tt>l</tt>.
pAnySym :: (IsParser p s) => [s] -> p s
pToks :: (IsParser p s) => [s] -> p [s]
pLocate :: (IsParser p s) => [[s]] -> p [s]

module UU.Parsing.Offside
parseOffside :: (Symbol s, InputState i s p, Position p) => OffsideParser i Pair s p a -> OffsideInput i s p -> Steps (a, OffsideInput i s p) (OffsideSymbol s) p
pBlock :: (InputState i s p, OutputState o, Position p, Symbol s, Ord s) => OffsideParser i o s p x -> OffsideParser i o s p y -> OffsideParser i o s p z -> OffsideParser i o s p a -> OffsideParser i o s p [a]
pBlock1 :: (InputState i s p, OutputState o, Position p, Symbol s, Ord s) => OffsideParser i o s p x -> OffsideParser i o s p y -> OffsideParser i o s p z -> OffsideParser i o s p a -> OffsideParser i o s p [a]
pOffside :: (InputState i s p, OutputState o, Position p, Symbol s, Ord s) => OffsideParser i o s p x -> OffsideParser i o s p y -> OffsideParser i o s p a -> OffsideParser i o s p a -> OffsideParser i o s p a
pOpen :: (OutputState o, InputState i s p, Position p, Symbol s, Ord s) => OffsideParser i o s p ()
pClose :: (OutputState o, InputState i s p, Position p, Symbol s, Ord s) => OffsideParser i o s p ()
pSeparator :: (OutputState o, InputState i s p, Position p, Symbol s, Ord s) => OffsideParser i o s p ()

-- | convert tokens to offside tokens, dealing with Haskell's layout rule
scanOffside :: (InputState i s p, Position p, Eq s) => s -> s -> s -> [s] -> i -> OffsideInput i s p
scanOffsideWithTriggers :: (InputState i s p, Position p, Eq s) => s -> s -> s -> [(OffsideTrigger, s)] -> i -> OffsideInput i s p

-- | plainly lift tokens to offside tokens scanLiftTokensToOffside ::
--   (InputState i s p) =&gt; [i] -&gt; OffsideInput i s p -&gt;
--   OffsideInput i s p
scanLiftTokensToOffside :: InputState state s p => state -> OffsideInput inp s p -> OffsideInput inp s p
data OffsideTrigger
Trigger_IndentGT :: OffsideTrigger
Trigger_IndentGE :: OffsideTrigger
data OffsideSymbol s
Symbol :: s -> OffsideSymbol s
SemiColon :: OffsideSymbol s
CloseBrace :: OffsideSymbol s
OpenBrace :: OffsideSymbol s
data OffsideInput inp s p
data Stream inp s p
newtype OffsideParser i o s p a
OP :: (AnaParser (OffsideInput i s p) o (OffsideSymbol s) p a) -> OffsideParser i o s p a
instance GHC.Show.Show s => GHC.Show.Show (UU.Parsing.Offside.OffsideSymbol s)
instance GHC.Classes.Eq s => GHC.Classes.Eq (UU.Parsing.Offside.OffsideSymbol s)
instance GHC.Classes.Ord s => GHC.Classes.Ord (UU.Parsing.Offside.OffsideSymbol s)
instance GHC.Classes.Eq UU.Parsing.Offside.OffsideTrigger
instance UU.Parsing.MachineInterface.InputState inp s p => UU.Parsing.MachineInterface.InputState (UU.Parsing.Offside.OffsideInput inp s p) (UU.Parsing.Offside.OffsideSymbol s) p
instance UU.Parsing.MachineInterface.Symbol s => UU.Parsing.MachineInterface.Symbol (UU.Parsing.Offside.OffsideSymbol s)
instance (UU.Parsing.MachineInterface.Symbol s, GHC.Classes.Ord s, UU.Parsing.MachineInterface.InputState i s p, UU.Parsing.MachineInterface.OutputState o) => UU.Parsing.Interface.IsParser (UU.Parsing.Offside.OffsideParser i o s p) s
instance (UU.Parsing.MachineInterface.Symbol s, GHC.Classes.Ord s, UU.Parsing.MachineInterface.InputState i s p, UU.Parsing.MachineInterface.OutputState o) => GHC.Base.Applicative (UU.Parsing.Offside.OffsideParser i o s p)
instance (UU.Parsing.MachineInterface.Symbol s, GHC.Classes.Ord s, UU.Parsing.MachineInterface.InputState i s p, UU.Parsing.MachineInterface.OutputState o) => GHC.Base.Alternative (UU.Parsing.Offside.OffsideParser i o s p)
instance (UU.Parsing.MachineInterface.Symbol s, GHC.Classes.Ord s, UU.Parsing.MachineInterface.InputState i s p, UU.Parsing.MachineInterface.OutputState o, GHC.Base.Applicative (UU.Parsing.Offside.OffsideParser i o s p)) => GHC.Base.Functor (UU.Parsing.Offside.OffsideParser i o s p)

module UU.Scanner.GenTokenParser
pCostReserved' :: IsParser p (GenToken key tp val) => Int -> key -> p (GenToken key tp val)
pReserved' :: IsParser p (GenToken key tp val) => key -> p (GenToken key tp val)
pCostValToken' :: IsParser p (GenToken key tp val) => Int -> tp -> val -> p (GenToken key tp val)
pValToken' :: IsParser p (GenToken key tp val) => tp -> val -> p (GenToken key tp val)
pCostReserved :: IsParser p (GenToken key tp val) => Int -> key -> p Pos
pCostValToken :: IsParser p (GenToken key tp val) => Int -> tp -> val -> p (val, Pos)
pReserved :: IsParser p (GenToken key tp val) => key -> p Pos
pValToken :: IsParser p (GenToken key tp val) => tp -> val -> p (val, Pos)
pValTokenNoPos :: IsParser p (GenToken key tp val) => tp -> val -> p val

module UU.Scanner.TokenParser
pKeyPos :: IsParser p Token => String -> p Pos
pSpecPos :: IsParser p Token => Char -> p Pos
pKey :: IsParser p Token => String -> p String
pSpec :: IsParser p Token => Char -> p String
pStringPos :: IsParser p Token => p (String, Pos)
pCharPos :: IsParser p Token => p (String, Pos)
pInteger8Pos :: IsParser p Token => p (String, Pos)
pInteger10Pos :: IsParser p Token => p (String, Pos)
pInteger16Pos :: IsParser p Token => p (String, Pos)
pFractionPos :: IsParser p Token => p (String, Pos)
pVaridPos :: IsParser p Token => p (String, Pos)
pConidPos :: IsParser p Token => p (String, Pos)
pTextnmPos :: IsParser p Token => p (String, Pos)
pTextlnPos :: IsParser p Token => p (String, Pos)
pIntegerPos :: IsParser p Token => p (String, Pos)
pVarsymPos :: IsParser p Token => p (String, Pos)
pConsymPos :: IsParser p Token => p (String, Pos)
pString :: IsParser p Token => p String
pChar :: IsParser p Token => p String
pInteger8 :: IsParser p Token => p String
pInteger10 :: IsParser p Token => p String
pInteger16 :: IsParser p Token => p String
pFraction :: IsParser p Token => p String
pVarid :: IsParser p Token => p String
pConid :: IsParser p Token => p String
pTextnm :: IsParser p Token => p String
pTextln :: IsParser p Token => p String
pInteger :: IsParser p Token => p String
pVarsym :: IsParser p Token => p String
pConsym :: IsParser p Token => p String
pComma :: IsParser p Token => p String
pSemi :: IsParser p Token => p String
pOParen :: IsParser p Token => p String
pCParen :: IsParser p Token => p String
pOBrack :: IsParser p Token => p String
pCBrack :: IsParser p Token => p String
pOCurly :: IsParser p Token => p String
pCCurly :: IsParser p Token => p String
pCommaPos :: IsParser p Token => p Pos
pSemiPos :: IsParser p Token => p Pos
pOParenPos :: IsParser p Token => p Pos
pCParenPos :: IsParser p Token => p Pos
pOBrackPos :: IsParser p Token => p Pos
pCBrackPos :: IsParser p Token => p Pos
pOCurlyPos :: IsParser p Token => p Pos
pCCurlyPos :: IsParser p Token => p Pos
pCommas :: IsParser p Token => p a -> p [a]
pSemics :: IsParser p Token => p a -> p [a]
pParens :: IsParser p Token => p a -> p a
pBracks :: IsParser p Token => p a -> p a
pCurly :: IsParser p Token => p a -> p a
pParens_pCommas :: IsParser p Token => p a -> p [a]
pBracks_pCommas :: IsParser p Token => p a -> p [a]
pCurly_pSemics :: IsParser p Token => p a -> p [a]

module UU.Scanner

module UU.Parsing.CharParser
type CharParser = AnaParser Input Pair Char Pos
data Input
Input :: String -> !Pos -> Input
parseString :: CharParser a -> [Char] -> Steps (Pair a (Pair Input ())) Char Pos
parseStringIO :: (Message Char Pos -> String) -> CharParser a -> [Char] -> IO a
parseFile :: (Message Char Pos -> String) -> CharParser a -> [Char] -> IO a
instance UU.Parsing.MachineInterface.Symbol GHC.Types.Char
instance UU.Parsing.MachineInterface.InputState UU.Parsing.CharParser.Input GHC.Types.Char UU.Scanner.Position.Pos

module UU.Parsing
parseIO :: (Eq s, Show s, Symbol s) => Parser s a -> [s] -> IO a

module UU.Parsing.Merge
(<||>) :: IsParser p s => (c, p (d -> d), e -> f -> g) -> (h, p (i -> i), g -> j -> k) -> ((c, h), p ((d, i) -> (d, i)), e -> (f, j) -> k)
pMerged :: IsParser p s => c -> (d, p (d -> d), c -> d -> e) -> p e
list_of :: IsParser p s => p c -> ([d], p ([c] -> [c]), e -> e)

module UU.Parsing.Perms
data Perms p a
pPerms :: IsParser p s => Perms p a -> p a
pPermsSep :: IsParser p s => p x -> Perms p a -> p a
succeedPerms :: IsParser p s => a -> Perms p a
(~*~) :: IsParser p s => Perms p (a -> b) -> p a -> Perms p b
(~$~) :: IsParser p s => (a -> b) -> p a -> Perms p b
instance UU.Parsing.Interface.IsParser p s => GHC.Base.Functor (UU.Parsing.Perms.Perms p)
instance UU.Parsing.Interface.IsParser p s => GHC.Base.Functor (UU.Parsing.Perms.Br p)