derive-2.6.5: A program and library to derive instances for data types

Safe HaskellNone
LanguageHaskell2010

Data.Derive.DSL.HSE

Synopsis

Documentation

data Output Source #

Instances
Eq Output Source # 
Instance details

Defined in Data.Derive.DSL.HSE

Methods

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

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

Data Output Source # 
Instance details

Defined in Data.Derive.DSL.HSE

Methods

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

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

toConstr :: Output -> Constr #

dataTypeOf :: Output -> DataType #

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

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

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

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

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

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

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

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

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

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

Show Output Source # 
Instance details

Defined in Data.Derive.DSL.HSE

type Out = [Decl ()] Source #

showOut :: Pretty a => [a] -> String Source #

toOutput :: Data a => a -> Output Source #

coerce :: (Typeable a1, Typeable a2) => a1 -> a2 Source #

out :: Data a => a -> Output Source #

fromState :: State a x -> x Source #

readExtensions :: String -> Maybe (Maybe Language, [Extension]) #

Gather the extensions declared in LANGUAGE pragmas at the top of the file. Returns Nothing if the parse of the pragmas fails.

parseFileContentsWithMode :: ParseMode -> String -> ParseResult (Module SrcSpanInfo) #

Parse a source file from a string using a custom parse mode.

parseFileContentsWithExts :: [Extension] -> String -> ParseResult (Module SrcSpanInfo) #

Parse a source file from a string, with an extra set of extensions to know about on top of what the file itself declares.

parseFileContents :: String -> ParseResult (Module SrcSpanInfo) #

Parse a source file from a string using the default parse mode.

parseFileWithCommentsAndPragmas :: ParseMode -> FilePath -> IO (ParseResult (Module SrcSpanInfo, [Comment], [UnknownPragma])) #

Parse a source file on disk, supplying a custom parse mode, and retaining comments as well as unknown pragmas.

parseFileWithMode :: ParseMode -> FilePath -> IO (ParseResult (Module SrcSpanInfo)) #

Parse a source file on disk, supplying a custom parse mode.

parseFileWithExts :: [Extension] -> FilePath -> IO (ParseResult (Module SrcSpanInfo)) #

Parse a source file on disk, with an extra set of extensions to know about on top of what the file itself declares.

parseFile :: FilePath -> IO (ParseResult (Module SrcSpanInfo)) #

Parse a source file on disk, using the default parse mode.

metaConPat :: String -> [Pat ()] -> Pat () #

Apply a constructor of a given name to a list of pattern arguments, forming a constructor pattern.

metaFunction :: String -> [Exp ()] -> Exp () #

Apply function of a given name to a list of arguments.

nameBind :: Name () -> Exp () -> Decl () #

Bind an identifier to an expression.

patBindWhere :: Pat () -> Exp () -> [Decl ()] -> Decl () #

A pattern bind where the pattern is a variable, and where there are no guards, but with a 'where' clause.

patBind :: Pat () -> Exp () -> Decl () #

A pattern bind where the pattern is a variable, and where there are no guards and no 'where' clause.

simpleFun :: Name () -> Name () -> Exp () -> Decl () #

A function with a single clause, a single argument, no guards and no where declarations

sfun :: Name () -> [Name ()] -> Rhs () -> Maybe (Binds ()) -> Decl () #

A function with a single clause

genNames :: String -> Int -> [Name ()] #

Generate k names by appending numbers 1 through k to a given string.

wildcard :: Pat () #

The wildcard pattern: _

noBinds :: Maybe (Binds ()) #

An empty binding group.

letStmt :: [Decl ()] -> Stmt () #

A let binding group as a statement.

genStmt :: Pat () -> Exp () -> Stmt () #

A generator statement: pat <- exp

qualStmt :: Exp () -> Stmt () #

A qualifier expression statement.

pParen :: Pat () -> Pat () #

Put parentheses around a pattern.

peList :: Pat () #

The empty list pattern.

eList :: Exp () #

The empty list expression.

listE :: [Exp ()] -> Exp () #

A list expression.

altGW :: Pat () -> [Stmt ()] -> Exp () -> Binds () -> Alt () #

An alternative with a single guard in a case expression.

alt :: Pat () -> Exp () -> Alt () #

An unguarded alternative in a case expression.

caseE :: Exp () -> [Alt ()] -> Exp () #

A case expression.

letE :: [Decl ()] -> Exp () -> Exp () #

A let ... in block.

lamE :: [Pat ()] -> Exp () -> Exp () #

Lambda abstraction, given a list of argument patterns and an expression body.

doE :: [Stmt ()] -> Exp () #

A do block formed by the given statements. The last statement in the list should be a Qualifier expression.

intP :: Integer -> Pat () #

A literal integer pattern.

charP :: Char -> Pat () #

A literal character pattern.

strP :: String -> Pat () #

A literal string pattern.

intE :: Integer -> Exp () #

A literal integer expression.

charE :: Char -> Exp () #

A literal character expression.

strE :: String -> Exp () #

A literal string expression.

function :: String -> Exp () #

A function with a given name.

pvarTuple :: [Name ()] -> Pat () #

A tuple pattern consisting of variables only.

varTuple :: [Name ()] -> Exp () #

A tuple expression consisting of variables only.

pTuple :: [Pat ()] -> Pat () #

A tuple pattern.

tuple :: [Exp ()] -> Exp () #

A tuple expression.

pApp :: Name () -> [Pat ()] -> Pat () #

A constructor pattern, with argument patterns.

appFun :: Exp () -> [Exp ()] -> Exp () #

Apply a function to a list of arguments.

infixApp :: Exp () -> QOp () -> Exp () -> Exp () #

Apply an operator infix.

pvar :: Name () -> Pat () #

A pattern variable.

qvar :: ModuleName () -> Name () -> Exp () #

A qualified variable as expression.

op :: Name () -> QOp () #

Use the given identifier as an operator.

sym :: String -> Name () #

A symbol identifier. The string should be a valid Haskell symbol identifier.

name :: String -> Name () #

An identifier with the given string as its name. The string should be a valid Haskell identifier.

exactPrint :: ExactP ast => ast SrcSpanInfo -> [Comment] -> String #

Print an AST exactly as specified by the annotations on the nodes in the tree.

class Annotated ast => ExactP (ast :: Type -> Type) #

Minimal complete definition

exactP

Instances
ExactP ModuleName 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ModuleName SrcSpanInfo -> EP ()

ExactP SpecialCon 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: SpecialCon SrcSpanInfo -> EP ()

ExactP QName 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: QName SrcSpanInfo -> EP ()

ExactP Name 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Name SrcSpanInfo -> EP ()

ExactP IPName 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: IPName SrcSpanInfo -> EP ()

ExactP QOp 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: QOp SrcSpanInfo -> EP ()

ExactP Op 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Op SrcSpanInfo -> EP ()

ExactP CName 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: CName SrcSpanInfo -> EP ()

ExactP Module 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Module SrcSpanInfo -> EP ()

ExactP ModuleHead 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ModuleHead SrcSpanInfo -> EP ()

ExactP ExportSpecList 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ExportSpecList SrcSpanInfo -> EP ()

ExactP ExportSpec 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ExportSpec SrcSpanInfo -> EP ()

ExactP Namespace 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Namespace SrcSpanInfo -> EP ()

ExactP ImportDecl 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ImportDecl SrcSpanInfo -> EP ()

ExactP ImportSpecList 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ImportSpecList SrcSpanInfo -> EP ()

ExactP ImportSpec 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ImportSpec SrcSpanInfo -> EP ()

ExactP Assoc 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Assoc SrcSpanInfo -> EP ()

ExactP Decl 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Decl SrcSpanInfo -> EP ()

ExactP TypeEqn 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: TypeEqn SrcSpanInfo -> EP ()

ExactP Annotation 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Annotation SrcSpanInfo -> EP ()

ExactP BooleanFormula 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: BooleanFormula SrcSpanInfo -> EP ()

ExactP Role 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Role SrcSpanInfo -> EP ()

ExactP DataOrNew 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: DataOrNew SrcSpanInfo -> EP ()

ExactP InjectivityInfo 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

ExactP ResultSig 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ResultSig SrcSpanInfo -> EP ()

ExactP DeclHead 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: DeclHead SrcSpanInfo -> EP ()

ExactP InstRule 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: InstRule SrcSpanInfo -> EP ()

ExactP InstHead 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: InstHead SrcSpanInfo -> EP ()

ExactP Deriving 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Deriving SrcSpanInfo -> EP ()

ExactP DerivStrategy 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: DerivStrategy SrcSpanInfo -> EP ()

ExactP Binds 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Binds SrcSpanInfo -> EP ()

ExactP IPBind 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: IPBind SrcSpanInfo -> EP ()

ExactP Match 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Match SrcSpanInfo -> EP ()

ExactP QualConDecl 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: QualConDecl SrcSpanInfo -> EP ()

ExactP ConDecl 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ConDecl SrcSpanInfo -> EP ()

ExactP FieldDecl 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: FieldDecl SrcSpanInfo -> EP ()

ExactP GadtDecl 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: GadtDecl SrcSpanInfo -> EP ()

ExactP ClassDecl 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ClassDecl SrcSpanInfo -> EP ()

ExactP InstDecl 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: InstDecl SrcSpanInfo -> EP ()

ExactP BangType 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: BangType SrcSpanInfo -> EP ()

ExactP Unpackedness 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Unpackedness SrcSpanInfo -> EP ()

ExactP Rhs 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Rhs SrcSpanInfo -> EP ()

ExactP GuardedRhs 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: GuardedRhs SrcSpanInfo -> EP ()

ExactP Type 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Type SrcSpanInfo -> EP ()

ExactP MaybePromotedName 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

ExactP Promoted 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Promoted SrcSpanInfo -> EP ()

ExactP TyVarBind 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: TyVarBind SrcSpanInfo -> EP ()

ExactP Kind 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Kind SrcSpanInfo -> EP ()

ExactP FunDep 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: FunDep SrcSpanInfo -> EP ()

ExactP Context 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Context SrcSpanInfo -> EP ()

ExactP Asst 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Asst SrcSpanInfo -> EP ()

ExactP Literal 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Literal SrcSpanInfo -> EP ()

ExactP Sign 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Sign SrcSpanInfo -> EP ()

ExactP Exp 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Exp SrcSpanInfo -> EP ()

ExactP XName 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: XName SrcSpanInfo -> EP ()

ExactP XAttr 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: XAttr SrcSpanInfo -> EP ()

ExactP Bracket 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Bracket SrcSpanInfo -> EP ()

ExactP Splice 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Splice SrcSpanInfo -> EP ()

ExactP Safety 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Safety SrcSpanInfo -> EP ()

ExactP CallConv 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: CallConv SrcSpanInfo -> EP ()

ExactP ModulePragma 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ModulePragma SrcSpanInfo -> EP ()

ExactP Overlap 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Overlap SrcSpanInfo -> EP ()

ExactP Activation 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Activation SrcSpanInfo -> EP ()

ExactP Rule 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Rule SrcSpanInfo -> EP ()

ExactP RuleVar 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: RuleVar SrcSpanInfo -> EP ()

ExactP WarningText 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: WarningText SrcSpanInfo -> EP ()

ExactP Pat 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Pat SrcSpanInfo -> EP ()

ExactP PXAttr 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: PXAttr SrcSpanInfo -> EP ()

ExactP RPatOp 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: RPatOp SrcSpanInfo -> EP ()

ExactP RPat 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: RPat SrcSpanInfo -> EP ()

ExactP PatField 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: PatField SrcSpanInfo -> EP ()

ExactP Stmt 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Stmt SrcSpanInfo -> EP ()

ExactP QualStmt 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: QualStmt SrcSpanInfo -> EP ()

ExactP FieldUpdate 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: FieldUpdate SrcSpanInfo -> EP ()

ExactP Alt 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Alt SrcSpanInfo -> EP ()

ExactP GuardedAlt 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: GuardedAlt SrcSpanInfo -> EP ()

ExactP GuardedAlts 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: GuardedAlts SrcSpanInfo -> EP ()

unListOf :: ListOf a -> [a] #

getTopPragmas :: String -> ParseResult [ModulePragma SrcSpanInfo] #

Non-greedy parse of a string starting with a series of top-level option pragmas.

parseImportDeclWithComments :: ParseMode -> String -> ParseResult (ImportDecl SrcSpanInfo, [Comment]) #

Parse of a string containing a complete Haskell module, using an explicit ParseMode, retaining comments.

parseImportDeclWithMode :: ParseMode -> String -> ParseResult (ImportDecl SrcSpanInfo) #

Parse of a string containing a Haskell type, using an explicit ParseMode.

parseImportDecl :: String -> ParseResult (ImportDecl SrcSpanInfo) #

Parse of a string containing a Haskell statement, using defaultParseMode.

parseStmtWithComments :: ParseMode -> String -> ParseResult (Stmt SrcSpanInfo, [Comment]) #

Parse of a string containing a complete Haskell module, using an explicit ParseMode, retaining comments.

parseStmtWithMode :: ParseMode -> String -> ParseResult (Stmt SrcSpanInfo) #

Parse of a string containing a Haskell type, using an explicit ParseMode.

parseStmt :: String -> ParseResult (Stmt SrcSpanInfo) #

Parse of a string containing a Haskell statement, using defaultParseMode.

parseTypeWithComments :: ParseMode -> String -> ParseResult (Type SrcSpanInfo, [Comment]) #

Parse of a string containing a complete Haskell module, using an explicit ParseMode, retaining comments.

parseTypeWithMode :: ParseMode -> String -> ParseResult (Type SrcSpanInfo) #

Parse of a string containing a Haskell type, using an explicit ParseMode.

parseType :: String -> ParseResult (Type SrcSpanInfo) #

Parse of a string containing a Haskell type, using defaultParseMode.

parseDeclWithComments :: ParseMode -> String -> ParseResult (Decl SrcSpanInfo, [Comment]) #

Parse of a string containing a complete Haskell module, using an explicit ParseMode, retaining comments.

parseDeclWithMode :: ParseMode -> String -> ParseResult (Decl SrcSpanInfo) #

Parse of a string containing a Haskell top-level declaration, using an explicit ParseMode.

parseDecl :: String -> ParseResult (Decl SrcSpanInfo) #

Parse of a string containing a Haskell top-level declaration, using defaultParseMode.

parsePatWithComments :: ParseMode -> String -> ParseResult (Pat SrcSpanInfo, [Comment]) #

Parse of a string containing a complete Haskell module, using an explicit ParseMode, retaining comments.

parsePatWithMode :: ParseMode -> String -> ParseResult (Pat SrcSpanInfo) #

Parse of a string containing a Haskell pattern, using an explicit ParseMode.

parsePat :: String -> ParseResult (Pat SrcSpanInfo) #

Parse of a string containing a Haskell pattern, using defaultParseMode.

parseExpWithComments :: ParseMode -> String -> ParseResult (Exp SrcSpanInfo, [Comment]) #

Parse of a string containing a complete Haskell module, using an explicit ParseMode, retaining comments.

parseExpWithMode :: ParseMode -> String -> ParseResult (Exp SrcSpanInfo) #

Parse of a string containing a Haskell expression, using an explicit ParseMode.

parseExp :: String -> ParseResult (Exp SrcSpanInfo) #

Parse of a string containing a Haskell expression, using defaultParseMode.

parseModuleWithComments :: ParseMode -> String -> ParseResult (Module SrcSpanInfo, [Comment]) #

Parse of a string containing a complete Haskell module, using an explicit ParseMode, retaining comments.

parseModuleWithMode :: ParseMode -> String -> ParseResult (Module SrcSpanInfo) #

Parse of a string containing a complete Haskell module, using an explicit ParseMode.

parseModule :: String -> ParseResult (Module SrcSpanInfo) #

Parse of a string, which should contain a complete Haskell module, using defaultParseMode.

data PragmasAndModuleName l #

Type intended to be used with Parseable, with instances that implement a non-greedy parse of the module name, including top-level pragmas. This means that a parse error that comes after the module header won't be returned. If the Maybe value is Nothing, then this means that there was no module header.

Instances
Eq l => Eq (PragmasAndModuleName l) 
Instance details

Defined in Language.Haskell.Exts.Parser

Data l => Data (PragmasAndModuleName l) 
Instance details

Defined in Language.Haskell.Exts.Parser

Methods

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

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

toConstr :: PragmasAndModuleName l -> Constr #

dataTypeOf :: PragmasAndModuleName l -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (PragmasAndModuleName l) 
Instance details

Defined in Language.Haskell.Exts.Parser

Show l => Show (PragmasAndModuleName l) 
Instance details

Defined in Language.Haskell.Exts.Parser

Parseable (NonGreedy (PragmasAndModuleName SrcSpanInfo)) 
Instance details

Defined in Language.Haskell.Exts.Parser

data PragmasAndModuleHead l #

Instances
Eq l => Eq (PragmasAndModuleHead l) 
Instance details

Defined in Language.Haskell.Exts.Parser

Data l => Data (PragmasAndModuleHead l) 
Instance details

Defined in Language.Haskell.Exts.Parser

Methods

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

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

toConstr :: PragmasAndModuleHead l -> Constr #

dataTypeOf :: PragmasAndModuleHead l -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (PragmasAndModuleHead l) 
Instance details

Defined in Language.Haskell.Exts.Parser

Show l => Show (PragmasAndModuleHead l) 
Instance details

Defined in Language.Haskell.Exts.Parser

Parseable (NonGreedy (PragmasAndModuleHead SrcSpanInfo)) 
Instance details

Defined in Language.Haskell.Exts.Parser

data ModuleHeadAndImports l #

Instances
Eq l => Eq (ModuleHeadAndImports l) 
Instance details

Defined in Language.Haskell.Exts.Parser

Data l => Data (ModuleHeadAndImports l) 
Instance details

Defined in Language.Haskell.Exts.Parser

Methods

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

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

toConstr :: ModuleHeadAndImports l -> Constr #

dataTypeOf :: ModuleHeadAndImports l -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (ModuleHeadAndImports l) 
Instance details

Defined in Language.Haskell.Exts.Parser

Show l => Show (ModuleHeadAndImports l) 
Instance details

Defined in Language.Haskell.Exts.Parser

Parseable (NonGreedy (ModuleHeadAndImports SrcSpanInfo)) 
Instance details

Defined in Language.Haskell.Exts.Parser

newtype NonGreedy a #

Instances of Parseable for NonGreedy a will only consume the input until a is fully parsed. This means that parse errors that come later in the input will be ignored. It's also more efficient, as it's fully lazy in the remainder of the input:

>>> parse (unlines ("module A where" : "main =" : repeat "blah")) :: ParseResult PragmasAndModuleHead
ParseOk (NonGreedy {unNonGreedy = PragmasAndModuleHead [] (ModuleName "A",Nothing,Nothing)})

(this example uses the simplified AST)

Constructors

NonGreedy 

Fields

Instances
Functor NonGreedy 
Instance details

Defined in Language.Haskell.Exts.Parser

Methods

fmap :: (a -> b) -> NonGreedy a -> NonGreedy b #

(<$) :: a -> NonGreedy b -> NonGreedy a #

Eq a => Eq (NonGreedy a) 
Instance details

Defined in Language.Haskell.Exts.Parser

Methods

(==) :: NonGreedy a -> NonGreedy a -> Bool #

(/=) :: NonGreedy a -> NonGreedy a -> Bool #

Data a => Data (NonGreedy a) 
Instance details

Defined in Language.Haskell.Exts.Parser

Methods

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

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

toConstr :: NonGreedy a -> Constr #

dataTypeOf :: NonGreedy a -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord a => Ord (NonGreedy a) 
Instance details

Defined in Language.Haskell.Exts.Parser

Show a => Show (NonGreedy a) 
Instance details

Defined in Language.Haskell.Exts.Parser

Parseable (NonGreedy (PragmasAndModuleName SrcSpanInfo)) 
Instance details

Defined in Language.Haskell.Exts.Parser

Parseable (NonGreedy (PragmasAndModuleHead SrcSpanInfo)) 
Instance details

Defined in Language.Haskell.Exts.Parser

Parseable (NonGreedy (ModuleHeadAndImports SrcSpanInfo)) 
Instance details

Defined in Language.Haskell.Exts.Parser

Parseable (NonGreedy (ListOf (ModulePragma SrcSpanInfo))) 
Instance details

Defined in Language.Haskell.Exts.Parser

data ListOf a #

ListOf a stores lists of the AST type a, along with a SrcSpanInfo, in order to provide Parseable instances for lists. These instances are provided when the type is used as a list in the syntax, and the same delimiters are used in all of its usages. Some exceptions are made:

Constructors

ListOf SrcSpanInfo [a] 
Instances
Functor ListOf 
Instance details

Defined in Language.Haskell.Exts.Parser

Methods

fmap :: (a -> b) -> ListOf a -> ListOf b #

(<$) :: a -> ListOf b -> ListOf a #

Eq a => Eq (ListOf a) 
Instance details

Defined in Language.Haskell.Exts.Parser

Methods

(==) :: ListOf a -> ListOf a -> Bool #

(/=) :: ListOf a -> ListOf a -> Bool #

Data a => Data (ListOf a) 
Instance details

Defined in Language.Haskell.Exts.Parser

Methods

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

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

toConstr :: ListOf a -> Constr #

dataTypeOf :: ListOf a -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord a => Ord (ListOf a) 
Instance details

Defined in Language.Haskell.Exts.Parser

Methods

compare :: ListOf a -> ListOf a -> Ordering #

(<) :: ListOf a -> ListOf a -> Bool #

(<=) :: ListOf a -> ListOf a -> Bool #

(>) :: ListOf a -> ListOf a -> Bool #

(>=) :: ListOf a -> ListOf a -> Bool #

max :: ListOf a -> ListOf a -> ListOf a #

min :: ListOf a -> ListOf a -> ListOf a #

Show a => Show (ListOf a) 
Instance details

Defined in Language.Haskell.Exts.Parser

Methods

showsPrec :: Int -> ListOf a -> ShowS #

show :: ListOf a -> String #

showList :: [ListOf a] -> ShowS #

Parseable (NonGreedy (ListOf (ModulePragma SrcSpanInfo))) 
Instance details

Defined in Language.Haskell.Exts.Parser

lexTokenStreamWithMode :: ParseMode -> String -> ParseResult [Loc Token] #

Lex a string into a list of Haskell source tokens, using an explicit mode.

lexTokenStream :: String -> ParseResult [Loc Token] #

Lex a string into a list of Haskell 2010 source tokens.

data Token #

Constructors

VarId String 
LabelVarId String 
QVarId (String, String) 
IDupVarId String 
ILinVarId String 
ConId String 
QConId (String, String) 
DVarId [String] 
VarSym String 
ConSym String 
QVarSym (String, String) 
QConSym (String, String) 
IntTok (Integer, String) 
FloatTok (Rational, String) 
Character (Char, String) 
StringTok (String, String) 
IntTokHash (Integer, String) 
WordTokHash (Integer, String) 
FloatTokHash (Rational, String) 
DoubleTokHash (Rational, String) 
CharacterHash (Char, String) 
StringHash (String, String) 
LeftParen 
RightParen 
LeftHashParen 
RightHashParen 
SemiColon 
LeftCurly 
RightCurly 
VRightCurly 
LeftSquare 
RightSquare 
ParArrayLeftSquare 
ParArrayRightSquare 
Comma 
Underscore 
BackQuote 
Dot 
DotDot 
Colon 
QuoteColon 
DoubleColon 
Equals 
Backslash 
Bar 
LeftArrow 
RightArrow 
At 
TApp 
Tilde 
DoubleArrow 
Minus 
Exclamation 
Star 
LeftArrowTail 
RightArrowTail 
LeftDblArrowTail 
RightDblArrowTail 
THExpQuote 
THPatQuote 
THDecQuote 
THTypQuote 
THCloseQuote 
THIdEscape String

]

THParenEscape 
THVarQuote 
THTyQuote 
THQuasiQuote (String, String) 
RPGuardOpen 
RPGuardClose 
RPCAt

)

XCodeTagOpen 
XCodeTagClose 
XStdTagOpen 
XStdTagClose 
XCloseTagOpen 
XEmptyTagClose 
XChildTagOpen 
XPCDATA String 
XRPatOpen 
XRPatClose 
PragmaEnd 
RULES 
INLINE Bool 
INLINE_CONLIKE 
SPECIALISE 
SPECIALISE_INLINE Bool 
SOURCE 
DEPRECATED 
WARNING 
SCC 
GENERATED 
CORE 
UNPACK 
NOUNPACK 
OPTIONS (Maybe String, String) 
LANGUAGE 
ANN 
MINIMAL 
NO_OVERLAP 
OVERLAP 
OVERLAPPING 
OVERLAPPABLE 
OVERLAPS 
INCOHERENT 
COMPLETE 
KW_As 
KW_By 
KW_Case 
KW_Class 
KW_Data 
KW_Default 
KW_Deriving 
KW_Do 
KW_MDo 
KW_Else 
KW_Family 
KW_Forall 
KW_Group 
KW_Hiding 
KW_If 
KW_Import 
KW_In 
KW_Infix 
KW_InfixL 
KW_InfixR 
KW_Instance 
KW_Let 
KW_Module 
KW_NewType 
KW_Of 
KW_Proc 
KW_Rec 
KW_Role 
KW_Then 
KW_Type 
KW_Using 
KW_Where 
KW_Qualified 
KW_Pattern 
KW_Stock 
KW_Anyclass 
KW_Foreign 
KW_Export 
KW_Safe 
KW_Unsafe 
KW_Threadsafe 
KW_Interruptible 
KW_StdCall 
KW_CCall 
KW_CPlusPlus 
KW_DotNet 
KW_Jvm 
KW_Js 
KW_JavaScript 
KW_CApi 
EOF 
Instances
Eq Token 
Instance details

Defined in Language.Haskell.Exts.InternalLexer

Methods

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

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

Show Token 
Instance details

Defined in Language.Haskell.Exts.InternalLexer

Methods

showsPrec :: Int -> Token -> ShowS #

show :: Token -> String #

showList :: [Token] -> ShowS #

defaultParseMode :: ParseMode #

Default parameters for a parse. The default is an unknown filename, no extensions (i.e. Haskell 98), don't ignore LANGUAGE pragmas, do ignore LINE pragmas, and be aware of fixities from the Prelude.

fromParseResult :: ParseResult a -> a #

Retrieve the result of a successful parse, throwing an error if the parse is actually not successful.

class Parseable ast where #

Class providing function for parsing at many different types.

Note that for convenience of implementation, the default methods have definitions equivalent to undefined. The minimal definition is all of the visible methods.

Minimal complete definition

parser

Methods

parse :: String -> ParseResult ast #

Parse a string with default mode.

parseWithMode :: ParseMode -> String -> ParseResult ast #

Parse a string with an explicit ParseMode.

parseWithComments :: ParseMode -> String -> ParseResult (ast, [Comment]) #

Parse a string with an explicit ParseMode, returning all comments along with the AST.

Instances
Parseable (NonGreedy (PragmasAndModuleName SrcSpanInfo)) 
Instance details

Defined in Language.Haskell.Exts.Parser

Parseable (NonGreedy (PragmasAndModuleHead SrcSpanInfo)) 
Instance details

Defined in Language.Haskell.Exts.Parser

Parseable (NonGreedy (ModuleHeadAndImports SrcSpanInfo)) 
Instance details

Defined in Language.Haskell.Exts.Parser

Parseable (NonGreedy (ListOf (ModulePragma SrcSpanInfo))) 
Instance details

Defined in Language.Haskell.Exts.Parser

data ParseResult a #

The result of a parse.

Constructors

ParseOk a

The parse succeeded, yielding a value.

ParseFailed SrcLoc String

The parse failed at the specified source location, with an error message.

Instances
Monad ParseResult 
Instance details

Defined in Language.Haskell.Exts.ParseMonad

Functor ParseResult 
Instance details

Defined in Language.Haskell.Exts.ParseMonad

Methods

fmap :: (a -> b) -> ParseResult a -> ParseResult b #

(<$) :: a -> ParseResult b -> ParseResult a #

MonadFail ParseResult 
Instance details

Defined in Language.Haskell.Exts.ParseMonad

Methods

fail :: String -> ParseResult a #

Applicative ParseResult 
Instance details

Defined in Language.Haskell.Exts.ParseMonad

Methods

pure :: a -> ParseResult a #

(<*>) :: ParseResult (a -> b) -> ParseResult a -> ParseResult b #

liftA2 :: (a -> b -> c) -> ParseResult a -> ParseResult b -> ParseResult c #

(*>) :: ParseResult a -> ParseResult b -> ParseResult b #

(<*) :: ParseResult a -> ParseResult b -> ParseResult a #

Show a => Show (ParseResult a) 
Instance details

Defined in Language.Haskell.Exts.ParseMonad

Semigroup m => Semigroup (ParseResult m) 
Instance details

Defined in Language.Haskell.Exts.ParseMonad

(Monoid m, Semigroup m) => Monoid (ParseResult m) 
Instance details

Defined in Language.Haskell.Exts.ParseMonad

data ParseMode #

Static parameters governing a parse. Note that the various parse functions in Language.Haskell.Exts.Parser never look at LANGUAGE pragmas, regardless of what the ignoreLanguagePragmas flag is set to. Only the various parseFile functions in Language.Haskell.Exts will act on it, when set to False.

Constructors

ParseMode 

Fields

associateHaddock :: (Annotated ast, Traversable ast) => (ast SrcSpanInfo, [Comment]) -> ast (SrcSpanInfo, [Comment]) #

Associates an AST with Source Span Information with relevant Haddock comments

data Comment #

A Haskell comment. The Bool is True if the comment is multi-line, i.e. {- -}.

Constructors

Comment Bool SrcSpan String 
Instances
Eq Comment 
Instance details

Defined in Language.Haskell.Exts.Comments

Methods

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

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

Data Comment 
Instance details

Defined in Language.Haskell.Exts.Comments

Methods

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

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

toConstr :: Comment -> Constr #

dataTypeOf :: Comment -> DataType #

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

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

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

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

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

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

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

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

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

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

Show Comment 
Instance details

Defined in Language.Haskell.Exts.Comments

data UnknownPragma #

An unknown pragma.

Instances
Eq UnknownPragma 
Instance details

Defined in Language.Haskell.Exts.Comments

Data UnknownPragma 
Instance details

Defined in Language.Haskell.Exts.Comments

Methods

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

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

toConstr :: UnknownPragma -> Constr #

dataTypeOf :: UnknownPragma -> DataType #

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

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

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

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

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

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

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

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

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

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

Show UnknownPragma 
Instance details

Defined in Language.Haskell.Exts.Comments

infix_ :: Int -> [String] -> [Fixity] #

infixl_ :: Int -> [String] -> [Fixity] #

infixr_ :: Int -> [String] -> [Fixity] #

baseFixities :: [Fixity] #

All fixities defined in the base package.

Note that the +++ operator appears in both Control.Arrows and Text.ParserCombinators.ReadP. The listed precedence for +++ in this list is that of Control.Arrows.

preludeFixities :: [Fixity] #

All fixities defined in the Prelude.

data Fixity #

Operator fixities are represented by their associativity (left, right or none) and their precedence (0-9).

Constructors

Fixity (Assoc ()) Int (QName ()) 
Instances
Eq Fixity 
Instance details

Defined in Language.Haskell.Exts.Fixity

Methods

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

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

Data Fixity 
Instance details

Defined in Language.Haskell.Exts.Fixity

Methods

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

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

toConstr :: Fixity -> Constr #

dataTypeOf :: Fixity -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Fixity 
Instance details

Defined in Language.Haskell.Exts.Fixity

Show Fixity 
Instance details

Defined in Language.Haskell.Exts.Fixity

class AppFixity (ast :: Type -> Type) where #

All AST elements that may include expressions which in turn may need fixity tweaking will be instances of this class.

Methods

applyFixities #

Arguments

:: Monad m 
=> [Fixity]

The fixities to account for.

-> ast SrcSpanInfo

The element to tweak.

-> m (ast SrcSpanInfo)

The same element, but with operator expressions updated, or a failure.

Tweak any expressions in the element to account for the fixities given. Assumes that all operator expressions are fully left associative chains to begin with.

Instances
AppFixity Module 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity Decl 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity PatternSynDirection 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity Annotation 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity Binds 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity IPBind 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity Match 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity ClassDecl 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity InstDecl 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity Rhs 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity GuardedRhs 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity Exp 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity XAttr 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity Bracket 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity Splice 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity Pat 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity PXAttr 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity RPat 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity PatField 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity Stmt 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity QualStmt 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity FieldUpdate 
Instance details

Defined in Language.Haskell.Exts.Fixity

AppFixity Alt 
Instance details

Defined in Language.Haskell.Exts.Fixity

prettyPrimWithMode :: Pretty a => PPHsMode -> a -> Doc #

pretty-print with the default style and a given mode.

prettyPrim :: Pretty a => a -> Doc #

pretty-print with the default style and defaultMode.

prettyPrint :: Pretty a => a -> String #

pretty-print with the default style and defaultMode.

prettyPrintWithMode :: Pretty a => PPHsMode -> a -> String #

pretty-print with the default style and a given mode.

prettyPrintStyleMode :: Pretty a => Style -> PPHsMode -> a -> String #

render the document with a given mode. renderWithMode :: PPHsMode -> Doc -> String renderWithMode = renderStyleMode P.style

render the document with defaultMode. render :: Doc -> String render = renderWithMode defaultMode

pretty-print with a given style and mode.

defaultMode :: PPHsMode #

The default mode: pretty-print using the offside rule and sensible defaults.

data PPLayout #

Varieties of layout we can use.

Constructors

PPOffsideRule

classical layout

PPSemiColon

classical layout made explicit

PPInLine

inline decls, with newlines between them

PPNoLayout

everything on a single line

Instances
Eq PPLayout 
Instance details

Defined in Language.Haskell.Exts.Pretty

type Indent = Int #

data PPHsMode #

Pretty-printing parameters.

Note: the onsideIndent must be positive and less than all other indents.

Constructors

PPHsMode 

Fields

class Pretty a #

Things that can be pretty-printed, including all the syntactic objects in Language.Haskell.Exts.Syntax.

Instances
Pretty Tool 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Tool -> Doc

prettyPrec :: Int -> Tool -> Doc

Pretty SrcLoc 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: SrcLoc -> Doc

prettyPrec :: Int -> SrcLoc -> Doc

Pretty SrcSpan 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: SrcSpan -> Doc

prettyPrec :: Int -> SrcSpan -> Doc

SrcInfo loc => Pretty (PExp loc) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: PExp loc -> Doc

prettyPrec :: Int -> PExp loc -> Doc

SrcInfo loc => Pretty (PFieldUpdate loc) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: PFieldUpdate loc -> Doc

prettyPrec :: Int -> PFieldUpdate loc -> Doc

SrcInfo loc => Pretty (ParseXAttr loc) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ParseXAttr loc -> Doc

prettyPrec :: Int -> ParseXAttr loc -> Doc

SrcInfo loc => Pretty (PContext loc) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: PContext loc -> Doc

prettyPrec :: Int -> PContext loc -> Doc

SrcInfo loc => Pretty (PType loc) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: PType loc -> Doc

prettyPrec :: Int -> PType loc -> Doc

SrcInfo loc => Pretty (PAsst loc) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: PAsst loc -> Doc

prettyPrec :: Int -> PAsst loc -> Doc

Pretty (ModuleName l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ModuleName l -> Doc

prettyPrec :: Int -> ModuleName l -> Doc

Pretty (SpecialCon l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: SpecialCon l -> Doc

prettyPrec :: Int -> SpecialCon l -> Doc

Pretty (QName l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: QName l -> Doc

prettyPrec :: Int -> QName l -> Doc

Pretty (Name l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Name l -> Doc

prettyPrec :: Int -> Name l -> Doc

Pretty (IPName l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: IPName l -> Doc

prettyPrec :: Int -> IPName l -> Doc

Pretty (QOp l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: QOp l -> Doc

prettyPrec :: Int -> QOp l -> Doc

Pretty (Op l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Op l -> Doc

prettyPrec :: Int -> Op l -> Doc

Pretty (CName l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: CName l -> Doc

prettyPrec :: Int -> CName l -> Doc

Pretty (Module pos) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Module pos -> Doc

prettyPrec :: Int -> Module pos -> Doc

Pretty (ModuleHead l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ModuleHead l -> Doc

prettyPrec :: Int -> ModuleHead l -> Doc

Pretty (ExportSpecList l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ExportSpecList l -> Doc

prettyPrec :: Int -> ExportSpecList l -> Doc

Pretty (ExportSpec l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ExportSpec l -> Doc

prettyPrec :: Int -> ExportSpec l -> Doc

Pretty (Namespace l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Namespace l -> Doc

prettyPrec :: Int -> Namespace l -> Doc

Pretty (ImportDecl l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ImportDecl l -> Doc

prettyPrec :: Int -> ImportDecl l -> Doc

Pretty (ImportSpecList l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ImportSpecList l -> Doc

prettyPrec :: Int -> ImportSpecList l -> Doc

Pretty (ImportSpec l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ImportSpec l -> Doc

prettyPrec :: Int -> ImportSpec l -> Doc

Pretty (Assoc l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Assoc l -> Doc

prettyPrec :: Int -> Assoc l -> Doc

Pretty (Decl l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Decl l -> Doc

prettyPrec :: Int -> Decl l -> Doc

Pretty (TypeEqn l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: TypeEqn l -> Doc

prettyPrec :: Int -> TypeEqn l -> Doc

Pretty (Annotation l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Annotation l -> Doc

prettyPrec :: Int -> Annotation l -> Doc

Pretty (BooleanFormula l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: BooleanFormula l -> Doc

prettyPrec :: Int -> BooleanFormula l -> Doc

Pretty (Role l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Role l -> Doc

prettyPrec :: Int -> Role l -> Doc

Pretty (DataOrNew l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: DataOrNew l -> Doc

prettyPrec :: Int -> DataOrNew l -> Doc

Pretty (InjectivityInfo l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: InjectivityInfo l -> Doc

prettyPrec :: Int -> InjectivityInfo l -> Doc

Pretty (ResultSig l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ResultSig l -> Doc

prettyPrec :: Int -> ResultSig l -> Doc

Pretty (DeclHead l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: DeclHead l -> Doc

prettyPrec :: Int -> DeclHead l -> Doc

Pretty (InstRule l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: InstRule l -> Doc

prettyPrec :: Int -> InstRule l -> Doc

Pretty (InstHead l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: InstHead l -> Doc

prettyPrec :: Int -> InstHead l -> Doc

Pretty (Deriving l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Deriving l -> Doc

prettyPrec :: Int -> Deriving l -> Doc

Pretty (DerivStrategy l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: DerivStrategy l -> Doc

prettyPrec :: Int -> DerivStrategy l -> Doc

Pretty (IPBind l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: IPBind l -> Doc

prettyPrec :: Int -> IPBind l -> Doc

Pretty (Match l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Match l -> Doc

prettyPrec :: Int -> Match l -> Doc

Pretty (QualConDecl l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: QualConDecl l -> Doc

prettyPrec :: Int -> QualConDecl l -> Doc

Pretty (ConDecl l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ConDecl l -> Doc

prettyPrec :: Int -> ConDecl l -> Doc

Pretty (FieldDecl l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: FieldDecl l -> Doc

prettyPrec :: Int -> FieldDecl l -> Doc

Pretty (GadtDecl l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: GadtDecl l -> Doc

prettyPrec :: Int -> GadtDecl l -> Doc

Pretty (ClassDecl l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ClassDecl l -> Doc

prettyPrec :: Int -> ClassDecl l -> Doc

Pretty (InstDecl l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: InstDecl l -> Doc

prettyPrec :: Int -> InstDecl l -> Doc

Pretty (BangType l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: BangType l -> Doc

prettyPrec :: Int -> BangType l -> Doc

Pretty (Unpackedness l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Unpackedness l -> Doc

prettyPrec :: Int -> Unpackedness l -> Doc

Pretty (Rhs l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Rhs l -> Doc

prettyPrec :: Int -> Rhs l -> Doc

Pretty (GuardedRhs l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: GuardedRhs l -> Doc

prettyPrec :: Int -> GuardedRhs l -> Doc

Pretty (Type l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Type l -> Doc

prettyPrec :: Int -> Type l -> Doc

Pretty (MaybePromotedName l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: MaybePromotedName l -> Doc

prettyPrec :: Int -> MaybePromotedName l -> Doc

Pretty (Promoted l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Promoted l -> Doc

prettyPrec :: Int -> Promoted l -> Doc

Pretty (TyVarBind l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: TyVarBind l -> Doc

prettyPrec :: Int -> TyVarBind l -> Doc

Pretty (Kind l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Kind l -> Doc

prettyPrec :: Int -> Kind l -> Doc

Pretty (FunDep l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: FunDep l -> Doc

prettyPrec :: Int -> FunDep l -> Doc

Pretty (Context l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Context l -> Doc

prettyPrec :: Int -> Context l -> Doc

Pretty (Asst l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Asst l -> Doc

prettyPrec :: Int -> Asst l -> Doc

Pretty (Literal l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Literal l -> Doc

prettyPrec :: Int -> Literal l -> Doc

Pretty (Exp l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Exp l -> Doc

prettyPrec :: Int -> Exp l -> Doc

Pretty (XName l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: XName l -> Doc

prettyPrec :: Int -> XName l -> Doc

Pretty (XAttr l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: XAttr l -> Doc

prettyPrec :: Int -> XAttr l -> Doc

Pretty (Bracket l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Bracket l -> Doc

prettyPrec :: Int -> Bracket l -> Doc

Pretty (Splice l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Splice l -> Doc

prettyPrec :: Int -> Splice l -> Doc

Pretty (Safety l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Safety l -> Doc

prettyPrec :: Int -> Safety l -> Doc

Pretty (CallConv l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: CallConv l -> Doc

prettyPrec :: Int -> CallConv l -> Doc

Pretty (ModulePragma l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ModulePragma l -> Doc

prettyPrec :: Int -> ModulePragma l -> Doc

Pretty (Overlap l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Overlap l -> Doc

prettyPrec :: Int -> Overlap l -> Doc

Pretty (Activation l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Activation l -> Doc

prettyPrec :: Int -> Activation l -> Doc

Pretty (Rule l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Rule l -> Doc

prettyPrec :: Int -> Rule l -> Doc

Pretty (RuleVar l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: RuleVar l -> Doc

prettyPrec :: Int -> RuleVar l -> Doc

Pretty (Pat l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Pat l -> Doc

prettyPrec :: Int -> Pat l -> Doc

Pretty (PXAttr l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: PXAttr l -> Doc

prettyPrec :: Int -> PXAttr l -> Doc

Pretty (RPatOp l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: RPatOp l -> Doc

prettyPrec :: Int -> RPatOp l -> Doc

Pretty (RPat l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: RPat l -> Doc

prettyPrec :: Int -> RPat l -> Doc

Pretty (PatField l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: PatField l -> Doc

prettyPrec :: Int -> PatField l -> Doc

Pretty (Stmt l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Stmt l -> Doc

prettyPrec :: Int -> Stmt l -> Doc

Pretty (QualStmt l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: QualStmt l -> Doc

prettyPrec :: Int -> QualStmt l -> Doc

Pretty (FieldUpdate l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: FieldUpdate l -> Doc

prettyPrec :: Int -> FieldUpdate l -> Doc

Pretty (Alt l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Alt l -> Doc

prettyPrec :: Int -> Alt l -> Doc

Pretty (GuardedAlt l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: GuardedAlt l -> Doc

prettyPrec :: Int -> GuardedAlt l -> Doc

Pretty (GuardedAlts l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: GuardedAlts l -> Doc

prettyPrec :: Int -> GuardedAlts l -> Doc

(=~=) :: (Annotated a, Eq (a ())) => a l1 -> a l2 -> Bool #

Test if two AST elements are equal modulo annotations.

tuple_tycon :: l -> Boxed -> Int -> Type l #

list_tycon :: l -> Type l #

fun_tycon :: l -> Type l #

unit_tycon :: l -> Type l #

tuple_tycon_name :: l -> Boxed -> Int -> QName l #

anyclass_name :: l -> Name l #

stock_name :: l -> Name l #

role_name :: l -> Name l #

family_name :: l -> Name l #

forall_name :: l -> Name l #

capi_name :: l -> Name l #

js_name :: l -> Name l #

jvm_name :: l -> Name l #

dotnet_name :: l -> Name l #

ccall_name :: l -> Name l #

stdcall_name :: l -> Name l #

unsafe_name :: l -> Name l #

safe_name :: l -> Name l #

export_name :: l -> Name l #

hole_name :: l -> QName l #

star_name :: l -> Name l #

dot_name :: l -> Name l #

bang_name :: l -> Name l #

minus_name :: l -> Name l #

hiding_name :: l -> Name l #

as_name :: l -> Name l #

tuple_con :: l -> Boxed -> Int -> Exp l #

unit_con :: l -> Exp l #

tuple_con_name :: l -> Boxed -> Int -> QName l #

main_name :: l -> Name l #

data ModuleName l #

The name of a Haskell module.

Constructors

ModuleName l String 
Instances
Functor ModuleName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ModuleName a -> ModuleName b #

(<$) :: a -> ModuleName b -> ModuleName a #

Foldable ModuleName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ModuleName m -> m #

foldMap :: Monoid m => (a -> m) -> ModuleName a -> m #

foldr :: (a -> b -> b) -> b -> ModuleName a -> b #

foldr' :: (a -> b -> b) -> b -> ModuleName a -> b #

foldl :: (b -> a -> b) -> b -> ModuleName a -> b #

foldl' :: (b -> a -> b) -> b -> ModuleName a -> b #

foldr1 :: (a -> a -> a) -> ModuleName a -> a #

foldl1 :: (a -> a -> a) -> ModuleName a -> a #

toList :: ModuleName a -> [a] #

null :: ModuleName a -> Bool #

length :: ModuleName a -> Int #

elem :: Eq a => a -> ModuleName a -> Bool #

maximum :: Ord a => ModuleName a -> a #

minimum :: Ord a => ModuleName a -> a #

sum :: Num a => ModuleName a -> a #

product :: Num a => ModuleName a -> a #

Traversable ModuleName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> ModuleName a -> f (ModuleName b) #

sequenceA :: Applicative f => ModuleName (f a) -> f (ModuleName a) #

mapM :: Monad m => (a -> m b) -> ModuleName a -> m (ModuleName b) #

sequence :: Monad m => ModuleName (m a) -> m (ModuleName a) #

ExactP ModuleName 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ModuleName SrcSpanInfo -> EP ()

Annotated ModuleName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ModuleName l -> l #

amap :: (l -> l) -> ModuleName l -> ModuleName l #

Eq l => Eq (ModuleName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: ModuleName l -> ModuleName l -> Bool #

(/=) :: ModuleName l -> ModuleName l -> Bool #

Data l => Data (ModuleName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: ModuleName l -> Constr #

dataTypeOf :: ModuleName l -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (ModuleName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (ModuleName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (ModuleName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ModuleName l) :: Type -> Type #

Methods

from :: ModuleName l -> Rep (ModuleName l) x #

to :: Rep (ModuleName l) x -> ModuleName l #

Pretty (ModuleName l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ModuleName l -> Doc

prettyPrec :: Int -> ModuleName l -> Doc

type Rep (ModuleName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (ModuleName l) = D1 (MetaData "ModuleName" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "ModuleName" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))

data SpecialCon l #

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

Constructors

UnitCon l

unit type and data constructor ()

ListCon l

list type constructor []

FunCon l

function type constructor ->

TupleCon l Boxed Int

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

Cons l

list data constructor (:)

UnboxedSingleCon l

unboxed singleton tuple constructor (# #)

ExprHole l

An expression hole _

Instances
Functor SpecialCon 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> SpecialCon a -> SpecialCon b #

(<$) :: a -> SpecialCon b -> SpecialCon a #

Foldable SpecialCon 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => SpecialCon m -> m #

foldMap :: Monoid m => (a -> m) -> SpecialCon a -> m #

foldr :: (a -> b -> b) -> b -> SpecialCon a -> b #

foldr' :: (a -> b -> b) -> b -> SpecialCon a -> b #

foldl :: (b -> a -> b) -> b -> SpecialCon a -> b #

foldl' :: (b -> a -> b) -> b -> SpecialCon a -> b #

foldr1 :: (a -> a -> a) -> SpecialCon a -> a #

foldl1 :: (a -> a -> a) -> SpecialCon a -> a #

toList :: SpecialCon a -> [a] #

null :: SpecialCon a -> Bool #

length :: SpecialCon a -> Int #

elem :: Eq a => a -> SpecialCon a -> Bool #

maximum :: Ord a => SpecialCon a -> a #

minimum :: Ord a => SpecialCon a -> a #

sum :: Num a => SpecialCon a -> a #

product :: Num a => SpecialCon a -> a #

Traversable SpecialCon 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> SpecialCon a -> f (SpecialCon b) #

sequenceA :: Applicative f => SpecialCon (f a) -> f (SpecialCon a) #

mapM :: Monad m => (a -> m b) -> SpecialCon a -> m (SpecialCon b) #

sequence :: Monad m => SpecialCon (m a) -> m (SpecialCon a) #

ExactP SpecialCon 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: SpecialCon SrcSpanInfo -> EP ()

Annotated SpecialCon 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: SpecialCon l -> l #

amap :: (l -> l) -> SpecialCon l -> SpecialCon l #

Eq l => Eq (SpecialCon l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: SpecialCon l -> SpecialCon l -> Bool #

(/=) :: SpecialCon l -> SpecialCon l -> Bool #

Data l => Data (SpecialCon l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: SpecialCon l -> Constr #

dataTypeOf :: SpecialCon l -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (SpecialCon l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (SpecialCon l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (SpecialCon l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (SpecialCon l) :: Type -> Type #

Methods

from :: SpecialCon l -> Rep (SpecialCon l) x #

to :: Rep (SpecialCon l) x -> SpecialCon l #

Pretty (SpecialCon l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: SpecialCon l -> Doc

prettyPrec :: Int -> SpecialCon l -> Doc

type Rep (SpecialCon l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

data QName l #

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

Constructors

Qual l (ModuleName l) (Name l)

name qualified with a module name

UnQual l (Name l)

unqualified local name

Special l (SpecialCon l)

built-in constructor with special syntax

Instances
Functor QName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> QName a -> QName b #

(<$) :: a -> QName b -> QName a #

Foldable QName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => QName m -> m #

foldMap :: Monoid m => (a -> m) -> QName a -> m #

foldr :: (a -> b -> b) -> b -> QName a -> b #

foldr' :: (a -> b -> b) -> b -> QName a -> b #

foldl :: (b -> a -> b) -> b -> QName a -> b #

foldl' :: (b -> a -> b) -> b -> QName a -> b #

foldr1 :: (a -> a -> a) -> QName a -> a #

foldl1 :: (a -> a -> a) -> QName a -> a #

toList :: QName a -> [a] #

null :: QName a -> Bool #

length :: QName a -> Int #

elem :: Eq a => a -> QName a -> Bool #

maximum :: Ord a => QName a -> a #

minimum :: Ord a => QName a -> a #

sum :: Num a => QName a -> a #

product :: Num a => QName a -> a #

Traversable QName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> QName a -> f (QName b) #

sequenceA :: Applicative f => QName (f a) -> f (QName a) #

mapM :: Monad m => (a -> m b) -> QName a -> m (QName b) #

sequence :: Monad m => QName (m a) -> m (QName a) #

ExactP QName 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: QName SrcSpanInfo -> EP ()

Annotated QName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: QName l -> l #

amap :: (l -> l) -> QName l -> QName l #

Convert Name (QName ()) Source # 
Instance details

Defined in Language.Haskell.Convert

Methods

conv :: Name -> QName ()

Eq l => Eq (QName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: QName l -> QName l -> Bool #

(/=) :: QName l -> QName l -> Bool #

Data l => Data (QName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: QName l -> Constr #

dataTypeOf :: QName l -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (QName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: QName l -> QName l -> Ordering #

(<) :: QName l -> QName l -> Bool #

(<=) :: QName l -> QName l -> Bool #

(>) :: QName l -> QName l -> Bool #

(>=) :: QName l -> QName l -> Bool #

max :: QName l -> QName l -> QName l #

min :: QName l -> QName l -> QName l #

Show l => Show (QName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> QName l -> ShowS #

show :: QName l -> String #

showList :: [QName l] -> ShowS #

Generic (QName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (QName l) :: Type -> Type #

Methods

from :: QName l -> Rep (QName l) x #

to :: Rep (QName l) x -> QName l #

Pretty (QName l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: QName l -> Doc

prettyPrec :: Int -> QName l -> Doc

Convert (QName ()) Name Source # 
Instance details

Defined in Language.Haskell.Convert

Methods

conv :: QName () -> Name

type Rep (QName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

data Name l #

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

Constructors

Ident l String

varid or conid.

Symbol l String

varsym or consym

Instances
Functor Name 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Name a -> Name b #

(<$) :: a -> Name b -> Name a #

Foldable Name 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Name m -> m #

foldMap :: Monoid m => (a -> m) -> Name a -> m #

foldr :: (a -> b -> b) -> b -> Name a -> b #

foldr' :: (a -> b -> b) -> b -> Name a -> b #

foldl :: (b -> a -> b) -> b -> Name a -> b #

foldl' :: (b -> a -> b) -> b -> Name a -> b #

foldr1 :: (a -> a -> a) -> Name a -> a #

foldl1 :: (a -> a -> a) -> Name a -> a #

toList :: Name a -> [a] #

null :: Name a -> Bool #

length :: Name a -> Int #

elem :: Eq a => a -> Name a -> Bool #

maximum :: Ord a => Name a -> a #

minimum :: Ord a => Name a -> a #

sum :: Num a => Name a -> a #

product :: Num a => Name a -> a #

Traversable Name 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Name a -> f (Name b) #

sequenceA :: Applicative f => Name (f a) -> f (Name a) #

mapM :: Monad m => (a -> m b) -> Name a -> m (Name b) #

sequence :: Monad m => Name (m a) -> m (Name a) #

ExactP Name 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Name SrcSpanInfo -> EP ()

Annotated Name 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Name l -> l #

amap :: (l -> l) -> Name l -> Name l #

Convert Name (Name ()) Source # 
Instance details

Defined in Language.Haskell.Convert

Methods

conv :: Name0 -> Name ()

Eq l => Eq (Name l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Name l -> Name l -> Bool #

(/=) :: Name l -> Name l -> Bool #

Data l => Data (Name l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: Name l -> Constr #

dataTypeOf :: Name l -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (Name l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Name l -> Name l -> Ordering #

(<) :: Name l -> Name l -> Bool #

(<=) :: Name l -> Name l -> Bool #

(>) :: Name l -> Name l -> Bool #

(>=) :: Name l -> Name l -> Bool #

max :: Name l -> Name l -> Name l #

min :: Name l -> Name l -> Name l #

Show l => Show (Name l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Name l -> ShowS #

show :: Name l -> String #

showList :: [Name l] -> ShowS #

Generic (Name l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Name l) :: Type -> Type #

Methods

from :: Name l -> Rep (Name l) x #

to :: Rep (Name l) x -> Name l #

Pretty (Name l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Name l -> Doc

prettyPrec :: Int -> Name l -> Doc

Convert (Name ()) Name Source # 
Instance details

Defined in Language.Haskell.Convert

Methods

conv :: Name () -> Name0

Convert ([Name ()], Type ()) [VarStrictType] Source # 
Instance details

Defined in Language.Haskell.Convert

Methods

conv :: ([Name ()], Type ()) -> [VarStrictType]

type Rep (Name l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

data IPName l #

An implicit parameter name.

Constructors

IPDup l String

?ident, non-linear implicit parameter

IPLin l String

%ident, linear implicit parameter

Instances
Functor IPName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> IPName a -> IPName b #

(<$) :: a -> IPName b -> IPName a #

Foldable IPName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => IPName m -> m #

foldMap :: Monoid m => (a -> m) -> IPName a -> m #

foldr :: (a -> b -> b) -> b -> IPName a -> b #

foldr' :: (a -> b -> b) -> b -> IPName a -> b #

foldl :: (b -> a -> b) -> b -> IPName a -> b #

foldl' :: (b -> a -> b) -> b -> IPName a -> b #

foldr1 :: (a -> a -> a) -> IPName a -> a #

foldl1 :: (a -> a -> a) -> IPName a -> a #

toList :: IPName a -> [a] #

null :: IPName a -> Bool #

length :: IPName a -> Int #

elem :: Eq a => a -> IPName a -> Bool #

maximum :: Ord a => IPName a -> a #

minimum :: Ord a => IPName a -> a #

sum :: Num a => IPName a -> a #

product :: Num a => IPName a -> a #

Traversable IPName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> IPName a -> f (IPName b) #

sequenceA :: Applicative f => IPName (f a) -> f (IPName a) #

mapM :: Monad m => (a -> m b) -> IPName a -> m (IPName b) #

sequence :: Monad m => IPName (m a) -> m (IPName a) #

ExactP IPName 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: IPName SrcSpanInfo -> EP ()

Annotated IPName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: IPName l -> l #

amap :: (l -> l) -> IPName l -> IPName l #

Eq l => Eq (IPName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: IPName l -> IPName l -> Bool #

(/=) :: IPName l -> IPName l -> Bool #

Data l => Data (IPName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: IPName l -> Constr #

dataTypeOf :: IPName l -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (IPName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: IPName l -> IPName l -> Ordering #

(<) :: IPName l -> IPName l -> Bool #

(<=) :: IPName l -> IPName l -> Bool #

(>) :: IPName l -> IPName l -> Bool #

(>=) :: IPName l -> IPName l -> Bool #

max :: IPName l -> IPName l -> IPName l #

min :: IPName l -> IPName l -> IPName l #

Show l => Show (IPName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> IPName l -> ShowS #

show :: IPName l -> String #

showList :: [IPName l] -> ShowS #

Generic (IPName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (IPName l) :: Type -> Type #

Methods

from :: IPName l -> Rep (IPName l) x #

to :: Rep (IPName l) x -> IPName l #

Pretty (IPName l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: IPName l -> Doc

prettyPrec :: Int -> IPName l -> Doc

type Rep (IPName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

data QOp l #

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

Constructors

QVarOp l (QName l)

variable operator (qvarop)

QConOp l (QName l)

constructor operator (qconop)

Instances
Functor QOp 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> QOp a -> QOp b #

(<$) :: a -> QOp b -> QOp a #

Foldable QOp 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => QOp m -> m #

foldMap :: Monoid m => (a -> m) -> QOp a -> m #

foldr :: (a -> b -> b) -> b -> QOp a -> b #

foldr' :: (a -> b -> b) -> b -> QOp a -> b #

foldl :: (b -> a -> b) -> b -> QOp a -> b #

foldl' :: (b -> a -> b) -> b -> QOp a -> b #

foldr1 :: (a -> a -> a) -> QOp a -> a #

foldl1 :: (a -> a -> a) -> QOp a -> a #

toList :: QOp a -> [a] #

null :: QOp a -> Bool #

length :: QOp a -> Int #

elem :: Eq a => a -> QOp a -> Bool #

maximum :: Ord a => QOp a -> a #

minimum :: Ord a => QOp a -> a #

sum :: Num a => QOp a -> a #

product :: Num a => QOp a -> a #

Traversable QOp 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> QOp a -> f (QOp b) #

sequenceA :: Applicative f => QOp (f a) -> f (QOp a) #

mapM :: Monad m => (a -> m b) -> QOp a -> m (QOp b) #

sequence :: Monad m => QOp (m a) -> m (QOp a) #

ExactP QOp 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: QOp SrcSpanInfo -> EP ()

Annotated QOp 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: QOp l -> l #

amap :: (l -> l) -> QOp l -> QOp l #

Eq l => Eq (QOp l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: QOp l -> QOp l -> Bool #

(/=) :: QOp l -> QOp l -> Bool #

Data l => Data (QOp l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: QOp l -> Constr #

dataTypeOf :: QOp l -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (QOp l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: QOp l -> QOp l -> Ordering #

(<) :: QOp l -> QOp l -> Bool #

(<=) :: QOp l -> QOp l -> Bool #

(>) :: QOp l -> QOp l -> Bool #

(>=) :: QOp l -> QOp l -> Bool #

max :: QOp l -> QOp l -> QOp l #

min :: QOp l -> QOp l -> QOp l #

Show l => Show (QOp l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> QOp l -> ShowS #

show :: QOp l -> String #

showList :: [QOp l] -> ShowS #

Generic (QOp l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (QOp l) :: Type -> Type #

Methods

from :: QOp l -> Rep (QOp l) x #

to :: Rep (QOp l) x -> QOp l #

Pretty (QOp l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: QOp l -> Doc

prettyPrec :: Int -> QOp l -> Doc

Convert (QOp ()) Exp Source # 
Instance details

Defined in Language.Haskell.Convert

Methods

conv :: QOp () -> Exp

type Rep (QOp l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

data Op l #

Operators appearing in infix declarations are never qualified.

Constructors

VarOp l (Name l)

variable operator (varop)

ConOp l (Name l)

constructor operator (conop)

Instances
Functor Op 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Op a -> Op b #

(<$) :: a -> Op b -> Op a #

Foldable Op 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Op m -> m #

foldMap :: Monoid m => (a -> m) -> Op a -> m #

foldr :: (a -> b -> b) -> b -> Op a -> b #

foldr' :: (a -> b -> b) -> b -> Op a -> b #

foldl :: (b -> a -> b) -> b -> Op a -> b #

foldl' :: (b -> a -> b) -> b -> Op a -> b #

foldr1 :: (a -> a -> a) -> Op a -> a #

foldl1 :: (a -> a -> a) -> Op a -> a #

toList :: Op a -> [a] #

null :: Op a -> Bool #

length :: Op a -> Int #

elem :: Eq a => a -> Op a -> Bool #

maximum :: Ord a => Op a -> a #

minimum :: Ord a => Op a -> a #

sum :: Num a => Op a -> a #

product :: Num a => Op a -> a #

Traversable Op 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Op a -> f (Op b) #

sequenceA :: Applicative f => Op (f a) -> f (Op a) #

mapM :: Monad m => (a -> m b) -> Op a -> m (Op b) #

sequence :: Monad m => Op (m a) -> m (Op a) #

ExactP Op 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Op SrcSpanInfo -> EP ()

Annotated Op 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Op l -> l #

amap :: (l -> l) -> Op l -> Op l #

Eq l => Eq (Op l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Op l -> Op l -> Bool #

(/=) :: Op l -> Op l -> Bool #

Data l => Data (Op l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: Op l -> Constr #

dataTypeOf :: Op l -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (Op l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Op l -> Op l -> Ordering #

(<) :: Op l -> Op l -> Bool #

(<=) :: Op l -> Op l -> Bool #

(>) :: Op l -> Op l -> Bool #

(>=) :: Op l -> Op l -> Bool #

max :: Op l -> Op l -> Op l #

min :: Op l -> Op l -> Op l #

Show l => Show (Op l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Op l -> ShowS #

show :: Op l -> String #

showList :: [Op l] -> ShowS #

Generic (Op l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Op l) :: Type -> Type #

Methods

from :: Op l -> Rep (Op l) x #

to :: Rep (Op l) x -> Op l #

Pretty (Op l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Op l -> Doc

prettyPrec :: Int -> Op l -> Doc

type Rep (Op l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

data CName l #

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

Constructors

VarName l (Name l)

name of a method or field

ConName l (Name l)

name of a data constructor

Instances
Functor CName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> CName a -> CName b #

(<$) :: a -> CName b -> CName a #

Foldable CName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => CName m -> m #

foldMap :: Monoid m => (a -> m) -> CName a -> m #

foldr :: (a -> b -> b) -> b -> CName a -> b #

foldr' :: (a -> b -> b) -> b -> CName a -> b #

foldl :: (b -> a -> b) -> b -> CName a -> b #

foldl' :: (b -> a -> b) -> b -> CName a -> b #

foldr1 :: (a -> a -> a) -> CName a -> a #

foldl1 :: (a -> a -> a) -> CName a -> a #

toList :: CName a -> [a] #

null :: CName a -> Bool #

length :: CName a -> Int #

elem :: Eq a => a -> CName a -> Bool #

maximum :: Ord a => CName a -> a #

minimum :: Ord a => CName a -> a #

sum :: Num a => CName a -> a #

product :: Num a => CName a -> a #

Traversable CName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> CName a -> f (CName b) #

sequenceA :: Applicative f => CName (f a) -> f (CName a) #

mapM :: Monad m => (a -> m b) -> CName a -> m (CName b) #

sequence :: Monad m => CName (m a) -> m (CName a) #

ExactP CName 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: CName SrcSpanInfo -> EP ()

Annotated CName 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: CName l -> l #

amap :: (l -> l) -> CName l -> CName l #

Eq l => Eq (CName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: CName l -> CName l -> Bool #

(/=) :: CName l -> CName l -> Bool #

Data l => Data (CName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: CName l -> Constr #

dataTypeOf :: CName l -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (CName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: CName l -> CName l -> Ordering #

(<) :: CName l -> CName l -> Bool #

(<=) :: CName l -> CName l -> Bool #

(>) :: CName l -> CName l -> Bool #

(>=) :: CName l -> CName l -> Bool #

max :: CName l -> CName l -> CName l #

min :: CName l -> CName l -> CName l #

Show l => Show (CName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> CName l -> ShowS #

show :: CName l -> String #

showList :: [CName l] -> ShowS #

Generic (CName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (CName l) :: Type -> Type #

Methods

from :: CName l -> Rep (CName l) x #

to :: Rep (CName l) x -> CName l #

Pretty (CName l) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: CName l -> Doc

prettyPrec :: Int -> CName l -> Doc

type Rep (CName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

data Module l #

A complete Haskell source module.

Constructors

Module l (Maybe (ModuleHead l)) [ModulePragma l] [ImportDecl l] [Decl l]

an ordinary Haskell module

XmlPage l (ModuleName l) [ModulePragma l] (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]

a module consisting of a single XML document. The ModuleName never appears in the source but is needed for semantic purposes, it will be the same as the file name.

XmlHybrid l (Maybe (ModuleHead l)) [ModulePragma l] [ImportDecl l] [Decl l] (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]

a hybrid module combining an XML document with an ordinary module

Instances
Functor Module 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Module a -> Module b #

(<$) :: a -> Module b -> Module a #

Foldable Module 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Module m -> m #

foldMap :: Monoid m => (a -> m) -> Module a -> m #

foldr :: (a -> b -> b) -> b -> Module a -> b #

foldr' :: (a -> b -> b) -> b -> Module a -> b #

foldl :: (b -> a -> b) -> b -> Module a -> b #

foldl' :: (b -> a -> b) -> b -> Module a -> b #

foldr1 :: (a -> a -> a) -> Module a -> a #

foldl1 :: (a -> a -> a) -> Module a -> a #

toList :: Module a -> [a] #

null :: Module a -> Bool #

length :: Module a -> Int #

elem :: Eq a => a -> Module a -> Bool #

maximum :: Ord a => Module a -> a #

minimum :: Ord a => Module a -> a #

sum :: Num a => Module a -> a #

product :: Num a => Module a -> a #

Traversable Module 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Module a -> f (Module b) #

sequenceA :: Applicative f => Module (f a) -> f (Module a) #

mapM :: Monad m => (a -> m b) -> Module a -> m (Module b) #

sequence :: Monad m => Module (m a) -> m (Module a) #

ExactP Module 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Module SrcSpanInfo -> EP ()

AppFixity Module 
Instance details

Defined in Language.Haskell.Exts.Fixity

Annotated Module 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Module l -> l #

amap :: (l -> l) -> Module l -> Module l #

Eq l => Eq (Module l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Data l => Data (Module l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: Module l -> Constr #

dataTypeOf :: Module l -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (Module l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Module l -> Module l -> Ordering #

(<) :: Module l -> Module l -> Bool #

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

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

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

max :: Module l -> Module l -> Module l #

min :: Module l -> Module l -> Module l #

Show l => Show (Module l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Module l -> ShowS #

show :: Module l -> String #

showList :: [Module l] -> ShowS #

Generic (Module l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Module l) :: Type -> Type #

Methods

from :: Module l -> Rep (Module l) x #

to :: Rep (Module l) x -> Module l #

Pretty (Module pos) 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Module pos -> Doc

prettyPrec :: Int -> Module pos -> Doc

type Rep (Module l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Module l) = D1 (MetaData "Module" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "Module" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ModuleHead l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ModulePragma l]) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ImportDecl l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Decl l])))) :+: (C1 (MetaCons "XmlPage" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ModuleName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ModulePragma l]))) :*: ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (XName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [XAttr l])) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Exp l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp l])))) :+: C1 (MetaCons "XmlHybrid" PrefixI False) (((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ModuleHead l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ModulePragma l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ImportDecl l]))) :*: ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Decl l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (XName l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [XAttr l]) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Exp l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp l])))))))

data ModuleHead l #

The head of a module, including the name and export specification.

Constructors

ModuleHead l (ModuleName l) (Maybe (WarningText l)) (Maybe (ExportSpecList l)) 
Instances
Functor ModuleHead 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ModuleHead a -> ModuleHead b #

(<$) :: a -> ModuleHead b -> ModuleHead a #

Foldable ModuleHead 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ModuleHead m -> m #

foldMap :: Monoid m => (a -> m) -> ModuleHead a -> m #

foldr :: (a -> b -> b) -> b -> ModuleHead a -> b #

foldr' :: (a -> b -> b) -> b -> ModuleHead a -> b #

foldl :: (b -> a -> b) -> b -> ModuleHead a -> b #

foldl' :: (b -> a -> b) -> b -> ModuleHead a -> b #

foldr1 :: (a -> a -> a) -> ModuleHead a -> a #

foldl1 :: (a -> a -> a) -> ModuleHead a -> a #

toList :: ModuleHead a -> [a] #

null :: ModuleHead a -> Bool #

length :: ModuleHead a -> Int #

elem :: Eq a => a -> ModuleHead a -> Bool #

maximum :: Ord a => ModuleHead a -> a #

minimum :: Ord a => ModuleHead a -> a #

sum :: Num a => ModuleHead a -> a #

product :: Num a => ModuleHead a -> a #

Traversable ModuleHead 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> ModuleHead a -> f (ModuleHead b) #

sequenceA :: Applicative f => ModuleHead (f a) -> f (ModuleHead a) #

mapM :: Monad m => (a -> m b) -> ModuleHead a -> m (ModuleHead b) #

sequence :: Monad m => ModuleHead (m a) -> m (ModuleHead a) #

ExactP ModuleHead 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ModuleHead SrcSpanInfo -> EP ()

Annotated ModuleHead 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ModuleHead l -> l #

amap :: (l -> l) -> ModuleHead l -> ModuleHead l #

Eq l => Eq (ModuleHead l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: ModuleHead l -> ModuleHead l -> Bool #

(/=) :: ModuleHead l -> ModuleHead l -> Bool