Copyright | (c) The GHC Team 1997-2000 |
---|---|
License | BSD-style (see the file libraries/base/LICENSE) |
Maintainer | libraries@haskell.org |
Stability | experimental |
Portability | portable |
Safe Haskell | None |
Language | Haskell98 |
Language.Haskell.Syntax
Contents
Description
A suite of datatypes describing the abstract syntax of Haskell 98 plus a few extensions:
- multi-parameter type classes
- parameters of type class assertions are unrestricted
This module has been changed so that show is a real show. For GHC, we also derive Typeable and Data for all types.
Synopsis
- data HsModule = HsModule SrcLoc Module (Maybe [HsExportSpec]) [HsImportDecl] [HsDecl]
- data HsExportSpec
- data HsImportDecl = HsImportDecl {
- importLoc :: SrcLoc
- importModule :: Module
- importQualified :: Bool
- importAs :: Maybe Module
- importSpecs :: Maybe (Bool, [HsImportSpec])
- data HsImportSpec
- data HsAssoc
- data HsDecl
- = HsTypeDecl SrcLoc HsName [HsName] HsType
- | HsDataDecl SrcLoc HsContext HsName [HsName] [HsConDecl] [HsQName]
- | HsInfixDecl SrcLoc HsAssoc Int [HsOp]
- | HsNewTypeDecl SrcLoc HsContext HsName [HsName] HsConDecl [HsQName]
- | HsClassDecl SrcLoc HsContext HsName [HsName] [HsDecl]
- | HsInstDecl SrcLoc HsContext HsQName [HsType] [HsDecl]
- | HsDefaultDecl SrcLoc [HsType]
- | HsTypeSig SrcLoc [HsName] HsQualType
- | HsFunBind [HsMatch]
- | HsPatBind SrcLoc HsPat HsRhs [HsDecl]
- | HsForeignImport SrcLoc String HsSafety String HsName HsType
- | HsForeignExport SrcLoc String String HsName HsType
- data HsConDecl
- = HsConDecl SrcLoc HsName [HsBangType]
- | HsRecDecl SrcLoc HsName [([HsName], HsBangType)]
- data HsBangType
- data HsMatch = HsMatch SrcLoc HsName [HsPat] HsRhs [HsDecl]
- data HsRhs
- data HsGuardedRhs = HsGuardedRhs SrcLoc HsExp HsExp
- data HsSafety
- data HsQualType = HsQualType HsContext HsType
- type HsContext = [HsAsst]
- type HsAsst = (HsQName, [HsType])
- data HsType
- data HsExp
- = HsVar HsQName
- | HsCon HsQName
- | HsLit HsLiteral
- | HsInfixApp HsExp HsQOp HsExp
- | HsApp HsExp HsExp
- | HsNegApp HsExp
- | HsLambda SrcLoc [HsPat] HsExp
- | HsLet [HsDecl] HsExp
- | HsIf HsExp HsExp HsExp
- | HsCase HsExp [HsAlt]
- | HsDo [HsStmt]
- | HsTuple [HsExp]
- | HsList [HsExp]
- | HsParen HsExp
- | HsLeftSection HsExp HsQOp
- | HsRightSection HsQOp HsExp
- | HsRecConstr HsQName [HsFieldUpdate]
- | HsRecUpdate HsExp [HsFieldUpdate]
- | HsEnumFrom HsExp
- | HsEnumFromTo HsExp HsExp
- | HsEnumFromThen HsExp HsExp
- | HsEnumFromThenTo HsExp HsExp HsExp
- | HsListComp HsExp [HsStmt]
- | HsExpTypeSig SrcLoc HsExp HsQualType
- | HsAsPat HsName HsExp
- | HsWildCard
- | HsIrrPat HsExp
- data HsStmt
- data HsFieldUpdate = HsFieldUpdate HsQName HsExp
- data HsAlt = HsAlt SrcLoc HsPat HsGuardedAlts [HsDecl]
- data HsGuardedAlts
- data HsGuardedAlt = HsGuardedAlt SrcLoc HsExp HsExp
- data HsPat
- data HsPatField = HsPFieldPat HsQName HsPat
- data HsLiteral
- newtype Module = Module String
- data HsQName
- data HsName
- data HsQOp
- data HsOp
- data HsSpecialCon
- data HsCName
- prelude_mod :: Module
- main_mod :: Module
- main_name :: HsName
- unit_con_name :: HsQName
- tuple_con_name :: Int -> HsQName
- list_cons_name :: HsQName
- unit_con :: HsExp
- tuple_con :: Int -> HsExp
- unit_tycon_name :: HsQName
- fun_tycon_name :: HsQName
- list_tycon_name :: HsQName
- tuple_tycon_name :: Int -> HsQName
- unit_tycon :: HsType
- fun_tycon :: HsType
- list_tycon :: HsType
- tuple_tycon :: Int -> HsType
- data SrcLoc = SrcLoc {}
Modules
A Haskell source module.
Constructors
HsModule SrcLoc Module (Maybe [HsExportSpec]) [HsImportDecl] [HsDecl] |
Instances
Data HsModule # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsModule -> c HsModule # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsModule # toConstr :: HsModule -> Constr # dataTypeOf :: HsModule -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsModule) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsModule) # gmapT :: (forall b. Data b => b -> b) -> HsModule -> HsModule # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsModule -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsModule -> r # gmapQ :: (forall d. Data d => d -> u) -> HsModule -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsModule -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsModule -> m HsModule # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule -> m HsModule # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule -> m HsModule # | |
Show HsModule # | |
Pretty HsModule # | |
Defined in Language.Haskell.Pretty |
data HsExportSpec #
Export specification.
Constructors
HsEVar HsQName | variable |
HsEAbs HsQName |
|
HsEThingAll HsQName |
|
HsEThingWith HsQName [HsCName] |
|
HsEModuleContents Module |
|
Instances
Eq HsExportSpec # | |
Defined in Language.Haskell.Syntax | |
Data HsExportSpec # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsExportSpec -> c HsExportSpec # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsExportSpec # toConstr :: HsExportSpec -> Constr # dataTypeOf :: HsExportSpec -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsExportSpec) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsExportSpec) # gmapT :: (forall b. Data b => b -> b) -> HsExportSpec -> HsExportSpec # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsExportSpec -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsExportSpec -> r # gmapQ :: (forall d. Data d => d -> u) -> HsExportSpec -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsExportSpec -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec # | |
Show HsExportSpec # | |
Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsExportSpec -> ShowS # show :: HsExportSpec -> String # showList :: [HsExportSpec] -> ShowS # | |
Pretty HsExportSpec # | |
Defined in Language.Haskell.Pretty |
data HsImportDecl #
Import declaration.
Constructors
HsImportDecl | |
Fields
|
Instances
Eq HsImportDecl # | |
Defined in Language.Haskell.Syntax | |
Data HsImportDecl # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsImportDecl -> c HsImportDecl # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsImportDecl # toConstr :: HsImportDecl -> Constr # dataTypeOf :: HsImportDecl -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsImportDecl) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsImportDecl) # gmapT :: (forall b. Data b => b -> b) -> HsImportDecl -> HsImportDecl # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsImportDecl -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsImportDecl -> r # gmapQ :: (forall d. Data d => d -> u) -> HsImportDecl -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsImportDecl -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl # | |
Show HsImportDecl # | |
Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsImportDecl -> ShowS # show :: HsImportDecl -> String # showList :: [HsImportDecl] -> ShowS # | |
Pretty HsImportDecl # | |
Defined in Language.Haskell.Pretty |
data HsImportSpec #
Import specification.
Constructors
HsIVar HsName | variable |
HsIAbs HsName |
|
HsIThingAll HsName |
|
HsIThingWith HsName [HsCName] |
|
Instances
Eq HsImportSpec # | |
Defined in Language.Haskell.Syntax | |
Data HsImportSpec # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsImportSpec -> c HsImportSpec # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsImportSpec # toConstr :: HsImportSpec -> Constr # dataTypeOf :: HsImportSpec -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsImportSpec) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsImportSpec) # gmapT :: (forall b. Data b => b -> b) -> HsImportSpec -> HsImportSpec # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsImportSpec -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsImportSpec -> r # gmapQ :: (forall d. Data d => d -> u) -> HsImportSpec -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsImportSpec -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec # | |
Show HsImportSpec # | |
Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsImportSpec -> ShowS # show :: HsImportSpec -> String # showList :: [HsImportSpec] -> ShowS # | |
Pretty HsImportSpec # | |
Defined in Language.Haskell.Pretty |
Associativity of an operator.
Constructors
HsAssocNone | non-associative operator (declared with |
HsAssocLeft | left-associative operator (declared with |
HsAssocRight | right-associative operator (declared with |
Instances
Eq HsAssoc # | |
Data HsAssoc # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsAssoc -> c HsAssoc # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsAssoc # toConstr :: HsAssoc -> Constr # dataTypeOf :: HsAssoc -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsAssoc) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsAssoc) # gmapT :: (forall b. Data b => b -> b) -> HsAssoc -> HsAssoc # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsAssoc -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsAssoc -> r # gmapQ :: (forall d. Data d => d -> u) -> HsAssoc -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsAssoc -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc # | |
Show HsAssoc # | |
Pretty HsAssoc # | |
Defined in Language.Haskell.Pretty |
Declarations
Constructors
Instances
Eq HsDecl # | |
Data HsDecl # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDecl -> c HsDecl # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsDecl # toConstr :: HsDecl -> Constr # dataTypeOf :: HsDecl -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsDecl) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsDecl) # gmapT :: (forall b. Data b => b -> b) -> HsDecl -> HsDecl # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl -> r # gmapQ :: (forall d. Data d => d -> u) -> HsDecl -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDecl -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDecl -> m HsDecl # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDecl -> m HsDecl # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDecl -> m HsDecl # | |
Show HsDecl # | |
Pretty HsDecl # | |
Defined in Language.Haskell.Pretty |
Declaration of a data constructor.
Constructors
HsConDecl SrcLoc HsName [HsBangType] | ordinary data constructor |
HsRecDecl SrcLoc HsName [([HsName], HsBangType)] | record constructor |
Instances
Eq HsConDecl # | |
Data HsConDecl # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDecl -> c HsConDecl # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsConDecl # toConstr :: HsConDecl -> Constr # dataTypeOf :: HsConDecl -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsConDecl) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsConDecl) # gmapT :: (forall b. Data b => b -> b) -> HsConDecl -> HsConDecl # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDecl -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDecl -> r # gmapQ :: (forall d. Data d => d -> u) -> HsConDecl -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDecl -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl # | |
Show HsConDecl # | |
Pretty HsConDecl # | |
Defined in Language.Haskell.Pretty |
data HsBangType #
The type of a constructor argument or field, optionally including a strictness annotation.
Constructors
HsBangedTy HsType | strict component, marked with " |
HsUnBangedTy HsType | non-strict component |
Instances
Eq HsBangType # | |
Defined in Language.Haskell.Syntax | |
Data HsBangType # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsBangType -> c HsBangType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsBangType # toConstr :: HsBangType -> Constr # dataTypeOf :: HsBangType -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsBangType) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsBangType) # gmapT :: (forall b. Data b => b -> b) -> HsBangType -> HsBangType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsBangType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsBangType -> r # gmapQ :: (forall d. Data d => d -> u) -> HsBangType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsBangType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsBangType -> m HsBangType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBangType -> m HsBangType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBangType -> m HsBangType # | |
Show HsBangType # | |
Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsBangType -> ShowS # show :: HsBangType -> String # showList :: [HsBangType] -> ShowS # | |
Pretty HsBangType # | |
Defined in Language.Haskell.Pretty |
Clauses of a function binding.
Instances
Eq HsMatch # | |
Data HsMatch # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsMatch -> c HsMatch # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsMatch # toConstr :: HsMatch -> Constr # dataTypeOf :: HsMatch -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsMatch) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsMatch) # gmapT :: (forall b. Data b => b -> b) -> HsMatch -> HsMatch # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsMatch -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsMatch -> r # gmapQ :: (forall d. Data d => d -> u) -> HsMatch -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsMatch -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsMatch -> m HsMatch # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMatch -> m HsMatch # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMatch -> m HsMatch # | |
Show HsMatch # | |
Pretty HsMatch # | |
Defined in Language.Haskell.Pretty |
The right hand side of a function or pattern binding.
Constructors
HsUnGuardedRhs HsExp | unguarded right hand side (exp) |
HsGuardedRhss [HsGuardedRhs] | guarded right hand side (gdrhs) |
Instances
Eq HsRhs # | |
Data HsRhs # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsRhs -> c HsRhs # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsRhs # dataTypeOf :: HsRhs -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsRhs) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRhs) # gmapT :: (forall b. Data b => b -> b) -> HsRhs -> HsRhs # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsRhs -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsRhs -> r # gmapQ :: (forall d. Data d => d -> u) -> HsRhs -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsRhs -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsRhs -> m HsRhs # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRhs -> m HsRhs # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRhs -> m HsRhs # | |
Show HsRhs # | |
Pretty HsRhs # | |
Defined in Language.Haskell.Pretty |
data HsGuardedRhs #
A guarded right hand side |
exp =
exp.
The first expression will be Boolean-valued.
Constructors
HsGuardedRhs SrcLoc HsExp HsExp |
Instances
Eq HsGuardedRhs # | |
Defined in Language.Haskell.Syntax | |
Data HsGuardedRhs # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsGuardedRhs -> c HsGuardedRhs # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsGuardedRhs # toConstr :: HsGuardedRhs -> Constr # dataTypeOf :: HsGuardedRhs -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsGuardedRhs) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsGuardedRhs) # gmapT :: (forall b. Data b => b -> b) -> HsGuardedRhs -> HsGuardedRhs # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsGuardedRhs -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsGuardedRhs -> r # gmapQ :: (forall d. Data d => d -> u) -> HsGuardedRhs -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsGuardedRhs -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs # | |
Show HsGuardedRhs # | |
Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsGuardedRhs -> ShowS # show :: HsGuardedRhs -> String # showList :: [HsGuardedRhs] -> ShowS # | |
Pretty HsGuardedRhs # | |
Defined in Language.Haskell.Pretty |
Safety level for invoking a foreign entity
Instances
Eq HsSafety # | |
Data HsSafety # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsSafety -> c HsSafety # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsSafety # toConstr :: HsSafety -> Constr # dataTypeOf :: HsSafety -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsSafety) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsSafety) # gmapT :: (forall b. Data b => b -> b) -> HsSafety -> HsSafety # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsSafety -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsSafety -> r # gmapQ :: (forall d. Data d => d -> u) -> HsSafety -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsSafety -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsSafety -> m HsSafety # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSafety -> m HsSafety # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSafety -> m HsSafety # | |
Ord HsSafety # | |
Defined in Language.Haskell.Syntax | |
Show HsSafety # | |
Pretty HsSafety # | |
Defined in Language.Haskell.Pretty |
Class Assertions and Contexts
data HsQualType #
A type qualified with a context. An unqualified type has an empty context.
Constructors
HsQualType HsContext HsType |
Instances
Eq HsQualType # | |
Defined in Language.Haskell.Syntax | |
Data HsQualType # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsQualType -> c HsQualType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsQualType # toConstr :: HsQualType -> Constr # dataTypeOf :: HsQualType -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsQualType) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQualType) # gmapT :: (forall b. Data b => b -> b) -> HsQualType -> HsQualType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsQualType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsQualType -> r # gmapQ :: (forall d. Data d => d -> u) -> HsQualType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsQualType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsQualType -> m HsQualType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsQualType -> m HsQualType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsQualType -> m HsQualType # | |
Show HsQualType # | |
Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsQualType -> ShowS # show :: HsQualType -> String # showList :: [HsQualType] -> ShowS # | |
Pretty HsQualType # | |
Defined in Language.Haskell.Pretty |
type HsAsst = (HsQName, [HsType]) #
Class assertions. In Haskell 98, the argument would be a tyvar, but this definition allows multiple parameters, and allows them to be types.
Types
Haskell types and type constructors.
Constructors
HsTyFun HsType HsType | function type |
HsTyTuple [HsType] | tuple type |
HsTyApp HsType HsType | application of a type constructor |
HsTyVar HsName | type variable |
HsTyCon HsQName | named type or type constructor |
Instances
Eq HsType # | |
Data HsType # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsType -> c HsType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsType # toConstr :: HsType -> Constr # dataTypeOf :: HsType -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsType) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsType) # gmapT :: (forall b. Data b => b -> b) -> HsType -> HsType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsType -> r # gmapQ :: (forall d. Data d => d -> u) -> HsType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsType -> m HsType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType -> m HsType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType -> m HsType # | |
Show HsType # | |
Pretty HsType # | |
Defined in Language.Haskell.Pretty |
Expressions
Haskell expressions.
Notes:
- Because it is difficult for parsers to distinguish patterns from expressions, they typically parse them in the same way and then check that they have the appropriate form. Hence the expression type includes some forms that are found only in patterns. After these checks, these constructors should not be used.
- The parser does not take precedence and associativity into account,
so it will leave
HsInfixApp
s associated to the left. - The
Pretty
instance forHsExp
does not add parentheses in printing.
Constructors
HsVar HsQName | variable |
HsCon HsQName | data constructor |
HsLit HsLiteral | literal constant |
HsInfixApp HsExp HsQOp HsExp | infix application |
HsApp HsExp HsExp | ordinary application |
HsNegApp HsExp | negation expression |
HsLambda SrcLoc [HsPat] HsExp | lambda expression |
HsLet [HsDecl] HsExp | local declarations with |
HsIf HsExp HsExp HsExp |
|
HsCase HsExp [HsAlt] |
|
HsDo [HsStmt] |
|
HsTuple [HsExp] | tuple expression |
HsList [HsExp] | list expression |
HsParen HsExp | parenthesized expression |
HsLeftSection HsExp HsQOp | left section |
HsRightSection HsQOp HsExp | right section |
HsRecConstr HsQName [HsFieldUpdate] | record construction expression |
HsRecUpdate HsExp [HsFieldUpdate] | record update expression |
HsEnumFrom HsExp | unbounded arithmetic sequence, incrementing by 1 |
HsEnumFromTo HsExp HsExp | bounded arithmetic sequence, incrementing by 1 |
HsEnumFromThen HsExp HsExp | unbounded arithmetic sequence, with first two elements given |
HsEnumFromThenTo HsExp HsExp HsExp | bounded arithmetic sequence, with first two elements given |
HsListComp HsExp [HsStmt] | list comprehension |
HsExpTypeSig SrcLoc HsExp HsQualType | expression type signature |
HsAsPat HsName HsExp | patterns only |
HsWildCard | patterns only |
HsIrrPat HsExp | patterns only |
Instances
Eq HsExp # | |
Data HsExp # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsExp -> c HsExp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsExp # dataTypeOf :: HsExp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsExp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsExp) # gmapT :: (forall b. Data b => b -> b) -> HsExp -> HsExp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsExp -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsExp -> r # gmapQ :: (forall d. Data d => d -> u) -> HsExp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsExp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsExp -> m HsExp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsExp -> m HsExp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsExp -> m HsExp # | |
Show HsExp # | |
Pretty HsExp # | |
Defined in Language.Haskell.Pretty |
This type represents both stmt in a do
-expression,
and qual in a list comprehension.
Constructors
HsGenerator SrcLoc HsPat HsExp | a generator pat |
HsQualifier HsExp | an exp by itself: in a |
HsLetStmt [HsDecl] | local bindings |
Instances
Eq HsStmt # | |
Data HsStmt # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsStmt -> c HsStmt # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsStmt # toConstr :: HsStmt -> Constr # dataTypeOf :: HsStmt -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsStmt) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsStmt) # gmapT :: (forall b. Data b => b -> b) -> HsStmt -> HsStmt # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsStmt -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsStmt -> r # gmapQ :: (forall d. Data d => d -> u) -> HsStmt -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsStmt -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsStmt -> m HsStmt # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsStmt -> m HsStmt # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsStmt -> m HsStmt # | |
Show HsStmt # | |
Pretty HsStmt # | |
Defined in Language.Haskell.Pretty |
data HsFieldUpdate #
An fbind in a labeled record construction or update expression.
Constructors
HsFieldUpdate HsQName HsExp |
Instances
Eq HsFieldUpdate # | |
Defined in Language.Haskell.Syntax Methods (==) :: HsFieldUpdate -> HsFieldUpdate -> Bool # (/=) :: HsFieldUpdate -> HsFieldUpdate -> Bool # | |
Data HsFieldUpdate # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsFieldUpdate -> c HsFieldUpdate # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsFieldUpdate # toConstr :: HsFieldUpdate -> Constr # dataTypeOf :: HsFieldUpdate -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsFieldUpdate) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsFieldUpdate) # gmapT :: (forall b. Data b => b -> b) -> HsFieldUpdate -> HsFieldUpdate # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsFieldUpdate -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsFieldUpdate -> r # gmapQ :: (forall d. Data d => d -> u) -> HsFieldUpdate -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsFieldUpdate -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate # | |
Show HsFieldUpdate # | |
Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsFieldUpdate -> ShowS # show :: HsFieldUpdate -> String # showList :: [HsFieldUpdate] -> ShowS # | |
Pretty HsFieldUpdate # | |
Defined in Language.Haskell.Pretty |
An alt in a case
expression.
Constructors
HsAlt SrcLoc HsPat HsGuardedAlts [HsDecl] |
Instances
Eq HsAlt # | |
Data HsAlt # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsAlt -> c HsAlt # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsAlt # dataTypeOf :: HsAlt -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsAlt) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsAlt) # gmapT :: (forall b. Data b => b -> b) -> HsAlt -> HsAlt # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsAlt -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsAlt -> r # gmapQ :: (forall d. Data d => d -> u) -> HsAlt -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsAlt -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsAlt -> m HsAlt # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsAlt -> m HsAlt # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsAlt -> m HsAlt # | |
Show HsAlt # | |
Pretty HsAlt # | |
Defined in Language.Haskell.Pretty |
data HsGuardedAlts #
Constructors
HsUnGuardedAlt HsExp |
|
HsGuardedAlts [HsGuardedAlt] | gdpat |
Instances
Eq HsGuardedAlts # | |
Defined in Language.Haskell.Syntax Methods (==) :: HsGuardedAlts -> HsGuardedAlts -> Bool # (/=) :: HsGuardedAlts -> HsGuardedAlts -> Bool # | |
Data HsGuardedAlts # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsGuardedAlts -> c HsGuardedAlts # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsGuardedAlts # toConstr :: HsGuardedAlts -> Constr # dataTypeOf :: HsGuardedAlts -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsGuardedAlts) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsGuardedAlts) # gmapT :: (forall b. Data b => b -> b) -> HsGuardedAlts -> HsGuardedAlts # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsGuardedAlts -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsGuardedAlts -> r # gmapQ :: (forall d. Data d => d -> u) -> HsGuardedAlts -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsGuardedAlts -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts # | |
Show HsGuardedAlts # | |
Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsGuardedAlts -> ShowS # show :: HsGuardedAlts -> String # showList :: [HsGuardedAlts] -> ShowS # | |
Pretty HsGuardedAlts # | |
Defined in Language.Haskell.Pretty |
data HsGuardedAlt #
A guarded alternative |
exp ->
exp.
The first expression will be Boolean-valued.
Constructors
HsGuardedAlt SrcLoc HsExp HsExp |
Instances
Eq HsGuardedAlt # | |
Defined in Language.Haskell.Syntax | |
Data HsGuardedAlt # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsGuardedAlt -> c HsGuardedAlt # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsGuardedAlt # toConstr :: HsGuardedAlt -> Constr # dataTypeOf :: HsGuardedAlt -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsGuardedAlt) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsGuardedAlt) # gmapT :: (forall b. Data b => b -> b) -> HsGuardedAlt -> HsGuardedAlt # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsGuardedAlt -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsGuardedAlt -> r # gmapQ :: (forall d. Data d => d -> u) -> HsGuardedAlt -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsGuardedAlt -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt # | |
Show HsGuardedAlt # | |
Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsGuardedAlt -> ShowS # show :: HsGuardedAlt -> String # showList :: [HsGuardedAlt] -> ShowS # | |
Pretty HsGuardedAlt # | |
Defined in Language.Haskell.Pretty |
Patterns
A pattern, to be matched against a value.
Constructors
HsPVar HsName | variable |
HsPLit HsLiteral | literal constant |
HsPNeg HsPat | negated pattern |
HsPInfixApp HsPat HsQName HsPat | pattern with infix data constructor |
HsPApp HsQName [HsPat] | data constructor and argument patterns |
HsPTuple [HsPat] | tuple pattern |
HsPList [HsPat] | list pattern |
HsPParen HsPat | parenthesized pattern |
HsPRec HsQName [HsPatField] | labelled pattern |
HsPAsPat HsName HsPat |
|
HsPWildCard | wildcard pattern ( |
HsPIrrPat HsPat | irrefutable pattern ( |
Instances
Eq HsPat # | |
Data HsPat # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsPat -> c HsPat # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsPat # dataTypeOf :: HsPat -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsPat) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsPat) # gmapT :: (forall b. Data b => b -> b) -> HsPat -> HsPat # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsPat -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsPat -> r # gmapQ :: (forall d. Data d => d -> u) -> HsPat -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsPat -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsPat -> m HsPat # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPat -> m HsPat # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPat -> m HsPat # | |
Show HsPat # | |
Pretty HsPat # | |
Defined in Language.Haskell.Pretty |
data HsPatField #
An fpat in a labeled record pattern.
Constructors
HsPFieldPat HsQName HsPat |
Instances
Eq HsPatField # | |
Defined in Language.Haskell.Syntax | |
Data HsPatField # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsPatField -> c HsPatField # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsPatField # toConstr :: HsPatField -> Constr # dataTypeOf :: HsPatField -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsPatField) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsPatField) # gmapT :: (forall b. Data b => b -> b) -> HsPatField -> HsPatField # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsPatField -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsPatField -> r # gmapQ :: (forall d. Data d => d -> u) -> HsPatField -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsPatField -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsPatField -> m HsPatField # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPatField -> m HsPatField # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPatField -> m HsPatField # | |
Show HsPatField # | |
Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsPatField -> ShowS # show :: HsPatField -> String # showList :: [HsPatField] -> ShowS # | |
Pretty HsPatField # | |
Defined in Language.Haskell.Pretty |
Literals
literal.
Values of this type hold the abstract value of the literal, not the
precise string representation used. For example, 10
, 0o12
and 0xa
have the same representation.
Constructors
HsChar Char | character literal |
HsString String | string literal |
HsInt Integer | integer literal |
HsFrac Rational | floating point literal |
HsCharPrim Char | GHC unboxed character literal |
HsStringPrim String | GHC unboxed string literal |
HsIntPrim Integer | GHC unboxed integer literal |
HsFloatPrim Rational | GHC unboxed float literal |
HsDoublePrim Rational | GHC unboxed double literal |
Instances
Eq HsLiteral # | |
Data HsLiteral # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsLiteral -> c HsLiteral # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsLiteral # toConstr :: HsLiteral -> Constr # dataTypeOf :: HsLiteral -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsLiteral) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsLiteral) # gmapT :: (forall b. Data b => b -> b) -> HsLiteral -> HsLiteral # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsLiteral -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsLiteral -> r # gmapQ :: (forall d. Data d => d -> u) -> HsLiteral -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsLiteral -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral # | |
Show HsLiteral # | |
Pretty HsLiteral # | |
Defined in Language.Haskell.Pretty |
Variables, Constructors and Operators
The name of a Haskell module.
Instances
Eq Module # | |
Data Module # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Module -> c Module # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Module # toConstr :: Module -> Constr # dataTypeOf :: Module -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Module) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module) # gmapT :: (forall b. Data b => b -> b) -> Module -> Module # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r # gmapQ :: (forall d. Data d => d -> u) -> Module -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module -> m Module # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module # | |
Ord Module # | |
Show Module # | |
Pretty Module # | |
Defined in Language.Haskell.Pretty |
This type is used to represent qualified variables, and also qualified constructors.
Constructors
Qual Module HsName | name qualified with a module name |
UnQual HsName | unqualified name |
Special HsSpecialCon | built-in constructor with special syntax |
Instances
Eq HsQName # | |
Data HsQName # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsQName -> c HsQName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsQName # toConstr :: HsQName -> Constr # dataTypeOf :: HsQName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsQName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQName) # gmapT :: (forall b. Data b => b -> b) -> HsQName -> HsQName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsQName -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsQName -> r # gmapQ :: (forall d. Data d => d -> u) -> HsQName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsQName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsQName -> m HsQName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsQName -> m HsQName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsQName -> m HsQName # | |
Ord HsQName # | |
Defined in Language.Haskell.Syntax | |
Show HsQName # | |
Pretty HsQName # | |
Defined in Language.Haskell.Pretty |
This type is used to represent variables, and also constructors.
Instances
Eq HsName # | |
Data HsName # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsName -> c HsName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsName # toConstr :: HsName -> Constr # dataTypeOf :: HsName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsName) # gmapT :: (forall b. Data b => b -> b) -> HsName -> HsName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsName -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsName -> r # gmapQ :: (forall d. Data d => d -> u) -> HsName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsName -> m HsName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsName -> m HsName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsName -> m HsName # | |
Ord HsName # | |
Show HsName # | |
Pretty HsName # | |
Defined in Language.Haskell.Pretty |
Possibly qualified infix operators (qop), appearing in expressions.
Instances
Eq HsQOp # | |
Data HsQOp # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsQOp -> c HsQOp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsQOp # dataTypeOf :: HsQOp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsQOp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQOp) # gmapT :: (forall b. Data b => b -> b) -> HsQOp -> HsQOp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsQOp -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsQOp -> r # gmapQ :: (forall d. Data d => d -> u) -> HsQOp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsQOp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsQOp -> m HsQOp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsQOp -> m HsQOp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsQOp -> m HsQOp # | |
Ord HsQOp # | |
Show HsQOp # | |
Pretty HsQOp # | |
Defined in Language.Haskell.Pretty |
Operators, appearing in infix
declarations.
Instances
Eq HsOp # | |
Data HsOp # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsOp -> c HsOp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsOp # dataTypeOf :: HsOp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsOp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsOp) # gmapT :: (forall b. Data b => b -> b) -> HsOp -> HsOp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsOp -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsOp -> r # gmapQ :: (forall d. Data d => d -> u) -> HsOp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsOp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsOp -> m HsOp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsOp -> m HsOp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsOp -> m HsOp # | |
Ord HsOp # | |
Show HsOp # | |
Pretty HsOp # | |
Defined in Language.Haskell.Pretty |
data HsSpecialCon #
Constructors with special syntax. These names are never qualified, and always refer to builtin type or data constructors.
Constructors
HsUnitCon | unit type and data constructor |
HsListCon | list type constructor |
HsFunCon | function type constructor |
HsTupleCon Int | n-ary tuple type and data
constructors |
HsCons | list data constructor |
Instances
A name (cname) of a component of a class or data type in an import
or export specification.
Instances
Eq HsCName # | |
Data HsCName # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsCName -> c HsCName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsCName # toConstr :: HsCName -> Constr # dataTypeOf :: HsCName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsCName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsCName) # gmapT :: (forall b. Data b => b -> b) -> HsCName -> HsCName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsCName -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsCName -> r # gmapQ :: (forall d. Data d => d -> u) -> HsCName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsCName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsCName -> m HsCName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsCName -> m HsCName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsCName -> m HsCName # | |
Ord HsCName # | |
Defined in Language.Haskell.Syntax | |
Show HsCName # | |
Pretty HsCName # | |
Defined in Language.Haskell.Pretty |
Builtin names
Modules
prelude_mod :: Module #
Main function of a program
Constructors
tuple_con_name :: Int -> HsQName #
Type constructors
tuple_tycon_name :: Int -> HsQName #
unit_tycon :: HsType #
list_tycon :: HsType #
tuple_tycon :: Int -> HsType #
Source coordinates
A position in the source.
Instances
Eq SrcLoc # | |
Data SrcLoc # | |
Defined in Language.Haskell.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcLoc -> c SrcLoc # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcLoc # toConstr :: SrcLoc -> Constr # dataTypeOf :: SrcLoc -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcLoc) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcLoc) # gmapT :: (forall b. Data b => b -> b) -> SrcLoc -> SrcLoc # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcLoc -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcLoc -> r # gmapQ :: (forall d. Data d => d -> u) -> SrcLoc -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcLoc -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc # | |
Ord SrcLoc # | |
Show SrcLoc # | |