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

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 Functor (Branch p)
instance Functor (Perms 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 Eq T_Frame
instance Ord Format
instance Eq Format
instance Ord T_Frame
instance Show PP_Doc
instance PP a => PP [a]
instance PP Char
instance PP PP_Doc

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 -> [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
(>-<<) :: PP a => a -> PP_Exp -> PP_Exp
(>>|<) :: PP a => PP_Exp -> a -> PP_Exp
(>>-<) :: PP a => PP_Exp -> a -> PP_Exp
pp_es :: PP a => [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 :: (PP a, PP a1, PP a2) => [a1] -> [a] -> [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 PP Float
instance PP Int

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 Show Doc
instance Pretty a => Pretty (Maybe a)
instance (Pretty a, Pretty b, Pretty c) => Pretty (a, b, c)
instance (Pretty a, Pretty b) => Pretty (a, b)
instance Pretty Double
instance Pretty Float
instance Pretty Integer
instance Pretty Int
instance Pretty Char
instance Pretty Bool
instance Pretty ()
instance Pretty Doc
instance Pretty a => Pretty [a]

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
splitStateE :: InputState state s pos => state -> Either' state s
splitState :: InputState state s pos => state -> (# s, state #)
getPosition :: InputState state s pos => state -> pos
reportError :: InputState state s pos => Message s pos -> state -> state
insertSymbol :: InputState state s pos => s -> state -> 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 a, Symbol a) => SymbolR a -> [a] -> [SymbolR a]
usererror :: [Char] -> t
systemerror :: [Char] -> [Char] -> t
instance Eq s => Eq (SymbolR s)
instance Ord s => Ord (SymbolR s)
instance Ord s => Ord (Expecting s)
instance Eq s => Eq (Expecting s)
instance (Eq s, Show s) => Show (SymbolR s)
instance Show s => Show (Action s)
instance (Eq s, Show s, Show p) => Show (Message s p)
instance (Eq s, Show s) => Show (Expecting 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 t1 t2 t3 t, RealRecogn t1 t2 t3) -> ParsRec t1 result t2 t3 t
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 t1 t2) => Int# -> t1 -> Expecting t1 -> ParsRec t result t1 t2 t1
libSucceed :: OutputState result => t -> ParsRec t1 result t2 t3 t
libSeq :: (OutputState result, OutputState t4) => ParsRec t3 t t1 t2 (t5 -> t6) -> ParsRec t3 t4 t1 t2 t5 -> ParsRec t3 result t1 t2 t6
libDollar :: OutputState result => (t4 -> t5) -> ParsRec t t1 t2 t3 t4 -> ParsRec t result t2 t3 t5
libDollarL :: OutputState result => t5 -> ParsRec t t1 t2 t3 t4 -> ParsRec t result t2 t3 t5
libDollarR :: OutputState result => t -> ParsRec t1 t2 t3 t4 t5 -> ParsRec t1 result t3 t4 t5
libSeqL :: OutputState result => ParsRec t3 t t1 t2 t6 -> ParsRec t3 t4 t1 t2 t5 -> ParsRec t3 result t1 t2 t6
libSeqR :: OutputState result => ParsRec t4 t t1 t2 t3 -> ParsRec t4 t5 t1 t2 t6 -> ParsRec t4 result t1 t2 t6
libOr :: (Ord t1, OutputState result) => ParsRec t5 t t1 t2 t4 -> ParsRec t5 t3 t1 t2 t4 -> ParsRec t5 result t1 t2 t4
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
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 t2 (ParsRec t3 result t4 t5 t2)) -> (t -> ParsRec t3 result t4 t5 t2 -> b) -> (t1 -> ParsRec t3 result t4 t5 t2 -> b) -> (t -> t2 -> 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 t1, Ord a, Symbol a, OutputState t) => [(SymbolR a, ParsRec t4 t t1 t2 t3)] -> [(SymbolR a, ParsRec t4 t t1 t2 t3)] -> [(SymbolR a, ParsRec t4 t t1 t2 t3)]
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 Eq Nat
instance Show 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 (InputState inp s p, OutputState out) => StateParser (AnaParser (inp, st) out s p) st
instance InputState inp s p => InputState (inp, state) s p

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 Show Pos
instance 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 (Ord key, Ord tp) => Ord (GenToken key tp val)
instance (Eq key, Eq tp) => Eq (GenToken key tp val)

module UU.Scanner.GenTokenSymbol
instance Symbol (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 Eq EnumValToken
instance Ord 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 Show EnumValToken
instance Show Token

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>.
class IsParser p s | p -> s where f <$> p = pSucceed f <*> p f <$ q = pSucceed f <* q p <* q = pSucceed const <*> p <*> q p *> q = pSucceed (flip const) <*> p <*> q pSym a = pCostSym 5# a a pRange = pCostRange 5#
(<*>) :: IsParser p s => p (a -> b) -> p a -> p b
(<*) :: IsParser p s => p a -> p b -> p a
(*>) :: IsParser p s => p a -> p b -> p b
(<$>) :: IsParser p s => (a -> b) -> p a -> p b
(<$) :: IsParser p s => b -> p a -> p b
pSucceed :: IsParser p s => a -> p a
pLow :: IsParser p s => a -> p a
(<|>) :: IsParser p s => p a -> p a -> p a
pFail :: IsParser p s => p a
pCostRange :: IsParser p s => Int# -> s -> SymbolR s -> p s
pCostSym :: IsParser p s => Int# -> s -> s -> p s
pSym :: IsParser p s => s -> p s
pRange :: IsParser p s => s -> SymbolR s -> p s
getfirsts :: IsParser p s => p v -> Expecting s
setfirsts :: IsParser p s => Expecting s -> p v -> p v
getzerop :: IsParser p s => p v -> Maybe (p v)
getonep :: IsParser p s => p v -> Maybe (p v)
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 pos) => a -> Steps (Pair a ()) s pos
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
instance OutputState Pair
instance InputState [s] s (Maybe s)
instance (Ord s, Symbol s, InputState state s p, OutputState result) => IsParser (AnaParser state result s p) s

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)

-- | Suppose we have a parser a with two alternatives that both start with
--   recognizing a non-terminal p, then we will typically rewrite:
--   
--   <pre>
--   a =     f &lt;$&gt; p &lt;*&gt; q 
--       &lt;|&gt; g &lt;$&gt; p &lt;*&gt; r 
--   </pre>
--   
--   into:
--   
--   <pre>
--   a = p &lt;**&gt; (f &lt;$$&gt; q &lt;|&gt; g &lt;$$&gt; r)
--   </pre>
(<**>) :: IsParser p s => p a -> p (a -> b) -> p 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_gr :: IsParser p s => (v -> b -> b, b) -> p v -> p b
pFoldr1_ng :: IsParser p s => (v -> b -> b, b) -> p v -> p b
pFoldr1 :: IsParser p s => (v -> b -> b, b) -> p v -> p b
pFoldrSep_gr :: IsParser p s => (v -> b -> b, b) -> p a -> p v -> p b
pFoldrSep_ng :: 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_gr :: IsParser p s => (a -> b -> b, b) -> p a1 -> p a -> p b
pFoldr1Sep_ng :: 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
list_alg :: (a -> [a] -> [a], [a1])
pList_gr :: IsParser p s => p a -> p [a]
pList_ng :: IsParser p s => p a -> p [a]
pList :: IsParser p s => p a -> p [a]
pList1_gr :: IsParser p s => p a -> p [a]
pList1_ng :: IsParser p s => p a -> p [a]
pList1 :: IsParser p s => p a -> p [a]
pListSep_gr :: IsParser p s => p a1 -> p a -> p [a]
pListSep_ng :: IsParser p s => p a1 -> p a -> p [a]
pListSep :: IsParser p s => p a -> p a1 -> p [a1]
pList1Sep_gr :: IsParser p s => p a1 -> p a -> p [a]
pList1Sep_ng :: IsParser p s => p a1 -> p a -> p [a]
pList1Sep :: IsParser p s => p a -> p a1 -> p [a1]
pChainr_gr :: IsParser p s => p (c -> c -> c) -> p c -> p c
pChainr_ng :: IsParser p s => p (a -> a -> a) -> p a -> p a
pChainr :: 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_ng :: 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 pos => state -> OffsideInput inp s pos -> OffsideInput inp s pos
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 Eq OffsideTrigger
instance Ord s => Ord (OffsideSymbol s)
instance Eq s => Eq (OffsideSymbol s)
instance Show s => Show (OffsideSymbol s)
instance (Symbol s, Ord s, InputState i s p, OutputState o) => IsParser (OffsideParser i o s p) s
instance Symbol s => Symbol (OffsideSymbol s)
instance InputState inp s p => InputState (OffsideInput inp s p) (OffsideSymbol 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)
pConsymPos :: IsParser p Token => p (String, Pos)
pVarsymPos :: IsParser p Token => p (String, Pos)
pIntegerPos :: IsParser p Token => p (String, Pos)
pTextlnPos :: IsParser p Token => p (String, Pos)
pTextnmPos :: IsParser p Token => p (String, Pos)
pConidPos :: IsParser p Token => p (String, Pos)
pVaridPos :: IsParser p Token => p (String, Pos)
pFractionPos :: IsParser p Token => p (String, Pos)
pInteger16Pos :: IsParser p Token => p (String, Pos)
pInteger10Pos :: IsParser p Token => p (String, Pos)
pInteger8Pos :: IsParser p Token => p (String, Pos)
pCharPos :: IsParser p Token => p (String, Pos)
pString :: IsParser p Token => p String
pConsym :: IsParser p Token => p String
pVarsym :: IsParser p Token => p String
pInteger :: IsParser p Token => p String
pTextln :: IsParser p Token => p String
pTextnm :: IsParser p Token => p String
pConid :: IsParser p Token => p String
pVarid :: IsParser p Token => p String
pFraction :: IsParser p Token => p String
pInteger16 :: IsParser p Token => p String
pInteger10 :: IsParser p Token => p String
pInteger8 :: IsParser p Token => p String
pChar :: IsParser p Token => p String
pComma :: IsParser p Token => p String
pCCurly :: IsParser p Token => p String
pOCurly :: IsParser p Token => p String
pCBrack :: IsParser p Token => p String
pOBrack :: IsParser p Token => p String
pCParen :: IsParser p Token => p String
pOParen :: IsParser p Token => p String
pSemi :: IsParser p Token => p String
pCommaPos :: IsParser p Token => p Pos
pCCurlyPos :: IsParser p Token => p Pos
pOCurlyPos :: IsParser p Token => p Pos
pCBrackPos :: IsParser p Token => p Pos
pOBrackPos :: IsParser p Token => p Pos
pCParenPos :: IsParser p Token => p Pos
pOParenPos :: IsParser p Token => p Pos
pSemiPos :: 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 InputState Input Char Pos
instance Symbol Char

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 IsParser p s => Functor (Br p)
instance IsParser p s => Functor (Perms p)
