haskell-src-exts 1.9.5 → 1.9.6

raw patch · 4 files changed

+13/−5 lines, 4 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Activation l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Alt l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Annotation l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Assoc l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Asst l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (BangType l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Binds l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Bracket l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (CName l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (CallConv l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (ClassDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (ConDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Context l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (DataOrNew l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Decl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (DeclHead l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Deriving l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Exp l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (ExportSpec l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (ExportSpecList l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (FieldDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (FieldUpdate l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (FunDep l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (GadtDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (GuardedAlt l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (GuardedAlts l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (GuardedRhs l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (IPBind l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (IPName l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (ImportDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (ImportSpec l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (ImportSpecList l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (InstDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (InstHead l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Kind l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Literal l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Match l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Module l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (ModuleHead l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (ModuleName l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (ModulePragma l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Name l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Op l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (PXAttr l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Pat l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (PatField l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (QName l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (QOp l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (QualConDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (QualStmt l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (RPat l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (RPatOp l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Rhs l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Rule l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (RuleVar l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Safety l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (SpecialCon l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Splice l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Stmt l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (TyVarBind l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (Type l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (WarningText l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (XAttr l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Data l) => Data (XName l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Activation l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Alt l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Annotation l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Assoc l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Asst l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (BangType l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Binds l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Bracket l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (CName l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (CallConv l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (ClassDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (ConDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Context l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (DataOrNew l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Decl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (DeclHead l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Deriving l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Exp l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (ExportSpec l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (ExportSpecList l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (FieldDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (FieldUpdate l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (FunDep l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (GadtDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (GuardedAlt l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (GuardedAlts l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (GuardedRhs l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (IPBind l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (IPName l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (ImportDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (ImportSpec l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (ImportSpecList l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (InstDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (InstHead l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Kind l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Literal l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Match l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Module l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (ModuleHead l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (ModuleName l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (ModulePragma l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Name l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Op l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (PXAttr l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Pat l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (PatField l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (QName l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (QOp l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (QualConDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (QualStmt l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (RPat l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (RPatOp l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Rhs l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Rule l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (RuleVar l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Safety l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (SpecialCon l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Splice l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Stmt l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (TyVarBind l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (Type l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (WarningText l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (XAttr l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Eq l) => Eq (XName l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Activation l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Alt l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Annotation l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Assoc l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Asst l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (BangType l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Binds l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Bracket l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (CName l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (CallConv l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (ClassDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (ConDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Context l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (DataOrNew l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Decl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (DeclHead l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Deriving l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Exp l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (ExportSpec l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (ExportSpecList l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (FieldDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (FieldUpdate l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (FunDep l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (GadtDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (GuardedAlt l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (GuardedAlts l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (GuardedRhs l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (IPBind l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (IPName l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (ImportDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (ImportSpec l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (ImportSpecList l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (InstDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (InstHead l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Kind l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Literal l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Match l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Module l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (ModuleHead l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (ModuleName l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (ModulePragma l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Name l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Op l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (PXAttr l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Pat l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (PatField l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (QName l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (QOp l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (QualConDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (QualStmt l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (RPat l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (RPatOp l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Rhs l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Rule l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (RuleVar l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Safety l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (SpecialCon l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Splice l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Stmt l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (TyVarBind l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (Type l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (WarningText l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (XAttr l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Ord l) => Ord (XName l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Activation l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Alt l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Annotation l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Assoc l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Asst l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (BangType l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Binds l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Bracket l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (CName l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (CallConv l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (ClassDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (ConDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Context l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (DataOrNew l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Decl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (DeclHead l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Deriving l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Exp l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (ExportSpec l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (ExportSpecList l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (FieldDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (FieldUpdate l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (FunDep l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (GadtDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (GuardedAlt l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (GuardedAlts l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (GuardedRhs l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (IPBind l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (IPName l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (ImportDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (ImportSpec l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (ImportSpecList l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (InstDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (InstHead l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Kind l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Literal l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Match l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Module l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (ModuleHead l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (ModuleName l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (ModulePragma l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Name l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Op l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (PXAttr l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Pat l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (PatField l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (QName l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (QOp l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (QualConDecl l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (QualStmt l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (RPat l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (RPatOp l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Rhs l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Rule l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (RuleVar l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Safety l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (SpecialCon l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Splice l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Stmt l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (TyVarBind l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (Type l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (WarningText l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (XAttr l)

- Language.Haskell.Exts.Annotated.Syntax: instance (Show l) => Show (XName l)

- Language.Haskell.Exts.Parser: instance (SrcInfo loc) => Parseable (Decl loc)

- Language.Haskell.Exts.Parser: instance (SrcInfo loc) => Parseable (Exp loc)

- Language.Haskell.Exts.Parser: instance (SrcInfo loc) => Parseable (Module loc)

- Language.Haskell.Exts.Parser: instance (SrcInfo loc) => Parseable (Pat loc)

- Language.Haskell.Exts.Parser: instance (SrcInfo loc) => Parseable (Stmt loc)

- Language.Haskell.Exts.Parser: instance (SrcInfo loc) => Parseable (Type loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (Alt loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (Annotation loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (Bracket loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (ClassDecl loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (Exp loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (FieldUpdate loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (GuardedAlt loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (GuardedAlts loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (GuardedRhs loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (IPBind loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (InstDecl loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (ModulePragma loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (PAsst loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (PContext loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (PExp loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (PFieldUpdate loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (PType loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (PXAttr loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (ParseXAttr loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (Pat loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (PatField loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (QualStmt loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (RPat loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (Rhs loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (Rule loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (Splice loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (Stmt loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo loc) => Pretty (XAttr loc)

- Language.Haskell.Exts.Pretty: instance (SrcInfo pos) => Pretty (Decl pos)

- Language.Haskell.Exts.Pretty: instance (SrcInfo pos) => Pretty (ImportDecl pos)

- Language.Haskell.Exts.Pretty: instance (SrcInfo pos) => Pretty (Match pos)

- Language.Haskell.Exts.Pretty: instance (SrcInfo pos) => Pretty (Module pos)

- Language.Haskell.Exts.SrcLoc: instance (Eq a) => Eq (Loc a)

- Language.Haskell.Exts.SrcLoc: instance (Ord a) => Ord (Loc a)

- Language.Haskell.Exts.SrcLoc: instance (Show a) => Show (Loc a)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Activation l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Alt l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Annotation l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Assoc l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Asst l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (BangType l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Binds l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Bracket l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (CName l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (CallConv l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (ClassDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (ConDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Context l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (DataOrNew l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Decl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (DeclHead l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Deriving l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Exp l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (ExportSpec l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (ExportSpecList l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (FieldDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (FieldUpdate l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (FunDep l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (GadtDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (GuardedAlt l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (GuardedAlts l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (GuardedRhs l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (IPBind l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (IPName l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (ImportDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (ImportSpec l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (ImportSpecList l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (InstDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (InstHead l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Kind l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Literal l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Match l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Module l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (ModuleHead l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (ModuleName l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (ModulePragma l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Name l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Op l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (PXAttr l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Pat l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (PatField l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (QName l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (QOp l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (QualConDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (QualStmt l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (RPat l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (RPatOp l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Rhs l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Rule l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (RuleVar l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Safety l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (SpecialCon l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Splice l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Stmt l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (TyVarBind l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (Type l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (WarningText l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (XAttr l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Data l => Data (XName l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Activation l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Alt l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Annotation l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Assoc l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Asst l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (BangType l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Binds l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Bracket l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (CName l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (CallConv l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (ClassDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (ConDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Context l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (DataOrNew l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Decl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (DeclHead l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Deriving l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Exp l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (ExportSpec l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (ExportSpecList l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (FieldDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (FieldUpdate l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (FunDep l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (GadtDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (GuardedAlt l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (GuardedAlts l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (GuardedRhs l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (IPBind l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (IPName l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (ImportDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (ImportSpec l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (ImportSpecList l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (InstDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (InstHead l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Kind l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Literal l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Match l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Module l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (ModuleHead l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (ModuleName l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (ModulePragma l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Name l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Op l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (PXAttr l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Pat l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (PatField l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (QName l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (QOp l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (QualConDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (QualStmt l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (RPat l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (RPatOp l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Rhs l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Rule l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (RuleVar l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Safety l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (SpecialCon l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Splice l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Stmt l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (TyVarBind l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (Type l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (WarningText l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (XAttr l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Eq l => Eq (XName l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Activation l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Alt l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Annotation l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Assoc l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Asst l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (BangType l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Binds l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Bracket l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (CName l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (CallConv l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (ClassDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (ConDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Context l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (DataOrNew l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Decl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (DeclHead l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Deriving l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Exp l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (ExportSpec l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (ExportSpecList l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (FieldDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (FieldUpdate l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (FunDep l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (GadtDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (GuardedAlt l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (GuardedAlts l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (GuardedRhs l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (IPBind l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (IPName l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (ImportDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (ImportSpec l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (ImportSpecList l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (InstDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (InstHead l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Kind l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Literal l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Match l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Module l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (ModuleHead l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (ModuleName l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (ModulePragma l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Name l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Op l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (PXAttr l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Pat l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (PatField l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (QName l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (QOp l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (QualConDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (QualStmt l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (RPat l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (RPatOp l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Rhs l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Rule l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (RuleVar l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Safety l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (SpecialCon l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Splice l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Stmt l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (TyVarBind l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (Type l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (WarningText l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (XAttr l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Ord l => Ord (XName l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Activation l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Alt l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Annotation l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Assoc l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Asst l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (BangType l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Binds l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Bracket l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (CName l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (CallConv l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (ClassDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (ConDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Context l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (DataOrNew l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Decl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (DeclHead l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Deriving l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Exp l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (ExportSpec l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (ExportSpecList l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (FieldDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (FieldUpdate l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (FunDep l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (GadtDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (GuardedAlt l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (GuardedAlts l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (GuardedRhs l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (IPBind l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (IPName l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (ImportDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (ImportSpec l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (ImportSpecList l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (InstDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (InstHead l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Kind l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Literal l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Match l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Module l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (ModuleHead l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (ModuleName l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (ModulePragma l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Name l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Op l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (PXAttr l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Pat l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (PatField l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (QName l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (QOp l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (QualConDecl l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (QualStmt l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (RPat l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (RPatOp l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Rhs l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Rule l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (RuleVar l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Safety l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (SpecialCon l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Splice l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Stmt l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (TyVarBind l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (Type l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (WarningText l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (XAttr l)

+ Language.Haskell.Exts.Annotated.Syntax: instance Show l => Show (XName l)

+ Language.Haskell.Exts.Parser: instance SrcInfo loc => Parseable (Decl loc)

+ Language.Haskell.Exts.Parser: instance SrcInfo loc => Parseable (Exp loc)

+ Language.Haskell.Exts.Parser: instance SrcInfo loc => Parseable (Module loc)

+ Language.Haskell.Exts.Parser: instance SrcInfo loc => Parseable (Pat loc)

+ Language.Haskell.Exts.Parser: instance SrcInfo loc => Parseable (Stmt loc)

+ Language.Haskell.Exts.Parser: instance SrcInfo loc => Parseable (Type loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (Alt loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (Annotation loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (Bracket loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (ClassDecl loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (Exp loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (FieldUpdate loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (GuardedAlt loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (GuardedAlts loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (GuardedRhs loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (IPBind loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (InstDecl loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (ModulePragma loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (PAsst loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (PContext loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (PExp loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (PFieldUpdate loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (PType loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (PXAttr loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (ParseXAttr loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (Pat loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (PatField loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (QualStmt loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (RPat loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (Rhs loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (Rule loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (Splice loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (Stmt loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo loc => Pretty (XAttr loc)

+ Language.Haskell.Exts.Pretty: instance SrcInfo pos => Pretty (Decl pos)

+ Language.Haskell.Exts.Pretty: instance SrcInfo pos => Pretty (ImportDecl pos)

+ Language.Haskell.Exts.Pretty: instance SrcInfo pos => Pretty (Match pos)

+ Language.Haskell.Exts.Pretty: instance SrcInfo pos => Pretty (Module pos)

+ Language.Haskell.Exts.SrcLoc: instance Eq a => Eq (Loc a)

+ Language.Haskell.Exts.SrcLoc: instance Ord a => Ord (Loc a)

+ Language.Haskell.Exts.SrcLoc: instance Show a => Show (Loc a)

- Language.Haskell.Exts.Annotated.ExactPrint: class (Annotated ast) => ExactP ast

+ Language.Haskell.Exts.Annotated.ExactPrint: class Annotated ast => ExactP ast

- Language.Haskell.Exts.Annotated.ExactPrint: exactPrint :: (ExactP ast) => ast SrcSpanInfo -> [Comment] -> String

+ Language.Haskell.Exts.Annotated.ExactPrint: exactPrint :: ExactP ast => ast SrcSpanInfo -> [Comment] -> String

- Language.Haskell.Exts.Annotated.Simplify: sAlt :: (SrcInfo loc) => Alt loc -> Alt

+ Language.Haskell.Exts.Annotated.Simplify: sAlt :: SrcInfo loc => Alt loc -> Alt

- Language.Haskell.Exts.Annotated.Simplify: sAnnotation :: (SrcInfo loc) => Annotation loc -> Annotation

+ Language.Haskell.Exts.Annotated.Simplify: sAnnotation :: SrcInfo loc => Annotation loc -> Annotation

- Language.Haskell.Exts.Annotated.Simplify: sBinds :: (SrcInfo loc) => Binds loc -> Binds

+ Language.Haskell.Exts.Annotated.Simplify: sBinds :: SrcInfo loc => Binds loc -> Binds

- Language.Haskell.Exts.Annotated.Simplify: sBracket :: (SrcInfo loc) => Bracket loc -> Bracket

+ Language.Haskell.Exts.Annotated.Simplify: sBracket :: SrcInfo loc => Bracket loc -> Bracket

- Language.Haskell.Exts.Annotated.Simplify: sClassDecl :: (SrcInfo loc) => ClassDecl loc -> ClassDecl

+ Language.Haskell.Exts.Annotated.Simplify: sClassDecl :: SrcInfo loc => ClassDecl loc -> ClassDecl

- Language.Haskell.Exts.Annotated.Simplify: sDecl :: (SrcInfo loc) => Decl loc -> Decl

+ Language.Haskell.Exts.Annotated.Simplify: sDecl :: SrcInfo loc => Decl loc -> Decl

- Language.Haskell.Exts.Annotated.Simplify: sExp :: (SrcInfo loc) => Exp loc -> Exp

+ Language.Haskell.Exts.Annotated.Simplify: sExp :: SrcInfo loc => Exp loc -> Exp

- Language.Haskell.Exts.Annotated.Simplify: sFieldUpdate :: (SrcInfo loc) => FieldUpdate loc -> FieldUpdate

+ Language.Haskell.Exts.Annotated.Simplify: sFieldUpdate :: SrcInfo loc => FieldUpdate loc -> FieldUpdate

- Language.Haskell.Exts.Annotated.Simplify: sGadtDecl :: (SrcInfo loc) => GadtDecl loc -> GadtDecl

+ Language.Haskell.Exts.Annotated.Simplify: sGadtDecl :: SrcInfo loc => GadtDecl loc -> GadtDecl

- Language.Haskell.Exts.Annotated.Simplify: sGuardedAlt :: (SrcInfo loc) => GuardedAlt loc -> GuardedAlt

+ Language.Haskell.Exts.Annotated.Simplify: sGuardedAlt :: SrcInfo loc => GuardedAlt loc -> GuardedAlt

- Language.Haskell.Exts.Annotated.Simplify: sGuardedAlts :: (SrcInfo loc) => GuardedAlts loc -> GuardedAlts

+ Language.Haskell.Exts.Annotated.Simplify: sGuardedAlts :: SrcInfo loc => GuardedAlts loc -> GuardedAlts

- Language.Haskell.Exts.Annotated.Simplify: sGuardedRhs :: (SrcInfo loc) => GuardedRhs loc -> GuardedRhs

+ Language.Haskell.Exts.Annotated.Simplify: sGuardedRhs :: SrcInfo loc => GuardedRhs loc -> GuardedRhs

- Language.Haskell.Exts.Annotated.Simplify: sIPBind :: (SrcInfo loc) => IPBind loc -> IPBind

+ Language.Haskell.Exts.Annotated.Simplify: sIPBind :: SrcInfo loc => IPBind loc -> IPBind

- Language.Haskell.Exts.Annotated.Simplify: sImportDecl :: (SrcInfo loc) => ImportDecl loc -> ImportDecl

+ Language.Haskell.Exts.Annotated.Simplify: sImportDecl :: SrcInfo loc => ImportDecl loc -> ImportDecl

- Language.Haskell.Exts.Annotated.Simplify: sInstDecl :: (SrcInfo loc) => InstDecl loc -> InstDecl

+ Language.Haskell.Exts.Annotated.Simplify: sInstDecl :: SrcInfo loc => InstDecl loc -> InstDecl

- Language.Haskell.Exts.Annotated.Simplify: sMatch :: (SrcInfo loc) => Match loc -> Match

+ Language.Haskell.Exts.Annotated.Simplify: sMatch :: SrcInfo loc => Match loc -> Match

- Language.Haskell.Exts.Annotated.Simplify: sModule :: (SrcInfo loc) => Module loc -> Module

+ Language.Haskell.Exts.Annotated.Simplify: sModule :: SrcInfo loc => Module loc -> Module

- Language.Haskell.Exts.Annotated.Simplify: sModulePragma :: (SrcInfo loc) => ModulePragma loc -> ModulePragma

+ Language.Haskell.Exts.Annotated.Simplify: sModulePragma :: SrcInfo loc => ModulePragma loc -> ModulePragma

- Language.Haskell.Exts.Annotated.Simplify: sPXAttr :: (SrcInfo loc) => PXAttr loc -> PXAttr

+ Language.Haskell.Exts.Annotated.Simplify: sPXAttr :: SrcInfo loc => PXAttr loc -> PXAttr

- Language.Haskell.Exts.Annotated.Simplify: sPat :: (SrcInfo loc) => Pat loc -> Pat

+ Language.Haskell.Exts.Annotated.Simplify: sPat :: SrcInfo loc => Pat loc -> Pat

- Language.Haskell.Exts.Annotated.Simplify: sPatField :: (SrcInfo loc) => PatField loc -> PatField

+ Language.Haskell.Exts.Annotated.Simplify: sPatField :: SrcInfo loc => PatField loc -> PatField

- Language.Haskell.Exts.Annotated.Simplify: sQualConDecl :: (SrcInfo loc) => QualConDecl loc -> QualConDecl

+ Language.Haskell.Exts.Annotated.Simplify: sQualConDecl :: SrcInfo loc => QualConDecl loc -> QualConDecl

- Language.Haskell.Exts.Annotated.Simplify: sQualStmt :: (SrcInfo loc) => QualStmt loc -> QualStmt

+ Language.Haskell.Exts.Annotated.Simplify: sQualStmt :: SrcInfo loc => QualStmt loc -> QualStmt

- Language.Haskell.Exts.Annotated.Simplify: sRPat :: (SrcInfo loc) => RPat loc -> RPat

+ Language.Haskell.Exts.Annotated.Simplify: sRPat :: SrcInfo loc => RPat loc -> RPat

- Language.Haskell.Exts.Annotated.Simplify: sRhs :: (SrcInfo loc) => Rhs loc -> Rhs

+ Language.Haskell.Exts.Annotated.Simplify: sRhs :: SrcInfo loc => Rhs loc -> Rhs

- Language.Haskell.Exts.Annotated.Simplify: sRule :: (SrcInfo loc) => Rule loc -> Rule

+ Language.Haskell.Exts.Annotated.Simplify: sRule :: SrcInfo loc => Rule loc -> Rule

- Language.Haskell.Exts.Annotated.Simplify: sSplice :: (SrcInfo loc) => Splice loc -> Splice

+ Language.Haskell.Exts.Annotated.Simplify: sSplice :: SrcInfo loc => Splice loc -> Splice

- Language.Haskell.Exts.Annotated.Simplify: sStmt :: (SrcInfo loc) => Stmt loc -> Stmt

+ Language.Haskell.Exts.Annotated.Simplify: sStmt :: SrcInfo loc => Stmt loc -> Stmt

- Language.Haskell.Exts.Annotated.Simplify: sXAttr :: (SrcInfo loc) => XAttr loc -> XAttr

+ Language.Haskell.Exts.Annotated.Simplify: sXAttr :: SrcInfo loc => XAttr loc -> XAttr

- Language.Haskell.Exts.Annotated.Syntax: amap :: (Annotated ast) => (l -> l) -> ast l -> ast l

+ Language.Haskell.Exts.Annotated.Syntax: amap :: Annotated ast => (l -> l) -> ast l -> ast l

- Language.Haskell.Exts.Annotated.Syntax: ann :: (Annotated ast) => ast l -> l

+ Language.Haskell.Exts.Annotated.Syntax: ann :: Annotated ast => ast l -> l

- Language.Haskell.Exts.Annotated.Syntax: class (Functor ast) => Annotated ast

+ Language.Haskell.Exts.Annotated.Syntax: class Functor ast => Annotated ast

- Language.Haskell.Exts.Parser: parse :: (Parseable ast) => String -> ParseResult ast

+ Language.Haskell.Exts.Parser: parse :: Parseable ast => String -> ParseResult ast

- Language.Haskell.Exts.Parser: parseWithComments :: (Parseable ast) => ParseMode -> String -> ParseResult (ast, [Comment])

+ Language.Haskell.Exts.Parser: parseWithComments :: Parseable ast => ParseMode -> String -> ParseResult (ast, [Comment])

- Language.Haskell.Exts.Parser: parseWithMode :: (Parseable ast) => ParseMode -> String -> ParseResult ast

+ Language.Haskell.Exts.Parser: parseWithMode :: Parseable ast => ParseMode -> String -> ParseResult ast

- Language.Haskell.Exts.Pretty: prettyPrint :: (Pretty a) => a -> String

+ Language.Haskell.Exts.Pretty: prettyPrint :: Pretty a => a -> String

- Language.Haskell.Exts.Pretty: prettyPrintStyleMode :: (Pretty a) => Style -> PPHsMode -> a -> String

+ Language.Haskell.Exts.Pretty: prettyPrintStyleMode :: Pretty a => Style -> PPHsMode -> a -> String

- Language.Haskell.Exts.Pretty: prettyPrintWithMode :: (Pretty a) => PPHsMode -> a -> String

+ Language.Haskell.Exts.Pretty: prettyPrintWithMode :: Pretty a => PPHsMode -> a -> String

- Language.Haskell.Exts.SrcLoc: fileName :: (SrcInfo si) => si -> String

+ Language.Haskell.Exts.SrcLoc: fileName :: SrcInfo si => si -> String

- Language.Haskell.Exts.SrcLoc: fromSrcInfo :: (SrcInfo si) => SrcSpanInfo -> si

+ Language.Haskell.Exts.SrcLoc: fromSrcInfo :: SrcInfo si => SrcSpanInfo -> si

- Language.Haskell.Exts.SrcLoc: getPointLoc :: (SrcInfo si) => si -> SrcLoc

+ Language.Haskell.Exts.SrcLoc: getPointLoc :: SrcInfo si => si -> SrcLoc

- Language.Haskell.Exts.SrcLoc: startColumn :: (SrcInfo si) => si -> Int

+ Language.Haskell.Exts.SrcLoc: startColumn :: SrcInfo si => si -> Int

- Language.Haskell.Exts.SrcLoc: startLine :: (SrcInfo si) => si -> Int

+ Language.Haskell.Exts.SrcLoc: startLine :: SrcInfo si => si -> Int

- Language.Haskell.Exts.SrcLoc: toSrcInfo :: (SrcInfo si) => SrcLoc -> [SrcSpan] -> SrcLoc -> si

+ Language.Haskell.Exts.SrcLoc: toSrcInfo :: SrcInfo si => SrcLoc -> [SrcSpan] -> SrcLoc -> si

Files

CHANGELOG +10/−3
haskell-src-exts.cabal +1/−1
src/Language/Haskell/Exts/Lexer.hs +1/−0
src/Language/Haskell/Exts/Pretty.hs +1/−1

CHANGELOG view

@@ -1,3 +1,12 @@+** 1.9.x
+
+1.9.5 --> 1.9.6
+===============
+
+* Fix a bug (#203) where the lexer loops on malformed quasi-quoters.
+
+* Fix a bug with pretty-printing RULES pragmas.
+
 1.9.4 --> 1.9.5
 ===============
 
@@ -7,8 +16,6 @@ * Pretty-printing patterns is now more accurate in inserting (and not
   inserting) parentheses when needed.
 
-** 1.9.x
-
 1.9.3 --> 1.9.4
 ===============
 
@@ -44,7 +51,6 @@ 
 * Export parseFileContentsWithExts from .Exts.
 
-
 1.8.2 --> 1.9.0
 ===============
 
@@ -58,6 +64,7 @@   to L.H.Exts .
 
 * More informative error messages when HSX tags are mismatched.
+
 
 
 ** 1.8.x

haskell-src-exts.cabal view

@@ -1,5 +1,5 @@ Name:                   haskell-src-exts-Version:                1.9.5+Version:                1.9.6 License:                BSD3 License-File:           LICENSE Author:                 Niklas Broberg

src/Language/Haskell/Exts/Lexer.hs view

@@ -764,6 +764,7 @@                   '\n':_ -> do lexNewline                                str <- lexQQBody                                return ('\n':str)+                  []     -> fail "Unexpected end of input while lexing quasi-quoter"                   _ -> do str <- lexWhile (not . (`elem` "\\|\n"))                           rest <- lexQQBody                           return (str++rest)

src/Language/Haskell/Exts/Pretty.hs view

@@ -613,7 +613,7 @@  instance Pretty RuleVar where     pretty (RuleVar n) = pretty n-    pretty (TypedRuleVar n t) = mySep [pretty n, text "::", pretty t]+    pretty (TypedRuleVar n t) = parens $ mySep [pretty n, text "::", pretty t]  instance Pretty ModulePragma where     pretty (LanguagePragma _ ns) =