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

Copyright(c) The GHC Team 1997-2000
LicenseBSD-style (see the file libraries/base/LICENSE)
Maintainerlibraries@haskell.org
Stabilityexperimental
Portabilityportable
Safe HaskellNone
LanguageHaskell98

Language.Haskell.Syntax

Contents

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.

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 # 
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 # 
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 # 
Pretty HsExportSpec # 

Methods

pretty :: HsExportSpec -> Doc

prettyPrec :: Int -> HsExportSpec -> Doc

data HsImportDecl #

Import declaration.

Constructors

HsImportDecl 

Fields

Instances

Eq HsImportDecl # 
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 # 
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 # 
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 # 
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 # 
Pretty HsAssoc # 

Methods

pretty :: HsAssoc -> Doc

prettyPrec :: Int -> HsAssoc -> Doc

Declarations

data HsDecl #

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 # 
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 # 
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 # 
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 # 
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 # 
Pretty HsBangType # 

Methods

pretty :: HsBangType -> Doc

prettyPrec :: Int -> HsBangType -> Doc

data HsMatch #

Clauses of a function binding.

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

Instances

Eq HsGuardedRhs # 
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 # 
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 # 
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 # 
Show HsSafety # 
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.

Instances

Eq HsQualType # 
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 # 
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 # 
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 # 
Pretty HsStmt # 

Methods

pretty :: HsStmt -> Doc

prettyPrec :: Int -> HsStmt -> Doc

data HsFieldUpdate #

An fbind in a labeled record construction or update expression.

Instances

Eq HsFieldUpdate # 
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 # 
Pretty HsFieldUpdate # 

Methods

pretty :: HsFieldUpdate -> Doc

prettyPrec :: Int -> HsFieldUpdate -> Doc

data HsAlt #

An alt in a case expression.

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 #

Instances

Eq HsGuardedAlts # 
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 # 
Pretty HsGuardedAlts # 

Methods

pretty :: HsGuardedAlts -> Doc

prettyPrec :: Int -> HsGuardedAlts -> Doc

data HsGuardedAlt #

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

Instances

Eq HsGuardedAlt # 
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 # 
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 # 
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 # 
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 # 
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 # 
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 # 
Show Module # 
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 # 
Show HsQName # 
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 # 
Show HsName # 
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 # 
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 # 
Show HsSpecialCon # 

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 # 
Show HsCName # 
Pretty HsCName # 

Methods

pretty :: HsCName -> Doc

prettyPrec :: Int -> HsCName -> Doc

Builtin names

Modules

Main function of a program

Constructors

Type constructors

Source coordinates

data SrcLoc #

A position in the source.

Constructors

SrcLoc 

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 # 
Show SrcLoc #