interface Language.Haskell.ParseMonad where {

{-# 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.Functor NHC.Internal.IO;

{-# NEED #-}
instance Prelude.Monad (Lex a);

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

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

{-# NEED #-}
instance Prelude.Ord LexContext;

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

{-# NEED #-}
instance Prelude.Ord Language.Haskell.Syntax.SrcLoc;

{-# NEED #-}
instance Prelude.Eq LexContext;

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

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Syntax.SrcLoc;

{-# NEED #-}
instance Prelude.Show LexContext;

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

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (ParseResult 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.Show Language.Haskell.Syntax.SrcLoc;
interface Ratio
{-# NEED Ratio #-}
data Ratio a;
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface ! Language.Haskell.ParseMonad
{-# NEED popContextL #-}
popContextL{-# 1 #-}::(Prelude.String -> (Lex a ()));

{-# NEED pushContextL #-}
pushContextL{-# 1 #-}::(LexContext -> (Lex a ()));

{-# NEED getOffside #-}
getOffside{-# 0 #-}::(Lex a Prelude.Ordering);

{-# NEED startToken #-}
startToken{-# 0 #-}::(Lex a ());

{-# NEED setBOL #-}
setBOL{-# 0 #-}::(Lex a ());

{-# NEED checkBOL #-}
checkBOL{-# 0 #-}::(Lex a Prelude.Bool);

{-# NEED alternative #-}
alternative{-# 1 #-}::((Lex a b) -> (Lex a (Lex a b)));

{-# NEED lexWhile #-}
lexWhile{-# 1 #-}::((Prelude.Char -> Prelude.Bool) -> (Lex a Prelude.String));

{-# NEED lexTab #-}
lexTab{-# 0 #-}::(Lex a ());

{-# NEED lexNewline #-}
lexNewline{-# 0 #-}::(Lex a ());

{-# NEED discard #-}
discard{-# 1 #-}::(Prelude.Int -> (Lex a ()));

{-# NEED getInput #-}
getInput{-# 0 #-}::(Lex a Prelude.String);

{-# NEED {Lex runL} #-}
newtype {-#  #-} Lex a b
  = Lex {runL :: ((b -> (P a)) -> (P a))};

{-# NEED popContext #-}
popContext{-# 0 #-}::(P ());

{-# NEED pushCurrentContext #-}
pushCurrentContext{-# 0 #-}::(P ());

{-# NEED getSrcLoc #-}
getSrcLoc{-# 0 #-}::(P Language.Haskell.Syntax.SrcLoc);

{-# NEED atSrcLoc #-}
atSrcLoc{-# 2 #-}::((P a) -> (Language.Haskell.Syntax.SrcLoc -> (P a)));

{-# NEED runParser #-}
runParser{-# 0 #-}::((P a) -> (Prelude.String -> (ParseResult a)));

{-# NEED runParserWithMode #-}
runParserWithMode{-# 3 #-}::(ParseMode -> ((P a) -> (Prelude.String -> (ParseResult a))));

{-# NEED {P runP} #-}
newtype {-#  #-} P a
  = P {runP :: (Prelude.String -> (Prelude.Int -> (Prelude.Int -> (Language.Haskell.Syntax.SrcLoc -> (ParseState -> (ParseMode -> (ParseStatus a)))))))};
interface Language.Haskell.ParseMonad
{-# NEED ParseStatus #-}
data ParseStatus a;

{-# NEED ParseState #-}
type {-# 1 #-} ParseState = [LexContext];
interface ! Language.Haskell.ParseMonad
{-# NEED defaultParseMode #-}
defaultParseMode{-# 0 #-}::ParseMode;

{-# NEED {ParseMode ParseMode parseFilename} #-}
data ParseMode
  = ParseMode {parseFilename :: Prelude.String};

{-# NEED {LexContext NoLayout Layout} #-}
data LexContext
  = NoLayout 
  | Layout Prelude.Int;

{-# NEED {ParseResult ParseOk ParseFailed} #-}
data ParseResult a
  = ParseOk a
  | ParseFailed Language.Haskell.Syntax.SrcLoc Prelude.String;
interface Language.Haskell.Syntax
{-# NEED SrcLoc #-}
data SrcLoc;
}