haskell-src-1.0.3.0: Support for manipulating Haskell source code

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

- Modules
- Declarations
- Class Assertions and Contexts
- Types
- Expressions
- Patterns
- Literals
- Variables, Constructors and Operators
- Builtin names
  - Modules
  - Main function of a program
  - Constructors
  - Type constructors
- Source coordinates

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
  - = HsEVar HsQName
  - | HsEAbs HsQName
  - | HsEThingAll HsQName
  - | HsEThingWith HsQName [HsCName]
  - | HsEModuleContents Module
- data HsImportDecl = HsImportDecl {
  - importLoc :: SrcLoc
  - importModule :: Module
  - importQualified :: Bool
  - importAs :: Maybe Module
  - importSpecs :: Maybe (Bool, [HsImportSpec])
  }
- data HsImportSpec
  - = HsIVar HsName
  - | HsIAbs HsName
  - | HsIThingAll HsName
  - | HsIThingWith HsName [HsCName]
- data HsAssoc
  - = HsAssocNone
  - | HsAssocLeft
  - | HsAssocRight
- 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
  - = HsBangedTy HsType
  - | HsUnBangedTy HsType
- data HsMatch = HsMatch SrcLoc HsName [HsPat] HsRhs [HsDecl]
- data HsRhs
  - = HsUnGuardedRhs HsExp
  - | HsGuardedRhss [HsGuardedRhs]
- data HsGuardedRhs = HsGuardedRhs SrcLoc HsExp HsExp
- data HsSafety
  - = HsSafe
  - | HsUnsafe
- data HsQualType = HsQualType HsContext HsType
- type HsContext = [HsAsst]
- type HsAsst = (HsQName, [HsType])
- data HsType
  - = HsTyFun HsType HsType
  - | HsTyTuple [HsType]
  - | HsTyApp HsType HsType
  - | HsTyVar HsName
  - | HsTyCon HsQName
- 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
  - = HsGenerator SrcLoc HsPat HsExp
  - | HsQualifier HsExp
  - | HsLetStmt [HsDecl]
- data HsFieldUpdate = HsFieldUpdate HsQName HsExp
- data HsAlt = HsAlt SrcLoc HsPat HsGuardedAlts [HsDecl]
- data HsGuardedAlts
  - = HsUnGuardedAlt HsExp
  - | HsGuardedAlts [HsGuardedAlt]
- data HsGuardedAlt = HsGuardedAlt SrcLoc HsExp HsExp
- data HsPat
  - = HsPVar HsName
  - | HsPLit HsLiteral
  - | HsPNeg HsPat
  - | HsPInfixApp HsPat HsQName HsPat
  - | HsPApp HsQName [HsPat]
  - | HsPTuple [HsPat]
  - | HsPList [HsPat]
  - | HsPParen HsPat
  - | HsPRec HsQName [HsPatField]
  - | HsPAsPat HsName HsPat
  - | HsPWildCard
  - | HsPIrrPat 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
  - = Qual Module HsName
  - | UnQual HsName
  - | Special HsSpecialCon
- data HsName
  - = HsIdent String
  - | HsSymbol String
- data HsQOp
  - = HsQVarOp HsQName
  - | HsQConOp HsQName
- data HsOp
  - = HsVarOp HsName
  - | HsConOp HsName
- data HsSpecialCon
  - = HsUnitCon
  - | HsListCon
  - | HsFunCon
  - | HsTupleCon Int
  - | HsCons
- data HsCName
  - = HsVarName HsName
  - | HsConName HsName
- 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

data HsModule #

A Haskell source module.

Constructors

HsModule SrcLoc Module (Maybe [HsExportSpec]) [HsImportDecl] [HsDecl] |

Instances

Data HsModule # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsModule -> ShowS # show :: HsModule -> String # showList :: [HsModule] -> ShowS #
Pretty HsModule # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsModule -> Doc prettyPrec :: Int -> HsModule -> Doc

data HsExportSpec #

Export specification.

Constructors

HsEVar HsQName | variable
HsEAbs HsQName | `T`: a class or datatype exported abstractly, or a type synonym.
HsEThingAll HsQName | `T(..)`: a class exported with all of its methods, or a datatype exported with all of its constructors.
HsEThingWith HsQName [HsCName] | `T(C_1,...,C_n)`: a class exported with some of its methods, or a datatype exported with some of its constructors.
HsEModuleContents Module | `module M`: re-export a module.

Instances

Eq HsExportSpec # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsExportSpec -> HsExportSpec -> Bool # (/=) :: HsExportSpec -> HsExportSpec -> Bool #
Data HsExportSpec # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsExportSpec -> ShowS # show :: HsExportSpec -> String # showList :: [HsExportSpec] -> ShowS #
Pretty HsExportSpec # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsExportSpec -> Doc prettyPrec :: Int -> HsExportSpec -> Doc

data HsImportDecl #

Import declaration.

Constructors

HsImportDecl |
Fields importLoc :: SrcLoc position of the `import` keyword. importModule :: Module name of the module imported. importQualified :: Bool imported `qualified`? importAs :: Maybe Module optional alias name in an `as` clause. importSpecs :: Maybe (Bool, [HsImportSpec]) optional list of import specifications. The `Bool` is `True` if the names are excluded by `hiding`.

Instances

Eq HsImportDecl # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsImportDecl -> HsImportDecl -> Bool # (/=) :: HsImportDecl -> HsImportDecl -> Bool #
Data HsImportDecl # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsImportDecl -> ShowS # show :: HsImportDecl -> String # showList :: [HsImportDecl] -> ShowS #
Pretty HsImportDecl # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsImportDecl -> Doc prettyPrec :: Int -> HsImportDecl -> Doc

data HsImportSpec #

Import specification.

Constructors

HsIVar HsName | variable
HsIAbs HsName | `T`: the name of a class, datatype or type synonym.
HsIThingAll HsName | `T(..)`: a class imported with all of its methods, or a datatype imported with all of its constructors.
HsIThingWith HsName [HsCName] | `T(C_1,...,C_n)`: a class imported with some of its methods, or a datatype imported with some of its constructors.

Instances

Eq HsImportSpec # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsImportSpec -> HsImportSpec -> Bool # (/=) :: HsImportSpec -> HsImportSpec -> Bool #
Data HsImportSpec # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsImportSpec -> ShowS # show :: HsImportSpec -> String # showList :: [HsImportSpec] -> ShowS #
Pretty HsImportSpec # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsImportSpec -> Doc prettyPrec :: Int -> HsImportSpec -> Doc

data HsAssoc #

Associativity of an operator.

Constructors

HsAssocNone | non-associative operator (declared with `infix`)
HsAssocLeft | left-associative operator (declared with `infixl`).
HsAssocRight | right-associative operator (declared with `infixr`)

Instances

Eq HsAssoc # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsAssoc -> HsAssoc -> Bool # (/=) :: HsAssoc -> HsAssoc -> Bool #
Data HsAssoc # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsAssoc -> ShowS # show :: HsAssoc -> String # showList :: [HsAssoc] -> ShowS #
Pretty HsAssoc # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsAssoc -> Doc prettyPrec :: Int -> HsAssoc -> Doc

# Declarations

data HsDecl #

Constructors

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

Eq HsDecl # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsDecl -> HsDecl -> Bool # (/=) :: HsDecl -> HsDecl -> Bool #
Data HsDecl # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsDecl -> ShowS # show :: HsDecl -> String # showList :: [HsDecl] -> ShowS #
Pretty HsDecl # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsDecl -> Doc prettyPrec :: Int -> HsDecl -> Doc

data HsConDecl #

Declaration of a data constructor.

Constructors

HsConDecl SrcLoc HsName [HsBangType] | ordinary data constructor
HsRecDecl SrcLoc HsName [([HsName], HsBangType)] | record constructor

Instances

Eq HsConDecl # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsConDecl -> HsConDecl -> Bool # (/=) :: HsConDecl -> HsConDecl -> Bool #
Data HsConDecl # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsConDecl -> ShowS # show :: HsConDecl -> String # showList :: [HsConDecl] -> ShowS #
Pretty HsConDecl # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsConDecl -> Doc prettyPrec :: Int -> HsConDecl -> Doc

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 # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsBangType -> HsBangType -> Bool # (/=) :: HsBangType -> HsBangType -> Bool #
Data HsBangType # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsBangType -> ShowS # show :: HsBangType -> String # showList :: [HsBangType] -> ShowS #
Pretty HsBangType # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsBangType -> Doc prettyPrec :: Int -> HsBangType -> Doc

data HsMatch #

Clauses of a function binding.

Constructors

HsMatch SrcLoc HsName [HsPat] HsRhs [HsDecl] |

Instances

Eq HsMatch # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsMatch -> HsMatch -> Bool # (/=) :: HsMatch -> HsMatch -> Bool #
Data HsMatch # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsMatch -> ShowS # show :: HsMatch -> String # showList :: [HsMatch] -> ShowS #
Pretty HsMatch # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsMatch -> Doc prettyPrec :: Int -> HsMatch -> Doc

data HsRhs #

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 # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsRhs -> HsRhs -> Bool # (/=) :: HsRhs -> HsRhs -> Bool #
Data HsRhs # |
Instance details 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 # toConstr :: HsRhs -> Constr # 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsRhs -> ShowS # show :: HsRhs -> String # showList :: [HsRhs] -> ShowS #
Pretty HsRhs # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsRhs -> Doc prettyPrec :: Int -> HsRhs -> Doc

data HsGuardedRhs #

A guarded right hand side `|` exp `=` exp. The first expression will be Boolean-valued.

Constructors

HsGuardedRhs SrcLoc HsExp HsExp |

Instances

Eq HsGuardedRhs # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsGuardedRhs -> HsGuardedRhs -> Bool # (/=) :: HsGuardedRhs -> HsGuardedRhs -> Bool #
Data HsGuardedRhs # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsGuardedRhs -> ShowS # show :: HsGuardedRhs -> String # showList :: [HsGuardedRhs] -> ShowS #
Pretty HsGuardedRhs # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsGuardedRhs -> Doc prettyPrec :: Int -> HsGuardedRhs -> Doc

data HsSafety #

Safety level for invoking a foreign entity

Constructors

HsSafe | call may generate callbacks
HsUnsafe | call will not generate callbacks

Instances

Eq HsSafety # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsSafety -> HsSafety -> Bool # (/=) :: HsSafety -> HsSafety -> Bool #
Data HsSafety # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods compare :: HsSafety -> HsSafety -> Ordering # (<) :: HsSafety -> HsSafety -> Bool # (<=) :: HsSafety -> HsSafety -> Bool # (>) :: HsSafety -> HsSafety -> Bool # (>=) :: HsSafety -> HsSafety -> Bool # max :: HsSafety -> HsSafety -> HsSafety # min :: HsSafety -> HsSafety -> HsSafety #
Show HsSafety # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsSafety -> ShowS # show :: HsSafety -> String # showList :: [HsSafety] -> ShowS #
Pretty HsSafety # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsSafety -> Doc prettyPrec :: Int -> HsSafety -> Doc

# 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 # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsQualType -> HsQualType -> Bool # (/=) :: HsQualType -> HsQualType -> Bool #
Data HsQualType # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsQualType -> ShowS # show :: HsQualType -> String # showList :: [HsQualType] -> ShowS #
Pretty HsQualType # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsQualType -> Doc prettyPrec :: Int -> HsQualType -> Doc

type HsContext = [HsAsst] #

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

data HsType #

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 # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsType -> HsType -> Bool # (/=) :: HsType -> HsType -> Bool #
Data HsType # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsType -> ShowS # show :: HsType -> String # showList :: [HsType] -> ShowS #
Pretty HsType # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsType -> Doc prettyPrec :: Int -> HsType -> Doc

# Expressions

data HsExp #

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 for `HsExp` 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 `-` exp
HsLambda SrcLoc [HsPat] HsExp | lambda expression
HsLet [HsDecl] HsExp | local declarations with `let`
HsIf HsExp HsExp HsExp | `if` exp `then` exp `else` exp
HsCase HsExp [HsAlt] | `case` exp `of` alts
HsDo [HsStmt] | `do`-expression: the last statement in the list should be an expression.
HsTuple [HsExp] | tuple expression
HsList [HsExp] | list expression
HsParen HsExp | parenthesized expression
HsLeftSection HsExp HsQOp | left section `(`exp qop`)`
HsRightSection HsQOp HsExp | right section `(`qop exp`)`
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 # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsExp -> HsExp -> Bool # (/=) :: HsExp -> HsExp -> Bool #
Data HsExp # |
Instance details 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 # toConstr :: HsExp -> Constr # 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsExp -> ShowS # show :: HsExp -> String # showList :: [HsExp] -> ShowS #
Pretty HsExp # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsExp -> Doc prettyPrec :: Int -> HsExp -> Doc

data HsStmt #

This type represents both stmt in a `do`-expression, and qual in a list comprehension.

Constructors

HsGenerator SrcLoc HsPat HsExp | a generator pat `<-` exp
HsQualifier HsExp | an exp by itself: in a `do`-expression, an action whose result is discarded; in a list comprehension, a guard expression
HsLetStmt [HsDecl] | local bindings

Instances

Eq HsStmt # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsStmt -> HsStmt -> Bool # (/=) :: HsStmt -> HsStmt -> Bool #
Data HsStmt # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsStmt -> ShowS # show :: HsStmt -> String # showList :: [HsStmt] -> ShowS #
Pretty HsStmt # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsStmt -> Doc prettyPrec :: Int -> HsStmt -> Doc

data HsFieldUpdate #

An fbind in a labeled record construction or update expression.

Constructors

HsFieldUpdate HsQName HsExp |

Instances

Eq HsFieldUpdate # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsFieldUpdate -> HsFieldUpdate -> Bool # (/=) :: HsFieldUpdate -> HsFieldUpdate -> Bool #
Data HsFieldUpdate # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsFieldUpdate -> ShowS # show :: HsFieldUpdate -> String # showList :: [HsFieldUpdate] -> ShowS #
Pretty HsFieldUpdate # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsFieldUpdate -> Doc prettyPrec :: Int -> HsFieldUpdate -> Doc

data HsAlt #

An alt in a `case` expression.

Constructors

HsAlt SrcLoc HsPat HsGuardedAlts [HsDecl] |

Instances

Eq HsAlt # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsAlt -> HsAlt -> Bool # (/=) :: HsAlt -> HsAlt -> Bool #
Data HsAlt # |
Instance details 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 # toConstr :: HsAlt -> Constr # 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsAlt -> ShowS # show :: HsAlt -> String # showList :: [HsAlt] -> ShowS #
Pretty HsAlt # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsAlt -> Doc prettyPrec :: Int -> HsAlt -> Doc

data HsGuardedAlts #

Constructors

HsUnGuardedAlt HsExp | `->` exp
HsGuardedAlts [HsGuardedAlt] | gdpat

Instances

Eq HsGuardedAlts # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsGuardedAlts -> HsGuardedAlts -> Bool # (/=) :: HsGuardedAlts -> HsGuardedAlts -> Bool #
Data HsGuardedAlts # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsGuardedAlts -> ShowS # show :: HsGuardedAlts -> String # showList :: [HsGuardedAlts] -> ShowS #
Pretty HsGuardedAlts # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsGuardedAlts -> Doc prettyPrec :: Int -> HsGuardedAlts -> Doc

data HsGuardedAlt #

A guarded alternative `|` exp `->` exp. The first expression will be Boolean-valued.

Constructors

HsGuardedAlt SrcLoc HsExp HsExp |

Instances

Eq HsGuardedAlt # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsGuardedAlt -> HsGuardedAlt -> Bool # (/=) :: HsGuardedAlt -> HsGuardedAlt -> Bool #
Data HsGuardedAlt # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsGuardedAlt -> ShowS # show :: HsGuardedAlt -> String # showList :: [HsGuardedAlt] -> ShowS #
Pretty HsGuardedAlt # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsGuardedAlt -> Doc prettyPrec :: Int -> HsGuardedAlt -> Doc

# Patterns

data HsPat #

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 | `@`-pattern
HsPWildCard | wildcard pattern (`_`)
HsPIrrPat HsPat | irrefutable pattern (`~`)

Instances

Eq HsPat # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsPat -> HsPat -> Bool # (/=) :: HsPat -> HsPat -> Bool #
Data HsPat # |
Instance details 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 # toConstr :: HsPat -> Constr # 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsPat -> ShowS # show :: HsPat -> String # showList :: [HsPat] -> ShowS #
Pretty HsPat # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsPat -> Doc prettyPrec :: Int -> HsPat -> Doc

data HsPatField #

An fpat in a labeled record pattern.

Constructors

HsPFieldPat HsQName HsPat |

Instances

Eq HsPatField # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsPatField -> HsPatField -> Bool # (/=) :: HsPatField -> HsPatField -> Bool #
Data HsPatField # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsPatField -> ShowS # show :: HsPatField -> String # showList :: [HsPatField] -> ShowS #
Pretty HsPatField # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsPatField -> Doc prettyPrec :: Int -> HsPatField -> Doc

# Literals

data HsLiteral #

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 # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsLiteral -> HsLiteral -> Bool # (/=) :: HsLiteral -> HsLiteral -> Bool #
Data HsLiteral # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsLiteral -> ShowS # show :: HsLiteral -> String # showList :: [HsLiteral] -> ShowS #
Pretty HsLiteral # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsLiteral -> Doc prettyPrec :: Int -> HsLiteral -> Doc

# Variables, Constructors and Operators

newtype Module #

The name of a Haskell module.

Constructors

Module String |

Instances

Eq Module # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: Module -> Module -> Bool # (/=) :: Module -> Module -> Bool #
Data Module # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods compare :: Module -> Module -> Ordering # (<) :: Module -> Module -> Bool # (<=) :: Module -> Module -> Bool # (>) :: Module -> Module -> Bool # (>=) :: Module -> Module -> Bool # max :: Module -> Module -> Module # min :: Module -> Module -> Module #
Show Module # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> Module -> ShowS # show :: Module -> String # showList :: [Module] -> ShowS #
Pretty Module # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: Module -> Doc prettyPrec :: Int -> Module -> Doc

data HsQName #

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 # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsQName -> HsQName -> Bool # (/=) :: HsQName -> HsQName -> Bool #
Data HsQName # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods compare :: HsQName -> HsQName -> Ordering # (<) :: HsQName -> HsQName -> Bool # (<=) :: HsQName -> HsQName -> Bool # (>) :: HsQName -> HsQName -> Bool # (>=) :: HsQName -> HsQName -> Bool # max :: HsQName -> HsQName -> HsQName # min :: HsQName -> HsQName -> HsQName #
Show HsQName # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsQName -> ShowS # show :: HsQName -> String # showList :: [HsQName] -> ShowS #
Pretty HsQName # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsQName -> Doc prettyPrec :: Int -> HsQName -> Doc

data HsName #

This type is used to represent variables, and also constructors.

Constructors

HsIdent String | varid or conid
HsSymbol String | varsym or consym

Instances

Eq HsName # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsName -> HsName -> Bool # (/=) :: HsName -> HsName -> Bool #
Data HsName # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods compare :: HsName -> HsName -> Ordering # (<) :: HsName -> HsName -> Bool # (<=) :: HsName -> HsName -> Bool # (>) :: HsName -> HsName -> Bool # (>=) :: HsName -> HsName -> Bool # max :: HsName -> HsName -> HsName # min :: HsName -> HsName -> HsName #
Show HsName # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsName -> ShowS # show :: HsName -> String # showList :: [HsName] -> ShowS #
Pretty HsName # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsName -> Doc prettyPrec :: Int -> HsName -> Doc

data HsQOp #

Possibly qualified infix operators (qop), appearing in expressions.

Constructors

HsQVarOp HsQName | variable operator (qvarop)
HsQConOp HsQName | constructor operator (qconop)

Instances

Eq HsQOp # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsQOp -> HsQOp -> Bool # (/=) :: HsQOp -> HsQOp -> Bool #
Data HsQOp # |
Instance details 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 # toConstr :: HsQOp -> Constr # 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 # |
Instance details Defined in Language.Haskell.Syntax Methods compare :: HsQOp -> HsQOp -> Ordering # (<) :: HsQOp -> HsQOp -> Bool # (<=) :: HsQOp -> HsQOp -> Bool # (>) :: HsQOp -> HsQOp -> Bool # (>=) :: HsQOp -> HsQOp -> Bool # max :: HsQOp -> HsQOp -> HsQOp # min :: HsQOp -> HsQOp -> HsQOp #
Show HsQOp # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsQOp -> ShowS # show :: HsQOp -> String # showList :: [HsQOp] -> ShowS #
Pretty HsQOp # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsQOp -> Doc prettyPrec :: Int -> HsQOp -> Doc

data HsOp #

Operators, appearing in `infix` declarations.

Constructors

HsVarOp HsName | variable operator (varop)
HsConOp HsName | constructor operator (conop)

Instances

Eq HsOp # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsOp -> HsOp -> Bool # (/=) :: HsOp -> HsOp -> Bool #
Data HsOp # |
Instance details 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 # toConstr :: HsOp -> Constr # 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 # |
Instance details Defined in Language.Haskell.Syntax Methods compare :: HsOp -> HsOp -> Ordering # (<) :: HsOp -> HsOp -> Bool # (<=) :: HsOp -> HsOp -> Bool # (>) :: HsOp -> HsOp -> Bool # (>=) :: HsOp -> HsOp -> Bool # max :: HsOp -> HsOp -> HsOp # min :: HsOp -> HsOp -> HsOp #
Show HsOp # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsOp -> ShowS # show :: HsOp -> String # showList :: [HsOp] -> ShowS #
Pretty HsOp # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsOp -> Doc prettyPrec :: Int -> HsOp -> Doc

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 `(,)` etc
HsCons | list data constructor `(:)`

Instances

Eq HsSpecialCon # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsSpecialCon -> HsSpecialCon -> Bool # (/=) :: HsSpecialCon -> HsSpecialCon -> Bool #
Data HsSpecialCon # |
Instance details Defined in Language.Haskell.Syntax Methods 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 :: (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 #
Ord HsSpecialCon # |
Instance details Defined in Language.Haskell.Syntax Methods compare :: HsSpecialCon -> HsSpecialCon -> Ordering # (<) :: HsSpecialCon -> HsSpecialCon -> Bool # (<=) :: HsSpecialCon -> HsSpecialCon -> Bool # (>) :: HsSpecialCon -> HsSpecialCon -> Bool # (>=) :: HsSpecialCon -> HsSpecialCon -> Bool # max :: HsSpecialCon -> HsSpecialCon -> HsSpecialCon # min :: HsSpecialCon -> HsSpecialCon -> HsSpecialCon #
Show HsSpecialCon # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsSpecialCon -> ShowS # show :: HsSpecialCon -> String # showList :: [HsSpecialCon] -> ShowS #

data HsCName #

A name (cname) of a component of a class or data type in an `import` or export specification.

Constructors

HsVarName HsName | name of a method or field
HsConName HsName | name of a data constructor

Instances

Eq HsCName # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: HsCName -> HsCName -> Bool # (/=) :: HsCName -> HsCName -> Bool #
Data HsCName # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods compare :: HsCName -> HsCName -> Ordering # (<) :: HsCName -> HsCName -> Bool # (<=) :: HsCName -> HsCName -> Bool # (>) :: HsCName -> HsCName -> Bool # (>=) :: HsCName -> HsCName -> Bool # max :: HsCName -> HsCName -> HsCName # min :: HsCName -> HsCName -> HsCName #
Show HsCName # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> HsCName -> ShowS # show :: HsCName -> String # showList :: [HsCName] -> ShowS #
Pretty HsCName # |
Instance details Defined in Language.Haskell.Pretty Methods pretty :: HsCName -> Doc prettyPrec :: Int -> HsCName -> Doc

# Builtin names

## Modules

prelude_mod :: Module #

main_mod :: Module #

## Main function of a program

main_name :: HsName #

## Constructors

unit_con_name :: HsQName #

tuple_con_name :: Int -> HsQName #

list_cons_name :: HsQName #

unit_con :: HsExp #

tuple_con :: Int -> HsExp #

## Type constructors

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 #

# Source coordinates

data SrcLoc #

A position in the source.

Constructors

SrcLoc |
Fields srcFilename :: String srcLine :: Int srcColumn :: Int

Instances

Eq SrcLoc # |
Instance details Defined in Language.Haskell.Syntax Methods (==) :: SrcLoc -> SrcLoc -> Bool # (/=) :: SrcLoc -> SrcLoc -> Bool #
Data SrcLoc # |
Instance details 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 # |
Instance details Defined in Language.Haskell.Syntax Methods compare :: SrcLoc -> SrcLoc -> Ordering # (<) :: SrcLoc -> SrcLoc -> Bool # (<=) :: SrcLoc -> SrcLoc -> Bool # (>) :: SrcLoc -> SrcLoc -> Bool # (>=) :: SrcLoc -> SrcLoc -> Bool # max :: SrcLoc -> SrcLoc -> SrcLoc # min :: SrcLoc -> SrcLoc -> SrcLoc #
Show SrcLoc # |
Instance details Defined in Language.Haskell.Syntax Methods showsPrec :: Int -> SrcLoc -> ShowS # show :: SrcLoc -> String # showList :: [SrcLoc] -> ShowS #