interface Language.Haskell.Pretty where {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Fractional (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.RealFrac (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.Eq PPLayout;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Show Text.PrettyPrint.HughesPJ.Doc;
interface Language.Haskell.Pretty
{-# NEED DocM #-}
newtype {-#  #-} DocM a b;
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface Language.Haskell.Syntax
{-# NEED HsModule #-}
data HsModule;

{-# NEED HsExportSpec #-}
data HsExportSpec;

{-# NEED HsImportDecl #-}
data HsImportDecl;

{-# NEED HsImportSpec #-}
data HsImportSpec;

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

{-# NEED HsQualType #-}
data HsQualType;

{-# 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 HsPatField HsPat #-}
data HsPatField;
data HsPat;

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

{-# NEED HsQOp #-}
data HsQOp;

{-# NEED HsQName #-}
data HsQName;

{-# NEED HsSpecialCon #-}
data HsSpecialCon;

{-# NEED Module #-}
newtype {-#  #-} Module;

{-# NEED HsOp #-}
data HsOp;

{-# NEED HsCName #-}
data HsCName;

{-# NEED HsName #-}
data HsName;

{-# NEED HsSafety #-}
data HsSafety;
interface Ratio
{-# NEED Ratio #-}
data (Prelude.Integral a) => Ratio a;
interface Text.PrettyPrint.HughesPJ
{-# NEED Doc #-}
data Doc;
interface ! Language.Haskell.Pretty
{-# NEED prettyPrint #-}
prettyPrint{-# 0 #-}::(Pretty a) => (a -> Prelude.String);

{-# NEED prettyPrintWithMode #-}
prettyPrintWithMode{-# 0 #-}::(Pretty a) => (PPHsMode -> (a -> Prelude.String));

{-# NEED prettyPrintStyleMode #-}
prettyPrintStyleMode{-# 2 #-}::(Pretty a) => (Text.PrettyPrint.HughesPJ.Style -> (PPHsMode -> (a -> Prelude.String)));
interface Text.PrettyPrint.HughesPJ
{-# NEED Style #-}
data Style;

{-# NEED Mode #-}
data Mode;
interface ! Language.Haskell.Pretty
{-# NEED Pretty #-}
class Pretty a;

{-# NEED defaultMode #-}
defaultMode{-# 0 #-}::PPHsMode;

{-# NEED {PPHsMode PPHsMode classIndent doIndent caseIndent letIndent whereIndent onsideIndent spacing layout linePragmas comments} #-}
data PPHsMode
  = PPHsMode {classIndent :: Indent} {doIndent :: Indent} {caseIndent :: Indent} {letIndent :: Indent} {whereIndent :: Indent} {onsideIndent :: Indent} {spacing :: Prelude.Bool} {layout :: PPLayout} {linePragmas :: Prelude.Bool} {comments :: Prelude.Bool};

{-# NEED Indent #-}
type {-# 1 #-} Indent = Prelude.Int;

{-# NEED {PPLayout PPOffsideRule PPSemiColon PPInLine PPNoLayout} #-}
data PPLayout
  = PPOffsideRule 
  | PPSemiColon 
  | PPInLine 
  | PPNoLayout ;
}