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

module UU.PPrint
data Doc
class Pretty a
pretty :: Pretty a => a -> Doc

-- | A specialised variant of showsPrec, using precedence context
--   zero, and returning an ordinary String.
show :: Show a => a -> String
putDoc :: Doc -> IO ()
hPutDoc :: Handle -> Doc -> IO ()
(<>) :: Doc -> Doc -> Doc
infixr 6 <>
(<+>) :: Doc -> Doc -> Doc
infixr 6 <+>
(</>) :: Doc -> Doc -> Doc
infixr 5 </>
(<//>) :: Doc -> Doc -> Doc
infixr 5 <//>
(<$>) :: Doc -> Doc -> Doc
infixr 5 <$>
(<$$>) :: Doc -> Doc -> Doc
infixr 5 <$$>
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 :: String -> 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.Num.Integer.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.Maybe.Maybe a)
instance GHC.Show.Show UU.PPrint.Doc

module UU.Parsing.MachineInterface

-- | The InputState class contains the interface that the AnaParser
--   parsers expect for the input. A minimal complete instance definition
--   consists of splitStateE, splitState and
--   getPosition.
class InputState state s pos | state -> s, state -> pos

-- | Splits the state in a strict variant of Either, with
--   Left' if a symbol can be split off and Right' 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 s 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 s 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
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 :: (Foldable t, Ord a, Symbol a) => SymbolR a -> t a -> [SymbolR a]
usererror :: [Char] -> a
systemerror :: [Char] -> [Char] -> a
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.Classes.Eq (UU.Parsing.MachineInterface.Expecting s)
instance GHC.Classes.Ord s => GHC.Classes.Ord (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.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 (UU.Parsing.MachineInterface.SymbolR s)
instance GHC.Show.Show s => GHC.Show.Show (UU.Parsing.MachineInterface.Action s)

module UU.Pretty.Basic
class Show a => PP a
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
infixr 3 >|<
(>-<) :: (PP a, PP b) => a -> b -> PP_Doc
infixr 2 >-<
fill :: PP a => [a] -> PP_Doc
fillblock :: PP a => Int -> [a] -> PP_Doc
(>//<) :: (PP a, PP b) => a -> b -> PP_Doc
infixr 1 >//<
join :: PP_Doc -> PP_Doc
par :: PP_Exp
(>>$<) :: PP a => PP_Exp -> [a] -> PP_Doc
infixr 0 >>$<
eindent :: Int -> PP_Exp -> PP_Exp
(>>|<<) :: PP_Exp -> PP_Exp -> PP_Exp
infixr 3 >>|<<
(>>-<<) :: PP_Exp -> PP_Exp -> PP_Exp
infixr 2 >>-<<
(>>//<<) :: PP_Exp -> PP_Exp -> PP_Exp
infixr 1 >>//<<
ejoin :: PP_Exp -> PP_Exp
(>>$<<) :: PP_Exp -> [PP_Exp] -> PP_Exp
infixr 0 >>$<<
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.Eq UU.Pretty.Basic.Format
instance GHC.Classes.Ord UU.Pretty.Basic.Format
instance GHC.Classes.Ord UU.Pretty.Basic.T_Frame

module UU.Pretty.Ext
(>^<) :: (PP a, PP b) => a -> b -> PP_Doc
infixr 1 >^<
(>>^<<) :: PP_Exp -> PP_Exp -> PP_Exp
infixr 1 >>^<<
(>#<) :: (PP a, PP b) => a -> b -> PP_Doc
infixr 3 >#<
(>>#<<) :: PP_Exp -> PP_Exp -> PP_Exp
infixr 3 >>#<<
wide_text :: Int -> [Char] -> 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
infixr 3 >|<<
(>-<<) :: PP a => a -> PP_Exp -> PP_Exp
infixr 2 >-<<
(>>|<) :: PP a => PP_Exp -> a -> PP_Exp
infixr 3 >>|<
(>>-<) :: PP a => PP_Exp -> a -> PP_Exp
infixr 2 >>-<
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 t, Foldable t, PP (t a), PP (t a), PP (t a)) => t a -> t a -> t a -> [PP_Doc] -> PP_Doc
pp_ite :: (PP a, PP b, PP a, PP b, PP a, PP b, PP a) => a -> a -> a -> a -> b -> b -> b -> 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.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.GenTokenSymbol
instance UU.Parsing.MachineInterface.Symbol (UU.Scanner.GenToken.GenToken key tp val)

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.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.TokenShow
instance GHC.Show.Show UU.Scanner.Token.Token
instance GHC.Show.Show UU.Scanner.Token.EnumValToken

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.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.Parsing.Machine
pDynE :: forall {state} {result :: Type -> Type -> Type} {s} {p} {a}. ParsRec state result s p a -> AnaParser state result s p a
pDynL :: forall {state} {result :: Type -> Type -> Type} {s} {p} {a}. 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 :: forall {result :: Type -> Type -> Type} {state} {s} {p} {a}. OutputState result => (RealParser state s p a, RealRecogn state s p) -> ParsRec state result s p a
unP :: RealParser state s p a -> (a -> r'' -> r') -> (state -> Steps r'' s p) -> state -> Steps r' s p
unR :: RealRecogn state s p -> (state -> Steps r s p) -> state -> Steps r s p
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 :: forall {result :: Type -> Type -> Type} {state} {a} {p}. (OutputState result, InputState state a p) => Int# -> a -> Expecting a -> ParsRec state result a p a
libSucceed :: forall {result :: Type -> Type -> Type} {a} {state} {s} {p}. OutputState result => a -> ParsRec state result s p a
libSeq :: forall {result :: Type -> Type -> Type} {result :: Type -> Type -> Type} {state} {result :: Type -> Type -> Type} {s} {p} {b} {a}. (OutputState result, OutputState result) => ParsRec state result s p (b -> a) -> ParsRec state result s p b -> ParsRec state result s p a
libDollar :: forall {result :: Type -> Type -> Type} {a} {a} {state} {result :: Type -> Type -> Type} {s} {p}. OutputState result => (a -> a) -> ParsRec state result s p a -> ParsRec state result s p a
libDollarL :: forall {result :: Type -> Type -> Type} {a} {state} {result :: Type -> Type -> Type} {s} {p} {a}. OutputState result => a -> ParsRec state result s p a -> ParsRec state result s p a
libDollarR :: forall {result :: Type -> Type -> Type} {p} {state} {result :: Type -> Type -> Type} {s} {p} {a}. OutputState result => p -> ParsRec state result s p a -> ParsRec state result s p a
libSeqL :: forall {result :: Type -> Type -> Type} {state} {result :: Type -> Type -> Type} {s} {p} {a} {result :: Type -> Type -> Type} {a}. OutputState result => ParsRec state result s p a -> ParsRec state result s p a -> ParsRec state result s p a
libSeqR :: forall {result :: Type -> Type -> Type} {state} {result :: Type -> Type -> Type} {s} {p} {a} {result :: Type -> Type -> Type} {a}. OutputState result => ParsRec state result s p a -> ParsRec state result s p a -> ParsRec state result s p a
libOr :: forall {result :: Type -> Type -> Type} {s} {state} {result :: Type -> Type -> Type} {p} {a} {result :: Type -> Type -> Type}. (OutputState result, Ord s) => ParsRec state result s p a -> ParsRec state result s p a -> ParsRec state 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 sym pos -> Expecting sym
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 :: forall {state} {result :: Type -> Type -> Type} {s} {p} {a}. OneDescr state result s p a
pEmpty :: forall {state} {result :: Type -> Type -> Type} {s} {p} {a}. ParsRec state result s p a -> (Bool, Either a (ParsRec state result s p a)) -> AnaParser state result s p a
anaSucceed :: forall {result :: Type -> Type -> Type} {a} {state} {s} {p}. OutputState result => a -> AnaParser state result s p a
anaLow :: forall {result :: Type -> Type -> Type} {a} {state} {s} {p}. OutputState result => a -> AnaParser state result s p a
anaDynE :: forall {state} {result :: Type -> Type -> Type} {s} {p} {a}. ParsRec state result s p a -> AnaParser state result s p a
anaDynL :: forall {state} {result :: Type -> Type -> Type} {s} {p} {a}. ParsRec state result s p a -> AnaParser state result s p a
anaOr :: forall {state} {s} {p} {result :: Type -> Type -> Type} {a}. (InputState state s p, Symbol s, OutputState result, Ord s) => AnaParser state result s p a -> AnaParser state result s p a -> AnaParser state result s p a
anaSeq :: forall {state} {s} {p} {result :: Type -> Type -> Type} {result :: Type -> Type -> Type} {a} {state} {p} {a} {a} {state} {result :: Type -> Type -> Type} {p}. (InputState state s p, Symbol s, Ord s, OutputState result, OutputState result) => (a -> ParsRec state result s p a -> ParsRec state result s p a) -> (ParsRec state result s p a -> ParsRec state result s p a -> ParsRec state result s p a) -> (a -> a -> a) -> AnaParser state result s p a -> AnaParser state result s p a -> AnaParser state result s p a
seqZeroZero :: forall {result :: Type -> Type -> Type} {t} {t} {a} {state} {s} {p} {b} {a}. OutputState result => Maybe (Bool, Either t t) -> Maybe (Bool, Either a (ParsRec state result s p a)) -> (t -> ParsRec state result s p a -> b) -> (t -> ParsRec state result s p a -> b) -> (t -> a -> a) -> Maybe (Bool, Either a b)
orOneOneDescr :: forall {s} {state} {result :: Type -> Type -> Type} {p} {a}. Ord s => OneDescr state result s p a -> OneDescr state result s p a -> Bool -> OneDescr state result s p a
anaCostRange :: forall {a :: Type -> Type -> Type} {b} {d} {p}. (OutputState a, InputState b d p, Symbol d, Ord d) => Int# -> d -> SymbolR d -> AnaParser b a d p d
anaGetFirsts :: forall {state} {result :: Type -> Type -> Type} {s} {p} {a}. AnaParser state result s p a -> Expecting s
anaSetFirsts :: forall {state} {s} {p} {result :: Type -> Type -> Type} {a}. (InputState state s p, Symbol s, Ord s, OutputState result) => Expecting s -> AnaParser state result s p a -> AnaParser state result s p a
mapOnePars :: forall {state} {result :: Type -> Type -> Type} {s} {p} {a} {state} {result :: Type -> Type -> Type} {p} {a}. (ParsRec state result s p a -> ParsRec state result s p a) -> OneDescr state result s p a -> 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 :: forall {a} {result :: Type -> Type -> Type} {s} {state} {p} {a}. (Symbol a, OutputState result, Ord a, Ord s) => [(SymbolR a, ParsRec state result s p a)] -> [(SymbolR a, ParsRec state result s p a)] -> [(SymbolR a, ParsRec state result 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
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.OutputState out) => UU.Parsing.StateParser.StateParser (UU.Parsing.Machine.AnaParser (inp, st) out s p) st
instance UU.Parsing.MachineInterface.InputState inp s p => UU.Parsing.MachineInterface.InputState (inp, state) s p

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
data Pair a r
Pair :: a -> r -> Pair a r

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

-- | Two variants of the parser for empty strings. pSucceed 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

-- | pLow parses the empty string, but alternatives to pLow are
--   always preferred over pLow 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

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

-- | getonep returns Nothing if the parser can only parse
--   the empty string, and returns Just p with p a parser
--   that does not parse any empty string.
getonep :: IsParser p s => p v -> Maybe (p v)
type Parser s = AnaParser [s] Pair s (Maybe s)
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
evalStepsIO :: (Message s p -> String) -> Steps b s p -> IO b
parseIOMessageN :: (Symbol s, InputState inp s p) => (Message s p -> String) -> Int -> AnaParser inp Pair s p a -> inp -> IO a
evalStepsIO' :: (Message s p -> String) -> Int -> Steps b s p -> IO b

-- | Sequential application.
--   
--   A few functors support an implementation of <*> that is
--   more efficient than the default one.
--   
--   
Example
--   
--   Used in combination with (<$>),
--   (<*>) can be used to build a record.
--   
--   
--   >>> data MyState = MyState {arg1 :: Foo, arg2 :: Bar, arg3 :: Baz}
--   
--   
--   
--   >>> produceFoo :: Applicative f => f Foo
--   
--   
--   
--   >>> produceBar :: Applicative f => f Bar
--   
--   >>> produceBaz :: Applicative f => f Baz
--   
--   
--   
--   >>> mkState :: Applicative f => f MyState
--   
--   >>> mkState = MyState <$> produceFoo <*> produceBar <*> produceBaz
--   
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
infixl 4 <*>

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

-- | Sequence actions, discarding the value of the first argument.
--   
--   
Examples
--   
--   If used in conjunction with the Applicative instance for Maybe,
--   you can chain Maybe computations, with a possible "early return" in
--   case of Nothing.
--   
--   
--   >>> Just 2 *> Just 3
--   Just 3
--   
--   
--   
--   >>> Nothing *> Just 3
--   Nothing
--   
--   
--   Of course a more interesting use case would be to have effectful
--   computations instead of just returning pure values.
--   
--   
--   >>> import Data.Char
--   
--   >>> import Text.ParserCombinators.ReadP
--   
--   >>> let p = string "my name is " *> munch1 isAlpha <* eof
--   
--   >>> readP_to_S p "my name is Simon"
--   [("Simon","")]
--   
(*>) :: Applicative f => f a -> f b -> f b
infixl 4 *>

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

-- | Replace all locations in the input with the same value. The default
--   definition is fmap . const, but this may be
--   overridden with a more efficient version.
(<$) :: Functor f => a -> f b -> f a
infixl 4 <$

-- | An associative binary operation
(<|>) :: Alternative f => f a -> f a -> f a
infixl 3 <|>
instance UU.Parsing.MachineInterface.OutputState UU.Parsing.Interface.Pair
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.Maybe.Maybe s)

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.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 pRange.
--   
--   Example:
--   
--   
--   pDig = 'a' <..> 'z'
--   
(<..>) :: IsParser p s => s -> s -> p s
infixl 5 <..>
pExcept :: (IsParser p s, Symbol s, Ord s, Eq (SymbolR s)) => (s, s, s) -> [s] -> p s

-- | Optionally recognize parser p.
--   
--   If p can be recognized, the return value of p is
--   used. Otherwise, the value v is used. Note that opt is
--   greedy, if you do not want this use ... | pSucceed v
--   instead. Furthermore, p should not recognise the empty
--   string.
opt :: IsParser p s => p a -> a -> p a
infixl 2 `opt`
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 pa and pb, and combines them
--   as a tuple.
(<+>) :: IsParser p s => p a -> p b -> p (a, b)
infixl 4 <+>

-- | A variant of <*> with the arguments reversed.
(<**>) :: Applicative f => f a -> f (a -> b) -> f b
infixl 4 <**>
(<$$>) :: IsParser p s => (a -> b -> c) -> p b -> p (a -> c)
(<??>) :: IsParser p s => p a -> p (a -> a) -> p a
infixl 4 <??>
(<?>) :: IsParser p s => p v -> String -> p v
infixl 2 <?>

-- | This can be used to parse x surrounded by l and
--   r.
--   
--   Example:
--   
--   
--   pParens = pPacked pOParen pCParen
--   
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 l.
--   
--   Warning: l may not be an empty list.
pAny :: IsParser p s => (a -> p a1) -> [a] -> p a1

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

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.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 :: forall i s p. (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) => [i] -> OffsideInput i s p ->
--   OffsideInput i s p
scanLiftTokensToOffside :: InputState t s p => t -> 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.Classes.Eq UU.Parsing.Offside.OffsideTrigger
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 (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)
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)

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.InputState UU.Parsing.CharParser.Input GHC.Types.Char UU.Scanner.Position.Pos
instance UU.Parsing.MachineInterface.Symbol GHC.Types.Char

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

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)

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