Copyright | (c) The GHC Team 1997-2000 |
---|---|
License | BSD-3-Clause |
Maintainer | Andreas Abel |
Stability | stable |
Portability | portable |
Safe Haskell | None |
Language | Haskell98 |
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
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
- = HsChar Char
- | HsString String
- | HsInt Integer
- | HsFrac Rational
- | HsCharPrim Char
- | HsStringPrim String
- | HsIntPrim Integer
- | HsFloatPrim Rational
- | HsDoublePrim Rational
- newtype Module = Module String
- data HsQName
- data HsName
- data HsQOp
- data HsOp
- data HsSpecialCon
- = HsUnitCon
- | HsListCon
- | HsFunCon
- | HsTupleCon Int
- | HsCons
- 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 {
- srcFilename :: String
- srcLine :: Int
- srcColumn :: Int
Modules
A Haskell source module.
HsModule SrcLoc Module (Maybe [HsExportSpec]) [HsImportDecl] [HsDecl] |
Instances
Data HsModule Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 Source # | |
Eq HsModule Source # | |
Pretty HsModule Source # | |
Defined in Language.Haskell.Pretty prettyPrec :: Int -> HsModule -> Doc |
data HsExportSpec Source #
Export specification.
HsEVar HsQName | Variable. |
HsEAbs HsQName |
|
HsEThingAll HsQName |
|
HsEThingWith HsQName [HsCName] |
|
HsEModuleContents Module |
|
Instances
Data HsExportSpec Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 Source # | |
Defined in Language.Haskell.Syntax showsPrec :: Int -> HsExportSpec -> ShowS show :: HsExportSpec -> String showList :: [HsExportSpec] -> ShowS | |
Eq HsExportSpec Source # | |
Defined in Language.Haskell.Syntax (==) :: HsExportSpec -> HsExportSpec -> Bool (/=) :: HsExportSpec -> HsExportSpec -> Bool | |
Pretty HsExportSpec Source # | |
Defined in Language.Haskell.Pretty pretty :: HsExportSpec -> Doc prettyPrec :: Int -> HsExportSpec -> Doc |
data HsImportDecl Source #
Import declaration.
HsImportDecl | |
|
Instances
Data HsImportDecl Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 Source # | |
Defined in Language.Haskell.Syntax showsPrec :: Int -> HsImportDecl -> ShowS show :: HsImportDecl -> String showList :: [HsImportDecl] -> ShowS | |
Eq HsImportDecl Source # | |
Defined in Language.Haskell.Syntax (==) :: HsImportDecl -> HsImportDecl -> Bool (/=) :: HsImportDecl -> HsImportDecl -> Bool | |
Pretty HsImportDecl Source # | |
Defined in Language.Haskell.Pretty pretty :: HsImportDecl -> Doc prettyPrec :: Int -> HsImportDecl -> Doc |
data HsImportSpec Source #
Import specification.
HsIVar HsName | Variable. |
HsIAbs HsName |
|
HsIThingAll HsName |
|
HsIThingWith HsName [HsCName] |
|
Instances
Data HsImportSpec Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 Source # | |
Defined in Language.Haskell.Syntax showsPrec :: Int -> HsImportSpec -> ShowS show :: HsImportSpec -> String showList :: [HsImportSpec] -> ShowS | |
Eq HsImportSpec Source # | |
Defined in Language.Haskell.Syntax (==) :: HsImportSpec -> HsImportSpec -> Bool (/=) :: HsImportSpec -> HsImportSpec -> Bool | |
Pretty HsImportSpec Source # | |
Defined in Language.Haskell.Pretty pretty :: HsImportSpec -> Doc prettyPrec :: Int -> HsImportSpec -> Doc |
Associativity of an operator.
HsAssocNone | Non-associative operator (declared with |
HsAssocLeft | Left-associative operator (declared with |
HsAssocRight | Right-associative operator (declared with |
Instances
Data HsAssoc Source # | |
Defined in Language.Haskell.Syntax 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 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 :: forall r r'. (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 Source # | |
Eq HsAssoc Source # | |
Pretty HsAssoc Source # | |
Defined in Language.Haskell.Pretty prettyPrec :: Int -> HsAssoc -> Doc |
Declarations
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 |
Instances
Data HsDecl Source # | |
Defined in Language.Haskell.Syntax 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 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 :: forall r r'. (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 Source # | |
Eq HsDecl Source # | |
Pretty HsDecl Source # | |
Defined in Language.Haskell.Pretty prettyPrec :: Int -> HsDecl -> Doc |
Declaration of a data constructor.
HsConDecl SrcLoc HsName [HsBangType] | Ordinary data constructor. |
HsRecDecl SrcLoc HsName [([HsName], HsBangType)] | Record constructor. |
Instances
Data HsConDecl Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 Source # | |
Eq HsConDecl Source # | |
Pretty HsConDecl Source # | |
Defined in Language.Haskell.Pretty prettyPrec :: Int -> HsConDecl -> Doc |
data HsBangType Source #
The type of a constructor argument or field, optionally including a strictness annotation.
HsBangedTy HsType | Strict component, marked with " |
HsUnBangedTy HsType | Non-strict component. |
Instances
Data HsBangType Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 Source # | |
Defined in Language.Haskell.Syntax showsPrec :: Int -> HsBangType -> ShowS show :: HsBangType -> String showList :: [HsBangType] -> ShowS | |
Eq HsBangType Source # | |
Defined in Language.Haskell.Syntax (==) :: HsBangType -> HsBangType -> Bool (/=) :: HsBangType -> HsBangType -> Bool | |
Pretty HsBangType Source # | |
Defined in Language.Haskell.Pretty pretty :: HsBangType -> Doc prettyPrec :: Int -> HsBangType -> Doc |
Clauses of a function binding.
Instances
Data HsMatch Source # | |
Defined in Language.Haskell.Syntax 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 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 :: forall r r'. (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 Source # | |
Eq HsMatch Source # | |
Pretty HsMatch Source # | |
Defined in Language.Haskell.Pretty prettyPrec :: Int -> HsMatch -> Doc |
The right hand side of a function or pattern binding.
HsUnGuardedRhs HsExp | Unguarded right hand side (exp). |
HsGuardedRhss [HsGuardedRhs] | Guarded right hand side (gdrhs). |
Instances
Data HsRhs Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 Source # | |
Eq HsRhs Source # | |
Pretty HsRhs Source # | |
Defined in Language.Haskell.Pretty prettyPrec :: Int -> HsRhs -> Doc |
data HsGuardedRhs Source #
A guarded right hand side |
exp =
exp.
The first expression will be Boolean-valued.
Instances
Data HsGuardedRhs Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 Source # | |
Defined in Language.Haskell.Syntax showsPrec :: Int -> HsGuardedRhs -> ShowS show :: HsGuardedRhs -> String showList :: [HsGuardedRhs] -> ShowS | |
Eq HsGuardedRhs Source # | |
Defined in Language.Haskell.Syntax (==) :: HsGuardedRhs -> HsGuardedRhs -> Bool (/=) :: HsGuardedRhs -> HsGuardedRhs -> Bool | |
Pretty HsGuardedRhs Source # | |
Defined in Language.Haskell.Pretty pretty :: HsGuardedRhs -> Doc prettyPrec :: Int -> HsGuardedRhs -> Doc |
Safety level for invoking a foreign entity.
Instances
Data HsSafety Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 | |
Show HsSafety Source # | |
Eq HsSafety Source # | |
Ord HsSafety Source # | |
Pretty HsSafety Source # | |
Defined in Language.Haskell.Pretty prettyPrec :: Int -> HsSafety -> Doc |
Class Assertions and Contexts
data HsQualType Source #
A type qualified with a context. An unqualified type has an empty context.
Instances
Data HsQualType Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 Source # | |
Defined in Language.Haskell.Syntax showsPrec :: Int -> HsQualType -> ShowS show :: HsQualType -> String showList :: [HsQualType] -> ShowS | |
Eq HsQualType Source # | |
Defined in Language.Haskell.Syntax (==) :: HsQualType -> HsQualType -> Bool (/=) :: HsQualType -> HsQualType -> Bool | |
Pretty HsQualType Source # | |
Defined in Language.Haskell.Pretty pretty :: HsQualType -> Doc prettyPrec :: Int -> HsQualType -> Doc |
type HsAsst = (HsQName, [HsType]) Source #
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.
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
Data HsType Source # | |
Defined in Language.Haskell.Syntax 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 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 :: forall r r'. (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 Source # | |
Eq HsType Source # | |
Pretty HsType Source # | |
Defined in Language.Haskell.Pretty prettyPrec :: Int -> HsType -> Doc |
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.
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
Data HsExp Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 Source # | |
Eq HsExp Source # | |
Pretty HsExp Source # | |
Defined in Language.Haskell.Pretty prettyPrec :: Int -> HsExp -> Doc |
This type represents both stmt in a do
-expression,
and qual in a list comprehension.
HsGenerator SrcLoc HsPat HsExp | A generator pat |
HsQualifier HsExp | An exp by itself: in a |
HsLetStmt [HsDecl] | Local bindings. |
Instances
Data HsStmt Source # | |
Defined in Language.Haskell.Syntax 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 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 :: forall r r'. (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 Source # | |
Eq HsStmt Source # | |
Pretty HsStmt Source # | |
Defined in Language.Haskell.Pretty prettyPrec :: Int -> HsStmt -> Doc |
data HsFieldUpdate Source #
An fbind in a labeled record construction or update expression.
Instances
Data HsFieldUpdate Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 Source # | |
Defined in Language.Haskell.Syntax showsPrec :: Int -> HsFieldUpdate -> ShowS show :: HsFieldUpdate -> String showList :: [HsFieldUpdate] -> ShowS | |
Eq HsFieldUpdate Source # | |
Defined in Language.Haskell.Syntax (==) :: HsFieldUpdate -> HsFieldUpdate -> Bool (/=) :: HsFieldUpdate -> HsFieldUpdate -> Bool | |
Pretty HsFieldUpdate Source # | |
Defined in Language.Haskell.Pretty pretty :: HsFieldUpdate -> Doc prettyPrec :: Int -> HsFieldUpdate -> Doc |
An alt in a case
expression.
Instances
Data HsAlt Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 Source # | |
Eq HsAlt Source # | |
Pretty HsAlt Source # | |
Defined in Language.Haskell.Pretty prettyPrec :: Int -> HsAlt -> Doc |
data HsGuardedAlts Source #
HsUnGuardedAlt HsExp |
|
HsGuardedAlts [HsGuardedAlt] | gdpat. |
Instances
Data HsGuardedAlts Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 Source # | |
Defined in Language.Haskell.Syntax showsPrec :: Int -> HsGuardedAlts -> ShowS show :: HsGuardedAlts -> String showList :: [HsGuardedAlts] -> ShowS | |
Eq HsGuardedAlts Source # | |
Defined in Language.Haskell.Syntax (==) :: HsGuardedAlts -> HsGuardedAlts -> Bool (/=) :: HsGuardedAlts -> HsGuardedAlts -> Bool | |
Pretty HsGuardedAlts Source # | |
Defined in Language.Haskell.Pretty pretty :: HsGuardedAlts -> Doc prettyPrec :: Int -> HsGuardedAlts -> Doc |
data HsGuardedAlt Source #
A guarded alternative |
exp ->
exp.
The first expression will be Boolean-valued.
Instances
Data HsGuardedAlt Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 Source # | |
Defined in Language.Haskell.Syntax showsPrec :: Int -> HsGuardedAlt -> ShowS show :: HsGuardedAlt -> String showList :: [HsGuardedAlt] -> ShowS | |
Eq HsGuardedAlt Source # | |
Defined in Language.Haskell.Syntax (==) :: HsGuardedAlt -> HsGuardedAlt -> Bool (/=) :: HsGuardedAlt -> HsGuardedAlt -> Bool | |
Pretty HsGuardedAlt Source # | |
Defined in Language.Haskell.Pretty pretty :: HsGuardedAlt -> Doc prettyPrec :: Int -> HsGuardedAlt -> Doc |
Patterns
A pattern, to be matched against a value.
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
Data HsPat Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 Source # | |
Eq HsPat Source # | |
Pretty HsPat Source # | |
Defined in Language.Haskell.Pretty prettyPrec :: Int -> HsPat -> Doc |
data HsPatField Source #
An fpat in a labeled record pattern.
Instances
Data HsPatField Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 Source # | |
Defined in Language.Haskell.Syntax showsPrec :: Int -> HsPatField -> ShowS show :: HsPatField -> String showList :: [HsPatField] -> ShowS | |
Eq HsPatField Source # | |
Defined in Language.Haskell.Syntax (==) :: HsPatField -> HsPatField -> Bool (/=) :: HsPatField -> HsPatField -> Bool | |
Pretty HsPatField Source # | |
Defined in Language.Haskell.Pretty pretty :: HsPatField -> Doc prettyPrec :: Int -> HsPatField -> Doc |
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.
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
Data HsLiteral Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 Source # | |
Eq HsLiteral Source # | |
Pretty HsLiteral Source # | |
Defined in Language.Haskell.Pretty prettyPrec :: Int -> HsLiteral -> Doc |
Variables, Constructors and Operators
The name of a Haskell module.
Module String |
Instances
Data Module Source # | |
Defined in Language.Haskell.Syntax 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 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 :: forall r r'. (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 | |
Show Module Source # | |
Eq Module Source # | |
Ord Module Source # | |
Pretty Module Source # | |
Defined in Language.Haskell.Pretty prettyPrec :: Int -> Module -> Doc |
This type is used to represent qualified variables, and also qualified constructors.
Qual Module HsName | Name qualified with a module name. |
UnQual HsName | Unqualified name. |
Special HsSpecialCon | Built-in constructor with special syntax. |
Instances
Data HsQName Source # | |
Defined in Language.Haskell.Syntax 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 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 :: forall r r'. (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 | |
Show HsQName Source # | |
Eq HsQName Source # | |
Ord HsQName Source # | |
Pretty HsQName Source # | |
Defined in Language.Haskell.Pretty prettyPrec :: Int -> HsQName -> Doc |
This type is used to represent variables, and also constructors.
Instances
Data HsName Source # | |
Defined in Language.Haskell.Syntax 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 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 :: forall r r'. (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 | |
Show HsName Source # | |
Eq HsName Source # | |
Ord HsName Source # | |
Pretty HsName Source # | |
Defined in Language.Haskell.Pretty prettyPrec :: Int -> HsName -> Doc |
Possibly qualified infix operators (qop), appearing in expressions.
Instances
Data HsQOp Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 | |
Show HsQOp Source # | |
Eq HsQOp Source # | |
Ord HsQOp Source # | |
Pretty HsQOp Source # | |
Defined in Language.Haskell.Pretty prettyPrec :: Int -> HsQOp -> Doc |
Operators, appearing in infix
declarations.
Instances
Data HsOp Source # | |
Defined in Language.Haskell.Syntax 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 :: forall r r'. (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 | |
Show HsOp Source # | |
Eq HsOp Source # | |
Ord HsOp Source # | |
Pretty HsOp Source # | |
Defined in Language.Haskell.Pretty prettyPrec :: Int -> HsOp -> Doc |
data HsSpecialCon Source #
Constructors with special syntax. These names are never qualified, and always refer to builtin type or data 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
Data HsSpecialCon Source # | |
Defined in Language.Haskell.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsSpecialCon -> c HsSpecialCon gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsSpecialCon toConstr :: HsSpecialCon -> Constr dataTypeOf :: HsSpecialCon -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsSpecialCon) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsSpecialCon) gmapT :: (forall b. Data b => b -> b) -> HsSpecialCon -> HsSpecialCon gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsSpecialCon -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsSpecialCon -> r gmapQ :: (forall d. Data d => d -> u) -> HsSpecialCon -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> HsSpecialCon -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon | |
Show HsSpecialCon Source # | |
Defined in Language.Haskell.Syntax showsPrec :: Int -> HsSpecialCon -> ShowS show :: HsSpecialCon -> String showList :: [HsSpecialCon] -> ShowS | |
Eq HsSpecialCon Source # | |
Defined in Language.Haskell.Syntax (==) :: HsSpecialCon -> HsSpecialCon -> Bool (/=) :: HsSpecialCon -> HsSpecialCon -> Bool | |
Ord HsSpecialCon Source # | |
Defined in Language.Haskell.Syntax compare :: HsSpecialCon -> HsSpecialCon -> Ordering (<) :: HsSpecialCon -> HsSpecialCon -> Bool (<=) :: HsSpecialCon -> HsSpecialCon -> Bool (>) :: HsSpecialCon -> HsSpecialCon -> Bool (>=) :: HsSpecialCon -> HsSpecialCon -> Bool max :: HsSpecialCon -> HsSpecialCon -> HsSpecialCon min :: HsSpecialCon -> HsSpecialCon -> HsSpecialCon |
A name (cname) of a component of a class or data type in an import
or export specification.
Instances
Data HsCName Source # | |
Defined in Language.Haskell.Syntax 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 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 :: forall r r'. (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 | |
Show HsCName Source # | |
Eq HsCName Source # | |
Ord HsCName Source # | |
Pretty HsCName Source # | |
Defined in Language.Haskell.Pretty prettyPrec :: Int -> HsCName -> Doc |
Builtin names
Modules
prelude_mod :: Module Source #
Main function of a program
Constructors
tuple_con_name :: Int -> HsQName Source #
Type constructors
tuple_tycon_name :: Int -> HsQName Source #
unit_tycon :: HsType Source #
list_tycon :: HsType Source #
tuple_tycon :: Int -> HsType Source #
Source coordinates
A position in the source.
SrcLoc | |
|
Instances
Data SrcLoc Source # | |
Defined in Language.Haskell.Syntax 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 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 :: forall r r'. (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 | |
Show SrcLoc Source # | |
Eq SrcLoc Source # | |
Ord SrcLoc Source # | |