interface Language.Haskell.Parser where {

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsModule;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsGuardedAlt;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsGuardedAlts;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsAlt;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsFieldUpdate;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsStmt;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsPatField;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsPat;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsExp;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsLiteral;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsType;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsQualType;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsGuardedRhs;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsRhs;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsBangType;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsConDecl;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsMatch;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsDecl;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsAssoc;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsImportSpec;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsImportDecl;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsExportSpec;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsSafety;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsCName;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsOp;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsQOp;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsName;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsQName;

{-# NEED #-}
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.Module;

{-# NEED #-}
instance Ix.Ix Data.Char.GeneralCategory;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CInt;

{-# NEED #-}
instance Prelude.Functor (Language.Haskell.Pretty.DocM a);

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

{-# NEED #-}
instance Prelude.Bounded Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.CInt;

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

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

{-# NEED #-}
instance Prelude.Num NHC.FFI.CInt;

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

{-# NEED #-}
instance Prelude.Real NHC.FFI.CInt;

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

{-# NEED #-}
instance Prelude.Enum Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.CInt;

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

{-# NEED #-}
instance Prelude.Read Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Read NHC.FFI.CInt;

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

{-# NEED #-}
instance Prelude.Integral NHC.FFI.CInt;

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Ord Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.CInt;

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

{-# NEED #-}
instance Prelude.Ord Language.Haskell.ParseMonad.LexContext;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Pretty.PPLayout;

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Eq Language.Haskell.Lexer.Token;

{-# NEED #-}
instance Prelude.Eq Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.CInt;

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

{-# NEED #-}
instance Prelude.Eq Language.Haskell.ParseMonad.LexContext;

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

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsModule;

{-# NEED #-}
instance Prelude.Show Text.PrettyPrint.HughesPJ.Doc;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsGuardedAlt;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsGuardedAlts;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsAlt;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsFieldUpdate;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsStmt;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsPatField;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsPat;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsExp;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsLiteral;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsType;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsQualType;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsGuardedRhs;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsRhs;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsBangType;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsConDecl;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsMatch;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsDecl;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsAssoc;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsImportSpec;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsImportDecl;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsExportSpec;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsSafety;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsCName;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsOp;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsQOp;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsName;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsQName;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.HsSpecialCon;

{-# NEED #-}
instance Prelude.Show Language.Haskell.Syntax.Module;

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

{-# NEED #-}
instance Prelude.Show Language.Haskell.Lexer.Token;

{-# NEED #-}
instance Prelude.Show Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Show NHC.FFI.CInt;

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

{-# NEED #-}
instance Prelude.Show Language.Haskell.ParseMonad.LexContext;

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

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (Language.Haskell.ParseMonad.ParseResult a);

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

{-# NEED #-}
instance Prelude.Monad (Language.Haskell.Pretty.DocM a);

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

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

{-# NEED #-}
instance Prelude.Monad Language.Haskell.ParseMonad.P;
interface Language.Haskell.Pretty
{-# NEED PPLayout #-}
data PPLayout;
interface Text.PrettyPrint.HughesPJ
{-# NEED Doc #-}
data Doc;
interface Language.Haskell.Lexer
{-# NEED Token #-}
data Token;
interface Data.Char
{-# NEED GeneralCategory #-}
data GeneralCategory;
interface NHC.FFI
{-# NEED CInt #-}
newtype {-#  #-} CInt;
interface Language.Haskell.Pretty
{-# NEED DocM #-}
newtype {-#  #-} DocM a b;
interface Language.Haskell.ParseMonad
{-# NEED Lex #-}
newtype {-#  #-} Lex a b;
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface Language.Haskell.ParseMonad
{-# NEED P #-}
newtype {-#  #-} P a;

{-# NEED ParseStatus #-}
data ParseStatus a;

{-# NEED ParseState #-}
type {-# 1 #-} ParseState = [LexContext];

{-# NEED LexContext #-}
data LexContext;
interface ! Language.Haskell.Parser
{-# NEED parseModuleWithMode #-}
parseModuleWithMode{-# 1 #-}::(Language.Haskell.ParseMonad.ParseMode -> (Prelude.String -> (Language.Haskell.ParseMonad.ParseResult Language.Haskell.Syntax.HsModule)));

{-# NEED parseModule #-}
parseModule{-# 0 #-}::(Prelude.String -> (Language.Haskell.ParseMonad.ParseResult Language.Haskell.Syntax.HsModule));
interface Language.Haskell.Syntax
{-# NEED HsModule #-}
data HsModule;

{-# NEED HsDecl HsMatch HsRhs HsGuardedRhs HsExp HsStmt HsFieldUpdate HsAlt HsGuardedAlts HsGuardedAlt #-}
data HsDecl;
data HsMatch;
data HsRhs;
data HsGuardedRhs;
data HsExp;
data HsStmt;
data HsFieldUpdate;
data HsAlt;
data HsGuardedAlts;
data HsGuardedAlt;

{-# NEED HsSafety #-}
data HsSafety;

{-# NEED HsQOp #-}
data HsQOp;

{-# NEED HsPat HsPatField #-}
data HsPat;
data HsPatField;

{-# NEED HsLiteral #-}
data HsLiteral;
interface Ratio
{-# NEED Rational #-}
type {-# 1 #-} Rational = (Ratio.Ratio Prelude.Integer);

{-# NEED Ratio #-}
data (Prelude.Integral a) => Ratio a;
interface Language.Haskell.Syntax
{-# NEED HsQualType #-}
data HsQualType;

{-# NEED HsOp #-}
data HsOp;

{-# NEED HsAssoc #-}
data HsAssoc;

{-# NEED HsConDecl #-}
data HsConDecl;

{-# NEED HsBangType #-}
data HsBangType;

{-# NEED HsContext #-}
type {-# 2 #-} HsContext = [HsAsst];

{-# NEED HsAsst #-}
type {-# 1 #-} HsAsst = (HsQName,[HsType]);

{-# NEED HsType #-}
data HsType;

{-# NEED HsImportDecl #-}
data HsImportDecl;

{-# NEED HsImportSpec #-}
data HsImportSpec;

{-# NEED HsExportSpec #-}
data HsExportSpec;

{-# NEED HsCName #-}
data HsCName;

{-# NEED HsQName #-}
data HsQName;

{-# NEED HsSpecialCon #-}
data HsSpecialCon;

{-# NEED HsName #-}
data HsName;

{-# NEED Module #-}
newtype {-#  #-} Module;
interface ! Language.Haskell.ParseMonad
{-# NEED defaultParseMode #-}
defaultParseMode{-# 0 #-}::Language.Haskell.ParseMonad.ParseMode;

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

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