haskell-src-1.0.3.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 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 # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsModule -> c HsModule #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsModule #

toConstr :: HsModule -> Constr #

dataTypeOf :: HsModule -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsModule) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsModule) #

gmapT :: (forall b. Data b => b -> b) -> HsModule -> HsModule #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsModule -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsModule -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsModule -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsModule -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsModule -> m HsModule #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule -> m HsModule #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule -> m HsModule #

Show HsModule # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsModule # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsModule -> Doc

prettyPrec :: Int -> HsModule -> Doc

data HsExportSpec #

Export specification.

Constructors

HsEVar HsQName

variable

HsEAbs HsQName

T: a class or datatype exported abstractly, or a type synonym.

HsEThingAll HsQName

T(..): a class exported with all of its methods, or a datatype exported with all of its constructors.

HsEThingWith HsQName [HsCName]

T(C_1,...,C_n): a class exported with some of its methods, or a datatype exported with some of its constructors.

HsEModuleContents Module

module M: re-export a module.

Instances
Eq HsExportSpec # 
Instance details

Defined in Language.Haskell.Syntax

Data HsExportSpec # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsExportSpec -> c HsExportSpec #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsExportSpec #

toConstr :: HsExportSpec -> Constr #

dataTypeOf :: HsExportSpec -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsExportSpec) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsExportSpec) #

gmapT :: (forall b. Data b => b -> b) -> HsExportSpec -> HsExportSpec #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsExportSpec -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsExportSpec -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsExportSpec -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsExportSpec -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsExportSpec -> m HsExportSpec #

Show HsExportSpec # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsExportSpec # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsExportSpec -> Doc

prettyPrec :: Int -> HsExportSpec -> Doc

data HsImportDecl #

Import declaration.

Constructors

HsImportDecl 

Fields

Instances
Eq HsImportDecl # 
Instance details

Defined in Language.Haskell.Syntax

Data HsImportDecl # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsImportDecl -> c HsImportDecl #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsImportDecl #

toConstr :: HsImportDecl -> Constr #

dataTypeOf :: HsImportDecl -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsImportDecl) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsImportDecl) #

gmapT :: (forall b. Data b => b -> b) -> HsImportDecl -> HsImportDecl #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsImportDecl -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsImportDecl -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsImportDecl -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsImportDecl -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImportDecl -> m HsImportDecl #

Show HsImportDecl # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsImportDecl # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsImportDecl -> Doc

prettyPrec :: Int -> HsImportDecl -> Doc

data HsImportSpec #

Import specification.

Constructors

HsIVar HsName

variable

HsIAbs HsName

T: the name of a class, datatype or type synonym.

HsIThingAll HsName

T(..): a class imported with all of its methods, or a datatype imported with all of its constructors.

HsIThingWith HsName [HsCName]

T(C_1,...,C_n): a class imported with some of its methods, or a datatype imported with some of its constructors.

Instances
Eq HsImportSpec # 
Instance details

Defined in Language.Haskell.Syntax

Data HsImportSpec # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsImportSpec -> c HsImportSpec #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsImportSpec #

toConstr :: HsImportSpec -> Constr #

dataTypeOf :: HsImportSpec -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsImportSpec) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsImportSpec) #

gmapT :: (forall b. Data b => b -> b) -> HsImportSpec -> HsImportSpec #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsImportSpec -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsImportSpec -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsImportSpec -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsImportSpec -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImportSpec -> m HsImportSpec #

Show HsImportSpec # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsImportSpec # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsImportSpec -> Doc

prettyPrec :: Int -> HsImportSpec -> Doc

data HsAssoc #

Associativity of an operator.

Constructors

HsAssocNone

non-associative operator (declared with infix)

HsAssocLeft

left-associative operator (declared with infixl).

HsAssocRight

right-associative operator (declared with infixr)

Instances
Eq HsAssoc # 
Instance details

Defined in Language.Haskell.Syntax

Methods

(==) :: HsAssoc -> HsAssoc -> Bool #

(/=) :: HsAssoc -> HsAssoc -> Bool #

Data HsAssoc # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsAssoc -> c HsAssoc #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsAssoc #

toConstr :: HsAssoc -> Constr #

dataTypeOf :: HsAssoc -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsAssoc) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsAssoc) #

gmapT :: (forall b. Data b => b -> b) -> HsAssoc -> HsAssoc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsAssoc -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsAssoc -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsAssoc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsAssoc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsAssoc -> m HsAssoc #

Show HsAssoc # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsAssoc # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsAssoc -> Doc

prettyPrec :: Int -> HsAssoc -> Doc

Declarations

data HsDecl #

Instances
Eq HsDecl # 
Instance details

Defined in Language.Haskell.Syntax

Methods

(==) :: HsDecl -> HsDecl -> Bool #

(/=) :: HsDecl -> HsDecl -> Bool #

Data HsDecl # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDecl -> c HsDecl #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsDecl #

toConstr :: HsDecl -> Constr #

dataTypeOf :: HsDecl -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsDecl) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsDecl) #

gmapT :: (forall b. Data b => b -> b) -> HsDecl -> HsDecl #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDecl -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsDecl -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDecl -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDecl -> m HsDecl #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDecl -> m HsDecl #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDecl -> m HsDecl #

Show HsDecl # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsDecl # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsDecl -> Doc

prettyPrec :: Int -> HsDecl -> Doc

data HsConDecl #

Declaration of a data constructor.

Constructors

HsConDecl SrcLoc HsName [HsBangType]

ordinary data constructor

HsRecDecl SrcLoc HsName [([HsName], HsBangType)]

record constructor

Instances
Eq HsConDecl # 
Instance details

Defined in Language.Haskell.Syntax

Data HsConDecl # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDecl -> c HsConDecl #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsConDecl #

toConstr :: HsConDecl -> Constr #

dataTypeOf :: HsConDecl -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsConDecl) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsConDecl) #

gmapT :: (forall b. Data b => b -> b) -> HsConDecl -> HsConDecl #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDecl -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDecl -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsConDecl -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDecl -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDecl -> m HsConDecl #

Show HsConDecl # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsConDecl # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsConDecl -> Doc

prettyPrec :: Int -> HsConDecl -> Doc

data HsBangType #

The type of a constructor argument or field, optionally including a strictness annotation.

Constructors

HsBangedTy HsType

strict component, marked with "!"

HsUnBangedTy HsType

non-strict component

Instances
Eq HsBangType # 
Instance details

Defined in Language.Haskell.Syntax

Data HsBangType # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsBangType -> c HsBangType #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsBangType #

toConstr :: HsBangType -> Constr #

dataTypeOf :: HsBangType -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsBangType) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsBangType) #

gmapT :: (forall b. Data b => b -> b) -> HsBangType -> HsBangType #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsBangType -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsBangType -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsBangType -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsBangType -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsBangType -> m HsBangType #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBangType -> m HsBangType #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBangType -> m HsBangType #

Show HsBangType # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsBangType # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsBangType -> Doc

prettyPrec :: Int -> HsBangType -> Doc

data HsMatch #

Clauses of a function binding.

Instances
Eq HsMatch # 
Instance details

Defined in Language.Haskell.Syntax

Methods

(==) :: HsMatch -> HsMatch -> Bool #

(/=) :: HsMatch -> HsMatch -> Bool #

Data HsMatch # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsMatch -> c HsMatch #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsMatch #

toConstr :: HsMatch -> Constr #

dataTypeOf :: HsMatch -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsMatch) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsMatch) #

gmapT :: (forall b. Data b => b -> b) -> HsMatch -> HsMatch #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsMatch -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsMatch -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsMatch -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsMatch -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsMatch -> m HsMatch #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMatch -> m HsMatch #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMatch -> m HsMatch #

Show HsMatch # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsMatch # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsMatch -> Doc

prettyPrec :: Int -> HsMatch -> Doc

data HsRhs #

The right hand side of a function or pattern binding.

Constructors

HsUnGuardedRhs HsExp

unguarded right hand side (exp)

HsGuardedRhss [HsGuardedRhs]

guarded right hand side (gdrhs)

Instances
Eq HsRhs # 
Instance details

Defined in Language.Haskell.Syntax

Methods

(==) :: HsRhs -> HsRhs -> Bool #

(/=) :: HsRhs -> HsRhs -> Bool #

Data HsRhs # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsRhs -> c HsRhs #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsRhs #

toConstr :: HsRhs -> Constr #

dataTypeOf :: HsRhs -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsRhs) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRhs) #

gmapT :: (forall b. Data b => b -> b) -> HsRhs -> HsRhs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsRhs -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsRhs -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsRhs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsRhs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsRhs -> m HsRhs #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRhs -> m HsRhs #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRhs -> m HsRhs #

Show HsRhs # 
Instance details

Defined in Language.Haskell.Syntax

Methods

showsPrec :: Int -> HsRhs -> ShowS #

show :: HsRhs -> String #

showList :: [HsRhs] -> ShowS #

Pretty HsRhs # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsRhs -> Doc

prettyPrec :: Int -> HsRhs -> Doc

data HsGuardedRhs #

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

Instances
Eq HsGuardedRhs # 
Instance details

Defined in Language.Haskell.Syntax

Data HsGuardedRhs # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsGuardedRhs -> c HsGuardedRhs #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsGuardedRhs #

toConstr :: HsGuardedRhs -> Constr #

dataTypeOf :: HsGuardedRhs -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsGuardedRhs) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsGuardedRhs) #

gmapT :: (forall b. Data b => b -> b) -> HsGuardedRhs -> HsGuardedRhs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsGuardedRhs -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsGuardedRhs -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsGuardedRhs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsGuardedRhs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGuardedRhs -> m HsGuardedRhs #

Show HsGuardedRhs # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsGuardedRhs # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsGuardedRhs -> Doc

prettyPrec :: Int -> HsGuardedRhs -> Doc

data HsSafety #

Safety level for invoking a foreign entity

Constructors

HsSafe

call may generate callbacks

HsUnsafe

call will not generate callbacks

Instances
Eq HsSafety # 
Instance details

Defined in Language.Haskell.Syntax

Data HsSafety # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsSafety -> c HsSafety #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsSafety #

toConstr :: HsSafety -> Constr #

dataTypeOf :: HsSafety -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsSafety) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsSafety) #

gmapT :: (forall b. Data b => b -> b) -> HsSafety -> HsSafety #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsSafety -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsSafety -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsSafety -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsSafety -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsSafety -> m HsSafety #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSafety -> m HsSafety #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSafety -> m HsSafety #

Ord HsSafety # 
Instance details

Defined in Language.Haskell.Syntax

Show HsSafety # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsSafety # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsSafety -> Doc

prettyPrec :: Int -> HsSafety -> Doc

Class Assertions and Contexts

data HsQualType #

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

Instances
Eq HsQualType # 
Instance details

Defined in Language.Haskell.Syntax

Data HsQualType # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsQualType -> c HsQualType #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsQualType #

toConstr :: HsQualType -> Constr #

dataTypeOf :: HsQualType -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsQualType) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQualType) #

gmapT :: (forall b. Data b => b -> b) -> HsQualType -> HsQualType #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsQualType -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsQualType -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsQualType -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsQualType -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsQualType -> m HsQualType #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsQualType -> m HsQualType #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsQualType -> m HsQualType #

Show HsQualType # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsQualType # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsQualType -> Doc

prettyPrec :: Int -> HsQualType -> Doc

type HsContext = [HsAsst] #

type HsAsst = (HsQName, [HsType]) #

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

Types

data HsType #

Haskell types and type constructors.

Constructors

HsTyFun HsType HsType

function type

HsTyTuple [HsType]

tuple type

HsTyApp HsType HsType

application of a type constructor

HsTyVar HsName

type variable

HsTyCon HsQName

named type or type constructor

Instances
Eq HsType # 
Instance details

Defined in Language.Haskell.Syntax

Methods

(==) :: HsType -> HsType -> Bool #

(/=) :: HsType -> HsType -> Bool #

Data HsType # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsType -> c HsType #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsType #

toConstr :: HsType -> Constr #

dataTypeOf :: HsType -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsType) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsType) #

gmapT :: (forall b. Data b => b -> b) -> HsType -> HsType #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsType -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsType -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsType -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsType -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsType -> m HsType #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType -> m HsType #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType -> m HsType #

Show HsType # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsType # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsType -> Doc

prettyPrec :: Int -> HsType -> Doc

Expressions

data HsExp #

Haskell expressions.

Notes:

  • Because it is difficult for parsers to distinguish patterns from expressions, they typically parse them in the same way and then check that they have the appropriate form. Hence the expression type includes some forms that are found only in patterns. After these checks, these constructors should not be used.
  • The parser does not take precedence and associativity into account, so it will leave 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 # 
Instance details

Defined in Language.Haskell.Syntax

Methods

(==) :: HsExp -> HsExp -> Bool #

(/=) :: HsExp -> HsExp -> Bool #

Data HsExp # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsExp -> c HsExp #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsExp #

toConstr :: HsExp -> Constr #

dataTypeOf :: HsExp -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsExp) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsExp) #

gmapT :: (forall b. Data b => b -> b) -> HsExp -> HsExp #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsExp -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsExp -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsExp -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsExp -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsExp -> m HsExp #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsExp -> m HsExp #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsExp -> m HsExp #

Show HsExp # 
Instance details

Defined in Language.Haskell.Syntax

Methods

showsPrec :: Int -> HsExp -> ShowS #

show :: HsExp -> String #

showList :: [HsExp] -> ShowS #

Pretty HsExp # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsExp -> Doc

prettyPrec :: Int -> HsExp -> Doc

data HsStmt #

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

Constructors

HsGenerator SrcLoc HsPat HsExp

a generator pat <- exp

HsQualifier HsExp

an exp by itself: in a do-expression, an action whose result is discarded; in a list comprehension, a guard expression

HsLetStmt [HsDecl]

local bindings

Instances
Eq HsStmt # 
Instance details

Defined in Language.Haskell.Syntax

Methods

(==) :: HsStmt -> HsStmt -> Bool #

(/=) :: HsStmt -> HsStmt -> Bool #

Data HsStmt # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsStmt -> c HsStmt #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsStmt #

toConstr :: HsStmt -> Constr #

dataTypeOf :: HsStmt -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsStmt) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsStmt) #

gmapT :: (forall b. Data b => b -> b) -> HsStmt -> HsStmt #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsStmt -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsStmt -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsStmt -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsStmt -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsStmt -> m HsStmt #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsStmt -> m HsStmt #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsStmt -> m HsStmt #

Show HsStmt # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsStmt # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsStmt -> Doc

prettyPrec :: Int -> HsStmt -> Doc

data HsFieldUpdate #

An fbind in a labeled record construction or update expression.

Instances
Eq HsFieldUpdate # 
Instance details

Defined in Language.Haskell.Syntax

Data HsFieldUpdate # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsFieldUpdate -> c HsFieldUpdate #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsFieldUpdate #

toConstr :: HsFieldUpdate -> Constr #

dataTypeOf :: HsFieldUpdate -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsFieldUpdate) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsFieldUpdate) #

gmapT :: (forall b. Data b => b -> b) -> HsFieldUpdate -> HsFieldUpdate #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsFieldUpdate -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsFieldUpdate -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsFieldUpdate -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsFieldUpdate -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsFieldUpdate -> m HsFieldUpdate #

Show HsFieldUpdate # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsFieldUpdate # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsFieldUpdate -> Doc

prettyPrec :: Int -> HsFieldUpdate -> Doc

data HsAlt #

An alt in a case expression.

Instances
Eq HsAlt # 
Instance details

Defined in Language.Haskell.Syntax

Methods

(==) :: HsAlt -> HsAlt -> Bool #

(/=) :: HsAlt -> HsAlt -> Bool #

Data HsAlt # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsAlt -> c HsAlt #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsAlt #

toConstr :: HsAlt -> Constr #

dataTypeOf :: HsAlt -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsAlt) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsAlt) #

gmapT :: (forall b. Data b => b -> b) -> HsAlt -> HsAlt #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsAlt -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsAlt -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsAlt -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsAlt -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsAlt -> m HsAlt #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsAlt -> m HsAlt #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsAlt -> m HsAlt #

Show HsAlt # 
Instance details

Defined in Language.Haskell.Syntax

Methods

showsPrec :: Int -> HsAlt -> ShowS #

show :: HsAlt -> String #

showList :: [HsAlt] -> ShowS #

Pretty HsAlt # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsAlt -> Doc

prettyPrec :: Int -> HsAlt -> Doc

data HsGuardedAlts #

Instances
Eq HsGuardedAlts # 
Instance details

Defined in Language.Haskell.Syntax

Data HsGuardedAlts # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsGuardedAlts -> c HsGuardedAlts #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsGuardedAlts #

toConstr :: HsGuardedAlts -> Constr #

dataTypeOf :: HsGuardedAlts -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsGuardedAlts) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsGuardedAlts) #

gmapT :: (forall b. Data b => b -> b) -> HsGuardedAlts -> HsGuardedAlts #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsGuardedAlts -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsGuardedAlts -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsGuardedAlts -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsGuardedAlts -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGuardedAlts -> m HsGuardedAlts #

Show HsGuardedAlts # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsGuardedAlts # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsGuardedAlts -> Doc

prettyPrec :: Int -> HsGuardedAlts -> Doc

data HsGuardedAlt #

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

Instances
Eq HsGuardedAlt # 
Instance details

Defined in Language.Haskell.Syntax

Data HsGuardedAlt # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsGuardedAlt -> c HsGuardedAlt #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsGuardedAlt #

toConstr :: HsGuardedAlt -> Constr #

dataTypeOf :: HsGuardedAlt -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsGuardedAlt) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsGuardedAlt) #

gmapT :: (forall b. Data b => b -> b) -> HsGuardedAlt -> HsGuardedAlt #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsGuardedAlt -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsGuardedAlt -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsGuardedAlt -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsGuardedAlt -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsGuardedAlt -> m HsGuardedAlt #

Show HsGuardedAlt # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsGuardedAlt # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsGuardedAlt -> Doc

prettyPrec :: Int -> HsGuardedAlt -> Doc

Patterns

data HsPat #

A pattern, to be matched against a value.

Constructors

HsPVar HsName

variable

HsPLit HsLiteral

literal constant

HsPNeg HsPat

negated pattern

HsPInfixApp HsPat HsQName HsPat

pattern with infix data constructor

HsPApp HsQName [HsPat]

data constructor and argument patterns

HsPTuple [HsPat]

tuple pattern

HsPList [HsPat]

list pattern

HsPParen HsPat

parenthesized pattern

HsPRec HsQName [HsPatField]

labelled pattern

HsPAsPat HsName HsPat

@-pattern

HsPWildCard

wildcard pattern (_)

HsPIrrPat HsPat

irrefutable pattern (~)

Instances
Eq HsPat # 
Instance details

Defined in Language.Haskell.Syntax

Methods

(==) :: HsPat -> HsPat -> Bool #

(/=) :: HsPat -> HsPat -> Bool #

Data HsPat # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsPat -> c HsPat #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsPat #

toConstr :: HsPat -> Constr #

dataTypeOf :: HsPat -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsPat) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsPat) #

gmapT :: (forall b. Data b => b -> b) -> HsPat -> HsPat #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsPat -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsPat -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsPat -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsPat -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsPat -> m HsPat #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPat -> m HsPat #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPat -> m HsPat #

Show HsPat # 
Instance details

Defined in Language.Haskell.Syntax

Methods

showsPrec :: Int -> HsPat -> ShowS #

show :: HsPat -> String #

showList :: [HsPat] -> ShowS #

Pretty HsPat # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsPat -> Doc

prettyPrec :: Int -> HsPat -> Doc

data HsPatField #

An fpat in a labeled record pattern.

Constructors

HsPFieldPat HsQName HsPat 
Instances
Eq HsPatField # 
Instance details

Defined in Language.Haskell.Syntax

Data HsPatField # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsPatField -> c HsPatField #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsPatField #

toConstr :: HsPatField -> Constr #

dataTypeOf :: HsPatField -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsPatField) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsPatField) #

gmapT :: (forall b. Data b => b -> b) -> HsPatField -> HsPatField #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsPatField -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsPatField -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsPatField -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsPatField -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsPatField -> m HsPatField #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPatField -> m HsPatField #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPatField -> m HsPatField #

Show HsPatField # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsPatField # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsPatField -> Doc

prettyPrec :: Int -> HsPatField -> Doc

Literals

data HsLiteral #

literal. Values of this type hold the abstract value of the literal, not the precise string representation used. For example, 10, 0o12 and 0xa have the same representation.

Constructors

HsChar Char

character literal

HsString String

string literal

HsInt Integer

integer literal

HsFrac Rational

floating point literal

HsCharPrim Char

GHC unboxed character literal

HsStringPrim String

GHC unboxed string literal

HsIntPrim Integer

GHC unboxed integer literal

HsFloatPrim Rational

GHC unboxed float literal

HsDoublePrim Rational

GHC unboxed double literal

Instances
Eq HsLiteral # 
Instance details

Defined in Language.Haskell.Syntax

Data HsLiteral # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsLiteral -> c HsLiteral #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsLiteral #

toConstr :: HsLiteral -> Constr #

dataTypeOf :: HsLiteral -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsLiteral) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsLiteral) #

gmapT :: (forall b. Data b => b -> b) -> HsLiteral -> HsLiteral #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsLiteral -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsLiteral -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsLiteral -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsLiteral -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsLiteral -> m HsLiteral #

Show HsLiteral # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsLiteral # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsLiteral -> Doc

prettyPrec :: Int -> HsLiteral -> Doc

Variables, Constructors and Operators

newtype Module #

The name of a Haskell module.

Constructors

Module String 
Instances
Eq Module # 
Instance details

Defined in Language.Haskell.Syntax

Methods

(==) :: Module -> Module -> Bool #

(/=) :: Module -> Module -> Bool #

Data Module # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Module -> c Module #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Module #

toConstr :: Module -> Constr #

dataTypeOf :: Module -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Module) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module) #

gmapT :: (forall b. Data b => b -> b) -> Module -> Module #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r #

gmapQ :: (forall d. Data d => d -> u) -> Module -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module -> m Module #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module #

Ord Module # 
Instance details

Defined in Language.Haskell.Syntax

Show Module # 
Instance details

Defined in Language.Haskell.Syntax

Pretty Module # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: Module -> Doc

prettyPrec :: Int -> Module -> Doc

data HsQName #

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

Constructors

Qual Module HsName

name qualified with a module name

UnQual HsName

unqualified name

Special HsSpecialCon

built-in constructor with special syntax

Instances
Eq HsQName # 
Instance details

Defined in Language.Haskell.Syntax

Methods

(==) :: HsQName -> HsQName -> Bool #

(/=) :: HsQName -> HsQName -> Bool #

Data HsQName # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsQName -> c HsQName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsQName #

toConstr :: HsQName -> Constr #

dataTypeOf :: HsQName -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsQName) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQName) #

gmapT :: (forall b. Data b => b -> b) -> HsQName -> HsQName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsQName -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsQName -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsQName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsQName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsQName -> m HsQName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsQName -> m HsQName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsQName -> m HsQName #

Ord HsQName # 
Instance details

Defined in Language.Haskell.Syntax

Show HsQName # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsQName # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsQName -> Doc

prettyPrec :: Int -> HsQName -> Doc

data HsName #

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

Constructors

HsIdent String

varid or conid

HsSymbol String

varsym or consym

Instances
Eq HsName # 
Instance details

Defined in Language.Haskell.Syntax

Methods

(==) :: HsName -> HsName -> Bool #

(/=) :: HsName -> HsName -> Bool #

Data HsName # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsName -> c HsName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsName #

toConstr :: HsName -> Constr #

dataTypeOf :: HsName -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsName) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsName) #

gmapT :: (forall b. Data b => b -> b) -> HsName -> HsName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsName -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsName -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsName -> m HsName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsName -> m HsName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsName -> m HsName #

Ord HsName # 
Instance details

Defined in Language.Haskell.Syntax

Show HsName # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsName # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsName -> Doc

prettyPrec :: Int -> HsName -> Doc

data HsQOp #

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

Constructors

HsQVarOp HsQName

variable operator (qvarop)

HsQConOp HsQName

constructor operator (qconop)

Instances
Eq HsQOp # 
Instance details

Defined in Language.Haskell.Syntax

Methods

(==) :: HsQOp -> HsQOp -> Bool #

(/=) :: HsQOp -> HsQOp -> Bool #

Data HsQOp # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsQOp -> c HsQOp #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsQOp #

toConstr :: HsQOp -> Constr #

dataTypeOf :: HsQOp -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsQOp) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQOp) #

gmapT :: (forall b. Data b => b -> b) -> HsQOp -> HsQOp #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsQOp -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsQOp -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsQOp -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsQOp -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsQOp -> m HsQOp #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsQOp -> m HsQOp #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsQOp -> m HsQOp #

Ord HsQOp # 
Instance details

Defined in Language.Haskell.Syntax

Methods

compare :: HsQOp -> HsQOp -> Ordering #

(<) :: HsQOp -> HsQOp -> Bool #

(<=) :: HsQOp -> HsQOp -> Bool #

(>) :: HsQOp -> HsQOp -> Bool #

(>=) :: HsQOp -> HsQOp -> Bool #

max :: HsQOp -> HsQOp -> HsQOp #

min :: HsQOp -> HsQOp -> HsQOp #

Show HsQOp # 
Instance details

Defined in Language.Haskell.Syntax

Methods

showsPrec :: Int -> HsQOp -> ShowS #

show :: HsQOp -> String #

showList :: [HsQOp] -> ShowS #

Pretty HsQOp # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsQOp -> Doc

prettyPrec :: Int -> HsQOp -> Doc

data HsOp #

Operators, appearing in infix declarations.

Constructors

HsVarOp HsName

variable operator (varop)

HsConOp HsName

constructor operator (conop)

Instances
Eq HsOp # 
Instance details

Defined in Language.Haskell.Syntax

Methods

(==) :: HsOp -> HsOp -> Bool #

(/=) :: HsOp -> HsOp -> Bool #

Data HsOp # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsOp -> c HsOp #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsOp #

toConstr :: HsOp -> Constr #

dataTypeOf :: HsOp -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsOp) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsOp) #

gmapT :: (forall b. Data b => b -> b) -> HsOp -> HsOp #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsOp -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsOp -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsOp -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsOp -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsOp -> m HsOp #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsOp -> m HsOp #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsOp -> m HsOp #

Ord HsOp # 
Instance details

Defined in Language.Haskell.Syntax

Methods

compare :: HsOp -> HsOp -> Ordering #

(<) :: HsOp -> HsOp -> Bool #

(<=) :: HsOp -> HsOp -> Bool #

(>) :: HsOp -> HsOp -> Bool #

(>=) :: HsOp -> HsOp -> Bool #

max :: HsOp -> HsOp -> HsOp #

min :: HsOp -> HsOp -> HsOp #

Show HsOp # 
Instance details

Defined in Language.Haskell.Syntax

Methods

showsPrec :: Int -> HsOp -> ShowS #

show :: HsOp -> String #

showList :: [HsOp] -> ShowS #

Pretty HsOp # 
Instance details

Defined in Language.Haskell.Pretty

Methods

pretty :: HsOp -> Doc

prettyPrec :: Int -> HsOp -> Doc

data HsSpecialCon #

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

Constructors

HsUnitCon

unit type and data constructor ()

HsListCon

list type constructor []

HsFunCon

function type constructor ->

HsTupleCon Int

n-ary tuple type and data constructors (,) etc

HsCons

list data constructor (:)

Instances
Eq HsSpecialCon # 
Instance details

Defined in Language.Haskell.Syntax

Data HsSpecialCon # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsSpecialCon -> c HsSpecialCon #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsSpecialCon #

toConstr :: HsSpecialCon -> Constr #

dataTypeOf :: HsSpecialCon -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsSpecialCon) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsSpecialCon) #

gmapT :: (forall b. Data b => b -> b) -> HsSpecialCon -> HsSpecialCon #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsSpecialCon -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsSpecialCon -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsSpecialCon -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsSpecialCon -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSpecialCon -> m HsSpecialCon #

Ord HsSpecialCon # 
Instance details

Defined in Language.Haskell.Syntax

Show HsSpecialCon # 
Instance details

Defined in Language.Haskell.Syntax

data HsCName #

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

Constructors

HsVarName HsName

name of a method or field

HsConName HsName

name of a data constructor

Instances
Eq HsCName # 
Instance details

Defined in Language.Haskell.Syntax

Methods

(==) :: HsCName -> HsCName -> Bool #

(/=) :: HsCName -> HsCName -> Bool #

Data HsCName # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsCName -> c HsCName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsCName #

toConstr :: HsCName -> Constr #

dataTypeOf :: HsCName -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsCName) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsCName) #

gmapT :: (forall b. Data b => b -> b) -> HsCName -> HsCName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsCName -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsCName -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsCName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsCName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsCName -> m HsCName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsCName -> m HsCName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsCName -> m HsCName #

Ord HsCName # 
Instance details

Defined in Language.Haskell.Syntax

Show HsCName # 
Instance details

Defined in Language.Haskell.Syntax

Pretty HsCName # 
Instance details

Defined in Language.Haskell.Pretty

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 # 
Instance details

Defined in Language.Haskell.Syntax

Methods

(==) :: SrcLoc -> SrcLoc -> Bool #

(/=) :: SrcLoc -> SrcLoc -> Bool #

Data SrcLoc # 
Instance details

Defined in Language.Haskell.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcLoc -> c SrcLoc #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcLoc #

toConstr :: SrcLoc -> Constr #

dataTypeOf :: SrcLoc -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcLoc) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcLoc) #

gmapT :: (forall b. Data b => b -> b) -> SrcLoc -> SrcLoc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcLoc -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcLoc -> r #

gmapQ :: (forall d. Data d => d -> u) -> SrcLoc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcLoc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc #

Ord SrcLoc # 
Instance details

Defined in Language.Haskell.Syntax

Show SrcLoc # 
Instance details

Defined in Language.Haskell.Syntax