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

A Haskell source module.

Constructors

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

Instances

Data HsModule Source #
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 Source #
Methods showsPrec :: Int -> HsModule -> ShowS # show :: HsModule -> String # showList :: [HsModule] -> ShowS #
Pretty HsModule Source #
Methods pretty :: HsModule -> Doc prettyPrec :: Int -> HsModule -> Doc

data HsExportSpec Source #

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

data HsImportDecl Source #

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

data HsImportSpec Source #

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

data HsAssoc Source #

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

Declarations

data HsDecl Source #

Instances

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

data HsConDecl Source #

Declaration of a data constructor.

Constructors

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

Instances

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

data HsBangType Source #

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

data HsMatch Source #

Clauses of a function binding.

Constructors

HsMatch SrcLoc HsName [HsPat] HsRhs [HsDecl]

Instances

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

data HsRhs Source #

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

data HsGuardedRhs Source #

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

Constructors

HsGuardedRhs SrcLoc HsExp HsExp

Instances

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

data HsSafety Source #

Safety level for invoking a foreign entity

Constructors

HsSafe	call may generate callbacks
HsUnsafe	call will not generate callbacks

Instances

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

Class Assertions and Contexts

data HsQualType Source #

A type qualified with a context. An unqualified type has an empty context.

Constructors

HsQualType HsContext HsType

Instances

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

type HsContext = [HsAsst] Source #

type HsAsst = (HsQName, [HsType]) Source #

Class assertions. In Haskell 98, the argument would be a tyvar, but this definition allows multiple parameters, and allows them to be types.

Types

data HsType Source #

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

Expressions

data HsExp Source #

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

data HsStmt Source #

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

data HsFieldUpdate Source #

An fbind in a labeled record construction or update expression.

Constructors

HsFieldUpdate HsQName HsExp

Instances

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

data HsAlt Source #

An alt in a case expression.

Constructors

HsAlt SrcLoc HsPat HsGuardedAlts [HsDecl]

Instances

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

data HsGuardedAlts Source #

Constructors

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

Instances

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

data HsGuardedAlt Source #

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

Constructors

HsGuardedAlt SrcLoc HsExp HsExp

Instances

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

Patterns

data HsPat Source #

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

data HsPatField Source #

An fpat in a labeled record pattern.

Constructors

HsPFieldPat HsQName HsPat

Instances

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

Literals

data HsLiteral Source #

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

Variables, Constructors and Operators

newtype Module Source #

The name of a Haskell module.

Constructors

Module String

Instances

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

data HsQName Source #

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

data HsName Source #

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

Constructors

HsIdent String	varid or conid
HsSymbol String	varsym or consym

Instances

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

data HsQOp Source #

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

Constructors

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

Instances

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

data HsOp Source #

Operators, appearing in infix declarations.

Constructors

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

Instances

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

data HsSpecialCon Source #

Constructors with special syntax. These names are never qualified, and always refer to builtin type or data constructors.

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 Source #
Methods (==) :: HsSpecialCon -> HsSpecialCon -> Bool # (/=) :: HsSpecialCon -> HsSpecialCon -> Bool #
Data HsSpecialCon Source #
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 Source #
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 Source #
Methods showsPrec :: Int -> HsSpecialCon -> ShowS # show :: HsSpecialCon -> String # showList :: [HsSpecialCon] -> ShowS #

data HsCName Source #

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

Builtin names

Modules

prelude_mod :: Module Source #

main_mod :: Module Source #

Main function of a program

main_name :: HsName Source #

Constructors

unit_con_name :: HsQName Source #

tuple_con_name :: Int -> HsQName Source #

list_cons_name :: HsQName Source #

unit_con :: HsExp Source #

tuple_con :: Int -> HsExp Source #

Type constructors

unit_tycon_name :: HsQName Source #

fun_tycon_name :: HsQName Source #

list_tycon_name :: HsQName Source #

tuple_tycon_name :: Int -> HsQName Source #

unit_tycon :: HsType Source #

fun_tycon :: HsType Source #

list_tycon :: HsType Source #

tuple_tycon :: Int -> HsType Source #

Source coordinates

data SrcLoc Source #

A position in the source.

Constructors

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

Instances

Eq SrcLoc Source #
Methods (==) :: SrcLoc -> SrcLoc -> Bool # (/=) :: SrcLoc -> SrcLoc -> Bool #
Data SrcLoc Source #
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 Source #
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 Source #
Methods showsPrec :: Int -> SrcLoc -> ShowS # show :: SrcLoc -> String # showList :: [SrcLoc] -> ShowS #

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