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
Source coordinates

Description

A suite of datatypes describing the abstract syntax of Haskell 98 http://www.haskell.org/onlinereport/ 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

Modules

data HsModule #

A Haskell source module.

Constructors

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

Instances

Data HsModule #
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 #
Methods showsPrec :: Int -> HsModule -> ShowS show :: HsModule -> String showList :: [HsModule] -> ShowS
Pretty HsModule #
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 #
Methods (==) :: HsExportSpec -> HsExportSpec -> Bool (/=) :: HsExportSpec -> HsExportSpec -> Bool
Data HsExportSpec #
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 #
Methods showsPrec :: Int -> HsExportSpec -> ShowS show :: HsExportSpec -> String showList :: [HsExportSpec] -> ShowS
Pretty HsExportSpec #
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 #
Methods (==) :: HsImportDecl -> HsImportDecl -> Bool (/=) :: HsImportDecl -> HsImportDecl -> Bool
Data HsImportDecl #
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 #
Methods showsPrec :: Int -> HsImportDecl -> ShowS show :: HsImportDecl -> String showList :: [HsImportDecl] -> ShowS
Pretty HsImportDecl #
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 #
Methods (==) :: HsImportSpec -> HsImportSpec -> Bool (/=) :: HsImportSpec -> HsImportSpec -> Bool
Data HsImportSpec #
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 #
Methods showsPrec :: Int -> HsImportSpec -> ShowS show :: HsImportSpec -> String showList :: [HsImportSpec] -> ShowS
Pretty HsImportSpec #
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 #
Methods (==) :: HsAssoc -> HsAssoc -> Bool (/=) :: HsAssoc -> HsAssoc -> Bool
Data HsAssoc #
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 #
Methods showsPrec :: Int -> HsAssoc -> ShowS show :: HsAssoc -> String showList :: [HsAssoc] -> ShowS
Pretty HsAssoc #
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 #
Methods (==) :: HsDecl -> HsDecl -> Bool (/=) :: HsDecl -> HsDecl -> Bool
Data HsDecl #
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 #
Methods showsPrec :: Int -> HsDecl -> ShowS show :: HsDecl -> String showList :: [HsDecl] -> ShowS
Pretty HsDecl #
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 #
Methods (==) :: HsConDecl -> HsConDecl -> Bool (/=) :: HsConDecl -> HsConDecl -> Bool
Data HsConDecl #
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 #
Methods showsPrec :: Int -> HsConDecl -> ShowS show :: HsConDecl -> String showList :: [HsConDecl] -> ShowS
Pretty HsConDecl #
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 #
Methods (==) :: HsBangType -> HsBangType -> Bool (/=) :: HsBangType -> HsBangType -> Bool
Data HsBangType #
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 #
Methods showsPrec :: Int -> HsBangType -> ShowS show :: HsBangType -> String showList :: [HsBangType] -> ShowS
Pretty HsBangType #
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 #
Methods (==) :: HsMatch -> HsMatch -> Bool (/=) :: HsMatch -> HsMatch -> Bool
Data HsMatch #
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 #
Methods showsPrec :: Int -> HsMatch -> ShowS show :: HsMatch -> String showList :: [HsMatch] -> ShowS
Pretty HsMatch #
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 #
Methods (==) :: HsRhs -> HsRhs -> Bool (/=) :: HsRhs -> HsRhs -> Bool
Data HsRhs #
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 #
Methods showsPrec :: Int -> HsRhs -> ShowS show :: HsRhs -> String showList :: [HsRhs] -> ShowS
Pretty HsRhs #
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 #
Methods (==) :: HsGuardedRhs -> HsGuardedRhs -> Bool (/=) :: HsGuardedRhs -> HsGuardedRhs -> Bool
Data HsGuardedRhs #
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 #
Methods showsPrec :: Int -> HsGuardedRhs -> ShowS show :: HsGuardedRhs -> String showList :: [HsGuardedRhs] -> ShowS
Pretty HsGuardedRhs #
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 #
Methods (==) :: HsSafety -> HsSafety -> Bool (/=) :: HsSafety -> HsSafety -> Bool
Data HsSafety #
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 #
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 #
Methods showsPrec :: Int -> HsSafety -> ShowS show :: HsSafety -> String showList :: [HsSafety] -> ShowS
Pretty HsSafety #
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 #
Methods (==) :: HsQualType -> HsQualType -> Bool (/=) :: HsQualType -> HsQualType -> Bool
Data HsQualType #
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 #
Methods showsPrec :: Int -> HsQualType -> ShowS show :: HsQualType -> String showList :: [HsQualType] -> ShowS
Pretty HsQualType #
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 #
Methods (==) :: HsType -> HsType -> Bool (/=) :: HsType -> HsType -> Bool
Data HsType #
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 #
Methods showsPrec :: Int -> HsType -> ShowS show :: HsType -> String showList :: [HsType] -> ShowS
Pretty HsType #
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 HsInfixApps 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 #
Methods (==) :: HsExp -> HsExp -> Bool (/=) :: HsExp -> HsExp -> Bool
Data HsExp #
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 #
Methods showsPrec :: Int -> HsExp -> ShowS show :: HsExp -> String showList :: [HsExp] -> ShowS
Pretty HsExp #
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 #
Methods (==) :: HsStmt -> HsStmt -> Bool (/=) :: HsStmt -> HsStmt -> Bool
Data HsStmt #
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 #
Methods showsPrec :: Int -> HsStmt -> ShowS show :: HsStmt -> String showList :: [HsStmt] -> ShowS
Pretty HsStmt #
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 #
Methods (==) :: HsFieldUpdate -> HsFieldUpdate -> Bool (/=) :: HsFieldUpdate -> HsFieldUpdate -> Bool
Data HsFieldUpdate #
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 #
Methods showsPrec :: Int -> HsFieldUpdate -> ShowS show :: HsFieldUpdate -> String showList :: [HsFieldUpdate] -> ShowS
Pretty HsFieldUpdate #
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 #
Methods (==) :: HsAlt -> HsAlt -> Bool (/=) :: HsAlt -> HsAlt -> Bool
Data HsAlt #
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 #
Methods showsPrec :: Int -> HsAlt -> ShowS show :: HsAlt -> String showList :: [HsAlt] -> ShowS
Pretty HsAlt #
Methods pretty :: HsAlt -> Doc prettyPrec :: Int -> HsAlt -> Doc

data HsGuardedAlts #

Constructors

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

Instances

Eq HsGuardedAlts #
Methods (==) :: HsGuardedAlts -> HsGuardedAlts -> Bool (/=) :: HsGuardedAlts -> HsGuardedAlts -> Bool
Data HsGuardedAlts #
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 #
Methods showsPrec :: Int -> HsGuardedAlts -> ShowS show :: HsGuardedAlts -> String showList :: [HsGuardedAlts] -> ShowS
Pretty HsGuardedAlts #
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 #
Methods (==) :: HsGuardedAlt -> HsGuardedAlt -> Bool (/=) :: HsGuardedAlt -> HsGuardedAlt -> Bool
Data HsGuardedAlt #
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 #
Methods showsPrec :: Int -> HsGuardedAlt -> ShowS show :: HsGuardedAlt -> String showList :: [HsGuardedAlt] -> ShowS
Pretty HsGuardedAlt #
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 #
Methods (==) :: HsPat -> HsPat -> Bool (/=) :: HsPat -> HsPat -> Bool
Data HsPat #
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 #
Methods showsPrec :: Int -> HsPat -> ShowS show :: HsPat -> String showList :: [HsPat] -> ShowS
Pretty HsPat #
Methods pretty :: HsPat -> Doc prettyPrec :: Int -> HsPat -> Doc

data HsPatField #

An fpat in a labeled record pattern.

Constructors

HsPFieldPat HsQName HsPat

Instances

Eq HsPatField #
Methods (==) :: HsPatField -> HsPatField -> Bool (/=) :: HsPatField -> HsPatField -> Bool
Data HsPatField #
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 #
Methods showsPrec :: Int -> HsPatField -> ShowS show :: HsPatField -> String showList :: [HsPatField] -> ShowS
Pretty HsPatField #
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 #
Methods (==) :: HsLiteral -> HsLiteral -> Bool (/=) :: HsLiteral -> HsLiteral -> Bool
Data HsLiteral #
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 #
Methods showsPrec :: Int -> HsLiteral -> ShowS show :: HsLiteral -> String showList :: [HsLiteral] -> ShowS
Pretty HsLiteral #
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 #
Methods (==) :: Module -> Module -> Bool (/=) :: Module -> Module -> Bool
Data Module #
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 #
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 #
Methods showsPrec :: Int -> Module -> ShowS show :: Module -> String showList :: [Module] -> ShowS
Pretty Module #
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 #
Methods (==) :: HsQName -> HsQName -> Bool (/=) :: HsQName -> HsQName -> Bool
Data HsQName #
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 #
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 #
Methods showsPrec :: Int -> HsQName -> ShowS show :: HsQName -> String showList :: [HsQName] -> ShowS
Pretty HsQName #
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 #
Methods (==) :: HsName -> HsName -> Bool (/=) :: HsName -> HsName -> Bool
Data HsName #
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 #
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 #
Methods showsPrec :: Int -> HsName -> ShowS show :: HsName -> String showList :: [HsName] -> ShowS
Pretty HsName #
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 #
Methods (==) :: HsQOp -> HsQOp -> Bool (/=) :: HsQOp -> HsQOp -> Bool
Data HsQOp #
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 #
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 #
Methods showsPrec :: Int -> HsQOp -> ShowS show :: HsQOp -> String showList :: [HsQOp] -> ShowS
Pretty HsQOp #
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 #
Methods (==) :: HsOp -> HsOp -> Bool (/=) :: HsOp -> HsOp -> Bool
Data HsOp #
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 #
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 #
Methods showsPrec :: Int -> HsOp -> ShowS show :: HsOp -> String showList :: [HsOp] -> ShowS
Pretty HsOp #
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 #
Methods (==) :: HsSpecialCon -> HsSpecialCon -> Bool (/=) :: HsSpecialCon -> HsSpecialCon -> Bool
Data HsSpecialCon #
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 #
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 #
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 #
Methods (==) :: HsCName -> HsCName -> Bool (/=) :: HsCName -> HsCName -> Bool
Data HsCName #
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 #
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 #
Methods showsPrec :: Int -> HsCName -> ShowS show :: HsCName -> String showList :: [HsCName] -> ShowS
Pretty HsCName #
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 #
Methods (==) :: SrcLoc -> SrcLoc -> Bool (/=) :: SrcLoc -> SrcLoc -> Bool
Data SrcLoc #
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 #
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 #
Methods showsPrec :: Int -> SrcLoc -> ShowS show :: SrcLoc -> String showList :: [SrcLoc] -> ShowS