derive 2.6.4 → 2.6.5

raw patch · 3 files changed

+16/−9 lines, 3 filesnew-uploaderPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- Language.Haskell.Convert: instance Language.Haskell.Convert.Convert (GHC.Base.Maybe (Language.Haskell.Exts.Syntax.Binds ())) [Language.Haskell.TH.Syntax.Dec]

- Language.Haskell.Convert: instance Language.Haskell.Convert.Convert (GHC.Base.Maybe (Language.Haskell.Exts.Syntax.Context ())) Language.Haskell.TH.Syntax.Cxt

+ Data.Derive.DSL.HSE: (<**) :: SrcSpanInfo -> [SrcSpan] -> SrcSpanInfo

+ Data.Derive.DSL.HSE: (<++>) :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo

+ Data.Derive.DSL.HSE: (<+?>) :: SrcSpanInfo -> Maybe SrcSpanInfo -> SrcSpanInfo

+ Data.Derive.DSL.HSE: (<?+>) :: Maybe SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo

+ Data.Derive.DSL.HSE: (<^^>) :: SrcSpan -> SrcSpan -> SrcSpanInfo

+ Data.Derive.DSL.HSE: (=~=) :: (Annotated a, Eq (a ())) => a l1 -> a l2 -> Bool

+ Data.Derive.DSL.HSE: (?) :: () => Bool -> a -> a -> a

+ Data.Derive.DSL.HSE: (~=) :: Pretty a => a -> String -> Bool

+ Data.Derive.DSL.HSE: ANN :: Token

+ Data.Derive.DSL.HSE: ActiveFrom :: l -> Int -> Activation l

+ Data.Derive.DSL.HSE: ActiveUntil :: l -> Int -> Activation l

+ Data.Derive.DSL.HSE: Alt :: l -> Pat l -> Rhs l -> Maybe (Binds l) -> Alt l

+ Data.Derive.DSL.HSE: AndFormula :: l -> [BooleanFormula l] -> BooleanFormula l

+ Data.Derive.DSL.HSE: Ann :: l -> Name l -> Exp l -> Annotation l

+ Data.Derive.DSL.HSE: AnnModulePragma :: l -> Annotation l -> ModulePragma l

+ Data.Derive.DSL.HSE: AnnPragma :: l -> Annotation l -> Decl l

+ Data.Derive.DSL.HSE: AppA :: l -> Name l -> [Type l] -> Asst l

+ Data.Derive.DSL.HSE: Arrows :: KnownExtension

+ Data.Derive.DSL.HSE: AssocLeft :: l -> Assoc l

+ Data.Derive.DSL.HSE: AssocNone :: l -> Assoc l

+ Data.Derive.DSL.HSE: AssocRight :: l -> Assoc l

+ Data.Derive.DSL.HSE: At :: Token

+ Data.Derive.DSL.HSE: BDecls :: l -> [Decl l] -> Binds l

+ Data.Derive.DSL.HSE: BackQuote :: Token

+ Data.Derive.DSL.HSE: Backslash :: Token

+ Data.Derive.DSL.HSE: BangPatterns :: KnownExtension

+ Data.Derive.DSL.HSE: BangedTy :: l -> BangType l

+ Data.Derive.DSL.HSE: Bar :: Token

+ Data.Derive.DSL.HSE: BinaryLiterals :: KnownExtension

+ Data.Derive.DSL.HSE: Boxed :: Boxed

+ Data.Derive.DSL.HSE: BracketExp :: l -> Bracket l -> Exp l

+ Data.Derive.DSL.HSE: CApi :: l -> CallConv l

+ Data.Derive.DSL.HSE: CApiFFI :: KnownExtension

+ Data.Derive.DSL.HSE: CCall :: l -> CallConv l

+ Data.Derive.DSL.HSE: COMPLETE :: Token

+ Data.Derive.DSL.HSE: CORE :: Token

+ Data.Derive.DSL.HSE: CPP :: KnownExtension

+ Data.Derive.DSL.HSE: CPlusPlus :: l -> CallConv l

+ Data.Derive.DSL.HSE: Case :: l -> Exp l -> [Alt l] -> Exp l

+ Data.Derive.DSL.HSE: Char :: l -> Char -> String -> Literal l

+ Data.Derive.DSL.HSE: Character :: (Char, String) -> Token

+ Data.Derive.DSL.HSE: CharacterHash :: (Char, String) -> Token

+ Data.Derive.DSL.HSE: ClassA :: l -> QName l -> [Type l] -> Asst l

+ Data.Derive.DSL.HSE: ClassDecl :: l -> Maybe (Context l) -> DeclHead l -> [FunDep l] -> Maybe [ClassDecl l] -> Decl l

+ Data.Derive.DSL.HSE: ClosedTypeFamDecl :: l -> DeclHead l -> Maybe (ResultSig l) -> Maybe (InjectivityInfo l) -> [TypeEqn l] -> Decl l

+ Data.Derive.DSL.HSE: ClsDataFam :: l -> Maybe (Context l) -> DeclHead l -> Maybe (ResultSig l) -> ClassDecl l

+ Data.Derive.DSL.HSE: ClsDecl :: l -> Decl l -> ClassDecl l

+ Data.Derive.DSL.HSE: ClsDefSig :: l -> Name l -> Type l -> ClassDecl l

+ Data.Derive.DSL.HSE: ClsTyDef :: l -> TypeEqn l -> ClassDecl l

+ Data.Derive.DSL.HSE: ClsTyFam :: l -> DeclHead l -> Maybe (ResultSig l) -> Maybe (InjectivityInfo l) -> ClassDecl l

+ Data.Derive.DSL.HSE: Colon :: Token

+ Data.Derive.DSL.HSE: Comma :: Token

+ Data.Derive.DSL.HSE: Comment :: Bool -> SrcSpan -> String -> Comment

+ Data.Derive.DSL.HSE: CompletePragma :: l -> [Name l] -> Maybe (QName l) -> Decl l

+ Data.Derive.DSL.HSE: Con :: l -> QName l -> Exp l

+ Data.Derive.DSL.HSE: ConDecl :: l -> Name l -> [Type l] -> ConDecl l

+ Data.Derive.DSL.HSE: ConId :: String -> Token

+ Data.Derive.DSL.HSE: ConName :: l -> Name l -> CName l

+ Data.Derive.DSL.HSE: ConOp :: l -> Name l -> Op l

+ Data.Derive.DSL.HSE: ConSym :: String -> Token

+ Data.Derive.DSL.HSE: Cons :: l -> SpecialCon l

+ Data.Derive.DSL.HSE: ConstrainedClassMethods :: KnownExtension

+ Data.Derive.DSL.HSE: ConstraintKinds :: KnownExtension

+ Data.Derive.DSL.HSE: CorePragma :: l -> String -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: CxEmpty :: l -> Context l

+ Data.Derive.DSL.HSE: CxSingle :: l -> Asst l -> Context l

+ Data.Derive.DSL.HSE: CxTuple :: l -> [Asst l] -> Context l

+ Data.Derive.DSL.HSE: DEPRECATED :: Token

+ Data.Derive.DSL.HSE: DHApp :: l -> DeclHead l -> TyVarBind l -> DeclHead l

+ Data.Derive.DSL.HSE: DHInfix :: l -> TyVarBind l -> Name l -> DeclHead l

+ Data.Derive.DSL.HSE: DHParen :: l -> DeclHead l -> DeclHead l

+ Data.Derive.DSL.HSE: DHead :: l -> Name l -> DeclHead l

+ Data.Derive.DSL.HSE: DVarId :: [String] -> Token

+ Data.Derive.DSL.HSE: DataDecl :: l -> DataOrNew l -> Maybe (Context l) -> DeclHead l -> [QualConDecl l] -> [Deriving l] -> Decl l

+ Data.Derive.DSL.HSE: DataFamDecl :: l -> Maybe (Context l) -> DeclHead l -> Maybe (ResultSig l) -> Decl l

+ Data.Derive.DSL.HSE: DataInsDecl :: l -> DataOrNew l -> Type l -> [QualConDecl l] -> [Deriving l] -> Decl l

+ Data.Derive.DSL.HSE: DataKinds :: KnownExtension

+ Data.Derive.DSL.HSE: DataType :: l -> DataOrNew l

+ Data.Derive.DSL.HSE: DatatypeContexts :: KnownExtension

+ Data.Derive.DSL.HSE: DeclBracket :: l -> [Decl l] -> Bracket l

+ Data.Derive.DSL.HSE: DefaultDecl :: l -> [Type l] -> Decl l

+ Data.Derive.DSL.HSE: DefaultSignatures :: KnownExtension

+ Data.Derive.DSL.HSE: DeprPragmaDecl :: l -> [([Name l], String)] -> Decl l

+ Data.Derive.DSL.HSE: DeprText :: l -> String -> WarningText l

+ Data.Derive.DSL.HSE: DerivAnyclass :: l -> DerivStrategy l

+ Data.Derive.DSL.HSE: DerivDecl :: l -> Maybe (DerivStrategy l) -> Maybe (Overlap l) -> InstRule l -> Decl l

+ Data.Derive.DSL.HSE: DerivNewtype :: l -> DerivStrategy l

+ Data.Derive.DSL.HSE: DerivStock :: l -> DerivStrategy l

+ Data.Derive.DSL.HSE: DeriveAnyClass :: KnownExtension

+ Data.Derive.DSL.HSE: DeriveDataTypeable :: KnownExtension

+ Data.Derive.DSL.HSE: DeriveFoldable :: KnownExtension

+ Data.Derive.DSL.HSE: DeriveFunctor :: KnownExtension

+ Data.Derive.DSL.HSE: DeriveGeneric :: KnownExtension

+ Data.Derive.DSL.HSE: DeriveTraversable :: KnownExtension

+ Data.Derive.DSL.HSE: Deriving :: l -> Maybe (DerivStrategy l) -> [InstRule l] -> Deriving l

+ Data.Derive.DSL.HSE: DerivingStrategies :: KnownExtension

+ Data.Derive.DSL.HSE: DisableExtension :: KnownExtension -> Extension

+ Data.Derive.DSL.HSE: DisambiguateRecordFields :: KnownExtension

+ Data.Derive.DSL.HSE: Do :: l -> [Stmt l] -> Exp l

+ Data.Derive.DSL.HSE: DoAndIfThenElse :: KnownExtension

+ Data.Derive.DSL.HSE: DoRec :: KnownExtension

+ Data.Derive.DSL.HSE: Dot :: Token

+ Data.Derive.DSL.HSE: DotDot :: Token

+ Data.Derive.DSL.HSE: DotNet :: l -> CallConv l

+ Data.Derive.DSL.HSE: DoubleArrow :: Token

+ Data.Derive.DSL.HSE: DoubleColon :: Token

+ Data.Derive.DSL.HSE: DoubleTokHash :: (Rational, String) -> Token

+ Data.Derive.DSL.HSE: EAbs :: l -> Namespace l -> QName l -> ExportSpec l

+ Data.Derive.DSL.HSE: EModuleContents :: l -> ModuleName l -> ExportSpec l

+ Data.Derive.DSL.HSE: EOF :: Token

+ Data.Derive.DSL.HSE: EThingWith :: l -> EWildcard l -> QName l -> [CName l] -> ExportSpec l

+ Data.Derive.DSL.HSE: EVar :: l -> QName l -> ExportSpec l

+ Data.Derive.DSL.HSE: EWildcard :: l -> Int -> EWildcard l

+ Data.Derive.DSL.HSE: EmptyCase :: KnownExtension

+ Data.Derive.DSL.HSE: EmptyDataDecls :: KnownExtension

+ Data.Derive.DSL.HSE: EnableExtension :: KnownExtension -> Extension

+ Data.Derive.DSL.HSE: EnumFrom :: l -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: EnumFromThen :: l -> Exp l -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: EnumFromThenTo :: l -> Exp l -> Exp l -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: EnumFromTo :: l -> Exp l -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: EqualP :: l -> Type l -> Type l -> Asst l

+ Data.Derive.DSL.HSE: Equals :: Token

+ Data.Derive.DSL.HSE: Exclamation :: Token

+ Data.Derive.DSL.HSE: ExistentialQuantification :: KnownExtension

+ Data.Derive.DSL.HSE: ExpBracket :: l -> Exp l -> Bracket l

+ Data.Derive.DSL.HSE: ExpTypeSig :: l -> Exp l -> Type l -> Exp l

+ Data.Derive.DSL.HSE: ExplicitBidirectional :: l -> [Decl l] -> PatternSynDirection l

+ Data.Derive.DSL.HSE: ExplicitForAll :: KnownExtension

+ Data.Derive.DSL.HSE: ExplicitNamespaces :: KnownExtension

+ Data.Derive.DSL.HSE: ExportSpecList :: l -> [ExportSpec l] -> ExportSpecList l

+ Data.Derive.DSL.HSE: ExprHole :: l -> SpecialCon l

+ Data.Derive.DSL.HSE: ExtendedDefaultRules :: KnownExtension

+ Data.Derive.DSL.HSE: ExtensibleRecords :: KnownExtension

+ Data.Derive.DSL.HSE: FieldPun :: l -> QName l -> FieldUpdate l

+ Data.Derive.DSL.HSE: FieldUpdate :: l -> QName l -> Exp l -> FieldUpdate l

+ Data.Derive.DSL.HSE: FieldWildcard :: l -> FieldUpdate l

+ Data.Derive.DSL.HSE: Fixity :: Assoc () -> Int -> QName () -> Fixity

+ Data.Derive.DSL.HSE: FlexibleContexts :: KnownExtension

+ Data.Derive.DSL.HSE: FlexibleInstances :: KnownExtension

+ Data.Derive.DSL.HSE: FloatTok :: (Rational, String) -> Token

+ Data.Derive.DSL.HSE: FloatTokHash :: (Rational, String) -> Token

+ Data.Derive.DSL.HSE: ForExp :: l -> CallConv l -> Maybe String -> Name l -> Type l -> Decl l

+ Data.Derive.DSL.HSE: ForImp :: l -> CallConv l -> Maybe (Safety l) -> Maybe String -> Name l -> Type l -> Decl l

+ Data.Derive.DSL.HSE: ForeignFunctionInterface :: KnownExtension

+ Data.Derive.DSL.HSE: Frac :: l -> Rational -> String -> Literal l

+ Data.Derive.DSL.HSE: FunBind :: l -> [Match l] -> Decl l

+ Data.Derive.DSL.HSE: FunCon :: l -> SpecialCon l

+ Data.Derive.DSL.HSE: FunDep :: l -> [Name l] -> [Name l] -> FunDep l

+ Data.Derive.DSL.HSE: FunctionalDependencies :: KnownExtension

+ Data.Derive.DSL.HSE: GADTs :: KnownExtension

+ Data.Derive.DSL.HSE: GDataDecl :: l -> DataOrNew l -> Maybe (Context l) -> DeclHead l -> Maybe (Kind l) -> [GadtDecl l] -> [Deriving l] -> Decl l

+ Data.Derive.DSL.HSE: GDataInsDecl :: l -> DataOrNew l -> Type l -> Maybe (Kind l) -> [GadtDecl l] -> [Deriving l] -> Decl l

+ Data.Derive.DSL.HSE: GENERATED :: Token

+ Data.Derive.DSL.HSE: GHC :: Tool

+ Data.Derive.DSL.HSE: GHCForeignImportPrim :: KnownExtension

+ Data.Derive.DSL.HSE: GadtDecl :: l -> Name l -> Maybe [FieldDecl l] -> Type l -> GadtDecl l

+ Data.Derive.DSL.HSE: GenPragma :: l -> String -> (Int, Int) -> (Int, Int) -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: GeneralizedNewtypeDeriving :: KnownExtension

+ Data.Derive.DSL.HSE: Generator :: l -> Pat l -> Exp l -> Stmt l

+ Data.Derive.DSL.HSE: Generics :: KnownExtension

+ Data.Derive.DSL.HSE: GroupBy :: l -> Exp l -> QualStmt l

+ Data.Derive.DSL.HSE: GroupByUsing :: l -> Exp l -> Exp l -> QualStmt l

+ Data.Derive.DSL.HSE: GroupUsing :: l -> Exp l -> QualStmt l

+ Data.Derive.DSL.HSE: GuardedRhs :: l -> [Stmt l] -> Exp l -> GuardedRhs l

+ Data.Derive.DSL.HSE: GuardedRhss :: l -> [GuardedRhs l] -> Rhs l

+ Data.Derive.DSL.HSE: HADDOCK :: Tool

+ Data.Derive.DSL.HSE: HUGS :: Tool

+ Data.Derive.DSL.HSE: Haskell2010 :: Language

+ Data.Derive.DSL.HSE: Haskell98 :: Language

+ Data.Derive.DSL.HSE: HaskellAllDisabled :: Language

+ Data.Derive.DSL.HSE: HereDocuments :: KnownExtension

+ Data.Derive.DSL.HSE: IAbs :: l -> Namespace l -> Name l -> ImportSpec l

+ Data.Derive.DSL.HSE: IDupVarId :: String -> Token

+ Data.Derive.DSL.HSE: IHApp :: l -> InstHead l -> Type l -> InstHead l

+ Data.Derive.DSL.HSE: IHCon :: l -> QName l -> InstHead l

+ Data.Derive.DSL.HSE: IHInfix :: l -> Type l -> QName l -> InstHead l

+ Data.Derive.DSL.HSE: IHParen :: l -> InstHead l -> InstHead l

+ Data.Derive.DSL.HSE: ILinVarId :: String -> Token

+ Data.Derive.DSL.HSE: INCOHERENT :: Token

+ Data.Derive.DSL.HSE: INLINE :: Bool -> Token

+ Data.Derive.DSL.HSE: INLINE_CONLIKE :: Token

+ Data.Derive.DSL.HSE: IPBind :: l -> IPName l -> Exp l -> IPBind l

+ Data.Derive.DSL.HSE: IPBinds :: l -> [IPBind l] -> Binds l

+ Data.Derive.DSL.HSE: IPDup :: l -> String -> IPName l

+ Data.Derive.DSL.HSE: IPLin :: l -> String -> IPName l

+ Data.Derive.DSL.HSE: IPVar :: l -> IPName l -> Exp l

+ Data.Derive.DSL.HSE: IParam :: l -> IPName l -> Type l -> Asst l

+ Data.Derive.DSL.HSE: IParen :: l -> InstRule l -> InstRule l

+ Data.Derive.DSL.HSE: IRule :: l -> Maybe [TyVarBind l] -> Maybe (Context l) -> InstHead l -> InstRule l

+ Data.Derive.DSL.HSE: IThingAll :: l -> Name l -> ImportSpec l

+ Data.Derive.DSL.HSE: IThingWith :: l -> Name l -> [CName l] -> ImportSpec l

+ Data.Derive.DSL.HSE: IVar :: l -> Name l -> ImportSpec l

+ Data.Derive.DSL.HSE: IdSplice :: l -> String -> Splice l

+ Data.Derive.DSL.HSE: Ident :: l -> String -> Name l

+ Data.Derive.DSL.HSE: If :: l -> Exp l -> Exp l -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: ImplicitBidirectional :: PatternSynDirection l

+ Data.Derive.DSL.HSE: ImplicitParams :: KnownExtension

+ Data.Derive.DSL.HSE: ImplicitPrelude :: KnownExtension

+ Data.Derive.DSL.HSE: ImportDecl :: l -> ModuleName l -> Bool -> Bool -> Bool -> Maybe String -> Maybe (ModuleName l) -> Maybe (ImportSpecList l) -> ImportDecl l

+ Data.Derive.DSL.HSE: ImportSpecList :: l -> Bool -> [ImportSpec l] -> ImportSpecList l

+ Data.Derive.DSL.HSE: ImpredicativeTypes :: KnownExtension

+ Data.Derive.DSL.HSE: Incoherent :: l -> Overlap l

+ Data.Derive.DSL.HSE: IncoherentInstances :: KnownExtension

+ Data.Derive.DSL.HSE: InfixA :: l -> Type l -> QName l -> Type l -> Asst l

+ Data.Derive.DSL.HSE: InfixApp :: l -> Exp l -> QOp l -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: InfixConDecl :: l -> Type l -> Name l -> Type l -> ConDecl l

+ Data.Derive.DSL.HSE: InfixDecl :: l -> Assoc l -> Maybe Int -> [Op l] -> Decl l

+ Data.Derive.DSL.HSE: InfixMatch :: l -> Pat l -> Name l -> [Pat l] -> Rhs l -> Maybe (Binds l) -> Match l

+ Data.Derive.DSL.HSE: InjectivityInfo :: l -> Name l -> [Name l] -> InjectivityInfo l

+ Data.Derive.DSL.HSE: InlineConlikeSig :: l -> Maybe (Activation l) -> QName l -> Decl l

+ Data.Derive.DSL.HSE: InlineSig :: l -> Bool -> Maybe (Activation l) -> QName l -> Decl l

+ Data.Derive.DSL.HSE: InsData :: l -> DataOrNew l -> Type l -> [QualConDecl l] -> [Deriving l] -> InstDecl l

+ Data.Derive.DSL.HSE: InsDecl :: l -> Decl l -> InstDecl l

+ Data.Derive.DSL.HSE: InsGData :: l -> DataOrNew l -> Type l -> Maybe (Kind l) -> [GadtDecl l] -> [Deriving l] -> InstDecl l

+ Data.Derive.DSL.HSE: InsType :: l -> Type l -> Type l -> InstDecl l

+ Data.Derive.DSL.HSE: InstDecl :: l -> Maybe (Overlap l) -> InstRule l -> Maybe [InstDecl l] -> Decl l

+ Data.Derive.DSL.HSE: InstSig :: l -> InstRule l -> Decl l

+ Data.Derive.DSL.HSE: InstanceSigs :: KnownExtension

+ Data.Derive.DSL.HSE: IntTok :: (Integer, String) -> Token

+ Data.Derive.DSL.HSE: IntTokHash :: (Integer, String) -> Token

+ Data.Derive.DSL.HSE: InterruptibleFFI :: KnownExtension

+ Data.Derive.DSL.HSE: JavaScript :: l -> CallConv l

+ Data.Derive.DSL.HSE: JavaScriptFFI :: KnownExtension

+ Data.Derive.DSL.HSE: Js :: l -> CallConv l

+ Data.Derive.DSL.HSE: Jvm :: l -> CallConv l

+ Data.Derive.DSL.HSE: KW_Anyclass :: Token

+ Data.Derive.DSL.HSE: KW_As :: Token

+ Data.Derive.DSL.HSE: KW_By :: Token

+ Data.Derive.DSL.HSE: KW_CApi :: Token

+ Data.Derive.DSL.HSE: KW_CCall :: Token

+ Data.Derive.DSL.HSE: KW_CPlusPlus :: Token

+ Data.Derive.DSL.HSE: KW_Case :: Token

+ Data.Derive.DSL.HSE: KW_Class :: Token

+ Data.Derive.DSL.HSE: KW_Data :: Token

+ Data.Derive.DSL.HSE: KW_Default :: Token

+ Data.Derive.DSL.HSE: KW_Deriving :: Token

+ Data.Derive.DSL.HSE: KW_Do :: Token

+ Data.Derive.DSL.HSE: KW_DotNet :: Token

+ Data.Derive.DSL.HSE: KW_Else :: Token

+ Data.Derive.DSL.HSE: KW_Export :: Token

+ Data.Derive.DSL.HSE: KW_Family :: Token

+ Data.Derive.DSL.HSE: KW_Forall :: Token

+ Data.Derive.DSL.HSE: KW_Foreign :: Token

+ Data.Derive.DSL.HSE: KW_Group :: Token

+ Data.Derive.DSL.HSE: KW_Hiding :: Token

+ Data.Derive.DSL.HSE: KW_If :: Token

+ Data.Derive.DSL.HSE: KW_Import :: Token

+ Data.Derive.DSL.HSE: KW_In :: Token

+ Data.Derive.DSL.HSE: KW_Infix :: Token

+ Data.Derive.DSL.HSE: KW_InfixL :: Token

+ Data.Derive.DSL.HSE: KW_InfixR :: Token

+ Data.Derive.DSL.HSE: KW_Instance :: Token

+ Data.Derive.DSL.HSE: KW_Interruptible :: Token

+ Data.Derive.DSL.HSE: KW_JavaScript :: Token

+ Data.Derive.DSL.HSE: KW_Js :: Token

+ Data.Derive.DSL.HSE: KW_Jvm :: Token

+ Data.Derive.DSL.HSE: KW_Let :: Token

+ Data.Derive.DSL.HSE: KW_MDo :: Token

+ Data.Derive.DSL.HSE: KW_Module :: Token

+ Data.Derive.DSL.HSE: KW_NewType :: Token

+ Data.Derive.DSL.HSE: KW_Of :: Token

+ Data.Derive.DSL.HSE: KW_Pattern :: Token

+ Data.Derive.DSL.HSE: KW_Proc :: Token

+ Data.Derive.DSL.HSE: KW_Qualified :: Token

+ Data.Derive.DSL.HSE: KW_Rec :: Token

+ Data.Derive.DSL.HSE: KW_Role :: Token

+ Data.Derive.DSL.HSE: KW_Safe :: Token

+ Data.Derive.DSL.HSE: KW_StdCall :: Token

+ Data.Derive.DSL.HSE: KW_Stock :: Token

+ Data.Derive.DSL.HSE: KW_Then :: Token

+ Data.Derive.DSL.HSE: KW_Threadsafe :: Token

+ Data.Derive.DSL.HSE: KW_Type :: Token

+ Data.Derive.DSL.HSE: KW_Unsafe :: Token

+ Data.Derive.DSL.HSE: KW_Using :: Token

+ Data.Derive.DSL.HSE: KW_Where :: Token

+ Data.Derive.DSL.HSE: KindApp :: l -> Kind l -> Kind l -> Kind l

+ Data.Derive.DSL.HSE: KindFn :: l -> Kind l -> Kind l -> Kind l

+ Data.Derive.DSL.HSE: KindList :: l -> Kind l -> Kind l

+ Data.Derive.DSL.HSE: KindParen :: l -> Kind l -> Kind l

+ Data.Derive.DSL.HSE: KindSig :: l -> Kind l -> ResultSig l

+ Data.Derive.DSL.HSE: KindSignatures :: KnownExtension

+ Data.Derive.DSL.HSE: KindStar :: l -> Kind l

+ Data.Derive.DSL.HSE: KindTuple :: l -> [Kind l] -> Kind l

+ Data.Derive.DSL.HSE: KindVar :: l -> QName l -> Kind l

+ Data.Derive.DSL.HSE: KindedVar :: l -> Name l -> Kind l -> TyVarBind l

+ Data.Derive.DSL.HSE: LANGUAGE :: Token

+ Data.Derive.DSL.HSE: LCase :: l -> [Alt l] -> Exp l

+ Data.Derive.DSL.HSE: LabelVarId :: String -> Token

+ Data.Derive.DSL.HSE: Lambda :: l -> [Pat l] -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: LambdaCase :: KnownExtension

+ Data.Derive.DSL.HSE: LanguagePragma :: l -> [Name l] -> ModulePragma l

+ Data.Derive.DSL.HSE: LazyTy :: l -> BangType l

+ Data.Derive.DSL.HSE: LeftArrApp :: l -> Exp l -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: LeftArrHighApp :: l -> Exp l -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: LeftArrow :: Token

+ Data.Derive.DSL.HSE: LeftArrowTail :: Token

+ Data.Derive.DSL.HSE: LeftCurly :: Token

+ Data.Derive.DSL.HSE: LeftDblArrowTail :: Token

+ Data.Derive.DSL.HSE: LeftHashParen :: Token

+ Data.Derive.DSL.HSE: LeftMode :: Mode

+ Data.Derive.DSL.HSE: LeftParen :: Token

+ Data.Derive.DSL.HSE: LeftSection :: l -> Exp l -> QOp l -> Exp l

+ Data.Derive.DSL.HSE: LeftSquare :: Token

+ Data.Derive.DSL.HSE: Let :: l -> Binds l -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: LetStmt :: l -> Binds l -> Stmt l

+ Data.Derive.DSL.HSE: LiberalTypeSynonyms :: KnownExtension

+ Data.Derive.DSL.HSE: ListComp :: l -> Exp l -> [QualStmt l] -> Exp l

+ Data.Derive.DSL.HSE: ListCon :: l -> SpecialCon l

+ Data.Derive.DSL.HSE: ListOf :: SrcSpanInfo -> [a] -> ListOf a

+ Data.Derive.DSL.HSE: Lit :: l -> Literal l -> Exp l

+ Data.Derive.DSL.HSE: Loc :: SrcSpan -> a -> Loc a

+ Data.Derive.DSL.HSE: MDo :: l -> [Stmt l] -> Exp l

+ Data.Derive.DSL.HSE: MINIMAL :: Token

+ Data.Derive.DSL.HSE: MagicHash :: KnownExtension

+ Data.Derive.DSL.HSE: Match :: l -> Name l -> [Pat l] -> Rhs l -> Maybe (Binds l) -> Match l

+ Data.Derive.DSL.HSE: MinimalPragma :: l -> Maybe (BooleanFormula l) -> Decl l

+ Data.Derive.DSL.HSE: Minus :: Token

+ Data.Derive.DSL.HSE: Module :: l -> Maybe (ModuleHead l) -> [ModulePragma l] -> [ImportDecl l] -> [Decl l] -> Module l

+ Data.Derive.DSL.HSE: ModuleAnn :: l -> Exp l -> Annotation l

+ Data.Derive.DSL.HSE: ModuleHead :: l -> ModuleName l -> Maybe (WarningText l) -> Maybe (ExportSpecList l) -> ModuleHead l

+ Data.Derive.DSL.HSE: ModuleHeadAndImports :: l -> [ModulePragma l] -> Maybe (ModuleHead l) -> [ImportDecl l] -> ModuleHeadAndImports l

+ Data.Derive.DSL.HSE: ModuleName :: l -> String -> ModuleName l

+ Data.Derive.DSL.HSE: MonoLocalBinds :: KnownExtension

+ Data.Derive.DSL.HSE: MonoPatBinds :: KnownExtension

+ Data.Derive.DSL.HSE: MonomorphismRestriction :: KnownExtension

+ Data.Derive.DSL.HSE: MultiIf :: l -> [GuardedRhs l] -> Exp l

+ Data.Derive.DSL.HSE: MultiParamTypeClasses :: KnownExtension

+ Data.Derive.DSL.HSE: MultiWayIf :: KnownExtension

+ Data.Derive.DSL.HSE: NHC98 :: Tool

+ Data.Derive.DSL.HSE: NOUNPACK :: Token

+ Data.Derive.DSL.HSE: NO_OVERLAP :: Token

+ Data.Derive.DSL.HSE: NPlusKPatterns :: KnownExtension

+ Data.Derive.DSL.HSE: NamedFieldPuns :: KnownExtension

+ Data.Derive.DSL.HSE: NamedWildCards :: KnownExtension

+ Data.Derive.DSL.HSE: NegApp :: l -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: Negative :: l -> Sign l

+ Data.Derive.DSL.HSE: NewQualifiedOperators :: KnownExtension

+ Data.Derive.DSL.HSE: NewType :: l -> DataOrNew l

+ Data.Derive.DSL.HSE: NoNamespace :: l -> Namespace l

+ Data.Derive.DSL.HSE: NoOverlap :: l -> Overlap l

+ Data.Derive.DSL.HSE: NoStrictAnnot :: l -> BangType l

+ Data.Derive.DSL.HSE: NoUnpack :: l -> Unpackedness l

+ Data.Derive.DSL.HSE: NoUnpackPragma :: l -> Unpackedness l

+ Data.Derive.DSL.HSE: NoWildcard :: l -> EWildcard l

+ Data.Derive.DSL.HSE: Nominal :: l -> Role l

+ Data.Derive.DSL.HSE: NonGreedy :: a -> NonGreedy a

+ Data.Derive.DSL.HSE: NondecreasingIndentation :: KnownExtension

+ Data.Derive.DSL.HSE: OPTIONS :: (Maybe String, String) -> Token

+ Data.Derive.DSL.HSE: OVERLAP :: Token

+ Data.Derive.DSL.HSE: OVERLAPPABLE :: Token

+ Data.Derive.DSL.HSE: OVERLAPPING :: Token

+ Data.Derive.DSL.HSE: OVERLAPS :: Token

+ Data.Derive.DSL.HSE: OneLineMode :: Mode

+ Data.Derive.DSL.HSE: OptionsPragma :: l -> Maybe Tool -> String -> ModulePragma l

+ Data.Derive.DSL.HSE: OrFormula :: l -> [BooleanFormula l] -> BooleanFormula l

+ Data.Derive.DSL.HSE: Overlap :: l -> Overlap l

+ Data.Derive.DSL.HSE: Overlappable :: l -> Overlap l

+ Data.Derive.DSL.HSE: Overlapping :: l -> Overlap l

+ Data.Derive.DSL.HSE: OverlappingInstances :: KnownExtension

+ Data.Derive.DSL.HSE: Overlaps :: l -> Overlap l

+ Data.Derive.DSL.HSE: OverloadedLabel :: l -> String -> Exp l

+ Data.Derive.DSL.HSE: OverloadedLabels :: KnownExtension

+ Data.Derive.DSL.HSE: OverloadedStrings :: KnownExtension

+ Data.Derive.DSL.HSE: PApp :: l -> QName l -> [Pat l] -> Pat l

+ Data.Derive.DSL.HSE: PAsPat :: l -> Name l -> Pat l -> Pat l

+ Data.Derive.DSL.HSE: PBangPat :: l -> Pat l -> Pat l

+ Data.Derive.DSL.HSE: PFieldPat :: l -> QName l -> Pat l -> PatField l

+ Data.Derive.DSL.HSE: PFieldPun :: l -> QName l -> PatField l

+ Data.Derive.DSL.HSE: PFieldWildcard :: l -> PatField l

+ Data.Derive.DSL.HSE: PInfixApp :: l -> Pat l -> QName l -> Pat l -> Pat l

+ Data.Derive.DSL.HSE: PIrrPat :: l -> Pat l -> Pat l

+ Data.Derive.DSL.HSE: PList :: l -> [Pat l] -> Pat l

+ Data.Derive.DSL.HSE: PLit :: l -> Sign l -> Literal l -> Pat l

+ Data.Derive.DSL.HSE: PNPlusK :: l -> Name l -> Integer -> Pat l

+ Data.Derive.DSL.HSE: PPHsMode :: Indent -> Indent -> Indent -> Indent -> Indent -> Indent -> Indent -> Bool -> PPLayout -> Bool -> PPHsMode

+ Data.Derive.DSL.HSE: PPInLine :: PPLayout

+ Data.Derive.DSL.HSE: PPNoLayout :: PPLayout

+ Data.Derive.DSL.HSE: PPOffsideRule :: PPLayout

+ Data.Derive.DSL.HSE: PPSemiColon :: PPLayout

+ Data.Derive.DSL.HSE: PParen :: l -> Pat l -> Pat l

+ Data.Derive.DSL.HSE: PQuasiQuote :: l -> String -> String -> Pat l

+ Data.Derive.DSL.HSE: PRPat :: l -> [RPat l] -> Pat l

+ Data.Derive.DSL.HSE: PRec :: l -> QName l -> [PatField l] -> Pat l

+ Data.Derive.DSL.HSE: PSplice :: l -> Splice l -> Pat l

+ Data.Derive.DSL.HSE: PTuple :: l -> Boxed -> [Pat l] -> Pat l

+ Data.Derive.DSL.HSE: PUnboxedSum :: l -> Int -> Int -> Pat l -> Pat l

+ Data.Derive.DSL.HSE: PVar :: l -> Name l -> Pat l

+ Data.Derive.DSL.HSE: PViewPat :: l -> Exp l -> Pat l -> Pat l

+ Data.Derive.DSL.HSE: PWildCard :: l -> Pat l

+ Data.Derive.DSL.HSE: PXAttr :: l -> XName l -> Pat l -> PXAttr l

+ Data.Derive.DSL.HSE: PXETag :: l -> XName l -> [PXAttr l] -> Maybe (Pat l) -> Pat l

+ Data.Derive.DSL.HSE: PXPatTag :: l -> Pat l -> Pat l

+ Data.Derive.DSL.HSE: PXPcdata :: l -> String -> Pat l

+ Data.Derive.DSL.HSE: PXRPats :: l -> [RPat l] -> Pat l

+ Data.Derive.DSL.HSE: PXTag :: l -> XName l -> [PXAttr l] -> Maybe (Pat l) -> [Pat l] -> Pat l

+ Data.Derive.DSL.HSE: PackageImports :: KnownExtension

+ Data.Derive.DSL.HSE: PageMode :: Mode

+ Data.Derive.DSL.HSE: ParArray :: l -> [Exp l] -> Exp l

+ Data.Derive.DSL.HSE: ParArrayComp :: l -> Exp l -> [[QualStmt l]] -> Exp l

+ Data.Derive.DSL.HSE: ParArrayFromThenTo :: l -> Exp l -> Exp l -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: ParArrayFromTo :: l -> Exp l -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: ParArrayLeftSquare :: Token

+ Data.Derive.DSL.HSE: ParArrayRightSquare :: Token

+ Data.Derive.DSL.HSE: ParComp :: l -> Exp l -> [[QualStmt l]] -> Exp l

+ Data.Derive.DSL.HSE: ParallelArrays :: KnownExtension

+ Data.Derive.DSL.HSE: ParallelListComp :: KnownExtension

+ Data.Derive.DSL.HSE: Paren :: l -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: ParenA :: l -> Asst l -> Asst l

+ Data.Derive.DSL.HSE: ParenFormula :: l -> BooleanFormula l -> BooleanFormula l

+ Data.Derive.DSL.HSE: ParenSplice :: l -> Exp l -> Splice l

+ Data.Derive.DSL.HSE: ParseFailed :: SrcLoc -> String -> ParseResult a

+ Data.Derive.DSL.HSE: ParseMode :: String -> Language -> [Extension] -> Bool -> Bool -> Maybe [Fixity] -> Bool -> ParseMode

+ Data.Derive.DSL.HSE: ParseOk :: a -> ParseResult a

+ Data.Derive.DSL.HSE: PartialTypeSignatures :: KnownExtension

+ Data.Derive.DSL.HSE: PatBind :: l -> Pat l -> Rhs l -> Maybe (Binds l) -> Decl l

+ Data.Derive.DSL.HSE: PatBracket :: l -> Pat l -> Bracket l

+ Data.Derive.DSL.HSE: PatSyn :: l -> Pat l -> Pat l -> PatternSynDirection l -> Decl l

+ Data.Derive.DSL.HSE: PatSynSig :: l -> [Name l] -> Maybe [TyVarBind l] -> Maybe (Context l) -> Maybe (Context l) -> Type l -> Decl l

+ Data.Derive.DSL.HSE: PatTypeSig :: l -> Pat l -> Type l -> Pat l

+ Data.Derive.DSL.HSE: PatternGuards :: KnownExtension

+ Data.Derive.DSL.HSE: PatternNamespace :: l -> Namespace l

+ Data.Derive.DSL.HSE: PatternSignatures :: KnownExtension

+ Data.Derive.DSL.HSE: PatternSynonyms :: KnownExtension

+ Data.Derive.DSL.HSE: Phantom :: l -> Role l

+ Data.Derive.DSL.HSE: PlayInterruptible :: l -> Safety l

+ Data.Derive.DSL.HSE: PlayRisky :: l -> Safety l

+ Data.Derive.DSL.HSE: PlaySafe :: l -> Bool -> Safety l

+ Data.Derive.DSL.HSE: PolyKinds :: KnownExtension

+ Data.Derive.DSL.HSE: PolymorphicComponents :: KnownExtension

+ Data.Derive.DSL.HSE: PostfixOperators :: KnownExtension

+ Data.Derive.DSL.HSE: PragmaEnd :: Token

+ Data.Derive.DSL.HSE: PragmasAndModuleHead :: l -> [ModulePragma l] -> Maybe (ModuleHead l) -> PragmasAndModuleHead l

+ Data.Derive.DSL.HSE: PragmasAndModuleName :: l -> [ModulePragma l] -> Maybe (ModuleName l) -> PragmasAndModuleName l

+ Data.Derive.DSL.HSE: PrimChar :: l -> Char -> String -> Literal l

+ Data.Derive.DSL.HSE: PrimDouble :: l -> Rational -> String -> Literal l

+ Data.Derive.DSL.HSE: PrimFloat :: l -> Rational -> String -> Literal l

+ Data.Derive.DSL.HSE: PrimInt :: l -> Integer -> String -> Literal l

+ Data.Derive.DSL.HSE: PrimString :: l -> String -> String -> Literal l

+ Data.Derive.DSL.HSE: PrimWord :: l -> Integer -> String -> Literal l

+ Data.Derive.DSL.HSE: Proc :: l -> Pat l -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: PromotedCon :: l -> Bool -> QName l -> Promoted l

+ Data.Derive.DSL.HSE: PromotedInteger :: l -> Integer -> String -> Promoted l

+ Data.Derive.DSL.HSE: PromotedList :: l -> Bool -> [Type l] -> Promoted l

+ Data.Derive.DSL.HSE: PromotedName :: l -> QName l -> MaybePromotedName l

+ Data.Derive.DSL.HSE: PromotedString :: l -> String -> String -> Promoted l

+ Data.Derive.DSL.HSE: PromotedTuple :: l -> [Type l] -> Promoted l

+ Data.Derive.DSL.HSE: PromotedUnit :: l -> Promoted l

+ Data.Derive.DSL.HSE: QConId :: (String, String) -> Token

+ Data.Derive.DSL.HSE: QConOp :: l -> QName l -> QOp l

+ Data.Derive.DSL.HSE: QConSym :: (String, String) -> Token

+ Data.Derive.DSL.HSE: QVarId :: (String, String) -> Token

+ Data.Derive.DSL.HSE: QVarOp :: l -> QName l -> QOp l

+ Data.Derive.DSL.HSE: QVarSym :: (String, String) -> Token

+ Data.Derive.DSL.HSE: Qual :: l -> ModuleName l -> Name l -> QName l

+ Data.Derive.DSL.HSE: QualConDecl :: l -> Maybe [TyVarBind l] -> Maybe (Context l) -> ConDecl l -> QualConDecl l

+ Data.Derive.DSL.HSE: QualStmt :: l -> Stmt l -> QualStmt l

+ Data.Derive.DSL.HSE: Qualifier :: l -> Exp l -> Stmt l

+ Data.Derive.DSL.HSE: QuasiQuote :: l -> String -> String -> Exp l

+ Data.Derive.DSL.HSE: QuasiQuotes :: KnownExtension

+ Data.Derive.DSL.HSE: QuoteColon :: Token

+ Data.Derive.DSL.HSE: RPAs :: l -> Name l -> RPat l -> RPat l

+ Data.Derive.DSL.HSE: RPCAs :: l -> Name l -> RPat l -> RPat l

+ Data.Derive.DSL.HSE: RPCAt :: Token

+ Data.Derive.DSL.HSE: RPEither :: l -> RPat l -> RPat l -> RPat l

+ Data.Derive.DSL.HSE: RPGuard :: l -> Pat l -> [Stmt l] -> RPat l

+ Data.Derive.DSL.HSE: RPGuardClose :: Token

+ Data.Derive.DSL.HSE: RPGuardOpen :: Token

+ Data.Derive.DSL.HSE: RPOp :: l -> RPat l -> RPatOp l -> RPat l

+ Data.Derive.DSL.HSE: RPOpt :: l -> RPatOp l

+ Data.Derive.DSL.HSE: RPOptG :: l -> RPatOp l

+ Data.Derive.DSL.HSE: RPParen :: l -> RPat l -> RPat l

+ Data.Derive.DSL.HSE: RPPat :: l -> Pat l -> RPat l

+ Data.Derive.DSL.HSE: RPPlus :: l -> RPatOp l

+ Data.Derive.DSL.HSE: RPPlusG :: l -> RPatOp l

+ Data.Derive.DSL.HSE: RPSeq :: l -> [RPat l] -> RPat l

+ Data.Derive.DSL.HSE: RPStar :: l -> RPatOp l

+ Data.Derive.DSL.HSE: RPStarG :: l -> RPatOp l

+ Data.Derive.DSL.HSE: RULES :: Token

+ Data.Derive.DSL.HSE: Rank2Types :: KnownExtension

+ Data.Derive.DSL.HSE: RankNTypes :: KnownExtension

+ Data.Derive.DSL.HSE: RebindableSyntax :: KnownExtension

+ Data.Derive.DSL.HSE: RecConstr :: l -> QName l -> [FieldUpdate l] -> Exp l

+ Data.Derive.DSL.HSE: RecDecl :: l -> Name l -> [FieldDecl l] -> ConDecl l

+ Data.Derive.DSL.HSE: RecStmt :: l -> [Stmt l] -> Stmt l

+ Data.Derive.DSL.HSE: RecUpdate :: l -> Exp l -> [FieldUpdate l] -> Exp l

+ Data.Derive.DSL.HSE: RecordPuns :: KnownExtension

+ Data.Derive.DSL.HSE: RecordWildCards :: KnownExtension

+ Data.Derive.DSL.HSE: RecursiveDo :: KnownExtension

+ Data.Derive.DSL.HSE: RegularPatterns :: KnownExtension

+ Data.Derive.DSL.HSE: RelaxedPolyRec :: KnownExtension

+ Data.Derive.DSL.HSE: Representational :: l -> Role l

+ Data.Derive.DSL.HSE: RestrictedTypeSynonyms :: KnownExtension

+ Data.Derive.DSL.HSE: RightArrApp :: l -> Exp l -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: RightArrHighApp :: l -> Exp l -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: RightArrow :: Token

+ Data.Derive.DSL.HSE: RightArrowTail :: Token

+ Data.Derive.DSL.HSE: RightCurly :: Token

+ Data.Derive.DSL.HSE: RightDblArrowTail :: Token

+ Data.Derive.DSL.HSE: RightHashParen :: Token

+ Data.Derive.DSL.HSE: RightParen :: Token

+ Data.Derive.DSL.HSE: RightSection :: l -> QOp l -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: RightSquare :: Token

+ Data.Derive.DSL.HSE: RoleAnnotDecl :: l -> QName l -> [Role l] -> Decl l

+ Data.Derive.DSL.HSE: RoleAnnotations :: KnownExtension

+ Data.Derive.DSL.HSE: RoleWildcard :: l -> Role l

+ Data.Derive.DSL.HSE: Rule :: l -> String -> Maybe (Activation l) -> Maybe [RuleVar l] -> Exp l -> Exp l -> Rule l

+ Data.Derive.DSL.HSE: RulePragmaDecl :: l -> [Rule l] -> Decl l

+ Data.Derive.DSL.HSE: RuleVar :: l -> Name l -> RuleVar l

+ Data.Derive.DSL.HSE: SCC :: Token

+ Data.Derive.DSL.HSE: SCCPragma :: l -> String -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: SOURCE :: Token

+ Data.Derive.DSL.HSE: SPECIALISE :: Token

+ Data.Derive.DSL.HSE: SPECIALISE_INLINE :: Bool -> Token

+ Data.Derive.DSL.HSE: Safe :: KnownExtension

+ Data.Derive.DSL.HSE: SafeImports :: KnownExtension

+ Data.Derive.DSL.HSE: ScopedTypeVariables :: KnownExtension

+ Data.Derive.DSL.HSE: SemiColon :: Token

+ Data.Derive.DSL.HSE: Signless :: l -> Sign l

+ Data.Derive.DSL.HSE: SpecInlineSig :: l -> Bool -> Maybe (Activation l) -> QName l -> [Type l] -> Decl l

+ Data.Derive.DSL.HSE: SpecSig :: l -> Maybe (Activation l) -> QName l -> [Type l] -> Decl l

+ Data.Derive.DSL.HSE: Special :: l -> SpecialCon l -> QName l

+ Data.Derive.DSL.HSE: SpliceDecl :: l -> Exp l -> Decl l

+ Data.Derive.DSL.HSE: SpliceExp :: l -> Splice l -> Exp l

+ Data.Derive.DSL.HSE: SrcLoc :: String -> Int -> Int -> SrcLoc

+ Data.Derive.DSL.HSE: SrcSpan :: String -> Int -> Int -> Int -> Int -> SrcSpan

+ Data.Derive.DSL.HSE: SrcSpanInfo :: SrcSpan -> [SrcSpan] -> SrcSpanInfo

+ Data.Derive.DSL.HSE: StandaloneDeriving :: KnownExtension

+ Data.Derive.DSL.HSE: Star :: Token

+ Data.Derive.DSL.HSE: StdCall :: l -> CallConv l

+ Data.Derive.DSL.HSE: StringHash :: (String, String) -> Token

+ Data.Derive.DSL.HSE: StringTok :: (String, String) -> Token

+ Data.Derive.DSL.HSE: Style :: Mode -> Int -> Float -> Style

+ Data.Derive.DSL.HSE: Symbol :: l -> String -> Name l

+ Data.Derive.DSL.HSE: TApp :: Token

+ Data.Derive.DSL.HSE: THCloseQuote :: Token

+ Data.Derive.DSL.HSE: THDecQuote :: Token

+ Data.Derive.DSL.HSE: THExpQuote :: Token

+ Data.Derive.DSL.HSE: THIdEscape :: String -> Token

+ Data.Derive.DSL.HSE: THParenEscape :: Token

+ Data.Derive.DSL.HSE: THPatQuote :: Token

+ Data.Derive.DSL.HSE: THQuasiQuote :: (String, String) -> Token

+ Data.Derive.DSL.HSE: THTyQuote :: Token

+ Data.Derive.DSL.HSE: THTypQuote :: Token

+ Data.Derive.DSL.HSE: THVarQuote :: Token

+ Data.Derive.DSL.HSE: TemplateHaskell :: KnownExtension

+ Data.Derive.DSL.HSE: ThenBy :: l -> Exp l -> Exp l -> QualStmt l

+ Data.Derive.DSL.HSE: ThenTrans :: l -> Exp l -> QualStmt l

+ Data.Derive.DSL.HSE: Tilde :: Token

+ Data.Derive.DSL.HSE: TransformListComp :: KnownExtension

+ Data.Derive.DSL.HSE: Trustworthy :: KnownExtension

+ Data.Derive.DSL.HSE: Tuple :: l -> Boxed -> [Exp l] -> Exp l

+ Data.Derive.DSL.HSE: TupleCon :: l -> Boxed -> Int -> SpecialCon l

+ Data.Derive.DSL.HSE: TupleSection :: l -> Boxed -> [Maybe (Exp l)] -> Exp l

+ Data.Derive.DSL.HSE: TupleSections :: KnownExtension

+ Data.Derive.DSL.HSE: TyApp :: l -> Type l -> Type l -> Type l

+ Data.Derive.DSL.HSE: TyBang :: l -> BangType l -> Unpackedness l -> Type l -> Type l

+ Data.Derive.DSL.HSE: TyCon :: l -> QName l -> Type l

+ Data.Derive.DSL.HSE: TyEquals :: l -> Type l -> Type l -> Type l

+ Data.Derive.DSL.HSE: TyForall :: l -> Maybe [TyVarBind l] -> Maybe (Context l) -> Type l -> Type l

+ Data.Derive.DSL.HSE: TyFun :: l -> Type l -> Type l -> Type l

+ Data.Derive.DSL.HSE: TyInfix :: l -> Type l -> MaybePromotedName l -> Type l -> Type l

+ Data.Derive.DSL.HSE: TyKind :: l -> Type l -> Kind l -> Type l

+ Data.Derive.DSL.HSE: TyList :: l -> Type l -> Type l

+ Data.Derive.DSL.HSE: TyParArray :: l -> Type l -> Type l

+ Data.Derive.DSL.HSE: TyParen :: l -> Type l -> Type l

+ Data.Derive.DSL.HSE: TyPromoted :: l -> Promoted l -> Type l

+ Data.Derive.DSL.HSE: TyQuasiQuote :: l -> String -> String -> Type l

+ Data.Derive.DSL.HSE: TySplice :: l -> Splice l -> Type l

+ Data.Derive.DSL.HSE: TyTuple :: l -> Boxed -> [Type l] -> Type l

+ Data.Derive.DSL.HSE: TyUnboxedSum :: l -> [Type l] -> Type l

+ Data.Derive.DSL.HSE: TyVar :: l -> Name l -> Type l

+ Data.Derive.DSL.HSE: TyVarSig :: l -> TyVarBind l -> ResultSig l

+ Data.Derive.DSL.HSE: TyWildCard :: l -> Maybe (Name l) -> Type l

+ Data.Derive.DSL.HSE: TypQuote :: l -> QName l -> Exp l

+ Data.Derive.DSL.HSE: TypeAnn :: l -> Name l -> Exp l -> Annotation l

+ Data.Derive.DSL.HSE: TypeApp :: l -> Type l -> Exp l

+ Data.Derive.DSL.HSE: TypeApplications :: KnownExtension

+ Data.Derive.DSL.HSE: TypeBracket :: l -> Type l -> Bracket l

+ Data.Derive.DSL.HSE: TypeDecl :: l -> DeclHead l -> Type l -> Decl l

+ Data.Derive.DSL.HSE: TypeEqn :: l -> Type l -> Type l -> TypeEqn l

+ Data.Derive.DSL.HSE: TypeFamDecl :: l -> DeclHead l -> Maybe (ResultSig l) -> Maybe (InjectivityInfo l) -> Decl l

+ Data.Derive.DSL.HSE: TypeFamilies :: KnownExtension

+ Data.Derive.DSL.HSE: TypeFamilyDependencies :: KnownExtension

+ Data.Derive.DSL.HSE: TypeInsDecl :: l -> Type l -> Type l -> Decl l

+ Data.Derive.DSL.HSE: TypeNamespace :: l -> Namespace l

+ Data.Derive.DSL.HSE: TypeOperators :: KnownExtension

+ Data.Derive.DSL.HSE: TypeSig :: l -> [Name l] -> Type l -> Decl l

+ Data.Derive.DSL.HSE: TypeSynonymInstances :: KnownExtension

+ Data.Derive.DSL.HSE: TypedRuleVar :: l -> Name l -> Type l -> RuleVar l

+ Data.Derive.DSL.HSE: UNPACK :: Token

+ Data.Derive.DSL.HSE: UnGuardedRhs :: l -> Exp l -> Rhs l

+ Data.Derive.DSL.HSE: UnQual :: l -> Name l -> QName l

+ Data.Derive.DSL.HSE: Unboxed :: Boxed

+ Data.Derive.DSL.HSE: UnboxedSingleCon :: l -> SpecialCon l

+ Data.Derive.DSL.HSE: UnboxedSum :: l -> Int -> Int -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: UnboxedSums :: KnownExtension

+ Data.Derive.DSL.HSE: UnboxedTuples :: KnownExtension

+ Data.Derive.DSL.HSE: UndecidableInstances :: KnownExtension

+ Data.Derive.DSL.HSE: Underscore :: Token

+ Data.Derive.DSL.HSE: UnicodeSyntax :: KnownExtension

+ Data.Derive.DSL.HSE: Unidirectional :: PatternSynDirection l

+ Data.Derive.DSL.HSE: UnitCon :: l -> SpecialCon l

+ Data.Derive.DSL.HSE: UnkindedVar :: l -> Name l -> TyVarBind l

+ Data.Derive.DSL.HSE: UnknownExtension :: String -> Extension

+ Data.Derive.DSL.HSE: UnknownLanguage :: String -> Language

+ Data.Derive.DSL.HSE: UnknownPragma :: SrcSpan -> String -> UnknownPragma

+ Data.Derive.DSL.HSE: UnknownTool :: String -> Tool

+ Data.Derive.DSL.HSE: UnliftedFFITypes :: KnownExtension

+ Data.Derive.DSL.HSE: Unpack :: l -> Unpackedness l

+ Data.Derive.DSL.HSE: UnpromotedName :: l -> QName l -> MaybePromotedName l

+ Data.Derive.DSL.HSE: VRightCurly :: Token

+ Data.Derive.DSL.HSE: Var :: l -> QName l -> Exp l

+ Data.Derive.DSL.HSE: VarFormula :: l -> Name l -> BooleanFormula l

+ Data.Derive.DSL.HSE: VarId :: String -> Token

+ Data.Derive.DSL.HSE: VarName :: l -> Name l -> CName l

+ Data.Derive.DSL.HSE: VarOp :: l -> Name l -> Op l

+ Data.Derive.DSL.HSE: VarQuote :: l -> QName l -> Exp l

+ Data.Derive.DSL.HSE: VarSym :: String -> Token

+ Data.Derive.DSL.HSE: ViewPatterns :: KnownExtension

+ Data.Derive.DSL.HSE: WARNING :: Token

+ Data.Derive.DSL.HSE: WarnPragmaDecl :: l -> [([Name l], String)] -> Decl l

+ Data.Derive.DSL.HSE: WarnText :: l -> String -> WarningText l

+ Data.Derive.DSL.HSE: WildCardA :: l -> Maybe (Name l) -> Asst l

+ Data.Derive.DSL.HSE: WordTokHash :: (Integer, String) -> Token

+ Data.Derive.DSL.HSE: XAttr :: l -> XName l -> Exp l -> XAttr l

+ Data.Derive.DSL.HSE: XChildTag :: l -> [Exp l] -> Exp l

+ Data.Derive.DSL.HSE: XChildTagOpen :: Token

+ Data.Derive.DSL.HSE: XCloseTagOpen :: Token

+ Data.Derive.DSL.HSE: XCodeTagClose :: Token

+ Data.Derive.DSL.HSE: XCodeTagOpen :: Token

+ Data.Derive.DSL.HSE: XDomName :: l -> String -> String -> XName l

+ Data.Derive.DSL.HSE: XETag :: l -> XName l -> [XAttr l] -> Maybe (Exp l) -> Exp l

+ Data.Derive.DSL.HSE: XEmptyTagClose :: Token

+ Data.Derive.DSL.HSE: XExpTag :: l -> Exp l -> Exp l

+ Data.Derive.DSL.HSE: XName :: l -> String -> XName l

+ Data.Derive.DSL.HSE: XPCDATA :: String -> Token

+ Data.Derive.DSL.HSE: XPcdata :: l -> String -> Exp l

+ Data.Derive.DSL.HSE: XRPatClose :: Token

+ Data.Derive.DSL.HSE: XRPatOpen :: Token

+ Data.Derive.DSL.HSE: XStdTagClose :: Token

+ Data.Derive.DSL.HSE: XStdTagOpen :: Token

+ Data.Derive.DSL.HSE: XTag :: l -> XName l -> [XAttr l] -> Maybe (Exp l) -> [Exp l] -> Exp l

+ Data.Derive.DSL.HSE: XmlHybrid :: l -> Maybe (ModuleHead l) -> [ModulePragma l] -> [ImportDecl l] -> [Decl l] -> XName l -> [XAttr l] -> Maybe (Exp l) -> [Exp l] -> Module l

+ Data.Derive.DSL.HSE: XmlPage :: l -> ModuleName l -> [ModulePragma l] -> XName l -> [XAttr l] -> Maybe (Exp l) -> [Exp l] -> Module l

+ Data.Derive.DSL.HSE: XmlSyntax :: KnownExtension

+ Data.Derive.DSL.HSE: YHC :: Tool

+ Data.Derive.DSL.HSE: ZigZagMode :: Mode

+ Data.Derive.DSL.HSE: [baseLanguage] :: ParseMode -> Language

+ Data.Derive.DSL.HSE: [caseIndent] :: PPHsMode -> Indent

+ Data.Derive.DSL.HSE: [classIndent] :: PPHsMode -> Indent

+ Data.Derive.DSL.HSE: [doIndent] :: PPHsMode -> Indent

+ Data.Derive.DSL.HSE: [extensions] :: ParseMode -> [Extension]

+ Data.Derive.DSL.HSE: [fixities] :: ParseMode -> Maybe [Fixity]

+ Data.Derive.DSL.HSE: [ignoreFunctionArity] :: ParseMode -> Bool

+ Data.Derive.DSL.HSE: [ignoreLanguagePragmas] :: ParseMode -> Bool

+ Data.Derive.DSL.HSE: [ignoreLinePragmas] :: ParseMode -> Bool

+ Data.Derive.DSL.HSE: [importAnn] :: ImportDecl l -> l

+ Data.Derive.DSL.HSE: [importAs] :: ImportDecl l -> Maybe (ModuleName l)

+ Data.Derive.DSL.HSE: [importModule] :: ImportDecl l -> ModuleName l

+ Data.Derive.DSL.HSE: [importPkg] :: ImportDecl l -> Maybe String

+ Data.Derive.DSL.HSE: [importQualified] :: ImportDecl l -> Bool

+ Data.Derive.DSL.HSE: [importSafe] :: ImportDecl l -> Bool

+ Data.Derive.DSL.HSE: [importSpecs] :: ImportDecl l -> Maybe (ImportSpecList l)

+ Data.Derive.DSL.HSE: [importSrc] :: ImportDecl l -> Bool

+ Data.Derive.DSL.HSE: [layout] :: PPHsMode -> PPLayout

+ Data.Derive.DSL.HSE: [letIndent] :: PPHsMode -> Indent

+ Data.Derive.DSL.HSE: [lineLength] :: Style -> Int

+ Data.Derive.DSL.HSE: [linePragmas] :: PPHsMode -> Bool

+ Data.Derive.DSL.HSE: [loc] :: Loc a -> SrcSpan

+ Data.Derive.DSL.HSE: [mode] :: Style -> Mode

+ Data.Derive.DSL.HSE: [multiIfIndent] :: PPHsMode -> Indent

+ Data.Derive.DSL.HSE: [onsideIndent] :: PPHsMode -> Indent

+ Data.Derive.DSL.HSE: [parseFilename] :: ParseMode -> String

+ Data.Derive.DSL.HSE: [ribbonsPerLine] :: Style -> Float

+ Data.Derive.DSL.HSE: [spacing] :: PPHsMode -> Bool

+ Data.Derive.DSL.HSE: [srcColumn] :: SrcLoc -> Int

+ Data.Derive.DSL.HSE: [srcFilename] :: SrcLoc -> String

+ Data.Derive.DSL.HSE: [srcInfoPoints] :: SrcSpanInfo -> [SrcSpan]

+ Data.Derive.DSL.HSE: [srcInfoSpan] :: SrcSpanInfo -> SrcSpan

+ Data.Derive.DSL.HSE: [srcLine] :: SrcLoc -> Int

+ Data.Derive.DSL.HSE: [srcSpanEndColumn] :: SrcSpan -> Int

+ Data.Derive.DSL.HSE: [srcSpanEndLine] :: SrcSpan -> Int

+ Data.Derive.DSL.HSE: [srcSpanFilename] :: SrcSpan -> String

+ Data.Derive.DSL.HSE: [srcSpanStartColumn] :: SrcSpan -> Int

+ Data.Derive.DSL.HSE: [srcSpanStartLine] :: SrcSpan -> Int

+ Data.Derive.DSL.HSE: [unLoc] :: Loc a -> a

+ Data.Derive.DSL.HSE: [unNonGreedy] :: NonGreedy a -> a

+ Data.Derive.DSL.HSE: [whereIndent] :: PPHsMode -> Indent

+ Data.Derive.DSL.HSE: alt :: Pat () -> Exp () -> Alt ()

+ Data.Derive.DSL.HSE: altGW :: Pat () -> [Stmt ()] -> Exp () -> Binds () -> Alt ()

+ Data.Derive.DSL.HSE: amap :: Annotated ast => (l -> l) -> ast l -> ast l

+ Data.Derive.DSL.HSE: ann :: Annotated ast => ast l -> l

+ Data.Derive.DSL.HSE: anyclass_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: appFun :: Exp () -> [Exp ()] -> Exp ()

+ Data.Derive.DSL.HSE: appP :: Exp () -> Exp () -> Exp ()

+ Data.Derive.DSL.HSE: applyFixities :: (AppFixity ast, Monad m) => [Fixity] -> ast SrcSpanInfo -> m (ast SrcSpanInfo)

+ Data.Derive.DSL.HSE: apps :: Exp () -> [Exp ()] -> Exp ()

+ Data.Derive.DSL.HSE: as_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: associateHaddock :: (Annotated ast, Traversable ast) => (ast SrcSpanInfo, [Comment]) -> ast (SrcSpanInfo, [Comment])

+ Data.Derive.DSL.HSE: bang_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: baseFixities :: [Fixity]

+ Data.Derive.DSL.HSE: bind :: String -> [Pat ()] -> Exp () -> Decl ()

+ Data.Derive.DSL.HSE: binds :: String -> [([Pat ()], Exp ())] -> Decl ()

+ Data.Derive.DSL.HSE: capi_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: caseE :: Exp () -> [Alt ()] -> Exp ()

+ Data.Derive.DSL.HSE: ccall_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: charE :: Char -> Exp ()

+ Data.Derive.DSL.HSE: charP :: Char -> Pat ()

+ Data.Derive.DSL.HSE: class Functor ast => Annotated (ast :: Type -> Type)

+ Data.Derive.DSL.HSE: class AppFixity (ast :: Type -> Type)

+ Data.Derive.DSL.HSE: class Annotated ast => ExactP (ast :: Type -> Type)

+ Data.Derive.DSL.HSE: class Parseable ast

+ Data.Derive.DSL.HSE: class Pretty a

+ Data.Derive.DSL.HSE: class SrcInfo si

+ Data.Derive.DSL.HSE: classifyExtension :: String -> Extension

+ Data.Derive.DSL.HSE: classifyLanguage :: String -> Language

+ Data.Derive.DSL.HSE: combSpanInfo :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo

+ Data.Derive.DSL.HSE: combSpanMaybe :: SrcSpanInfo -> Maybe SrcSpanInfo -> SrcSpanInfo

+ Data.Derive.DSL.HSE: con :: String -> Exp ()

+ Data.Derive.DSL.HSE: cplusplus_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: ctorDeclArity :: CtorDecl -> Int

+ Data.Derive.DSL.HSE: ctorDeclFields :: CtorDecl -> FieldDecl

+ Data.Derive.DSL.HSE: ctorDeclName :: CtorDecl -> String

+ Data.Derive.DSL.HSE: ctorDeclName' :: CtorDecl -> Name ()

+ Data.Derive.DSL.HSE: data Activation l

+ Data.Derive.DSL.HSE: data Alt l

+ Data.Derive.DSL.HSE: data Annotation l

+ Data.Derive.DSL.HSE: data Assoc l

+ Data.Derive.DSL.HSE: data Asst l

+ Data.Derive.DSL.HSE: data BangType l

+ Data.Derive.DSL.HSE: data Binds l

+ Data.Derive.DSL.HSE: data BooleanFormula l

+ Data.Derive.DSL.HSE: data Boxed

+ Data.Derive.DSL.HSE: data Bracket l

+ Data.Derive.DSL.HSE: data CName l

+ Data.Derive.DSL.HSE: data CallConv l

+ Data.Derive.DSL.HSE: data ClassDecl l

+ Data.Derive.DSL.HSE: data Comment

+ Data.Derive.DSL.HSE: data ConDecl l

+ Data.Derive.DSL.HSE: data Context l

+ Data.Derive.DSL.HSE: data DataOrNew l

+ Data.Derive.DSL.HSE: data Decl l

+ Data.Derive.DSL.HSE: data DeclHead l

+ Data.Derive.DSL.HSE: data DerivStrategy l

+ Data.Derive.DSL.HSE: data Deriving l

+ Data.Derive.DSL.HSE: data EWildcard l

+ Data.Derive.DSL.HSE: data Exp l

+ Data.Derive.DSL.HSE: data ExportSpec l

+ Data.Derive.DSL.HSE: data ExportSpecList l

+ Data.Derive.DSL.HSE: data Extension

+ Data.Derive.DSL.HSE: data FieldUpdate l

+ Data.Derive.DSL.HSE: data Fixity

+ Data.Derive.DSL.HSE: data FunDep l

+ Data.Derive.DSL.HSE: data GadtDecl l

+ Data.Derive.DSL.HSE: data GuardedRhs l

+ Data.Derive.DSL.HSE: data IPBind l

+ Data.Derive.DSL.HSE: data IPName l

+ Data.Derive.DSL.HSE: data ImportDecl l

+ Data.Derive.DSL.HSE: data ImportSpec l

+ Data.Derive.DSL.HSE: data ImportSpecList l

+ Data.Derive.DSL.HSE: data InjectivityInfo l

+ Data.Derive.DSL.HSE: data InstDecl l

+ Data.Derive.DSL.HSE: data InstHead l

+ Data.Derive.DSL.HSE: data InstRule l

+ Data.Derive.DSL.HSE: data Kind l

+ Data.Derive.DSL.HSE: data KnownExtension

+ Data.Derive.DSL.HSE: data Language

+ Data.Derive.DSL.HSE: data ListOf a

+ Data.Derive.DSL.HSE: data Literal l

+ Data.Derive.DSL.HSE: data Loc a

+ Data.Derive.DSL.HSE: data Match l

+ Data.Derive.DSL.HSE: data MaybePromotedName l

+ Data.Derive.DSL.HSE: data Mode

+ Data.Derive.DSL.HSE: data Module l

+ Data.Derive.DSL.HSE: data ModuleHead l

+ Data.Derive.DSL.HSE: data ModuleHeadAndImports l

+ Data.Derive.DSL.HSE: data ModuleName l

+ Data.Derive.DSL.HSE: data ModulePragma l

+ Data.Derive.DSL.HSE: data Name l

+ Data.Derive.DSL.HSE: data Namespace l

+ Data.Derive.DSL.HSE: data Op l

+ Data.Derive.DSL.HSE: data Overlap l

+ Data.Derive.DSL.HSE: data PPHsMode

+ Data.Derive.DSL.HSE: data PPLayout

+ Data.Derive.DSL.HSE: data PXAttr l

+ Data.Derive.DSL.HSE: data ParseMode

+ Data.Derive.DSL.HSE: data ParseResult a

+ Data.Derive.DSL.HSE: data Pat l

+ Data.Derive.DSL.HSE: data PatField l

+ Data.Derive.DSL.HSE: data PatternSynDirection l

+ Data.Derive.DSL.HSE: data PragmasAndModuleHead l

+ Data.Derive.DSL.HSE: data PragmasAndModuleName l

+ Data.Derive.DSL.HSE: data Promoted l

+ Data.Derive.DSL.HSE: data QName l

+ Data.Derive.DSL.HSE: data QOp l

+ Data.Derive.DSL.HSE: data QualConDecl l

+ Data.Derive.DSL.HSE: data QualStmt l

+ Data.Derive.DSL.HSE: data RPat l

+ Data.Derive.DSL.HSE: data RPatOp l

+ Data.Derive.DSL.HSE: data ResultSig l

+ Data.Derive.DSL.HSE: data Rhs l

+ Data.Derive.DSL.HSE: data Role l

+ Data.Derive.DSL.HSE: data Rule l

+ Data.Derive.DSL.HSE: data RuleVar l

+ Data.Derive.DSL.HSE: data Safety l

+ Data.Derive.DSL.HSE: data Sign l

+ Data.Derive.DSL.HSE: data SpecialCon l

+ Data.Derive.DSL.HSE: data Splice l

+ Data.Derive.DSL.HSE: data SrcLoc

+ Data.Derive.DSL.HSE: data SrcSpan

+ Data.Derive.DSL.HSE: data SrcSpanInfo

+ Data.Derive.DSL.HSE: data Stmt l

+ Data.Derive.DSL.HSE: data Style

+ Data.Derive.DSL.HSE: data Token

+ Data.Derive.DSL.HSE: data Tool

+ Data.Derive.DSL.HSE: data TyVarBind l

+ Data.Derive.DSL.HSE: data Type l

+ Data.Derive.DSL.HSE: data TypeEqn l

+ Data.Derive.DSL.HSE: data UnknownPragma

+ Data.Derive.DSL.HSE: data Unpackedness l

+ Data.Derive.DSL.HSE: data WarningText l

+ Data.Derive.DSL.HSE: data XAttr l

+ Data.Derive.DSL.HSE: data XName l

+ Data.Derive.DSL.HSE: dataDeclArity :: DataDecl -> Int

+ Data.Derive.DSL.HSE: dataDeclCtors :: DataDecl -> [CtorDecl]

+ Data.Derive.DSL.HSE: dataDeclFields :: DataDecl -> [String]

+ Data.Derive.DSL.HSE: dataDeclName :: DataDecl -> String

+ Data.Derive.DSL.HSE: dataDeclType :: DataDecl -> Type ()

+ Data.Derive.DSL.HSE: dataDeclVars :: DataDecl -> [String]

+ Data.Derive.DSL.HSE: dataDeclVarsStar :: DataDecl -> [String]

+ Data.Derive.DSL.HSE: declName :: Decl () -> String

+ Data.Derive.DSL.HSE: defaultMode :: PPHsMode

+ Data.Derive.DSL.HSE: defaultParseMode :: ParseMode

+ Data.Derive.DSL.HSE: deprecatedExtensions :: [(Extension, Maybe Extension)]

+ Data.Derive.DSL.HSE: doE :: [Stmt ()] -> Exp ()

+ Data.Derive.DSL.HSE: dot_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: dotnet_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: eList :: Exp ()

+ Data.Derive.DSL.HSE: exactPrint :: ExactP ast => ast SrcSpanInfo -> [Comment] -> String

+ Data.Derive.DSL.HSE: export_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: family_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: fileName :: SrcInfo si => si -> String

+ Data.Derive.DSL.HSE: forall_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: foralls :: Type () -> Type ()

+ Data.Derive.DSL.HSE: fromDeclHead :: DeclHead a -> (Name a, [TyVarBind a])

+ Data.Derive.DSL.HSE: fromIParen :: InstRule a -> InstRule a

+ Data.Derive.DSL.HSE: fromInstHead :: InstHead a -> (QName a, [Type a])

+ Data.Derive.DSL.HSE: fromParseResult :: () => ParseResult a -> a

+ Data.Derive.DSL.HSE: fromSrcInfo :: SrcInfo si => SrcSpanInfo -> si

+ Data.Derive.DSL.HSE: fromTyApps :: Type () -> (Type (), [Type ()])

+ Data.Derive.DSL.HSE: fromTyList :: () => Type l -> Maybe (Type l)

+ Data.Derive.DSL.HSE: fromTyParen :: Type () -> Type ()

+ Data.Derive.DSL.HSE: fromTyParens :: Type () -> Type ()

+ Data.Derive.DSL.HSE: fromTyTuple :: () => Type l -> [Type l]

+ Data.Derive.DSL.HSE: fun_tycon :: () => l -> Type l

+ Data.Derive.DSL.HSE: fun_tycon_name :: () => l -> QName l

+ Data.Derive.DSL.HSE: function :: String -> Exp ()

+ Data.Derive.DSL.HSE: genNames :: String -> Int -> [Name ()]

+ Data.Derive.DSL.HSE: genStmt :: Pat () -> Exp () -> Stmt ()

+ Data.Derive.DSL.HSE: getPointLoc :: SrcInfo si => si -> SrcLoc

+ Data.Derive.DSL.HSE: getTopPragmas :: String -> ParseResult [ModulePragma SrcSpanInfo]

+ Data.Derive.DSL.HSE: ghcDefault :: [Extension]

+ Data.Derive.DSL.HSE: glasgowExts :: [Extension]

+ Data.Derive.DSL.HSE: hiding_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: hole_name :: () => l -> QName l

+ Data.Derive.DSL.HSE: impliesExts :: [KnownExtension] -> [KnownExtension]

+ Data.Derive.DSL.HSE: infix 1 ?

+ Data.Derive.DSL.HSE: infixApp :: Exp () -> QOp () -> Exp () -> Exp ()

+ Data.Derive.DSL.HSE: infix_ :: Int -> [String] -> [Fixity]

+ Data.Derive.DSL.HSE: infixl 4 <+?>

+ Data.Derive.DSL.HSE: infixl 5 <++>

+ Data.Derive.DSL.HSE: infixl 6 <^^>

+ Data.Derive.DSL.HSE: infixl_ :: Int -> [String] -> [Fixity]

+ Data.Derive.DSL.HSE: infixr_ :: Int -> [String] -> [Fixity]

+ Data.Derive.DSL.HSE: infoSpan :: SrcSpan -> [SrcSpan] -> SrcSpanInfo

+ Data.Derive.DSL.HSE: intE :: Integer -> Exp ()

+ Data.Derive.DSL.HSE: intP :: Integer -> Pat ()

+ Data.Derive.DSL.HSE: interruptible_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: isAtom :: () => Exp l -> Bool

+ Data.Derive.DSL.HSE: isDataDecl :: Decl () -> Bool

+ Data.Derive.DSL.HSE: isGuardFalse :: () => Match l -> Bool

+ Data.Derive.DSL.HSE: isIdent :: [Char] -> Bool

+ Data.Derive.DSL.HSE: isNullSpan :: SrcSpan -> Bool

+ Data.Derive.DSL.HSE: isTyFun :: Type () -> Bool

+ Data.Derive.DSL.HSE: isTyParen :: () => Type l -> Bool

+ Data.Derive.DSL.HSE: javascript_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: js_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: jvm_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: knownExtensions :: [Extension]

+ Data.Derive.DSL.HSE: knownLanguages :: [Language]

+ Data.Derive.DSL.HSE: lamE :: [Pat ()] -> Exp () -> Exp ()

+ Data.Derive.DSL.HSE: letE :: [Decl ()] -> Exp () -> Exp ()

+ Data.Derive.DSL.HSE: letStmt :: [Decl ()] -> Stmt ()

+ Data.Derive.DSL.HSE: lexTokenStream :: String -> ParseResult [Loc Token]

+ Data.Derive.DSL.HSE: lexTokenStreamWithMode :: ParseMode -> String -> ParseResult [Loc Token]

+ Data.Derive.DSL.HSE: listE :: [Exp ()] -> Exp ()

+ Data.Derive.DSL.HSE: list_cons_name :: () => l -> QName l

+ Data.Derive.DSL.HSE: list_tycon :: () => l -> Type l

+ Data.Derive.DSL.HSE: list_tycon_name :: () => l -> QName l

+ Data.Derive.DSL.HSE: main_mod :: () => l -> ModuleName l

+ Data.Derive.DSL.HSE: main_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: mergeSrcSpan :: SrcSpan -> SrcSpan -> SrcSpan

+ Data.Derive.DSL.HSE: metaConPat :: String -> [Pat ()] -> Pat ()

+ Data.Derive.DSL.HSE: metaFunction :: String -> [Exp ()] -> Exp ()

+ Data.Derive.DSL.HSE: minus_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan

+ Data.Derive.DSL.HSE: moduleDecls :: () => Module l -> [Decl l]

+ Data.Derive.DSL.HSE: moduleImports :: () => Module l -> [ImportDecl l]

+ Data.Derive.DSL.HSE: moduleName :: () => Module l -> ModuleName l

+ Data.Derive.DSL.HSE: modulePragmas :: () => Module l -> [ModulePragma l]

+ Data.Derive.DSL.HSE: name :: String -> Name ()

+ Data.Derive.DSL.HSE: nameBind :: Name () -> Exp () -> Decl ()

+ Data.Derive.DSL.HSE: newtype NonGreedy a

+ Data.Derive.DSL.HSE: noBinds :: Maybe (Binds ())

+ Data.Derive.DSL.HSE: noInfoSpan :: SrcSpan -> SrcSpanInfo

+ Data.Derive.DSL.HSE: noLoc :: SrcLoc

+ Data.Derive.DSL.HSE: noSl :: Data from => from -> from

+ Data.Derive.DSL.HSE: noSrcSpan :: SrcSpanInfo

+ Data.Derive.DSL.HSE: op :: Name () -> QOp ()

+ Data.Derive.DSL.HSE: pApp :: Name () -> [Pat ()] -> Pat ()

+ Data.Derive.DSL.HSE: pParen :: Pat () -> Pat ()

+ Data.Derive.DSL.HSE: pTuple :: [Pat ()] -> Pat ()

+ Data.Derive.DSL.HSE: pVar :: String -> Pat ()

+ Data.Derive.DSL.HSE: paren :: Exp () -> Exp ()

+ Data.Derive.DSL.HSE: parse :: Parseable ast => String -> ParseResult ast

+ Data.Derive.DSL.HSE: parseDecl :: String -> ParseResult (Decl SrcSpanInfo)

+ Data.Derive.DSL.HSE: parseDeclWithComments :: ParseMode -> String -> ParseResult (Decl SrcSpanInfo, [Comment])

+ Data.Derive.DSL.HSE: parseDeclWithMode :: ParseMode -> String -> ParseResult (Decl SrcSpanInfo)

+ Data.Derive.DSL.HSE: parseExp :: String -> ParseResult (Exp SrcSpanInfo)

+ Data.Derive.DSL.HSE: parseExpWithComments :: ParseMode -> String -> ParseResult (Exp SrcSpanInfo, [Comment])

+ Data.Derive.DSL.HSE: parseExpWithMode :: ParseMode -> String -> ParseResult (Exp SrcSpanInfo)

+ Data.Derive.DSL.HSE: parseExtension :: String -> Extension

+ Data.Derive.DSL.HSE: parseFile :: FilePath -> IO (ParseResult (Module SrcSpanInfo))

+ Data.Derive.DSL.HSE: parseFileContents :: String -> ParseResult (Module SrcSpanInfo)

+ Data.Derive.DSL.HSE: parseFileContentsWithComments :: ParseMode -> String -> ParseResult (Module SrcSpanInfo, [Comment])

+ Data.Derive.DSL.HSE: parseFileContentsWithExts :: [Extension] -> String -> ParseResult (Module SrcSpanInfo)

+ Data.Derive.DSL.HSE: parseFileContentsWithMode :: ParseMode -> String -> ParseResult (Module SrcSpanInfo)

+ Data.Derive.DSL.HSE: parseFileWithComments :: ParseMode -> FilePath -> IO (ParseResult (Module SrcSpanInfo, [Comment]))

+ Data.Derive.DSL.HSE: parseFileWithCommentsAndPragmas :: ParseMode -> FilePath -> IO (ParseResult (Module SrcSpanInfo, [Comment], [UnknownPragma]))

+ Data.Derive.DSL.HSE: parseFileWithExts :: [Extension] -> FilePath -> IO (ParseResult (Module SrcSpanInfo))

+ Data.Derive.DSL.HSE: parseFileWithMode :: ParseMode -> FilePath -> IO (ParseResult (Module SrcSpanInfo))

+ Data.Derive.DSL.HSE: parseImportDecl :: String -> ParseResult (ImportDecl SrcSpanInfo)

+ Data.Derive.DSL.HSE: parseImportDeclWithComments :: ParseMode -> String -> ParseResult (ImportDecl SrcSpanInfo, [Comment])

+ Data.Derive.DSL.HSE: parseImportDeclWithMode :: ParseMode -> String -> ParseResult (ImportDecl SrcSpanInfo)

+ Data.Derive.DSL.HSE: parseModule :: String -> ParseResult (Module SrcSpanInfo)

+ Data.Derive.DSL.HSE: parseModuleWithComments :: ParseMode -> String -> ParseResult (Module SrcSpanInfo, [Comment])

+ Data.Derive.DSL.HSE: parseModuleWithMode :: ParseMode -> String -> ParseResult (Module SrcSpanInfo)

+ Data.Derive.DSL.HSE: parsePat :: String -> ParseResult (Pat SrcSpanInfo)

+ Data.Derive.DSL.HSE: parsePatWithComments :: ParseMode -> String -> ParseResult (Pat SrcSpanInfo, [Comment])

+ Data.Derive.DSL.HSE: parsePatWithMode :: ParseMode -> String -> ParseResult (Pat SrcSpanInfo)

+ Data.Derive.DSL.HSE: parseStmt :: String -> ParseResult (Stmt SrcSpanInfo)

+ Data.Derive.DSL.HSE: parseStmtWithComments :: ParseMode -> String -> ParseResult (Stmt SrcSpanInfo, [Comment])

+ Data.Derive.DSL.HSE: parseStmtWithMode :: ParseMode -> String -> ParseResult (Stmt SrcSpanInfo)

+ Data.Derive.DSL.HSE: parseType :: String -> ParseResult (Type SrcSpanInfo)

+ Data.Derive.DSL.HSE: parseTypeWithComments :: ParseMode -> String -> ParseResult (Type SrcSpanInfo, [Comment])

+ Data.Derive.DSL.HSE: parseTypeWithMode :: ParseMode -> String -> ParseResult (Type SrcSpanInfo)

+ Data.Derive.DSL.HSE: parseWithComments :: Parseable ast => ParseMode -> String -> ParseResult (ast, [Comment])

+ Data.Derive.DSL.HSE: parseWithMode :: Parseable ast => ParseMode -> String -> ParseResult ast

+ Data.Derive.DSL.HSE: patBind :: Pat () -> Exp () -> Decl ()

+ Data.Derive.DSL.HSE: patBindWhere :: Pat () -> Exp () -> [Decl ()] -> Decl ()

+ Data.Derive.DSL.HSE: peList :: Pat ()

+ Data.Derive.DSL.HSE: preludeFixities :: [Fixity]

+ Data.Derive.DSL.HSE: prelude_mod :: () => l -> ModuleName l

+ Data.Derive.DSL.HSE: prettyExtension :: Extension -> String

+ Data.Derive.DSL.HSE: prettyLanguage :: Language -> String

+ Data.Derive.DSL.HSE: prettyPrim :: Pretty a => a -> Doc

+ Data.Derive.DSL.HSE: prettyPrimWithMode :: Pretty a => PPHsMode -> a -> Doc

+ Data.Derive.DSL.HSE: prettyPrint :: Pretty a => a -> String

+ Data.Derive.DSL.HSE: prettyPrintStyleMode :: Pretty a => Style -> PPHsMode -> a -> String

+ Data.Derive.DSL.HSE: prettyPrintWithMode :: Pretty a => PPHsMode -> a -> String

+ Data.Derive.DSL.HSE: pvar :: Name () -> Pat ()

+ Data.Derive.DSL.HSE: pvarTuple :: [Name ()] -> Pat ()

+ Data.Derive.DSL.HSE: qname :: String -> QName ()

+ Data.Derive.DSL.HSE: qualStmt :: Exp () -> Stmt ()

+ Data.Derive.DSL.HSE: qualified_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: qvar :: ModuleName () -> Name () -> Exp ()

+ Data.Derive.DSL.HSE: qvop :: String -> QOp ()

+ Data.Derive.DSL.HSE: readExtensions :: String -> Maybe (Maybe Language, [Extension])

+ Data.Derive.DSL.HSE: rename :: QName () -> QName ()

+ Data.Derive.DSL.HSE: role_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: safe_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: sfun :: Name () -> [Name ()] -> Rhs () -> Maybe (Binds ()) -> Decl ()

+ Data.Derive.DSL.HSE: showDecls :: Pretty a => [a] -> String

+ Data.Derive.DSL.HSE: simpleFun :: Name () -> Name () -> Exp () -> Decl ()

+ Data.Derive.DSL.HSE: simplify :: Data a => a -> a

+ Data.Derive.DSL.HSE: sl :: SrcLoc

+ Data.Derive.DSL.HSE: spanSize :: SrcSpan -> (Int, Int)

+ Data.Derive.DSL.HSE: srcSpanEnd :: SrcSpan -> (Int, Int)

+ Data.Derive.DSL.HSE: srcSpanStart :: SrcSpan -> (Int, Int)

+ Data.Derive.DSL.HSE: star_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: startColumn :: SrcInfo si => si -> Int

+ Data.Derive.DSL.HSE: startLine :: SrcInfo si => si -> Int

+ Data.Derive.DSL.HSE: stdcall_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: stock_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: strE :: String -> Exp ()

+ Data.Derive.DSL.HSE: strP :: String -> Pat ()

+ Data.Derive.DSL.HSE: style :: Style

+ Data.Derive.DSL.HSE: sym :: String -> Name ()

+ Data.Derive.DSL.HSE: threadsafe_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: title :: [Char] -> [Char]

+ Data.Derive.DSL.HSE: toExtensionList :: Language -> [Extension] -> [KnownExtension]

+ Data.Derive.DSL.HSE: toSrcInfo :: SrcInfo si => SrcLoc -> [SrcSpan] -> SrcLoc -> si

+ Data.Derive.DSL.HSE: tuple :: [Exp ()] -> Exp ()

+ Data.Derive.DSL.HSE: tuple_con :: () => l -> Boxed -> Int -> Exp l

+ Data.Derive.DSL.HSE: tuple_con_name :: () => l -> Boxed -> Int -> QName l

+ Data.Derive.DSL.HSE: tuple_tycon :: () => l -> Boxed -> Int -> Type l

+ Data.Derive.DSL.HSE: tuple_tycon_name :: () => l -> Boxed -> Int -> QName l

+ Data.Derive.DSL.HSE: tyApp :: Type () -> [Type ()] -> Type ()

+ Data.Derive.DSL.HSE: tyApps :: Type () -> [Type ()] -> Type ()

+ Data.Derive.DSL.HSE: tyCon :: String -> Type ()

+ Data.Derive.DSL.HSE: tyFun :: [Type ()] -> Type ()

+ Data.Derive.DSL.HSE: tyRoot :: Type () -> String

+ Data.Derive.DSL.HSE: tyVar :: String -> Type ()

+ Data.Derive.DSL.HSE: tyVarBind :: String -> TyVarBind ()

+ Data.Derive.DSL.HSE: type CtorDecl = Either (QualConDecl ()) (GadtDecl ())

+ Data.Derive.DSL.HSE: type DataDecl = Decl ()

+ Data.Derive.DSL.HSE: type FieldDecl = [(String, Type ())]

+ Data.Derive.DSL.HSE: type FullDataDecl = (ModuleName (), DataDecl)

+ Data.Derive.DSL.HSE: type Indent = Int

+ Data.Derive.DSL.HSE: unListOf :: () => ListOf a -> [a]

+ Data.Derive.DSL.HSE: unboxed_singleton_con :: () => l -> Exp l

+ Data.Derive.DSL.HSE: unboxed_singleton_con_name :: () => l -> QName l

+ Data.Derive.DSL.HSE: unboxed_singleton_tycon :: () => l -> Type l

+ Data.Derive.DSL.HSE: unboxed_singleton_tycon_name :: () => l -> QName l

+ Data.Derive.DSL.HSE: unit_con :: () => l -> Exp l

+ Data.Derive.DSL.HSE: unit_con_name :: () => l -> QName l

+ Data.Derive.DSL.HSE: unit_tycon :: () => l -> Type l

+ Data.Derive.DSL.HSE: unit_tycon_name :: () => l -> QName l

+ Data.Derive.DSL.HSE: unsafe_name :: () => l -> Name l

+ Data.Derive.DSL.HSE: var :: String -> Exp ()

+ Data.Derive.DSL.HSE: varTuple :: [Name ()] -> Exp ()

+ Data.Derive.DSL.HSE: wildcard :: Pat ()

+ Language.Haskell: (<**) :: SrcSpanInfo -> [SrcSpan] -> SrcSpanInfo

+ Language.Haskell: (<++>) :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo

+ Language.Haskell: (<+?>) :: SrcSpanInfo -> Maybe SrcSpanInfo -> SrcSpanInfo

+ Language.Haskell: (<?+>) :: Maybe SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo

+ Language.Haskell: (<^^>) :: SrcSpan -> SrcSpan -> SrcSpanInfo

+ Language.Haskell: (=~=) :: (Annotated a, Eq (a ())) => a l1 -> a l2 -> Bool

+ Language.Haskell: ANN :: Token

+ Language.Haskell: ActiveFrom :: l -> Int -> Activation l

+ Language.Haskell: ActiveUntil :: l -> Int -> Activation l

+ Language.Haskell: Alt :: l -> Pat l -> Rhs l -> Maybe (Binds l) -> Alt l

+ Language.Haskell: AndFormula :: l -> [BooleanFormula l] -> BooleanFormula l

+ Language.Haskell: Ann :: l -> Name l -> Exp l -> Annotation l

+ Language.Haskell: AnnModulePragma :: l -> Annotation l -> ModulePragma l

+ Language.Haskell: AnnPragma :: l -> Annotation l -> Decl l

+ Language.Haskell: App :: l -> Exp l -> Exp l -> Exp l

+ Language.Haskell: AppA :: l -> Name l -> [Type l] -> Asst l

+ Language.Haskell: Arrows :: KnownExtension

+ Language.Haskell: AssocLeft :: l -> Assoc l

+ Language.Haskell: AssocNone :: l -> Assoc l

+ Language.Haskell: AssocRight :: l -> Assoc l

+ Language.Haskell: At :: Token

+ Language.Haskell: BDecls :: l -> [Decl l] -> Binds l

+ Language.Haskell: BackQuote :: Token

+ Language.Haskell: Backslash :: Token

+ Language.Haskell: BangPatterns :: KnownExtension

+ Language.Haskell: BangedTy :: l -> BangType l

+ Language.Haskell: Bar :: Token

+ Language.Haskell: BinaryLiterals :: KnownExtension

+ Language.Haskell: Boxed :: Boxed

+ Language.Haskell: BracketExp :: l -> Bracket l -> Exp l

+ Language.Haskell: CApi :: l -> CallConv l

+ Language.Haskell: CApiFFI :: KnownExtension

+ Language.Haskell: CCall :: l -> CallConv l

+ Language.Haskell: COMPLETE :: Token

+ Language.Haskell: CORE :: Token

+ Language.Haskell: CPP :: KnownExtension

+ Language.Haskell: CPlusPlus :: l -> CallConv l

+ Language.Haskell: Case :: l -> Exp l -> [Alt l] -> Exp l

+ Language.Haskell: Char :: l -> Char -> String -> Literal l

+ Language.Haskell: Character :: (Char, String) -> Token

+ Language.Haskell: CharacterHash :: (Char, String) -> Token

+ Language.Haskell: ClassA :: l -> QName l -> [Type l] -> Asst l

+ Language.Haskell: ClassDecl :: l -> Maybe (Context l) -> DeclHead l -> [FunDep l] -> Maybe [ClassDecl l] -> Decl l

+ Language.Haskell: ClosedTypeFamDecl :: l -> DeclHead l -> Maybe (ResultSig l) -> Maybe (InjectivityInfo l) -> [TypeEqn l] -> Decl l

+ Language.Haskell: ClsDataFam :: l -> Maybe (Context l) -> DeclHead l -> Maybe (ResultSig l) -> ClassDecl l

+ Language.Haskell: ClsDecl :: l -> Decl l -> ClassDecl l

+ Language.Haskell: ClsDefSig :: l -> Name l -> Type l -> ClassDecl l

+ Language.Haskell: ClsTyDef :: l -> TypeEqn l -> ClassDecl l

+ Language.Haskell: ClsTyFam :: l -> DeclHead l -> Maybe (ResultSig l) -> Maybe (InjectivityInfo l) -> ClassDecl l

+ Language.Haskell: Colon :: Token

+ Language.Haskell: Comma :: Token

+ Language.Haskell: Comment :: Bool -> SrcSpan -> String -> Comment

+ Language.Haskell: CompletePragma :: l -> [Name l] -> Maybe (QName l) -> Decl l

+ Language.Haskell: Con :: l -> QName l -> Exp l

+ Language.Haskell: ConDecl :: l -> Name l -> [Type l] -> ConDecl l

+ Language.Haskell: ConId :: String -> Token

+ Language.Haskell: ConName :: l -> Name l -> CName l

+ Language.Haskell: ConOp :: l -> Name l -> Op l

+ Language.Haskell: ConSym :: String -> Token

+ Language.Haskell: Cons :: l -> SpecialCon l

+ Language.Haskell: ConstrainedClassMethods :: KnownExtension

+ Language.Haskell: ConstraintKinds :: KnownExtension

+ Language.Haskell: CorePragma :: l -> String -> Exp l -> Exp l

+ Language.Haskell: CxEmpty :: l -> Context l

+ Language.Haskell: CxSingle :: l -> Asst l -> Context l

+ Language.Haskell: CxTuple :: l -> [Asst l] -> Context l

+ Language.Haskell: DEPRECATED :: Token

+ Language.Haskell: DHApp :: l -> DeclHead l -> TyVarBind l -> DeclHead l

+ Language.Haskell: DHInfix :: l -> TyVarBind l -> Name l -> DeclHead l

+ Language.Haskell: DHParen :: l -> DeclHead l -> DeclHead l

+ Language.Haskell: DHead :: l -> Name l -> DeclHead l

+ Language.Haskell: DVarId :: [String] -> Token

+ Language.Haskell: DataDecl :: l -> DataOrNew l -> Maybe (Context l) -> DeclHead l -> [QualConDecl l] -> [Deriving l] -> Decl l

+ Language.Haskell: DataFamDecl :: l -> Maybe (Context l) -> DeclHead l -> Maybe (ResultSig l) -> Decl l

+ Language.Haskell: DataInsDecl :: l -> DataOrNew l -> Type l -> [QualConDecl l] -> [Deriving l] -> Decl l

+ Language.Haskell: DataKinds :: KnownExtension

+ Language.Haskell: DataType :: l -> DataOrNew l

+ Language.Haskell: DatatypeContexts :: KnownExtension

+ Language.Haskell: DeclBracket :: l -> [Decl l] -> Bracket l

+ Language.Haskell: DefaultDecl :: l -> [Type l] -> Decl l

+ Language.Haskell: DefaultSignatures :: KnownExtension

+ Language.Haskell: DeprPragmaDecl :: l -> [([Name l], String)] -> Decl l

+ Language.Haskell: DeprText :: l -> String -> WarningText l

+ Language.Haskell: DerivAnyclass :: l -> DerivStrategy l

+ Language.Haskell: DerivDecl :: l -> Maybe (DerivStrategy l) -> Maybe (Overlap l) -> InstRule l -> Decl l

+ Language.Haskell: DerivNewtype :: l -> DerivStrategy l

+ Language.Haskell: DerivStock :: l -> DerivStrategy l

+ Language.Haskell: DeriveAnyClass :: KnownExtension

+ Language.Haskell: DeriveDataTypeable :: KnownExtension

+ Language.Haskell: DeriveFoldable :: KnownExtension

+ Language.Haskell: DeriveFunctor :: KnownExtension

+ Language.Haskell: DeriveGeneric :: KnownExtension

+ Language.Haskell: DeriveTraversable :: KnownExtension

+ Language.Haskell: Deriving :: l -> Maybe (DerivStrategy l) -> [InstRule l] -> Deriving l

+ Language.Haskell: DerivingStrategies :: KnownExtension

+ Language.Haskell: DisableExtension :: KnownExtension -> Extension

+ Language.Haskell: DisambiguateRecordFields :: KnownExtension

+ Language.Haskell: Do :: l -> [Stmt l] -> Exp l

+ Language.Haskell: DoAndIfThenElse :: KnownExtension

+ Language.Haskell: DoRec :: KnownExtension

+ Language.Haskell: Dot :: Token

+ Language.Haskell: DotDot :: Token

+ Language.Haskell: DotNet :: l -> CallConv l

+ Language.Haskell: DoubleArrow :: Token

+ Language.Haskell: DoubleColon :: Token

+ Language.Haskell: DoubleTokHash :: (Rational, String) -> Token

+ Language.Haskell: EAbs :: l -> Namespace l -> QName l -> ExportSpec l

+ Language.Haskell: EModuleContents :: l -> ModuleName l -> ExportSpec l

+ Language.Haskell: EOF :: Token

+ Language.Haskell: EThingWith :: l -> EWildcard l -> QName l -> [CName l] -> ExportSpec l

+ Language.Haskell: EVar :: l -> QName l -> ExportSpec l

+ Language.Haskell: EWildcard :: l -> Int -> EWildcard l

+ Language.Haskell: EmptyCase :: KnownExtension

+ Language.Haskell: EmptyDataDecls :: KnownExtension

+ Language.Haskell: EnableExtension :: KnownExtension -> Extension

+ Language.Haskell: EnumFrom :: l -> Exp l -> Exp l

+ Language.Haskell: EnumFromThen :: l -> Exp l -> Exp l -> Exp l

+ Language.Haskell: EnumFromThenTo :: l -> Exp l -> Exp l -> Exp l -> Exp l

+ Language.Haskell: EnumFromTo :: l -> Exp l -> Exp l -> Exp l

+ Language.Haskell: EqualP :: l -> Type l -> Type l -> Asst l

+ Language.Haskell: Equals :: Token

+ Language.Haskell: Exclamation :: Token

+ Language.Haskell: ExistentialQuantification :: KnownExtension

+ Language.Haskell: ExpBracket :: l -> Exp l -> Bracket l

+ Language.Haskell: ExpTypeSig :: l -> Exp l -> Type l -> Exp l

+ Language.Haskell: ExplicitBidirectional :: l -> [Decl l] -> PatternSynDirection l

+ Language.Haskell: ExplicitForAll :: KnownExtension

+ Language.Haskell: ExplicitNamespaces :: KnownExtension

+ Language.Haskell: ExportSpecList :: l -> [ExportSpec l] -> ExportSpecList l

+ Language.Haskell: ExprHole :: l -> SpecialCon l

+ Language.Haskell: ExtendedDefaultRules :: KnownExtension

+ Language.Haskell: ExtensibleRecords :: KnownExtension

+ Language.Haskell: FieldPun :: l -> QName l -> FieldUpdate l

+ Language.Haskell: FieldUpdate :: l -> QName l -> Exp l -> FieldUpdate l

+ Language.Haskell: FieldWildcard :: l -> FieldUpdate l

+ Language.Haskell: Fixity :: Assoc () -> Int -> QName () -> Fixity

+ Language.Haskell: FlexibleContexts :: KnownExtension

+ Language.Haskell: FlexibleInstances :: KnownExtension

+ Language.Haskell: FloatTok :: (Rational, String) -> Token

+ Language.Haskell: FloatTokHash :: (Rational, String) -> Token

+ Language.Haskell: ForExp :: l -> CallConv l -> Maybe String -> Name l -> Type l -> Decl l

+ Language.Haskell: ForImp :: l -> CallConv l -> Maybe (Safety l) -> Maybe String -> Name l -> Type l -> Decl l

+ Language.Haskell: ForeignFunctionInterface :: KnownExtension

+ Language.Haskell: Frac :: l -> Rational -> String -> Literal l

+ Language.Haskell: FunBind :: l -> [Match l] -> Decl l

+ Language.Haskell: FunCon :: l -> SpecialCon l

+ Language.Haskell: FunDep :: l -> [Name l] -> [Name l] -> FunDep l

+ Language.Haskell: FunctionalDependencies :: KnownExtension

+ Language.Haskell: GADTs :: KnownExtension

+ Language.Haskell: GDataDecl :: l -> DataOrNew l -> Maybe (Context l) -> DeclHead l -> Maybe (Kind l) -> [GadtDecl l] -> [Deriving l] -> Decl l

+ Language.Haskell: GDataInsDecl :: l -> DataOrNew l -> Type l -> Maybe (Kind l) -> [GadtDecl l] -> [Deriving l] -> Decl l

+ Language.Haskell: GENERATED :: Token

+ Language.Haskell: GHC :: Tool

+ Language.Haskell: GHCForeignImportPrim :: KnownExtension

+ Language.Haskell: GadtDecl :: l -> Name l -> Maybe [FieldDecl l] -> Type l -> GadtDecl l

+ Language.Haskell: GenPragma :: l -> String -> (Int, Int) -> (Int, Int) -> Exp l -> Exp l

+ Language.Haskell: GeneralizedNewtypeDeriving :: KnownExtension

+ Language.Haskell: Generator :: l -> Pat l -> Exp l -> Stmt l

+ Language.Haskell: Generics :: KnownExtension

+ Language.Haskell: GroupBy :: l -> Exp l -> QualStmt l

+ Language.Haskell: GroupByUsing :: l -> Exp l -> Exp l -> QualStmt l

+ Language.Haskell: GroupUsing :: l -> Exp l -> QualStmt l

+ Language.Haskell: GuardedRhs :: l -> [Stmt l] -> Exp l -> GuardedRhs l

+ Language.Haskell: GuardedRhss :: l -> [GuardedRhs l] -> Rhs l

+ Language.Haskell: HADDOCK :: Tool

+ Language.Haskell: HUGS :: Tool

+ Language.Haskell: Haskell2010 :: Language

+ Language.Haskell: Haskell98 :: Language

+ Language.Haskell: HaskellAllDisabled :: Language

+ Language.Haskell: HereDocuments :: KnownExtension

+ Language.Haskell: IAbs :: l -> Namespace l -> Name l -> ImportSpec l

+ Language.Haskell: IDupVarId :: String -> Token

+ Language.Haskell: IHApp :: l -> InstHead l -> Type l -> InstHead l

+ Language.Haskell: IHCon :: l -> QName l -> InstHead l

+ Language.Haskell: IHInfix :: l -> Type l -> QName l -> InstHead l

+ Language.Haskell: IHParen :: l -> InstHead l -> InstHead l

+ Language.Haskell: ILinVarId :: String -> Token

+ Language.Haskell: INCOHERENT :: Token

+ Language.Haskell: INLINE :: Bool -> Token

+ Language.Haskell: INLINE_CONLIKE :: Token

+ Language.Haskell: IPBind :: l -> IPName l -> Exp l -> IPBind l

+ Language.Haskell: IPBinds :: l -> [IPBind l] -> Binds l

+ Language.Haskell: IPDup :: l -> String -> IPName l

+ Language.Haskell: IPLin :: l -> String -> IPName l

+ Language.Haskell: IPVar :: l -> IPName l -> Exp l

+ Language.Haskell: IParam :: l -> IPName l -> Type l -> Asst l

+ Language.Haskell: IParen :: l -> InstRule l -> InstRule l

+ Language.Haskell: IRule :: l -> Maybe [TyVarBind l] -> Maybe (Context l) -> InstHead l -> InstRule l

+ Language.Haskell: IThingAll :: l -> Name l -> ImportSpec l

+ Language.Haskell: IThingWith :: l -> Name l -> [CName l] -> ImportSpec l

+ Language.Haskell: IVar :: l -> Name l -> ImportSpec l

+ Language.Haskell: IdSplice :: l -> String -> Splice l

+ Language.Haskell: Ident :: l -> String -> Name l

+ Language.Haskell: If :: l -> Exp l -> Exp l -> Exp l -> Exp l

+ Language.Haskell: ImplicitBidirectional :: PatternSynDirection l

+ Language.Haskell: ImplicitParams :: KnownExtension

+ Language.Haskell: ImplicitPrelude :: KnownExtension

+ Language.Haskell: ImportDecl :: l -> ModuleName l -> Bool -> Bool -> Bool -> Maybe String -> Maybe (ModuleName l) -> Maybe (ImportSpecList l) -> ImportDecl l

+ Language.Haskell: ImportSpecList :: l -> Bool -> [ImportSpec l] -> ImportSpecList l

+ Language.Haskell: ImpredicativeTypes :: KnownExtension

+ Language.Haskell: Incoherent :: l -> Overlap l

+ Language.Haskell: IncoherentInstances :: KnownExtension

+ Language.Haskell: InfixA :: l -> Type l -> QName l -> Type l -> Asst l

+ Language.Haskell: InfixApp :: l -> Exp l -> QOp l -> Exp l -> Exp l

+ Language.Haskell: InfixConDecl :: l -> Type l -> Name l -> Type l -> ConDecl l

+ Language.Haskell: InfixDecl :: l -> Assoc l -> Maybe Int -> [Op l] -> Decl l

+ Language.Haskell: InfixMatch :: l -> Pat l -> Name l -> [Pat l] -> Rhs l -> Maybe (Binds l) -> Match l

+ Language.Haskell: InjectivityInfo :: l -> Name l -> [Name l] -> InjectivityInfo l

+ Language.Haskell: InlineConlikeSig :: l -> Maybe (Activation l) -> QName l -> Decl l

+ Language.Haskell: InlineSig :: l -> Bool -> Maybe (Activation l) -> QName l -> Decl l

+ Language.Haskell: InsData :: l -> DataOrNew l -> Type l -> [QualConDecl l] -> [Deriving l] -> InstDecl l

+ Language.Haskell: InsDecl :: l -> Decl l -> InstDecl l

+ Language.Haskell: InsGData :: l -> DataOrNew l -> Type l -> Maybe (Kind l) -> [GadtDecl l] -> [Deriving l] -> InstDecl l

+ Language.Haskell: InsType :: l -> Type l -> Type l -> InstDecl l

+ Language.Haskell: InstDecl :: l -> Maybe (Overlap l) -> InstRule l -> Maybe [InstDecl l] -> Decl l

+ Language.Haskell: InstSig :: l -> InstRule l -> Decl l

+ Language.Haskell: InstanceSigs :: KnownExtension

+ Language.Haskell: Int :: l -> Integer -> String -> Literal l

+ Language.Haskell: IntTok :: (Integer, String) -> Token

+ Language.Haskell: IntTokHash :: (Integer, String) -> Token

+ Language.Haskell: InterruptibleFFI :: KnownExtension

+ Language.Haskell: JavaScript :: l -> CallConv l

+ Language.Haskell: JavaScriptFFI :: KnownExtension

+ Language.Haskell: Js :: l -> CallConv l

+ Language.Haskell: Jvm :: l -> CallConv l

+ Language.Haskell: KW_Anyclass :: Token

+ Language.Haskell: KW_As :: Token

+ Language.Haskell: KW_By :: Token

+ Language.Haskell: KW_CApi :: Token

+ Language.Haskell: KW_CCall :: Token

+ Language.Haskell: KW_CPlusPlus :: Token

+ Language.Haskell: KW_Case :: Token

+ Language.Haskell: KW_Class :: Token

+ Language.Haskell: KW_Data :: Token

+ Language.Haskell: KW_Default :: Token

+ Language.Haskell: KW_Deriving :: Token

+ Language.Haskell: KW_Do :: Token

+ Language.Haskell: KW_DotNet :: Token

+ Language.Haskell: KW_Else :: Token

+ Language.Haskell: KW_Export :: Token

+ Language.Haskell: KW_Family :: Token

+ Language.Haskell: KW_Forall :: Token

+ Language.Haskell: KW_Foreign :: Token

+ Language.Haskell: KW_Group :: Token

+ Language.Haskell: KW_Hiding :: Token

+ Language.Haskell: KW_If :: Token

+ Language.Haskell: KW_Import :: Token

+ Language.Haskell: KW_In :: Token

+ Language.Haskell: KW_Infix :: Token

+ Language.Haskell: KW_InfixL :: Token

+ Language.Haskell: KW_InfixR :: Token

+ Language.Haskell: KW_Instance :: Token

+ Language.Haskell: KW_Interruptible :: Token

+ Language.Haskell: KW_JavaScript :: Token

+ Language.Haskell: KW_Js :: Token

+ Language.Haskell: KW_Jvm :: Token

+ Language.Haskell: KW_Let :: Token

+ Language.Haskell: KW_MDo :: Token

+ Language.Haskell: KW_Module :: Token

+ Language.Haskell: KW_NewType :: Token

+ Language.Haskell: KW_Of :: Token

+ Language.Haskell: KW_Pattern :: Token

+ Language.Haskell: KW_Proc :: Token

+ Language.Haskell: KW_Qualified :: Token

+ Language.Haskell: KW_Rec :: Token

+ Language.Haskell: KW_Role :: Token

+ Language.Haskell: KW_Safe :: Token

+ Language.Haskell: KW_StdCall :: Token

+ Language.Haskell: KW_Stock :: Token

+ Language.Haskell: KW_Then :: Token

+ Language.Haskell: KW_Threadsafe :: Token

+ Language.Haskell: KW_Type :: Token

+ Language.Haskell: KW_Unsafe :: Token

+ Language.Haskell: KW_Using :: Token

+ Language.Haskell: KW_Where :: Token

+ Language.Haskell: KindApp :: l -> Kind l -> Kind l -> Kind l

+ Language.Haskell: KindFn :: l -> Kind l -> Kind l -> Kind l

+ Language.Haskell: KindList :: l -> Kind l -> Kind l

+ Language.Haskell: KindParen :: l -> Kind l -> Kind l

+ Language.Haskell: KindSig :: l -> Kind l -> ResultSig l

+ Language.Haskell: KindSignatures :: KnownExtension

+ Language.Haskell: KindStar :: l -> Kind l

+ Language.Haskell: KindTuple :: l -> [Kind l] -> Kind l

+ Language.Haskell: KindVar :: l -> QName l -> Kind l

+ Language.Haskell: KindedVar :: l -> Name l -> Kind l -> TyVarBind l

+ Language.Haskell: LANGUAGE :: Token

+ Language.Haskell: LCase :: l -> [Alt l] -> Exp l

+ Language.Haskell: LabelVarId :: String -> Token

+ Language.Haskell: Lambda :: l -> [Pat l] -> Exp l -> Exp l

+ Language.Haskell: LambdaCase :: KnownExtension

+ Language.Haskell: LanguagePragma :: l -> [Name l] -> ModulePragma l

+ Language.Haskell: LazyTy :: l -> BangType l

+ Language.Haskell: LeftArrApp :: l -> Exp l -> Exp l -> Exp l

+ Language.Haskell: LeftArrHighApp :: l -> Exp l -> Exp l -> Exp l

+ Language.Haskell: LeftArrow :: Token

+ Language.Haskell: LeftArrowTail :: Token

+ Language.Haskell: LeftCurly :: Token

+ Language.Haskell: LeftDblArrowTail :: Token

+ Language.Haskell: LeftHashParen :: Token

+ Language.Haskell: LeftMode :: Mode

+ Language.Haskell: LeftParen :: Token

+ Language.Haskell: LeftSection :: l -> Exp l -> QOp l -> Exp l

+ Language.Haskell: LeftSquare :: Token

+ Language.Haskell: Let :: l -> Binds l -> Exp l -> Exp l

+ Language.Haskell: LetStmt :: l -> Binds l -> Stmt l

+ Language.Haskell: LiberalTypeSynonyms :: KnownExtension

+ Language.Haskell: List :: l -> [Exp l] -> Exp l

+ Language.Haskell: ListComp :: l -> Exp l -> [QualStmt l] -> Exp l

+ Language.Haskell: ListCon :: l -> SpecialCon l

+ Language.Haskell: ListOf :: SrcSpanInfo -> [a] -> ListOf a

+ Language.Haskell: Lit :: l -> Literal l -> Exp l

+ Language.Haskell: Loc :: SrcSpan -> a -> Loc a

+ Language.Haskell: MDo :: l -> [Stmt l] -> Exp l

+ Language.Haskell: MINIMAL :: Token

+ Language.Haskell: MagicHash :: KnownExtension

+ Language.Haskell: Match :: l -> Name l -> [Pat l] -> Rhs l -> Maybe (Binds l) -> Match l

+ Language.Haskell: MinimalPragma :: l -> Maybe (BooleanFormula l) -> Decl l

+ Language.Haskell: Minus :: Token

+ Language.Haskell: Module :: l -> Maybe (ModuleHead l) -> [ModulePragma l] -> [ImportDecl l] -> [Decl l] -> Module l

+ Language.Haskell: ModuleAnn :: l -> Exp l -> Annotation l

+ Language.Haskell: ModuleHead :: l -> ModuleName l -> Maybe (WarningText l) -> Maybe (ExportSpecList l) -> ModuleHead l

+ Language.Haskell: ModuleHeadAndImports :: l -> [ModulePragma l] -> Maybe (ModuleHead l) -> [ImportDecl l] -> ModuleHeadAndImports l

+ Language.Haskell: ModuleName :: l -> String -> ModuleName l

+ Language.Haskell: MonoLocalBinds :: KnownExtension

+ Language.Haskell: MonoPatBinds :: KnownExtension

+ Language.Haskell: MonomorphismRestriction :: KnownExtension

+ Language.Haskell: MultiIf :: l -> [GuardedRhs l] -> Exp l

+ Language.Haskell: MultiParamTypeClasses :: KnownExtension

+ Language.Haskell: MultiWayIf :: KnownExtension

+ Language.Haskell: NHC98 :: Tool

+ Language.Haskell: NOUNPACK :: Token

+ Language.Haskell: NO_OVERLAP :: Token

+ Language.Haskell: NPlusKPatterns :: KnownExtension

+ Language.Haskell: NamedFieldPuns :: KnownExtension

+ Language.Haskell: NamedWildCards :: KnownExtension

+ Language.Haskell: NegApp :: l -> Exp l -> Exp l

+ Language.Haskell: Negative :: l -> Sign l

+ Language.Haskell: NewQualifiedOperators :: KnownExtension

+ Language.Haskell: NewType :: l -> DataOrNew l

+ Language.Haskell: NoNamespace :: l -> Namespace l

+ Language.Haskell: NoOverlap :: l -> Overlap l

+ Language.Haskell: NoStrictAnnot :: l -> BangType l

+ Language.Haskell: NoUnpack :: l -> Unpackedness l

+ Language.Haskell: NoUnpackPragma :: l -> Unpackedness l

+ Language.Haskell: NoWildcard :: l -> EWildcard l

+ Language.Haskell: Nominal :: l -> Role l

+ Language.Haskell: NonGreedy :: a -> NonGreedy a

+ Language.Haskell: NondecreasingIndentation :: KnownExtension

+ Language.Haskell: OPTIONS :: (Maybe String, String) -> Token

+ Language.Haskell: OVERLAP :: Token

+ Language.Haskell: OVERLAPPABLE :: Token

+ Language.Haskell: OVERLAPPING :: Token

+ Language.Haskell: OVERLAPS :: Token

+ Language.Haskell: OneLineMode :: Mode

+ Language.Haskell: OptionsPragma :: l -> Maybe Tool -> String -> ModulePragma l

+ Language.Haskell: OrFormula :: l -> [BooleanFormula l] -> BooleanFormula l

+ Language.Haskell: Overlap :: l -> Overlap l

+ Language.Haskell: Overlappable :: l -> Overlap l

+ Language.Haskell: Overlapping :: l -> Overlap l

+ Language.Haskell: OverlappingInstances :: KnownExtension

+ Language.Haskell: Overlaps :: l -> Overlap l

+ Language.Haskell: OverloadedLabel :: l -> String -> Exp l

+ Language.Haskell: OverloadedLabels :: KnownExtension

+ Language.Haskell: OverloadedStrings :: KnownExtension

+ Language.Haskell: PApp :: l -> QName l -> [Pat l] -> Pat l

+ Language.Haskell: PAsPat :: l -> Name l -> Pat l -> Pat l

+ Language.Haskell: PBangPat :: l -> Pat l -> Pat l

+ Language.Haskell: PFieldPat :: l -> QName l -> Pat l -> PatField l

+ Language.Haskell: PFieldPun :: l -> QName l -> PatField l

+ Language.Haskell: PFieldWildcard :: l -> PatField l

+ Language.Haskell: PInfixApp :: l -> Pat l -> QName l -> Pat l -> Pat l

+ Language.Haskell: PIrrPat :: l -> Pat l -> Pat l

+ Language.Haskell: PList :: l -> [Pat l] -> Pat l

+ Language.Haskell: PLit :: l -> Sign l -> Literal l -> Pat l

+ Language.Haskell: PNPlusK :: l -> Name l -> Integer -> Pat l

+ Language.Haskell: PPHsMode :: Indent -> Indent -> Indent -> Indent -> Indent -> Indent -> Indent -> Bool -> PPLayout -> Bool -> PPHsMode

+ Language.Haskell: PPInLine :: PPLayout

+ Language.Haskell: PPNoLayout :: PPLayout

+ Language.Haskell: PPOffsideRule :: PPLayout

+ Language.Haskell: PPSemiColon :: PPLayout

+ Language.Haskell: PParen :: l -> Pat l -> Pat l

+ Language.Haskell: PQuasiQuote :: l -> String -> String -> Pat l

+ Language.Haskell: PRPat :: l -> [RPat l] -> Pat l

+ Language.Haskell: PRec :: l -> QName l -> [PatField l] -> Pat l

+ Language.Haskell: PSplice :: l -> Splice l -> Pat l

+ Language.Haskell: PTuple :: l -> Boxed -> [Pat l] -> Pat l

+ Language.Haskell: PUnboxedSum :: l -> Int -> Int -> Pat l -> Pat l

+ Language.Haskell: PVar :: l -> Name l -> Pat l

+ Language.Haskell: PViewPat :: l -> Exp l -> Pat l -> Pat l

+ Language.Haskell: PWildCard :: l -> Pat l

+ Language.Haskell: PXAttr :: l -> XName l -> Pat l -> PXAttr l

+ Language.Haskell: PXETag :: l -> XName l -> [PXAttr l] -> Maybe (Pat l) -> Pat l

+ Language.Haskell: PXPatTag :: l -> Pat l -> Pat l

+ Language.Haskell: PXPcdata :: l -> String -> Pat l

+ Language.Haskell: PXRPats :: l -> [RPat l] -> Pat l

+ Language.Haskell: PXTag :: l -> XName l -> [PXAttr l] -> Maybe (Pat l) -> [Pat l] -> Pat l

+ Language.Haskell: PackageImports :: KnownExtension

+ Language.Haskell: PageMode :: Mode

+ Language.Haskell: ParArray :: l -> [Exp l] -> Exp l

+ Language.Haskell: ParArrayComp :: l -> Exp l -> [[QualStmt l]] -> Exp l

+ Language.Haskell: ParArrayFromThenTo :: l -> Exp l -> Exp l -> Exp l -> Exp l

+ Language.Haskell: ParArrayFromTo :: l -> Exp l -> Exp l -> Exp l

+ Language.Haskell: ParArrayLeftSquare :: Token

+ Language.Haskell: ParArrayRightSquare :: Token

+ Language.Haskell: ParComp :: l -> Exp l -> [[QualStmt l]] -> Exp l

+ Language.Haskell: ParallelArrays :: KnownExtension

+ Language.Haskell: ParallelListComp :: KnownExtension

+ Language.Haskell: Paren :: l -> Exp l -> Exp l

+ Language.Haskell: ParenA :: l -> Asst l -> Asst l

+ Language.Haskell: ParenFormula :: l -> BooleanFormula l -> BooleanFormula l

+ Language.Haskell: ParenSplice :: l -> Exp l -> Splice l

+ Language.Haskell: ParseFailed :: SrcLoc -> String -> ParseResult a

+ Language.Haskell: ParseMode :: String -> Language -> [Extension] -> Bool -> Bool -> Maybe [Fixity] -> Bool -> ParseMode

+ Language.Haskell: ParseOk :: a -> ParseResult a

+ Language.Haskell: PartialTypeSignatures :: KnownExtension

+ Language.Haskell: PatBind :: l -> Pat l -> Rhs l -> Maybe (Binds l) -> Decl l

+ Language.Haskell: PatBracket :: l -> Pat l -> Bracket l

+ Language.Haskell: PatSyn :: l -> Pat l -> Pat l -> PatternSynDirection l -> Decl l

+ Language.Haskell: PatSynSig :: l -> [Name l] -> Maybe [TyVarBind l] -> Maybe (Context l) -> Maybe (Context l) -> Type l -> Decl l

+ Language.Haskell: PatTypeSig :: l -> Pat l -> Type l -> Pat l

+ Language.Haskell: PatternGuards :: KnownExtension

+ Language.Haskell: PatternNamespace :: l -> Namespace l

+ Language.Haskell: PatternSignatures :: KnownExtension

+ Language.Haskell: PatternSynonyms :: KnownExtension

+ Language.Haskell: Phantom :: l -> Role l

+ Language.Haskell: PlayInterruptible :: l -> Safety l

+ Language.Haskell: PlayRisky :: l -> Safety l

+ Language.Haskell: PlaySafe :: l -> Bool -> Safety l

+ Language.Haskell: PolyKinds :: KnownExtension

+ Language.Haskell: PolymorphicComponents :: KnownExtension

+ Language.Haskell: PostfixOperators :: KnownExtension

+ Language.Haskell: PragmaEnd :: Token

+ Language.Haskell: PragmasAndModuleHead :: l -> [ModulePragma l] -> Maybe (ModuleHead l) -> PragmasAndModuleHead l

+ Language.Haskell: PragmasAndModuleName :: l -> [ModulePragma l] -> Maybe (ModuleName l) -> PragmasAndModuleName l

+ Language.Haskell: PrimChar :: l -> Char -> String -> Literal l

+ Language.Haskell: PrimDouble :: l -> Rational -> String -> Literal l

+ Language.Haskell: PrimFloat :: l -> Rational -> String -> Literal l

+ Language.Haskell: PrimInt :: l -> Integer -> String -> Literal l

+ Language.Haskell: PrimString :: l -> String -> String -> Literal l

+ Language.Haskell: PrimWord :: l -> Integer -> String -> Literal l

+ Language.Haskell: Proc :: l -> Pat l -> Exp l -> Exp l

+ Language.Haskell: PromotedCon :: l -> Bool -> QName l -> Promoted l

+ Language.Haskell: PromotedInteger :: l -> Integer -> String -> Promoted l

+ Language.Haskell: PromotedList :: l -> Bool -> [Type l] -> Promoted l

+ Language.Haskell: PromotedName :: l -> QName l -> MaybePromotedName l

+ Language.Haskell: PromotedString :: l -> String -> String -> Promoted l

+ Language.Haskell: PromotedTuple :: l -> [Type l] -> Promoted l

+ Language.Haskell: PromotedUnit :: l -> Promoted l

+ Language.Haskell: QConId :: (String, String) -> Token

+ Language.Haskell: QConOp :: l -> QName l -> QOp l

+ Language.Haskell: QConSym :: (String, String) -> Token

+ Language.Haskell: QVarId :: (String, String) -> Token

+ Language.Haskell: QVarOp :: l -> QName l -> QOp l

+ Language.Haskell: QVarSym :: (String, String) -> Token

+ Language.Haskell: Qual :: l -> ModuleName l -> Name l -> QName l

+ Language.Haskell: QualConDecl :: l -> Maybe [TyVarBind l] -> Maybe (Context l) -> ConDecl l -> QualConDecl l

+ Language.Haskell: QualStmt :: l -> Stmt l -> QualStmt l

+ Language.Haskell: Qualifier :: l -> Exp l -> Stmt l

+ Language.Haskell: QuasiQuote :: l -> String -> String -> Exp l

+ Language.Haskell: QuasiQuotes :: KnownExtension

+ Language.Haskell: QuoteColon :: Token

+ Language.Haskell: RPAs :: l -> Name l -> RPat l -> RPat l

+ Language.Haskell: RPCAs :: l -> Name l -> RPat l -> RPat l

+ Language.Haskell: RPCAt :: Token

+ Language.Haskell: RPEither :: l -> RPat l -> RPat l -> RPat l

+ Language.Haskell: RPGuard :: l -> Pat l -> [Stmt l] -> RPat l

+ Language.Haskell: RPGuardClose :: Token

+ Language.Haskell: RPGuardOpen :: Token

+ Language.Haskell: RPOp :: l -> RPat l -> RPatOp l -> RPat l

+ Language.Haskell: RPOpt :: l -> RPatOp l

+ Language.Haskell: RPOptG :: l -> RPatOp l

+ Language.Haskell: RPParen :: l -> RPat l -> RPat l

+ Language.Haskell: RPPat :: l -> Pat l -> RPat l

+ Language.Haskell: RPPlus :: l -> RPatOp l

+ Language.Haskell: RPPlusG :: l -> RPatOp l

+ Language.Haskell: RPSeq :: l -> [RPat l] -> RPat l

+ Language.Haskell: RPStar :: l -> RPatOp l

+ Language.Haskell: RPStarG :: l -> RPatOp l

+ Language.Haskell: RULES :: Token

+ Language.Haskell: Rank2Types :: KnownExtension

+ Language.Haskell: RankNTypes :: KnownExtension

+ Language.Haskell: RebindableSyntax :: KnownExtension

+ Language.Haskell: RecConstr :: l -> QName l -> [FieldUpdate l] -> Exp l

+ Language.Haskell: RecDecl :: l -> Name l -> [FieldDecl l] -> ConDecl l

+ Language.Haskell: RecStmt :: l -> [Stmt l] -> Stmt l

+ Language.Haskell: RecUpdate :: l -> Exp l -> [FieldUpdate l] -> Exp l

+ Language.Haskell: RecordPuns :: KnownExtension

+ Language.Haskell: RecordWildCards :: KnownExtension

+ Language.Haskell: RecursiveDo :: KnownExtension

+ Language.Haskell: RegularPatterns :: KnownExtension

+ Language.Haskell: RelaxedPolyRec :: KnownExtension

+ Language.Haskell: Representational :: l -> Role l

+ Language.Haskell: RestrictedTypeSynonyms :: KnownExtension

+ Language.Haskell: RightArrApp :: l -> Exp l -> Exp l -> Exp l

+ Language.Haskell: RightArrHighApp :: l -> Exp l -> Exp l -> Exp l

+ Language.Haskell: RightArrow :: Token

+ Language.Haskell: RightArrowTail :: Token

+ Language.Haskell: RightCurly :: Token

+ Language.Haskell: RightDblArrowTail :: Token

+ Language.Haskell: RightHashParen :: Token

+ Language.Haskell: RightParen :: Token

+ Language.Haskell: RightSection :: l -> QOp l -> Exp l -> Exp l

+ Language.Haskell: RightSquare :: Token

+ Language.Haskell: RoleAnnotDecl :: l -> QName l -> [Role l] -> Decl l

+ Language.Haskell: RoleAnnotations :: KnownExtension

+ Language.Haskell: RoleWildcard :: l -> Role l

+ Language.Haskell: Rule :: l -> String -> Maybe (Activation l) -> Maybe [RuleVar l] -> Exp l -> Exp l -> Rule l

+ Language.Haskell: RulePragmaDecl :: l -> [Rule l] -> Decl l

+ Language.Haskell: RuleVar :: l -> Name l -> RuleVar l

+ Language.Haskell: SCC :: Token

+ Language.Haskell: SCCPragma :: l -> String -> Exp l -> Exp l

+ Language.Haskell: SOURCE :: Token

+ Language.Haskell: SPECIALISE :: Token

+ Language.Haskell: SPECIALISE_INLINE :: Bool -> Token

+ Language.Haskell: Safe :: KnownExtension

+ Language.Haskell: SafeImports :: KnownExtension

+ Language.Haskell: ScopedTypeVariables :: KnownExtension

+ Language.Haskell: SemiColon :: Token

+ Language.Haskell: Signless :: l -> Sign l

+ Language.Haskell: SpecInlineSig :: l -> Bool -> Maybe (Activation l) -> QName l -> [Type l] -> Decl l

+ Language.Haskell: SpecSig :: l -> Maybe (Activation l) -> QName l -> [Type l] -> Decl l

+ Language.Haskell: Special :: l -> SpecialCon l -> QName l

+ Language.Haskell: SpliceDecl :: l -> Exp l -> Decl l

+ Language.Haskell: SpliceExp :: l -> Splice l -> Exp l

+ Language.Haskell: SrcLoc :: String -> Int -> Int -> SrcLoc

+ Language.Haskell: SrcSpan :: String -> Int -> Int -> Int -> Int -> SrcSpan

+ Language.Haskell: SrcSpanInfo :: SrcSpan -> [SrcSpan] -> SrcSpanInfo

+ Language.Haskell: StandaloneDeriving :: KnownExtension

+ Language.Haskell: Star :: Token

+ Language.Haskell: StdCall :: l -> CallConv l

+ Language.Haskell: String :: l -> String -> String -> Literal l

+ Language.Haskell: StringHash :: (String, String) -> Token

+ Language.Haskell: StringTok :: (String, String) -> Token

+ Language.Haskell: Style :: Mode -> Int -> Float -> Style

+ Language.Haskell: Symbol :: l -> String -> Name l

+ Language.Haskell: TApp :: Token

+ Language.Haskell: THCloseQuote :: Token

+ Language.Haskell: THDecQuote :: Token

+ Language.Haskell: THExpQuote :: Token

+ Language.Haskell: THIdEscape :: String -> Token

+ Language.Haskell: THParenEscape :: Token

+ Language.Haskell: THPatQuote :: Token

+ Language.Haskell: THQuasiQuote :: (String, String) -> Token

+ Language.Haskell: THTyQuote :: Token

+ Language.Haskell: THTypQuote :: Token

+ Language.Haskell: THVarQuote :: Token

+ Language.Haskell: TemplateHaskell :: KnownExtension

+ Language.Haskell: ThenBy :: l -> Exp l -> Exp l -> QualStmt l

+ Language.Haskell: ThenTrans :: l -> Exp l -> QualStmt l

+ Language.Haskell: Tilde :: Token

+ Language.Haskell: TransformListComp :: KnownExtension

+ Language.Haskell: Trustworthy :: KnownExtension

+ Language.Haskell: Tuple :: l -> Boxed -> [Exp l] -> Exp l

+ Language.Haskell: TupleCon :: l -> Boxed -> Int -> SpecialCon l

+ Language.Haskell: TupleSection :: l -> Boxed -> [Maybe (Exp l)] -> Exp l

+ Language.Haskell: TupleSections :: KnownExtension

+ Language.Haskell: TyApp :: l -> Type l -> Type l -> Type l

+ Language.Haskell: TyBang :: l -> BangType l -> Unpackedness l -> Type l -> Type l

+ Language.Haskell: TyCon :: l -> QName l -> Type l

+ Language.Haskell: TyEquals :: l -> Type l -> Type l -> Type l

+ Language.Haskell: TyForall :: l -> Maybe [TyVarBind l] -> Maybe (Context l) -> Type l -> Type l

+ Language.Haskell: TyFun :: l -> Type l -> Type l -> Type l

+ Language.Haskell: TyInfix :: l -> Type l -> MaybePromotedName l -> Type l -> Type l

+ Language.Haskell: TyKind :: l -> Type l -> Kind l -> Type l

+ Language.Haskell: TyList :: l -> Type l -> Type l

+ Language.Haskell: TyParArray :: l -> Type l -> Type l

+ Language.Haskell: TyParen :: l -> Type l -> Type l

+ Language.Haskell: TyPromoted :: l -> Promoted l -> Type l

+ Language.Haskell: TyQuasiQuote :: l -> String -> String -> Type l

+ Language.Haskell: TySplice :: l -> Splice l -> Type l

+ Language.Haskell: TyTuple :: l -> Boxed -> [Type l] -> Type l

+ Language.Haskell: TyUnboxedSum :: l -> [Type l] -> Type l

+ Language.Haskell: TyVar :: l -> Name l -> Type l

+ Language.Haskell: TyVarSig :: l -> TyVarBind l -> ResultSig l

+ Language.Haskell: TyWildCard :: l -> Maybe (Name l) -> Type l

+ Language.Haskell: TypQuote :: l -> QName l -> Exp l

+ Language.Haskell: TypeAnn :: l -> Name l -> Exp l -> Annotation l

+ Language.Haskell: TypeApp :: l -> Type l -> Exp l

+ Language.Haskell: TypeApplications :: KnownExtension

+ Language.Haskell: TypeBracket :: l -> Type l -> Bracket l

+ Language.Haskell: TypeDecl :: l -> DeclHead l -> Type l -> Decl l

+ Language.Haskell: TypeEqn :: l -> Type l -> Type l -> TypeEqn l

+ Language.Haskell: TypeFamDecl :: l -> DeclHead l -> Maybe (ResultSig l) -> Maybe (InjectivityInfo l) -> Decl l

+ Language.Haskell: TypeFamilies :: KnownExtension

+ Language.Haskell: TypeFamilyDependencies :: KnownExtension

+ Language.Haskell: TypeInsDecl :: l -> Type l -> Type l -> Decl l

+ Language.Haskell: TypeNamespace :: l -> Namespace l

+ Language.Haskell: TypeOperators :: KnownExtension

+ Language.Haskell: TypeSig :: l -> [Name l] -> Type l -> Decl l

+ Language.Haskell: TypeSynonymInstances :: KnownExtension

+ Language.Haskell: TypedRuleVar :: l -> Name l -> Type l -> RuleVar l

+ Language.Haskell: UNPACK :: Token

+ Language.Haskell: UnGuardedRhs :: l -> Exp l -> Rhs l

+ Language.Haskell: UnQual :: l -> Name l -> QName l

+ Language.Haskell: Unboxed :: Boxed

+ Language.Haskell: UnboxedSingleCon :: l -> SpecialCon l

+ Language.Haskell: UnboxedSum :: l -> Int -> Int -> Exp l -> Exp l

+ Language.Haskell: UnboxedSums :: KnownExtension

+ Language.Haskell: UnboxedTuples :: KnownExtension

+ Language.Haskell: UndecidableInstances :: KnownExtension

+ Language.Haskell: Underscore :: Token

+ Language.Haskell: UnicodeSyntax :: KnownExtension

+ Language.Haskell: Unidirectional :: PatternSynDirection l

+ Language.Haskell: UnitCon :: l -> SpecialCon l

+ Language.Haskell: UnkindedVar :: l -> Name l -> TyVarBind l

+ Language.Haskell: UnknownExtension :: String -> Extension

+ Language.Haskell: UnknownLanguage :: String -> Language

+ Language.Haskell: UnknownPragma :: SrcSpan -> String -> UnknownPragma

+ Language.Haskell: UnknownTool :: String -> Tool

+ Language.Haskell: UnliftedFFITypes :: KnownExtension

+ Language.Haskell: Unpack :: l -> Unpackedness l

+ Language.Haskell: UnpromotedName :: l -> QName l -> MaybePromotedName l

+ Language.Haskell: VRightCurly :: Token

+ Language.Haskell: Var :: l -> QName l -> Exp l

+ Language.Haskell: VarFormula :: l -> Name l -> BooleanFormula l

+ Language.Haskell: VarId :: String -> Token

+ Language.Haskell: VarName :: l -> Name l -> CName l

+ Language.Haskell: VarOp :: l -> Name l -> Op l

+ Language.Haskell: VarQuote :: l -> QName l -> Exp l

+ Language.Haskell: VarSym :: String -> Token

+ Language.Haskell: ViewPatterns :: KnownExtension

+ Language.Haskell: WARNING :: Token

+ Language.Haskell: WarnPragmaDecl :: l -> [([Name l], String)] -> Decl l

+ Language.Haskell: WarnText :: l -> String -> WarningText l

+ Language.Haskell: WildCardA :: l -> Maybe (Name l) -> Asst l

+ Language.Haskell: WordTokHash :: (Integer, String) -> Token

+ Language.Haskell: XAttr :: l -> XName l -> Exp l -> XAttr l

+ Language.Haskell: XChildTag :: l -> [Exp l] -> Exp l

+ Language.Haskell: XChildTagOpen :: Token

+ Language.Haskell: XCloseTagOpen :: Token

+ Language.Haskell: XCodeTagClose :: Token

+ Language.Haskell: XCodeTagOpen :: Token

+ Language.Haskell: XDomName :: l -> String -> String -> XName l

+ Language.Haskell: XETag :: l -> XName l -> [XAttr l] -> Maybe (Exp l) -> Exp l

+ Language.Haskell: XEmptyTagClose :: Token

+ Language.Haskell: XExpTag :: l -> Exp l -> Exp l

+ Language.Haskell: XName :: l -> String -> XName l

+ Language.Haskell: XPCDATA :: String -> Token

+ Language.Haskell: XPcdata :: l -> String -> Exp l

+ Language.Haskell: XRPatClose :: Token

+ Language.Haskell: XRPatOpen :: Token

+ Language.Haskell: XStdTagClose :: Token

+ Language.Haskell: XStdTagOpen :: Token

+ Language.Haskell: XTag :: l -> XName l -> [XAttr l] -> Maybe (Exp l) -> [Exp l] -> Exp l

+ Language.Haskell: XmlHybrid :: l -> Maybe (ModuleHead l) -> [ModulePragma l] -> [ImportDecl l] -> [Decl l] -> XName l -> [XAttr l] -> Maybe (Exp l) -> [Exp l] -> Module l

+ Language.Haskell: XmlPage :: l -> ModuleName l -> [ModulePragma l] -> XName l -> [XAttr l] -> Maybe (Exp l) -> [Exp l] -> Module l

+ Language.Haskell: XmlSyntax :: KnownExtension

+ Language.Haskell: YHC :: Tool

+ Language.Haskell: ZigZagMode :: Mode

+ Language.Haskell: [baseLanguage] :: ParseMode -> Language

+ Language.Haskell: [caseIndent] :: PPHsMode -> Indent

+ Language.Haskell: [classIndent] :: PPHsMode -> Indent

+ Language.Haskell: [doIndent] :: PPHsMode -> Indent

+ Language.Haskell: [extensions] :: ParseMode -> [Extension]

+ Language.Haskell: [fixities] :: ParseMode -> Maybe [Fixity]

+ Language.Haskell: [ignoreFunctionArity] :: ParseMode -> Bool

+ Language.Haskell: [ignoreLanguagePragmas] :: ParseMode -> Bool

+ Language.Haskell: [ignoreLinePragmas] :: ParseMode -> Bool

+ Language.Haskell: [importAnn] :: ImportDecl l -> l

+ Language.Haskell: [importAs] :: ImportDecl l -> Maybe (ModuleName l)

+ Language.Haskell: [importModule] :: ImportDecl l -> ModuleName l

+ Language.Haskell: [importPkg] :: ImportDecl l -> Maybe String

+ Language.Haskell: [importQualified] :: ImportDecl l -> Bool

+ Language.Haskell: [importSafe] :: ImportDecl l -> Bool

+ Language.Haskell: [importSpecs] :: ImportDecl l -> Maybe (ImportSpecList l)

+ Language.Haskell: [importSrc] :: ImportDecl l -> Bool

+ Language.Haskell: [layout] :: PPHsMode -> PPLayout

+ Language.Haskell: [letIndent] :: PPHsMode -> Indent

+ Language.Haskell: [lineLength] :: Style -> Int

+ Language.Haskell: [linePragmas] :: PPHsMode -> Bool

+ Language.Haskell: [loc] :: Loc a -> SrcSpan

+ Language.Haskell: [mode] :: Style -> Mode

+ Language.Haskell: [multiIfIndent] :: PPHsMode -> Indent

+ Language.Haskell: [onsideIndent] :: PPHsMode -> Indent

+ Language.Haskell: [parseFilename] :: ParseMode -> String

+ Language.Haskell: [ribbonsPerLine] :: Style -> Float

+ Language.Haskell: [spacing] :: PPHsMode -> Bool

+ Language.Haskell: [srcColumn] :: SrcLoc -> Int

+ Language.Haskell: [srcFilename] :: SrcLoc -> String

+ Language.Haskell: [srcInfoPoints] :: SrcSpanInfo -> [SrcSpan]

+ Language.Haskell: [srcInfoSpan] :: SrcSpanInfo -> SrcSpan

+ Language.Haskell: [srcLine] :: SrcLoc -> Int

+ Language.Haskell: [srcSpanEndColumn] :: SrcSpan -> Int

+ Language.Haskell: [srcSpanEndLine] :: SrcSpan -> Int

+ Language.Haskell: [srcSpanFilename] :: SrcSpan -> String

+ Language.Haskell: [srcSpanStartColumn] :: SrcSpan -> Int

+ Language.Haskell: [srcSpanStartLine] :: SrcSpan -> Int

+ Language.Haskell: [unLoc] :: Loc a -> a

+ Language.Haskell: [unNonGreedy] :: NonGreedy a -> a

+ Language.Haskell: [whereIndent] :: PPHsMode -> Indent

+ Language.Haskell: alt :: Pat () -> Exp () -> Alt ()

+ Language.Haskell: altGW :: Pat () -> [Stmt ()] -> Exp () -> Binds () -> Alt ()

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

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

+ Language.Haskell: anyclass_name :: () => l -> Name l

+ Language.Haskell: appFun :: Exp () -> [Exp ()] -> Exp ()

+ Language.Haskell: applyFixities :: (AppFixity ast, Monad m) => [Fixity] -> ast SrcSpanInfo -> m (ast SrcSpanInfo)

+ Language.Haskell: as_name :: () => l -> Name l

+ Language.Haskell: associateHaddock :: (Annotated ast, Traversable ast) => (ast SrcSpanInfo, [Comment]) -> ast (SrcSpanInfo, [Comment])

+ Language.Haskell: bang_name :: () => l -> Name l

+ Language.Haskell: baseFixities :: [Fixity]

+ Language.Haskell: capi_name :: () => l -> Name l

+ Language.Haskell: caseE :: Exp () -> [Alt ()] -> Exp ()

+ Language.Haskell: ccall_name :: () => l -> Name l

+ Language.Haskell: charE :: Char -> Exp ()

+ Language.Haskell: charP :: Char -> Pat ()

+ Language.Haskell: class Functor ast => Annotated (ast :: Type -> Type)

+ Language.Haskell: class AppFixity (ast :: Type -> Type)

+ Language.Haskell: class Annotated ast => ExactP (ast :: Type -> Type)

+ Language.Haskell: class Parseable ast

+ Language.Haskell: class Pretty a

+ Language.Haskell: class SrcInfo si

+ Language.Haskell: classifyExtension :: String -> Extension

+ Language.Haskell: classifyLanguage :: String -> Language

+ Language.Haskell: combSpanInfo :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo

+ Language.Haskell: combSpanMaybe :: SrcSpanInfo -> Maybe SrcSpanInfo -> SrcSpanInfo

+ Language.Haskell: cplusplus_name :: () => l -> Name l

+ Language.Haskell: data Activation l

+ Language.Haskell: data Alt l

+ Language.Haskell: data Annotation l

+ Language.Haskell: data Assoc l

+ Language.Haskell: data Asst l

+ Language.Haskell: data BangType l

+ Language.Haskell: data Binds l

+ Language.Haskell: data BooleanFormula l

+ Language.Haskell: data Boxed

+ Language.Haskell: data Bracket l

+ Language.Haskell: data CName l

+ Language.Haskell: data CallConv l

+ Language.Haskell: data ClassDecl l

+ Language.Haskell: data Comment

+ Language.Haskell: data ConDecl l

+ Language.Haskell: data Context l

+ Language.Haskell: data DataOrNew l

+ Language.Haskell: data Decl l

+ Language.Haskell: data DeclHead l

+ Language.Haskell: data DerivStrategy l

+ Language.Haskell: data Deriving l

+ Language.Haskell: data EWildcard l

+ Language.Haskell: data Exp l

+ Language.Haskell: data ExportSpec l

+ Language.Haskell: data ExportSpecList l

+ Language.Haskell: data Extension

+ Language.Haskell: data FieldUpdate l

+ Language.Haskell: data Fixity

+ Language.Haskell: data FunDep l

+ Language.Haskell: data GadtDecl l

+ Language.Haskell: data GuardedRhs l

+ Language.Haskell: data IPBind l

+ Language.Haskell: data IPName l

+ Language.Haskell: data ImportDecl l

+ Language.Haskell: data ImportSpec l

+ Language.Haskell: data ImportSpecList l

+ Language.Haskell: data InjectivityInfo l

+ Language.Haskell: data InstDecl l

+ Language.Haskell: data InstHead l

+ Language.Haskell: data InstRule l

+ Language.Haskell: data Kind l

+ Language.Haskell: data KnownExtension

+ Language.Haskell: data Language

+ Language.Haskell: data ListOf a

+ Language.Haskell: data Literal l

+ Language.Haskell: data Loc a

+ Language.Haskell: data Match l

+ Language.Haskell: data MaybePromotedName l

+ Language.Haskell: data Mode

+ Language.Haskell: data Module l

+ Language.Haskell: data ModuleHead l

+ Language.Haskell: data ModuleHeadAndImports l

+ Language.Haskell: data ModuleName l

+ Language.Haskell: data ModulePragma l

+ Language.Haskell: data Name l

+ Language.Haskell: data Namespace l

+ Language.Haskell: data Op l

+ Language.Haskell: data Overlap l

+ Language.Haskell: data PPHsMode

+ Language.Haskell: data PPLayout

+ Language.Haskell: data PXAttr l

+ Language.Haskell: data ParseMode

+ Language.Haskell: data ParseResult a

+ Language.Haskell: data Pat l

+ Language.Haskell: data PatField l

+ Language.Haskell: data PatternSynDirection l

+ Language.Haskell: data PragmasAndModuleHead l

+ Language.Haskell: data PragmasAndModuleName l

+ Language.Haskell: data Promoted l

+ Language.Haskell: data QName l

+ Language.Haskell: data QOp l

+ Language.Haskell: data QualConDecl l

+ Language.Haskell: data QualStmt l

+ Language.Haskell: data RPat l

+ Language.Haskell: data RPatOp l

+ Language.Haskell: data ResultSig l

+ Language.Haskell: data Rhs l

+ Language.Haskell: data Role l

+ Language.Haskell: data Rule l

+ Language.Haskell: data RuleVar l

+ Language.Haskell: data Safety l

+ Language.Haskell: data Sign l

+ Language.Haskell: data SpecialCon l

+ Language.Haskell: data Splice l

+ Language.Haskell: data SrcLoc

+ Language.Haskell: data SrcSpan

+ Language.Haskell: data SrcSpanInfo

+ Language.Haskell: data Stmt l

+ Language.Haskell: data Style

+ Language.Haskell: data Token

+ Language.Haskell: data Tool

+ Language.Haskell: data TyVarBind l

+ Language.Haskell: data Type l

+ Language.Haskell: data TypeEqn l

+ Language.Haskell: data UnknownPragma

+ Language.Haskell: data Unpackedness l

+ Language.Haskell: data WarningText l

+ Language.Haskell: data XAttr l

+ Language.Haskell: data XName l

+ Language.Haskell: defaultMode :: PPHsMode

+ Language.Haskell: defaultParseMode :: ParseMode

+ Language.Haskell: deprecatedExtensions :: [(Extension, Maybe Extension)]

+ Language.Haskell: doE :: [Stmt ()] -> Exp ()

+ Language.Haskell: dot_name :: () => l -> Name l

+ Language.Haskell: dotnet_name :: () => l -> Name l

+ Language.Haskell: eList :: Exp ()

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

+ Language.Haskell: export_name :: () => l -> Name l

+ Language.Haskell: family_name :: () => l -> Name l

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

+ Language.Haskell: forall_name :: () => l -> Name l

+ Language.Haskell: fromParseResult :: () => ParseResult a -> a

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

+ Language.Haskell: fun_tycon :: () => l -> Type l

+ Language.Haskell: fun_tycon_name :: () => l -> QName l

+ Language.Haskell: function :: String -> Exp ()

+ Language.Haskell: genNames :: String -> Int -> [Name ()]

+ Language.Haskell: genStmt :: Pat () -> Exp () -> Stmt ()

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

+ Language.Haskell: getTopPragmas :: String -> ParseResult [ModulePragma SrcSpanInfo]

+ Language.Haskell: ghcDefault :: [Extension]

+ Language.Haskell: glasgowExts :: [Extension]

+ Language.Haskell: hiding_name :: () => l -> Name l

+ Language.Haskell: hole_name :: () => l -> QName l

+ Language.Haskell: impliesExts :: [KnownExtension] -> [KnownExtension]

+ Language.Haskell: infixApp :: Exp () -> QOp () -> Exp () -> Exp ()

+ Language.Haskell: infix_ :: Int -> [String] -> [Fixity]

+ Language.Haskell: infixl 4 <+?>

+ Language.Haskell: infixl 5 <++>

+ Language.Haskell: infixl 6 <^^>

+ Language.Haskell: infixl_ :: Int -> [String] -> [Fixity]

+ Language.Haskell: infixr_ :: Int -> [String] -> [Fixity]

+ Language.Haskell: infoSpan :: SrcSpan -> [SrcSpan] -> SrcSpanInfo

+ Language.Haskell: intE :: Integer -> Exp ()

+ Language.Haskell: intP :: Integer -> Pat ()

+ Language.Haskell: interruptible_name :: () => l -> Name l

+ Language.Haskell: isNullSpan :: SrcSpan -> Bool

+ Language.Haskell: javascript_name :: () => l -> Name l

+ Language.Haskell: js_name :: () => l -> Name l

+ Language.Haskell: jvm_name :: () => l -> Name l

+ Language.Haskell: knownExtensions :: [Extension]

+ Language.Haskell: knownLanguages :: [Language]

+ Language.Haskell: lamE :: [Pat ()] -> Exp () -> Exp ()

+ Language.Haskell: letE :: [Decl ()] -> Exp () -> Exp ()

+ Language.Haskell: letStmt :: [Decl ()] -> Stmt ()

+ Language.Haskell: lexTokenStream :: String -> ParseResult [Loc Token]

+ Language.Haskell: lexTokenStreamWithMode :: ParseMode -> String -> ParseResult [Loc Token]

+ Language.Haskell: listE :: [Exp ()] -> Exp ()

+ Language.Haskell: list_cons_name :: () => l -> QName l

+ Language.Haskell: list_tycon :: () => l -> Type l

+ Language.Haskell: list_tycon_name :: () => l -> QName l

+ Language.Haskell: main_mod :: () => l -> ModuleName l

+ Language.Haskell: main_name :: () => l -> Name l

+ Language.Haskell: mergeSrcSpan :: SrcSpan -> SrcSpan -> SrcSpan

+ Language.Haskell: metaConPat :: String -> [Pat ()] -> Pat ()

+ Language.Haskell: metaFunction :: String -> [Exp ()] -> Exp ()

+ Language.Haskell: minus_name :: () => l -> Name l

+ Language.Haskell: mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan

+ Language.Haskell: name :: String -> Name ()

+ Language.Haskell: nameBind :: Name () -> Exp () -> Decl ()

+ Language.Haskell: newtype NonGreedy a

+ Language.Haskell: noBinds :: Maybe (Binds ())

+ Language.Haskell: noInfoSpan :: SrcSpan -> SrcSpanInfo

+ Language.Haskell: noLoc :: SrcLoc

+ Language.Haskell: noSrcSpan :: SrcSpanInfo

+ Language.Haskell: op :: Name () -> QOp ()

+ Language.Haskell: pApp :: Name () -> [Pat ()] -> Pat ()

+ Language.Haskell: pParen :: Pat () -> Pat ()

+ Language.Haskell: pTuple :: [Pat ()] -> Pat ()

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

+ Language.Haskell: parseDecl :: String -> ParseResult (Decl SrcSpanInfo)

+ Language.Haskell: parseDeclWithComments :: ParseMode -> String -> ParseResult (Decl SrcSpanInfo, [Comment])

+ Language.Haskell: parseDeclWithMode :: ParseMode -> String -> ParseResult (Decl SrcSpanInfo)

+ Language.Haskell: parseExp :: String -> ParseResult (Exp SrcSpanInfo)

+ Language.Haskell: parseExpWithComments :: ParseMode -> String -> ParseResult (Exp SrcSpanInfo, [Comment])

+ Language.Haskell: parseExpWithMode :: ParseMode -> String -> ParseResult (Exp SrcSpanInfo)

+ Language.Haskell: parseExtension :: String -> Extension

+ Language.Haskell: parseFile :: FilePath -> IO (ParseResult (Module SrcSpanInfo))

+ Language.Haskell: parseFileContents :: String -> ParseResult (Module SrcSpanInfo)

+ Language.Haskell: parseFileContentsWithComments :: ParseMode -> String -> ParseResult (Module SrcSpanInfo, [Comment])

+ Language.Haskell: parseFileContentsWithExts :: [Extension] -> String -> ParseResult (Module SrcSpanInfo)

+ Language.Haskell: parseFileContentsWithMode :: ParseMode -> String -> ParseResult (Module SrcSpanInfo)

+ Language.Haskell: parseFileWithComments :: ParseMode -> FilePath -> IO (ParseResult (Module SrcSpanInfo, [Comment]))

+ Language.Haskell: parseFileWithCommentsAndPragmas :: ParseMode -> FilePath -> IO (ParseResult (Module SrcSpanInfo, [Comment], [UnknownPragma]))

+ Language.Haskell: parseFileWithExts :: [Extension] -> FilePath -> IO (ParseResult (Module SrcSpanInfo))

+ Language.Haskell: parseFileWithMode :: ParseMode -> FilePath -> IO (ParseResult (Module SrcSpanInfo))

+ Language.Haskell: parseImportDecl :: String -> ParseResult (ImportDecl SrcSpanInfo)

+ Language.Haskell: parseImportDeclWithComments :: ParseMode -> String -> ParseResult (ImportDecl SrcSpanInfo, [Comment])

+ Language.Haskell: parseImportDeclWithMode :: ParseMode -> String -> ParseResult (ImportDecl SrcSpanInfo)

+ Language.Haskell: parseModule :: String -> ParseResult (Module SrcSpanInfo)

+ Language.Haskell: parseModuleWithComments :: ParseMode -> String -> ParseResult (Module SrcSpanInfo, [Comment])

+ Language.Haskell: parseModuleWithMode :: ParseMode -> String -> ParseResult (Module SrcSpanInfo)

+ Language.Haskell: parsePat :: String -> ParseResult (Pat SrcSpanInfo)

+ Language.Haskell: parsePatWithComments :: ParseMode -> String -> ParseResult (Pat SrcSpanInfo, [Comment])

+ Language.Haskell: parsePatWithMode :: ParseMode -> String -> ParseResult (Pat SrcSpanInfo)

+ Language.Haskell: parseStmt :: String -> ParseResult (Stmt SrcSpanInfo)

+ Language.Haskell: parseStmtWithComments :: ParseMode -> String -> ParseResult (Stmt SrcSpanInfo, [Comment])

+ Language.Haskell: parseStmtWithMode :: ParseMode -> String -> ParseResult (Stmt SrcSpanInfo)

+ Language.Haskell: parseType :: String -> ParseResult (Type SrcSpanInfo)

+ Language.Haskell: parseTypeWithComments :: ParseMode -> String -> ParseResult (Type SrcSpanInfo, [Comment])

+ Language.Haskell: parseTypeWithMode :: ParseMode -> String -> ParseResult (Type SrcSpanInfo)

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

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

+ Language.Haskell: patBind :: Pat () -> Exp () -> Decl ()

+ Language.Haskell: patBindWhere :: Pat () -> Exp () -> [Decl ()] -> Decl ()

+ Language.Haskell: peList :: Pat ()

+ Language.Haskell: preludeFixities :: [Fixity]

+ Language.Haskell: prelude_mod :: () => l -> ModuleName l

+ Language.Haskell: prettyExtension :: Extension -> String

+ Language.Haskell: prettyLanguage :: Language -> String

+ Language.Haskell: prettyPrim :: Pretty a => a -> Doc

+ Language.Haskell: prettyPrimWithMode :: Pretty a => PPHsMode -> a -> Doc

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

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

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

+ Language.Haskell: pvar :: Name () -> Pat ()

+ Language.Haskell: pvarTuple :: [Name ()] -> Pat ()

+ Language.Haskell: qualStmt :: Exp () -> Stmt ()

+ Language.Haskell: qualified_name :: () => l -> Name l

+ Language.Haskell: qvar :: ModuleName () -> Name () -> Exp ()

+ Language.Haskell: readExtensions :: String -> Maybe (Maybe Language, [Extension])

+ Language.Haskell: role_name :: () => l -> Name l

+ Language.Haskell: safe_name :: () => l -> Name l

+ Language.Haskell: sfun :: Name () -> [Name ()] -> Rhs () -> Maybe (Binds ()) -> Decl ()

+ Language.Haskell: simpleFun :: Name () -> Name () -> Exp () -> Decl ()

+ Language.Haskell: spanSize :: SrcSpan -> (Int, Int)

+ Language.Haskell: srcSpanEnd :: SrcSpan -> (Int, Int)

+ Language.Haskell: srcSpanStart :: SrcSpan -> (Int, Int)

+ Language.Haskell: star_name :: () => l -> Name l

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

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

+ Language.Haskell: stdcall_name :: () => l -> Name l

+ Language.Haskell: stock_name :: () => l -> Name l

+ Language.Haskell: strE :: String -> Exp ()

+ Language.Haskell: strP :: String -> Pat ()

+ Language.Haskell: style :: Style

+ Language.Haskell: sym :: String -> Name ()

+ Language.Haskell: threadsafe_name :: () => l -> Name l

+ Language.Haskell: toExtensionList :: Language -> [Extension] -> [KnownExtension]

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

+ Language.Haskell: tuple :: [Exp ()] -> Exp ()

+ Language.Haskell: tuple_con :: () => l -> Boxed -> Int -> Exp l

+ Language.Haskell: tuple_con_name :: () => l -> Boxed -> Int -> QName l

+ Language.Haskell: tuple_tycon :: () => l -> Boxed -> Int -> Type l

+ Language.Haskell: tuple_tycon_name :: () => l -> Boxed -> Int -> QName l

+ Language.Haskell: type Indent = Int

+ Language.Haskell: unListOf :: () => ListOf a -> [a]

+ Language.Haskell: unboxed_singleton_con :: () => l -> Exp l

+ Language.Haskell: unboxed_singleton_con_name :: () => l -> QName l

+ Language.Haskell: unboxed_singleton_tycon :: () => l -> Type l

+ Language.Haskell: unboxed_singleton_tycon_name :: () => l -> QName l

+ Language.Haskell: unit_con :: () => l -> Exp l

+ Language.Haskell: unit_con_name :: () => l -> QName l

+ Language.Haskell: unit_tycon :: () => l -> Type l

+ Language.Haskell: unit_tycon_name :: () => l -> QName l

+ Language.Haskell: unsafe_name :: () => l -> Name l

+ Language.Haskell: varTuple :: [Name ()] -> Exp ()

+ Language.Haskell: wildcard :: Pat ()

+ Language.Haskell.Convert: instance Language.Haskell.Convert.Convert (GHC.Maybe.Maybe (Language.Haskell.Exts.Syntax.Binds ())) [Language.Haskell.TH.Syntax.Dec]

+ Language.Haskell.Convert: instance Language.Haskell.Convert.Convert (GHC.Maybe.Maybe (Language.Haskell.Exts.Syntax.Context ())) Language.Haskell.TH.Syntax.Cxt

- Data.Derive.DSL.HSE: coerce :: (Typeable * a2, Typeable * a1) => a1 -> a2

+ Data.Derive.DSL.HSE: coerce :: (Typeable a1, Typeable a2) => a1 -> a2

- Data.Derive.Internal.Derivation: customContext :: (FullDataDecl -> Context () -> Context ()) -> (FullDataDecl -> [Decl ()] -> [Decl ()])

+ Data.Derive.Internal.Derivation: customContext :: (FullDataDecl -> Context () -> Context ()) -> FullDataDecl -> [Decl ()] -> [Decl ()]

- Data.Derive.Internal.Derivation: customSplice :: (FullDataDecl -> Exp () -> Exp ()) -> (FullDataDecl -> [Decl ()] -> [Decl ()])

+ Data.Derive.Internal.Derivation: customSplice :: (FullDataDecl -> Exp () -> Exp ()) -> FullDataDecl -> [Decl ()] -> [Decl ()]

- Language.Haskell: fromTyList :: () => Type l -> Maybe Type l

+ Language.Haskell: fromTyList :: () => Type l -> Maybe (Type l)

derive.cabal view

@@ -1,7 +1,7 @@ cabal-version:  1.18 build-type:     Simple name:           derive-version:        2.6.4+version:        2.6.5 copyright:      Neil Mitchell 2006-2017 author:         Neil Mitchell <ndmitchell@gmail.com> and others maintainer:     None

src/Data/Derive/DSL/HSE.hs view

@@ -99,7 +99,10 @@           res = evalState (fromConstrM f $ readCon dat str) args           f :: Data a => State [Output] a           f = res where res = if typeOf (fromState res) == typeOf sl then return $ coerce sl else-                              do x:xs <- get; put xs; return $ fromOutput x+                              do l <- get+                                 case l of+                                     x:xs -> do put xs; return $ fromOutput x+                                     [] -> error "fromOutput: null"  fromOutput (OString x) = coerce x fromOutput (OInt x) = coerce x

src/Data/Derive/DSL/SYB.hs view

@@ -27,13 +27,13 @@  dlistAny :: forall a . Data a => DSL -> Maybe a dlistAny x | isNothing con = Nothing-           | otherwise = res +           | otherwise = res     where         con = readConstr dat "(:)"         val = fromConstr (fromJust con) :: a-        +         dat = dataTypeOf (undefined :: a)-        +         res = gmapQi 0 f val          f :: Data d => d -> Maybe a@@ -56,10 +56,14 @@         f :: forall b . Data b => State (Bool,[DSL]) b         f = if typeOf (undefined :: b) == typeOf sl then return $ coerce sl             else do-                (b,x:xs) <- get-                case syb x of-                    Nothing -> do put (False,xs) ; return undefined-                    Just y -> do put (b,xs) ; return y+                (b,l) <- get+                case l of+                    x:xs ->+                        case syb x of+                            Nothing -> do put (False,xs) ; return undefined+                            Just y -> do put (b,xs) ; return y+                    [] ->+                        error "dapp: null"   dsimple :: Data a => DSL -> Maybe a