interface Text.ParserCombinators.HuttonMeijer where {
infixr  5 +++;

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Fractional (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.RealFrac (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Num (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Real (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Enum (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Read a,Prelude.Integral a) => Prelude.Read (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Ord (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Show (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (NHC.Internal.IO a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Eq (Ratio.Ratio a);

{-# NEED #-}
instance Monad.MonadPlus Parser;

{-# NEED #-}
instance Monad.MonadPlus Prelude.Maybe;

{-# NEED #-}
instance Monad.MonadPlus Prelude.[];

{-# NEED #-}
instance Prelude.Monad Parser;

{-# NEED #-}
instance Prelude.Monad NHC.Internal.IO;

{-# NEED #-}
instance Prelude.Functor Parser;

{-# NEED #-}
instance Prelude.Functor NHC.Internal.IO;
interface Ratio
{-# NEED Ratio #-}
data Ratio a;
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface ! Text.ParserCombinators.HuttonMeijer
{-# NEED identifier #-}
identifier{-# 1 #-}::([Prelude.String] -> (Parser Prelude.String));

{-# NEED symbol #-}
symbol{-# 1 #-}::(Prelude.String -> (Parser Prelude.String));

{-# NEED integer #-}
integer{-# 0 #-}::(Parser Prelude.Int);

{-# NEED natural #-}
natural{-# 0 #-}::(Parser Prelude.Int);

{-# NEED token #-}
token{-# 1 #-}::((Parser a) -> (Parser a));

{-# NEED skip #-}
skip{-# 1 #-}::((Parser a) -> (Parser a));

{-# NEED junk #-}
junk{-# 0 #-}::(Parser ());

{-# NEED comment #-}
comment{-# 0 #-}::(Parser ());

{-# NEED spaces #-}
spaces{-# 0 #-}::(Parser ());

{-# NEED int #-}
int{-# 0 #-}::(Parser Prelude.Int);

{-# NEED nat #-}
nat{-# 0 #-}::(Parser Prelude.Int);

{-# NEED ident #-}
ident{-# 0 #-}::(Parser Prelude.String);

{-# NEED string #-}
string{-# 1 #-}::(Prelude.String -> (Parser Prelude.String));

{-# NEED alphanum #-}
alphanum{-# 0 #-}::(Parser Prelude.Char);

{-# NEED letter #-}
letter{-# 0 #-}::(Parser Prelude.Char);

{-# NEED upper #-}
upper{-# 0 #-}::(Parser Prelude.Char);

{-# NEED lower #-}
lower{-# 0 #-}::(Parser Prelude.Char);

{-# NEED digit #-}
digit{-# 0 #-}::(Parser Prelude.Char);

{-# NEED char #-}
char{-# 1 #-}::(Prelude.Char -> (Parser Prelude.Char));

{-# NEED bracket #-}
bracket{-# 3 #-}::((Parser a) -> ((Parser b) -> ((Parser c) -> (Parser b))));

{-# NEED ops #-}
ops{-# 1 #-}::([((Parser a),b)] -> (Parser b));

{-# NEED chainr1 #-}
chainr1{-# 2 #-}::((Parser a) -> ((Parser (a -> (a -> a))) -> (Parser a)));

{-# NEED chainr #-}
chainr{-# 3 #-}::((Parser a) -> ((Parser (a -> (a -> a))) -> (a -> (Parser a))));

{-# NEED chainl1 #-}
chainl1{-# 2 #-}::((Parser a) -> ((Parser (a -> (a -> a))) -> (Parser a)));

{-# NEED chainl #-}
chainl{-# 3 #-}::((Parser a) -> ((Parser (a -> (a -> a))) -> (a -> (Parser a))));

{-# NEED sepby1 #-}
sepby1{-# 2 #-}::((Parser a) -> ((Parser b) -> (Parser [a])));

{-# NEED sepby #-}
sepby{-# 2 #-}::((Parser a) -> ((Parser b) -> (Parser [a])));

{-# NEED many1 #-}
many1{-# 1 #-}::((Parser a) -> (Parser [a]));

{-# NEED many #-}
many{-# 1 #-}::((Parser a) -> (Parser [a]));

{-# NEED sat #-}
sat{-# 1 #-}::((Token -> Prelude.Bool) -> (Parser Token));

{-# NEED (+++) #-}
(+++){-# 2 #-}::((Parser a) -> ((Parser a) -> (Parser a)));

{-# NEED papply #-}
papply{-# 2 #-}::((Parser a) -> ([Token] -> [(a,[Token])]));

{-# NEED first #-}
first{-# 1 #-}::((Parser a) -> (Parser a));

{-# NEED item #-}
item{-# 0 #-}::(Parser Token);

{-# NEED {Parser P} #-}
newtype {-#  #-} Parser a
  = P ([Token] -> [(a,[Token])]);
interface Text.ParserCombinators.HuttonMeijer
{-# NEED Token #-}
type {-# 1 #-} Token = Prelude.Char;
}