interface Language.Haskell.Syntax where {

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

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

{-# 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.Ord HsSafety;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED World #-}
data World;
interface ! Language.Haskell.Syntax
{-# NEED tuple_tycon #-}
tuple_tycon{-# 1 #-}::(Prelude.Int -> HsType);

{-# NEED list_tycon #-}
list_tycon{-# 0 #-}::HsType;

{-# NEED fun_tycon #-}
fun_tycon{-# 0 #-}::HsType;

{-# NEED unit_tycon #-}
unit_tycon{-# 0 #-}::HsType;

{-# NEED tuple_tycon_name #-}
tuple_tycon_name{-# 1 #-}::(Prelude.Int -> HsQName);

{-# NEED list_tycon_name #-}
list_tycon_name{-# 0 #-}::HsQName;

{-# NEED fun_tycon_name #-}
fun_tycon_name{-# 0 #-}::HsQName;

{-# NEED unit_tycon_name #-}
unit_tycon_name{-# 0 #-}::HsQName;

{-# NEED tuple_con #-}
tuple_con{-# 1 #-}::(Prelude.Int -> HsExp);

{-# NEED unit_con #-}
unit_con{-# 0 #-}::HsExp;

{-# NEED list_cons_name #-}
list_cons_name{-# 0 #-}::HsQName;

{-# NEED tuple_con_name #-}
tuple_con_name{-# 1 #-}::(Prelude.Int -> HsQName);

{-# NEED unit_con_name #-}
unit_con_name{-# 0 #-}::HsQName;

{-# NEED main_name #-}
main_name{-# 0 #-}::HsName;

{-# NEED main_mod #-}
main_mod{-# 0 #-}::Module;

{-# NEED prelude_mod #-}
prelude_mod{-# 0 #-}::Module;

{-# NEED {HsModule HsModule} #-}
data HsModule
  = HsModule SrcLoc Module (Prelude.Maybe [HsExportSpec]) [HsImportDecl] [HsDecl];

{-# NEED {HsDecl HsTypeDecl HsDataDecl HsInfixDecl HsNewTypeDecl HsClassDecl HsInstDecl HsDefaultDecl HsTypeSig HsFunBind HsPatBind HsForeignImport HsForeignExport} {HsMatch HsMatch} {HsRhs HsUnGuardedRhs HsGuardedRhss} {HsGuardedRhs HsGuardedRhs} {HsExp HsVar HsCon HsLit HsInfixApp HsApp HsNegApp HsLambda HsLet HsIf HsCase HsDo HsTuple HsList HsParen HsLeftSection HsRightSection HsRecConstr HsRecUpdate HsEnumFrom HsEnumFromTo HsEnumFromThen HsEnumFromThenTo HsListComp HsExpTypeSig HsAsPat HsWildCard HsIrrPat} {HsStmt HsGenerator HsQualifier HsLetStmt} {HsFieldUpdate HsFieldUpdate} {HsAlt HsAlt} {HsGuardedAlts HsUnGuardedAlt HsGuardedAlts} {HsGuardedAlt HsGuardedAlt} #-}
data HsDecl
  = HsTypeDecl SrcLoc HsName [HsName] HsType
  | HsDataDecl SrcLoc HsContext HsName [HsName] [HsConDecl] [HsQName]
  | HsInfixDecl SrcLoc HsAssoc Prelude.Int [HsOp]
  | HsNewTypeDecl SrcLoc HsContext HsName [HsName] HsConDecl [HsQName]
  | HsClassDecl SrcLoc HsContext HsName [HsName] [HsDecl]
  | HsInstDecl SrcLoc HsContext HsQName [HsType] [HsDecl]
  | HsDefaultDecl SrcLoc [HsType]
  | HsTypeSig SrcLoc [HsName] HsQualType
  | HsFunBind [HsMatch]
  | HsPatBind SrcLoc HsPat HsRhs [HsDecl]
  | HsForeignImport SrcLoc Prelude.String HsSafety Prelude.String HsName HsType
  | HsForeignExport SrcLoc Prelude.String Prelude.String HsName HsType;
data HsMatch
  = HsMatch SrcLoc HsName [HsPat] HsRhs [HsDecl];
data HsRhs
  = HsUnGuardedRhs HsExp
  | HsGuardedRhss [HsGuardedRhs];
data HsGuardedRhs
  = HsGuardedRhs SrcLoc HsExp HsExp;
data HsExp
  = HsVar HsQName
  | HsCon HsQName
  | HsLit HsLiteral
  | HsInfixApp HsExp HsQOp HsExp
  | HsApp HsExp HsExp
  | HsNegApp HsExp
  | HsLambda SrcLoc [HsPat] HsExp
  | HsLet [HsDecl] HsExp
  | HsIf HsExp HsExp HsExp
  | HsCase HsExp [HsAlt]
  | HsDo [HsStmt]
  | HsTuple [HsExp]
  | HsList [HsExp]
  | HsParen HsExp
  | HsLeftSection HsExp HsQOp
  | HsRightSection HsQOp HsExp
  | HsRecConstr HsQName [HsFieldUpdate]
  | HsRecUpdate HsExp [HsFieldUpdate]
  | HsEnumFrom HsExp
  | HsEnumFromTo HsExp HsExp
  | HsEnumFromThen HsExp HsExp
  | HsEnumFromThenTo HsExp HsExp HsExp
  | HsListComp HsExp [HsStmt]
  | HsExpTypeSig SrcLoc HsExp HsQualType
  | HsAsPat HsName HsExp
  | HsWildCard 
  | HsIrrPat HsExp;
data HsStmt
  = HsGenerator SrcLoc HsPat HsExp
  | HsQualifier HsExp
  | HsLetStmt [HsDecl];
data HsFieldUpdate
  = HsFieldUpdate HsQName HsExp;
data HsAlt
  = HsAlt SrcLoc HsPat HsGuardedAlts [HsDecl];
data HsGuardedAlts
  = HsUnGuardedAlt HsExp
  | HsGuardedAlts [HsGuardedAlt];
data HsGuardedAlt
  = HsGuardedAlt SrcLoc HsExp HsExp;

{-# NEED {HsSafety HsSafe HsUnsafe} #-}
data HsSafety
  = HsSafe 
  | HsUnsafe ;

{-# NEED {HsPat HsPVar HsPLit HsPNeg HsPInfixApp HsPApp HsPTuple HsPList HsPParen HsPRec HsPAsPat HsPWildCard HsPIrrPat} {HsPatField HsPFieldPat} #-}
data HsPat
  = HsPVar HsName
  | HsPLit HsLiteral
  | HsPNeg HsPat
  | HsPInfixApp HsPat HsQName HsPat
  | HsPApp HsQName [HsPat]
  | HsPTuple [HsPat]
  | HsPList [HsPat]
  | HsPParen HsPat
  | HsPRec HsQName [HsPatField]
  | HsPAsPat HsName HsPat
  | HsPWildCard 
  | HsPIrrPat HsPat;
data HsPatField
  = HsPFieldPat HsQName HsPat;

{-# NEED {HsLiteral HsChar HsString HsInt HsFrac HsCharPrim HsStringPrim HsIntPrim HsFloatPrim HsDoublePrim} #-}
data HsLiteral
  = HsChar Prelude.Char
  | HsString Prelude.String
  | HsInt Prelude.Integer
  | HsFrac Ratio.Rational
  | HsCharPrim Prelude.Char
  | HsStringPrim Prelude.String
  | HsIntPrim Prelude.Integer
  | HsFloatPrim Ratio.Rational
  | HsDoublePrim Ratio.Rational;
interface Ratio
{-# NEED Rational #-}
type {-# 1 #-} Rational = (Ratio.Ratio Prelude.Integer);

{-# NEED Ratio #-}
data Ratio a;
interface ! Language.Haskell.Syntax
{-# NEED {HsQualType HsQualType} #-}
data HsQualType
  = HsQualType HsContext HsType;

{-# NEED {HsAssoc HsAssocNone HsAssocLeft HsAssocRight} #-}
data HsAssoc
  = HsAssocNone 
  | HsAssocLeft 
  | HsAssocRight ;

{-# NEED {HsConDecl HsConDecl HsRecDecl} #-}
data HsConDecl
  = HsConDecl SrcLoc HsName [HsBangType]
  | HsRecDecl SrcLoc HsName [([HsName],HsBangType)];

{-# NEED {HsBangType HsBangedTy HsUnBangedTy} #-}
data HsBangType
  = HsBangedTy HsType
  | HsUnBangedTy HsType;

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

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

{-# NEED {HsType HsTyFun HsTyTuple HsTyApp HsTyVar HsTyCon} #-}
data HsType
  = HsTyFun HsType HsType
  | HsTyTuple [HsType]
  | HsTyApp HsType HsType
  | HsTyVar HsName
  | HsTyCon HsQName;

{-# NEED {HsImportDecl HsImportDecl importLoc importModule importQualified importAs importSpecs} #-}
data HsImportDecl
  = HsImportDecl {importLoc :: SrcLoc} {importModule :: Module} {importQualified :: Prelude.Bool} {importAs :: (Prelude.Maybe Module)} {importSpecs :: (Prelude.Maybe (Prelude.Bool,[HsImportSpec]))};

{-# NEED {HsImportSpec HsIVar HsIAbs HsIThingAll HsIThingWith} #-}
data HsImportSpec
  = HsIVar HsName
  | HsIAbs HsName
  | HsIThingAll HsName
  | HsIThingWith HsName [HsCName];

{-# NEED {HsExportSpec HsEVar HsEAbs HsEThingAll HsEThingWith HsEModuleContents} #-}
data HsExportSpec
  = HsEVar HsQName
  | HsEAbs HsQName
  | HsEThingAll HsQName
  | HsEThingWith HsQName [HsCName]
  | HsEModuleContents Module;

{-# NEED {HsCName HsVarName HsConName} #-}
data HsCName
  = HsVarName HsName
  | HsConName HsName;

{-# NEED {HsOp HsVarOp HsConOp} #-}
data HsOp
  = HsVarOp HsName
  | HsConOp HsName;

{-# NEED {HsQOp HsQVarOp HsQConOp} #-}
data HsQOp
  = HsQVarOp HsQName
  | HsQConOp HsQName;

{-# NEED {HsQName Qual UnQual Special} #-}
data HsQName
  = Qual Module HsName
  | UnQual HsName
  | Special HsSpecialCon;

{-# NEED {HsName HsIdent HsSymbol} #-}
data HsName
  = HsIdent Prelude.String
  | HsSymbol Prelude.String;

{-# NEED {HsSpecialCon HsUnitCon HsListCon HsFunCon HsTupleCon HsCons} #-}
data HsSpecialCon
  = HsUnitCon 
  | HsListCon 
  | HsFunCon 
  | HsTupleCon Prelude.Int
  | HsCons ;

{-# NEED {Module Module} #-}
newtype {-#  #-} Module
  = Module Prelude.String;

{-# NEED {SrcLoc SrcLoc srcFilename srcLine srcColumn} #-}
data SrcLoc
  = SrcLoc {srcFilename :: Prelude.String} {srcLine :: Prelude.Int} {srcColumn :: Prelude.Int};
}