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

Safe Haskell | None
Language | Haskell2010

Language.Haskell

Synopsis

- type FullDataDecl = (ModuleName (), DataDecl)
- type FieldDecl = [(String, Type ())]
- type CtorDecl = Either (QualConDecl ()) (GadtDecl ())
- type DataDecl = Decl ()
- (?) :: Bool -> a -> a -> a
- foralls :: Type () -> Type ()
- tyApps :: Type () -> [Type ()] -> Type ()
- fromTyApps :: Type () -> (Type (), [Type ()])
- fromTyTuple :: Type l -> [Type l]
- fromTyParen :: Type () -> Type ()
- fromTyParens :: Type () -> Type ()
- tyRoot :: Type () -> String
- isTyFun :: Type () -> Bool
- isTyParen :: Type l -> Bool
- fromTyList :: Type l -> Maybe (Type l)
- (~=) :: Pretty a => a -> String -> Bool
- appP :: Exp () -> Exp () -> Exp ()
- simplify :: Data a => a -> a
- isGuardFalse :: Match l -> Bool
- rename :: QName () -> QName ()
- isAtom :: Exp l -> Bool
- paren :: Exp () -> Exp ()
- sl :: SrcLoc
- noSl :: Data from => from -> from
- isIdent :: [Char] -> Bool
- title :: [Char] -> [Char]
- qname :: String -> QName ()
- var :: String -> Exp ()
- con :: String -> Exp ()
- tyVar :: String -> Type ()
- tyVarBind :: String -> TyVarBind ()
- tyCon :: String -> Type ()
- pVar :: String -> Pat ()
- qvop :: String -> QOp ()
- dataDeclType :: DataDecl -> Type ()
- dataDeclFields :: DataDecl -> [String]
- moduleName :: Module l -> ModuleName l
- moduleDecls :: Module l -> [Decl l]
- moduleImports :: Module l -> [ImportDecl l]
- modulePragmas :: Module l -> [ModulePragma l]
- showDecls :: Pretty a => [a] -> String
- tyApp :: Type () -> [Type ()] -> Type ()
- tyFun :: [Type ()] -> Type ()
- apps :: Exp () -> [Exp ()] -> Exp ()
- bind :: String -> [Pat ()] -> Exp () -> Decl ()
- binds :: String -> [([Pat ()], Exp ())] -> Decl ()
- isDataDecl :: Decl () -> Bool
- dataDeclName :: DataDecl -> String
- fromDeclHead :: DeclHead a -> (Name a, [TyVarBind a])
- fromIParen :: InstRule a -> InstRule a
- fromInstHead :: InstHead a -> (QName a, [Type a])
- dataDeclVars :: DataDecl -> [String]
- dataDeclVarsStar :: DataDecl -> [String]
- dataDeclArity :: DataDecl -> Int
- dataDeclCtors :: DataDecl -> [CtorDecl]
- ctorDeclName :: CtorDecl -> String
- ctorDeclName' :: CtorDecl -> Name ()
- ctorDeclFields :: CtorDecl -> FieldDecl
- ctorDeclArity :: CtorDecl -> Int
- declName :: Decl () -> String
- readExtensions :: String -> Maybe (Maybe Language, [Extension])
- parseFileContentsWithComments :: ParseMode -> String -> ParseResult (Module SrcSpanInfo, [Comment])
- parseFileContentsWithMode :: ParseMode -> String -> ParseResult (Module SrcSpanInfo)
- parseFileContentsWithExts :: [Extension] -> String -> ParseResult (Module SrcSpanInfo)
- parseFileContents :: String -> ParseResult (Module SrcSpanInfo)
- parseFileWithCommentsAndPragmas :: ParseMode -> FilePath -> IO (ParseResult (Module SrcSpanInfo, [Comment], [UnknownPragma]))
- parseFileWithComments :: ParseMode -> FilePath -> IO (ParseResult (Module SrcSpanInfo, [Comment]))
- parseFileWithMode :: ParseMode -> FilePath -> IO (ParseResult (Module SrcSpanInfo))
- parseFileWithExts :: [Extension] -> FilePath -> IO (ParseResult (Module SrcSpanInfo))
- parseFile :: FilePath -> IO (ParseResult (Module SrcSpanInfo))
- metaConPat :: String -> [Pat ()] -> Pat ()
- metaFunction :: String -> [Exp ()] -> Exp ()
- nameBind :: Name () -> Exp () -> Decl ()
- patBindWhere :: Pat () -> Exp () -> [Decl ()] -> Decl ()
- patBind :: Pat () -> Exp () -> Decl ()
- simpleFun :: Name () -> Name () -> Exp () -> Decl ()
- sfun :: Name () -> [Name ()] -> Rhs () -> Maybe (Binds ()) -> Decl ()
- genNames :: String -> Int -> [Name ()]
- wildcard :: Pat ()
- noBinds :: Maybe (Binds ())
- letStmt :: [Decl ()] -> Stmt ()
- genStmt :: Pat () -> Exp () -> Stmt ()
- qualStmt :: Exp () -> Stmt ()
- pParen :: Pat () -> Pat ()
- peList :: Pat ()
- eList :: Exp ()
- listE :: [Exp ()] -> Exp ()
- altGW :: Pat () -> [Stmt ()] -> Exp () -> Binds () -> Alt ()
- alt :: Pat () -> Exp () -> Alt ()
- caseE :: Exp () -> [Alt ()] -> Exp ()
- letE :: [Decl ()] -> Exp () -> Exp ()
- lamE :: [Pat ()] -> Exp () -> Exp ()
- doE :: [Stmt ()] -> Exp ()
- intP :: Integer -> Pat ()
- charP :: Char -> Pat ()
- strP :: String -> Pat ()
- intE :: Integer -> Exp ()
- charE :: Char -> Exp ()
- strE :: String -> Exp ()
- function :: String -> Exp ()
- pvarTuple :: [Name ()] -> Pat ()
- varTuple :: [Name ()] -> Exp ()
- pTuple :: [Pat ()] -> Pat ()
- tuple :: [Exp ()] -> Exp ()
- pApp :: Name () -> [Pat ()] -> Pat ()
- appFun :: Exp () -> [Exp ()] -> Exp ()
- infixApp :: Exp () -> QOp () -> Exp () -> Exp ()
- pvar :: Name () -> Pat ()
- qvar :: ModuleName () -> Name () -> Exp ()
- op :: Name () -> QOp ()
- sym :: String -> Name ()
- name :: String -> Name ()
- exactPrint :: ExactP ast => ast SrcSpanInfo -> [Comment] -> String
- class Annotated ast => ExactP (ast :: Type -> Type)
- unListOf :: ListOf a -> [a]
- getTopPragmas :: String -> ParseResult [ModulePragma SrcSpanInfo]
- parseImportDeclWithComments :: ParseMode -> String -> ParseResult (ImportDecl SrcSpanInfo, [Comment])
- parseImportDeclWithMode :: ParseMode -> String -> ParseResult (ImportDecl SrcSpanInfo)
- parseImportDecl :: String -> ParseResult (ImportDecl SrcSpanInfo)
- parseStmtWithComments :: ParseMode -> String -> ParseResult (Stmt SrcSpanInfo, [Comment])
- parseStmtWithMode :: ParseMode -> String -> ParseResult (Stmt SrcSpanInfo)
- parseStmt :: String -> ParseResult (Stmt SrcSpanInfo)
- parseTypeWithComments :: ParseMode -> String -> ParseResult (Type SrcSpanInfo, [Comment])
- parseTypeWithMode :: ParseMode -> String -> ParseResult (Type SrcSpanInfo)
- parseType :: String -> ParseResult (Type SrcSpanInfo)
- parseDeclWithComments :: ParseMode -> String -> ParseResult (Decl SrcSpanInfo, [Comment])
- parseDeclWithMode :: ParseMode -> String -> ParseResult (Decl SrcSpanInfo)
- parseDecl :: String -> ParseResult (Decl SrcSpanInfo)
- parsePatWithComments :: ParseMode -> String -> ParseResult (Pat SrcSpanInfo, [Comment])
- parsePatWithMode :: ParseMode -> String -> ParseResult (Pat SrcSpanInfo)
- parsePat :: String -> ParseResult (Pat SrcSpanInfo)
- parseExpWithComments :: ParseMode -> String -> ParseResult (Exp SrcSpanInfo, [Comment])
- parseExpWithMode :: ParseMode -> String -> ParseResult (Exp SrcSpanInfo)
- parseExp :: String -> ParseResult (Exp SrcSpanInfo)
- parseModuleWithComments :: ParseMode -> String -> ParseResult (Module SrcSpanInfo, [Comment])
- parseModuleWithMode :: ParseMode -> String -> ParseResult (Module SrcSpanInfo)
- parseModule :: String -> ParseResult (Module SrcSpanInfo)
- data PragmasAndModuleName l = PragmasAndModuleName l [ModulePragma l] (Maybe (ModuleName l))
- data PragmasAndModuleHead l = PragmasAndModuleHead l [ModulePragma l] (Maybe (ModuleHead l))
- data ModuleHeadAndImports l = ModuleHeadAndImports l [ModulePragma l] (Maybe (ModuleHead l)) [ImportDecl l]
- newtype NonGreedy a = NonGreedy {
  - unNonGreedy :: a
  }
- data ListOf a = ListOf SrcSpanInfo [a]
- lexTokenStreamWithMode :: ParseMode -> String -> ParseResult [Loc Token]
- lexTokenStream :: String -> ParseResult [Loc Token]
- data Token
  - = 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
- defaultParseMode :: ParseMode
- fromParseResult :: ParseResult a -> a
- class Parseable ast where
  - parse :: String -> ParseResult ast
  - parseWithMode :: ParseMode -> String -> ParseResult ast
  - parseWithComments :: ParseMode -> String -> ParseResult (ast, [Comment])
- data ParseResult a
  - = ParseOk a
  - | ParseFailed SrcLoc String
- data ParseMode = ParseMode {
  - parseFilename :: String
  - baseLanguage :: Language
  - extensions :: [Extension]
  - ignoreLanguagePragmas :: Bool
  - ignoreLinePragmas :: Bool
  - fixities :: Maybe [Fixity]
  - ignoreFunctionArity :: Bool
  }
- associateHaddock :: (Annotated ast, Traversable ast) => (ast SrcSpanInfo, [Comment]) -> ast (SrcSpanInfo, [Comment])
- data Comment = Comment Bool SrcSpan String
- data UnknownPragma = UnknownPragma SrcSpan String
- infix_ :: Int -> [String] -> [Fixity]
- infixl_ :: Int -> [String] -> [Fixity]
- infixr_ :: Int -> [String] -> [Fixity]
- baseFixities :: [Fixity]
- preludeFixities :: [Fixity]
- data Fixity = Fixity (Assoc ()) Int (QName ())
- class AppFixity (ast :: Type -> Type) where
  - applyFixities :: Monad m => [Fixity] -> ast SrcSpanInfo -> m (ast SrcSpanInfo)
- prettyPrimWithMode :: Pretty a => PPHsMode -> a -> Doc
- prettyPrim :: Pretty a => a -> Doc
- prettyPrint :: Pretty a => a -> String
- prettyPrintWithMode :: Pretty a => PPHsMode -> a -> String
- prettyPrintStyleMode :: Pretty a => Style -> PPHsMode -> a -> String
- defaultMode :: PPHsMode
- data PPLayout
  - = PPOffsideRule
  - | PPSemiColon
  - | PPInLine
  - | PPNoLayout
- type Indent = Int
- data PPHsMode = PPHsMode {
  - classIndent :: Indent
  - doIndent :: Indent
  - multiIfIndent :: Indent
  - caseIndent :: Indent
  - letIndent :: Indent
  - whereIndent :: Indent
  - onsideIndent :: Indent
  - spacing :: Bool
  - layout :: PPLayout
  - linePragmas :: Bool
  }
- class Pretty a
- (=~=) :: (Annotated a, Eq (a ())) => a l1 -> a l2 -> Bool
- tuple_tycon :: l -> Boxed -> Int -> Type l
- unboxed_singleton_tycon :: l -> 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
- unboxed_singleton_tycon_name :: l -> QName l
- list_tycon_name :: l -> QName l
- fun_tycon_name :: l -> QName l
- unit_tycon_name :: l -> 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
- javascript_name :: l -> Name l
- js_name :: l -> Name l
- jvm_name :: l -> Name l
- dotnet_name :: l -> Name l
- cplusplus_name :: l -> Name l
- ccall_name :: l -> Name l
- stdcall_name :: l -> Name l
- threadsafe_name :: l -> Name l
- interruptible_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
- qualified_name :: l -> Name l
- as_name :: l -> Name l
- unboxed_singleton_con :: l -> Exp l
- tuple_con :: l -> Boxed -> Int -> Exp l
- unit_con :: l -> Exp l
- unboxed_singleton_con_name :: l -> QName l
- list_cons_name :: l -> QName l
- tuple_con_name :: l -> Boxed -> Int -> QName l
- unit_con_name :: l -> QName l
- main_name :: l -> Name l
- main_mod :: l -> ModuleName l
- prelude_mod :: l -> ModuleName l
- data ModuleName l = ModuleName l String
- data SpecialCon l
  - = UnitCon l
  - | ListCon l
  - | FunCon l
  - | TupleCon l Boxed Int
  - | Cons l
  - | UnboxedSingleCon l
  - | ExprHole l
- data QName l
  - = Qual l (ModuleName l) (Name l)
  - | UnQual l (Name l)
  - | Special l (SpecialCon l)
- data Name l
  - = Ident l String
  - | Symbol l String
- data IPName l
  - = IPDup l String
  - | IPLin l String
- data QOp l
  - = QVarOp l (QName l)
  - | QConOp l (QName l)
- data Op l
  - = VarOp l (Name l)
  - | ConOp l (Name l)
- data CName l
  - = VarName l (Name l)
  - | ConName l (Name l)
- data Module l
  - = Module l (Maybe (ModuleHead l)) [ModulePragma l] [ImportDecl l] [Decl l]
  - | XmlPage l (ModuleName l) [ModulePragma l] (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]
  - | XmlHybrid l (Maybe (ModuleHead l)) [ModulePragma l] [ImportDecl l] [Decl l] (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]
- data ModuleHead l = ModuleHead l (ModuleName l) (Maybe (WarningText l)) (Maybe (ExportSpecList l))
- data ExportSpecList l = ExportSpecList l [ExportSpec l]
- data ExportSpec l
  - = EVar l (QName l)
  - | EAbs l (Namespace l) (QName l)
  - | EThingWith l (EWildcard l) (QName l) [CName l]
  - | EModuleContents l (ModuleName l)
- data EWildcard l
  - = NoWildcard l
  - | EWildcard l Int
- data Namespace l
  - = NoNamespace l
  - | TypeNamespace l
  - | PatternNamespace l
- data ImportDecl l = ImportDecl {
  - importAnn :: l
  - importModule :: ModuleName l
  - importQualified :: Bool
  - importSrc :: Bool
  - importSafe :: Bool
  - importPkg :: Maybe String
  - importAs :: Maybe (ModuleName l)
  - importSpecs :: Maybe (ImportSpecList l)
  }
- data ImportSpecList l = ImportSpecList l Bool [ImportSpec l]
- data ImportSpec l
  - = IVar l (Name l)
  - | IAbs l (Namespace l) (Name l)
  - | IThingAll l (Name l)
  - | IThingWith l (Name l) [CName l]
- data Assoc l
  - = AssocNone l
  - | AssocLeft l
  - | AssocRight l
- data Decl l
  - = TypeDecl l (DeclHead l) (Type l)
  - | TypeFamDecl l (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l))
  - | ClosedTypeFamDecl l (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l)) [TypeEqn l]
  - | DataDecl l (DataOrNew l) (Maybe (Context l)) (DeclHead l) [QualConDecl l] [Deriving l]
  - | GDataDecl l (DataOrNew l) (Maybe (Context l)) (DeclHead l) (Maybe (Kind l)) [GadtDecl l] [Deriving l]
  - | DataFamDecl l (Maybe (Context l)) (DeclHead l) (Maybe (ResultSig l))
  - | TypeInsDecl l (Type l) (Type l)
  - | DataInsDecl l (DataOrNew l) (Type l) [QualConDecl l] [Deriving l]
  - | GDataInsDecl l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] [Deriving l]
  - | ClassDecl l (Maybe (Context l)) (DeclHead l) [FunDep l] (Maybe [ClassDecl l])
  - | InstDecl l (Maybe (Overlap l)) (InstRule l) (Maybe [InstDecl l])
  - | DerivDecl l (Maybe (DerivStrategy l)) (Maybe (Overlap l)) (InstRule l)
  - | InfixDecl l (Assoc l) (Maybe Int) [Op l]
  - | DefaultDecl l [Type l]
  - | SpliceDecl l (Exp l)
  - | TypeSig l [Name l] (Type l)
  - | PatSynSig l [Name l] (Maybe [TyVarBind l]) (Maybe (Context l)) (Maybe (Context l)) (Type l)
  - | FunBind l [Match l]
  - | PatBind l (Pat l) (Rhs l) (Maybe (Binds l))
  - | PatSyn l (Pat l) (Pat l) (PatternSynDirection l)
  - | ForImp l (CallConv l) (Maybe (Safety l)) (Maybe String) (Name l) (Type l)
  - | ForExp l (CallConv l) (Maybe String) (Name l) (Type l)
  - | RulePragmaDecl l [Rule l]
  - | DeprPragmaDecl l [([Name l], String)]
  - | WarnPragmaDecl l [([Name l], String)]
  - | InlineSig l Bool (Maybe (Activation l)) (QName l)
  - | InlineConlikeSig l (Maybe (Activation l)) (QName l)
  - | SpecSig l (Maybe (Activation l)) (QName l) [Type l]
  - | SpecInlineSig l Bool (Maybe (Activation l)) (QName l) [Type l]
  - | InstSig l (InstRule l)
  - | AnnPragma l (Annotation l)
  - | MinimalPragma l (Maybe (BooleanFormula l))
  - | RoleAnnotDecl l (QName l) [Role l]
  - | CompletePragma l [Name l] (Maybe (QName l))
- data PatternSynDirection l
  - = Unidirectional
  - | ImplicitBidirectional
  - | ExplicitBidirectional l [Decl l]
- data TypeEqn l = TypeEqn l (Type l) (Type l)
- data Annotation l
  - = Ann l (Name l) (Exp l)
  - | TypeAnn l (Name l) (Exp l)
  - | ModuleAnn l (Exp l)
- data BooleanFormula l
  - = VarFormula l (Name l)
  - | AndFormula l [BooleanFormula l]
  - | OrFormula l [BooleanFormula l]
  - | ParenFormula l (BooleanFormula l)
- data Role l
  - = Nominal l
  - | Representational l
  - | Phantom l
  - | RoleWildcard l
- data DataOrNew l
  - = DataType l
  - | NewType l
- data InjectivityInfo l = InjectivityInfo l (Name l) [Name l]
- data ResultSig l
  - = KindSig l (Kind l)
  - | TyVarSig l (TyVarBind l)
- data DeclHead l
  - = DHead l (Name l)
  - | DHInfix l (TyVarBind l) (Name l)
  - | DHParen l (DeclHead l)
  - | DHApp l (DeclHead l) (TyVarBind l)
- data InstRule l
  - = IRule l (Maybe [TyVarBind l]) (Maybe (Context l)) (InstHead l)
  - | IParen l (InstRule l)
- data InstHead l
  - = IHCon l (QName l)
  - | IHInfix l (Type l) (QName l)
  - | IHParen l (InstHead l)
  - | IHApp l (InstHead l) (Type l)
- data Deriving l = Deriving l (Maybe (DerivStrategy l)) [InstRule l]
- data DerivStrategy l
  - = DerivStock l
  - | DerivAnyclass l
  - | DerivNewtype l
- data Binds l
  - = BDecls l [Decl l]
  - | IPBinds l [IPBind l]
- data IPBind l = IPBind l (IPName l) (Exp l)
- data Match l
  - = Match l (Name l) [Pat l] (Rhs l) (Maybe (Binds l))
  - | InfixMatch l (Pat l) (Name l) [Pat l] (Rhs l) (Maybe (Binds l))
- data QualConDecl l = QualConDecl l (Maybe [TyVarBind l]) (Maybe (Context l)) (ConDecl l)
- data ConDecl l
  - = ConDecl l (Name l) [Type l]
  - | InfixConDecl l (Type l) (Name l) (Type l)
  - | RecDecl l (Name l) [FieldDecl l]
- data GadtDecl l = GadtDecl l (Name l) (Maybe [FieldDecl l]) (Type l)
- data ClassDecl l
  - = ClsDecl l (Decl l)
  - | ClsDataFam l (Maybe (Context l)) (DeclHead l) (Maybe (ResultSig l))
  - | ClsTyFam l (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l))
  - | ClsTyDef l (TypeEqn l)
  - | ClsDefSig l (Name l) (Type l)
- data InstDecl l
  - = InsDecl l (Decl l)
  - | InsType l (Type l) (Type l)
  - | InsData l (DataOrNew l) (Type l) [QualConDecl l] [Deriving l]
  - | InsGData l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] [Deriving l]
- data BangType l
  - = BangedTy l
  - | LazyTy l
  - | NoStrictAnnot l
- data Unpackedness l
  - = Unpack l
  - | NoUnpack l
  - | NoUnpackPragma l
- data Rhs l
  - = UnGuardedRhs l (Exp l)
  - | GuardedRhss l [GuardedRhs l]
- data GuardedRhs l = GuardedRhs l [Stmt l] (Exp l)
- data Type l
  - = TyForall l (Maybe [TyVarBind l]) (Maybe (Context l)) (Type l)
  - | TyFun l (Type l) (Type l)
  - | TyTuple l Boxed [Type l]
  - | TyUnboxedSum l [Type l]
  - | TyList l (Type l)
  - | TyParArray l (Type l)
  - | TyApp l (Type l) (Type l)
  - | TyVar l (Name l)
  - | TyCon l (QName l)
  - | TyParen l (Type l)
  - | TyInfix l (Type l) (MaybePromotedName l) (Type l)
  - | TyKind l (Type l) (Kind l)
  - | TyPromoted l (Promoted l)
  - | TyEquals l (Type l) (Type l)
  - | TySplice l (Splice l)
  - | TyBang l (BangType l) (Unpackedness l) (Type l)
  - | TyWildCard l (Maybe (Name l))
  - | TyQuasiQuote l String String
- data MaybePromotedName l
  - = PromotedName l (QName l)
  - | UnpromotedName l (QName l)
- data Promoted l
  - = PromotedInteger l Integer String
  - | PromotedString l String String
  - | PromotedCon l Bool (QName l)
  - | PromotedList l Bool [Type l]
  - | PromotedTuple l [Type l]
  - | PromotedUnit l
- data Boxed
  - = Boxed
  - | Unboxed
- data TyVarBind l
  - = KindedVar l (Name l) (Kind l)
  - | UnkindedVar l (Name l)
- data Kind l
  - = KindStar l
  - | KindFn l (Kind l) (Kind l)
  - | KindParen l (Kind l)
  - | KindVar l (QName l)
  - | KindApp l (Kind l) (Kind l)
  - | KindTuple l [Kind l]
  - | KindList l (Kind l)
- data FunDep l = FunDep l [Name l] [Name l]
- data Context l
  - = CxSingle l (Asst l)
  - | CxTuple l [Asst l]
  - | CxEmpty l
- data Asst l
  - = ClassA l (QName l) [Type l]
  - | AppA l (Name l) [Type l]
  - | InfixA l (Type l) (QName l) (Type l)
  - | IParam l (IPName l) (Type l)
  - | EqualP l (Type l) (Type l)
  - | ParenA l (Asst l)
  - | WildCardA l (Maybe (Name l))
- data Literal l
  - = Char l Char String
  - | String l String String
  - | Int l Integer String
  - | Frac l Rational String
  - | PrimInt l Integer String
  - | PrimWord l Integer String
  - | PrimFloat l Rational String
  - | PrimDouble l Rational String
  - | PrimChar l Char String
  - | PrimString l String String
- data Sign l
  - = Signless l
  - | Negative l
- data Exp l
  - = Var l (QName l)
  - | OverloadedLabel l String
  - | IPVar l (IPName l)
  - | Con l (QName l)
  - | Lit l (Literal l)
  - | InfixApp l (Exp l) (QOp l) (Exp l)
  - | App l (Exp l) (Exp l)
  - | NegApp l (Exp l)
  - | Lambda l [Pat l] (Exp l)
  - | Let l (Binds l) (Exp l)
  - | If l (Exp l) (Exp l) (Exp l)
  - | MultiIf l [GuardedRhs l]
  - | Case l (Exp l) [Alt l]
  - | Do l [Stmt l]
  - | MDo l [Stmt l]
  - | Tuple l Boxed [Exp l]
  - | UnboxedSum l Int Int (Exp l)
  - | TupleSection l Boxed [Maybe (Exp l)]
  - | List l [Exp l]
  - | ParArray l [Exp l]
  - | Paren l (Exp l)
  - | LeftSection l (Exp l) (QOp l)
  - | RightSection l (QOp l) (Exp l)
  - | RecConstr l (QName l) [FieldUpdate l]
  - | RecUpdate l (Exp l) [FieldUpdate l]
  - | EnumFrom l (Exp l)
  - | EnumFromTo l (Exp l) (Exp l)
  - | EnumFromThen l (Exp l) (Exp l)
  - | EnumFromThenTo l (Exp l) (Exp l) (Exp l)
  - | ParArrayFromTo l (Exp l) (Exp l)
  - | ParArrayFromThenTo l (Exp l) (Exp l) (Exp l)
  - | ListComp l (Exp l) [QualStmt l]
  - | ParComp l (Exp l) [[QualStmt l]]
  - | ParArrayComp l (Exp l) [[QualStmt l]]
  - | ExpTypeSig l (Exp l) (Type l)
  - | VarQuote l (QName l)
  - | TypQuote l (QName l)
  - | BracketExp l (Bracket l)
  - | SpliceExp l (Splice l)
  - | QuasiQuote l String String
  - | TypeApp l (Type l)
  - | XTag l (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]
  - | XETag l (XName l) [XAttr l] (Maybe (Exp l))
  - | XPcdata l String
  - | XExpTag l (Exp l)
  - | XChildTag l [Exp l]
  - | CorePragma l String (Exp l)
  - | SCCPragma l String (Exp l)
  - | GenPragma l String (Int, Int) (Int, Int) (Exp l)
  - | Proc l (Pat l) (Exp l)
  - | LeftArrApp l (Exp l) (Exp l)
  - | RightArrApp l (Exp l) (Exp l)
  - | LeftArrHighApp l (Exp l) (Exp l)
  - | RightArrHighApp l (Exp l) (Exp l)
  - | LCase l [Alt l]
- data XName l
  - = XName l String
  - | XDomName l String String
- data XAttr l = XAttr l (XName l) (Exp l)
- data Bracket l
  - = ExpBracket l (Exp l)
  - | PatBracket l (Pat l)
  - | TypeBracket l (Type l)
  - | DeclBracket l [Decl l]
- data Splice l
  - = IdSplice l String
  - | ParenSplice l (Exp l)
- data Safety l
  - = PlayRisky l
  - | PlaySafe l Bool
  - | PlayInterruptible l
- data CallConv l
  - = StdCall l
  - | CCall l
  - | CPlusPlus l
  - | DotNet l
  - | Jvm l
  - | Js l
  - | JavaScript l
  - | CApi l
- data ModulePragma l
  - = LanguagePragma l [Name l]
  - | OptionsPragma l (Maybe Tool) String
  - | AnnModulePragma l (Annotation l)
- data Tool
  - = GHC
  - | HUGS
  - | NHC98
  - | YHC
  - | HADDOCK
  - | UnknownTool String
- data Overlap l
  - = NoOverlap l
  - | Overlap l
  - | Overlapping l
  - | Overlaps l
  - | Overlappable l
  - | Incoherent l
- data Activation l
  - = ActiveFrom l Int
  - | ActiveUntil l Int
- data Rule l = Rule l String (Maybe (Activation l)) (Maybe [RuleVar l]) (Exp l) (Exp l)
- data RuleVar l
  - = RuleVar l (Name l)
  - | TypedRuleVar l (Name l) (Type l)
- data WarningText l
  - = DeprText l String
  - | WarnText l String
- data Pat l
  - = PVar l (Name l)
  - | PLit l (Sign l) (Literal l)
  - | PNPlusK l (Name l) Integer
  - | PInfixApp l (Pat l) (QName l) (Pat l)
  - | PApp l (QName l) [Pat l]
  - | PTuple l Boxed [Pat l]
  - | PUnboxedSum l Int Int (Pat l)
  - | PList l [Pat l]
  - | PParen l (Pat l)
  - | PRec l (QName l) [PatField l]
  - | PAsPat l (Name l) (Pat l)
  - | PWildCard l
  - | PIrrPat l (Pat l)
  - | PatTypeSig l (Pat l) (Type l)
  - | PViewPat l (Exp l) (Pat l)
  - | PRPat l [RPat l]
  - | PXTag l (XName l) [PXAttr l] (Maybe (Pat l)) [Pat l]
  - | PXETag l (XName l) [PXAttr l] (Maybe (Pat l))
  - | PXPcdata l String
  - | PXPatTag l (Pat l)
  - | PXRPats l [RPat l]
  - | PSplice l (Splice l)
  - | PQuasiQuote l String String
  - | PBangPat l (Pat l)
- data PXAttr l = PXAttr l (XName l) (Pat l)
- data RPatOp l
  - = RPStar l
  - | RPStarG l
  - | RPPlus l
  - | RPPlusG l
  - | RPOpt l
  - | RPOptG l
- data RPat l
  - = RPOp l (RPat l) (RPatOp l)
  - | RPEither l (RPat l) (RPat l)
  - | RPSeq l [RPat l]
  - | RPGuard l (Pat l) [Stmt l]
  - | RPCAs l (Name l) (RPat l)
  - | RPAs l (Name l) (RPat l)
  - | RPParen l (RPat l)
  - | RPPat l (Pat l)
- data PatField l
  - = PFieldPat l (QName l) (Pat l)
  - | PFieldPun l (QName l)
  - | PFieldWildcard l
- data Stmt l
  - = Generator l (Pat l) (Exp l)
  - | Qualifier l (Exp l)
  - | LetStmt l (Binds l)
  - | RecStmt l [Stmt l]
- data QualStmt l
  - = QualStmt l (Stmt l)
  - | ThenTrans l (Exp l)
  - | ThenBy l (Exp l) (Exp l)
  - | GroupBy l (Exp l)
  - | GroupUsing l (Exp l)
  - | GroupByUsing l (Exp l) (Exp l)
- data FieldUpdate l
  - = FieldUpdate l (QName l) (Exp l)
  - | FieldPun l (QName l)
  - | FieldWildcard l
- data Alt l = Alt l (Pat l) (Rhs l) (Maybe (Binds l))
- class Functor ast => Annotated (ast :: Type -> Type) where
  - ann :: ast l -> l
  - amap :: (l -> l) -> ast l -> ast l
- (<^^>) :: SrcSpan -> SrcSpan -> SrcSpanInfo
- (<**) :: SrcSpanInfo -> [SrcSpan] -> SrcSpanInfo
- (<?+>) :: Maybe SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo
- (<+?>) :: SrcSpanInfo -> Maybe SrcSpanInfo -> SrcSpanInfo
- (<++>) :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo
- combSpanMaybe :: SrcSpanInfo -> Maybe SrcSpanInfo -> SrcSpanInfo
- combSpanInfo :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo
- infoSpan :: SrcSpan -> [SrcSpan] -> SrcSpanInfo
- noSrcSpan :: SrcSpanInfo
- noInfoSpan :: SrcSpan -> SrcSpanInfo
- spanSize :: SrcSpan -> (Int, Int)
- isNullSpan :: SrcSpan -> Bool
- mergeSrcSpan :: SrcSpan -> SrcSpan -> SrcSpan
- mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan
- srcSpanEnd :: SrcSpan -> (Int, Int)
- srcSpanStart :: SrcSpan -> (Int, Int)
- noLoc :: SrcLoc
- data SrcLoc = SrcLoc {
  - srcFilename :: String
  - srcLine :: Int
  - srcColumn :: Int
  }
- data SrcSpan = SrcSpan {
  - srcSpanFilename :: String
  - srcSpanStartLine :: Int
  - srcSpanStartColumn :: Int
  - srcSpanEndLine :: Int
  - srcSpanEndColumn :: Int
  }
- data Loc a = Loc {
  - loc :: SrcSpan
  - unLoc :: a
  }
- data SrcSpanInfo = SrcSpanInfo {
  - srcInfoSpan :: SrcSpan
  - srcInfoPoints :: [SrcSpan]
  }
- class SrcInfo si where
  - toSrcInfo :: SrcLoc -> [SrcSpan] -> SrcLoc -> si
  - fromSrcInfo :: SrcSpanInfo -> si
  - getPointLoc :: si -> SrcLoc
  - fileName :: si -> String
  - startLine :: si -> Int
  - startColumn :: si -> Int
- toExtensionList :: Language -> [Extension] -> [KnownExtension]
- prettyExtension :: Extension -> String
- parseExtension :: String -> Extension
- classifyExtension :: String -> Extension
- deprecatedExtensions :: [(Extension, Maybe Extension)]
- knownExtensions :: [Extension]
- ghcDefault :: [Extension]
- glasgowExts :: [Extension]
- impliesExts :: [KnownExtension] -> [KnownExtension]
- prettyLanguage :: Language -> String
- classifyLanguage :: String -> Language
- knownLanguages :: [Language]
- data Language
  - = Haskell98
  - | Haskell2010
  - | HaskellAllDisabled
  - | UnknownLanguage String
- data Extension
  - = EnableExtension KnownExtension
  - | DisableExtension KnownExtension
  - | UnknownExtension String
- data KnownExtension
  - = OverlappingInstances
  - | UndecidableInstances
  - | IncoherentInstances
  - | InstanceSigs
  - | DoRec
  - | RecursiveDo
  - | ParallelListComp
  - | MultiParamTypeClasses
  - | MonomorphismRestriction
  - | FunctionalDependencies
  - | Rank2Types
  - | RankNTypes
  - | PolymorphicComponents
  - | ExistentialQuantification
  - | ScopedTypeVariables
  - | PatternSignatures
  - | ImplicitParams
  - | FlexibleContexts
  - | FlexibleInstances
  - | EmptyDataDecls
  - | CPP
  - | KindSignatures
  - | BangPatterns
  - | TypeSynonymInstances
  - | TemplateHaskell
  - | ForeignFunctionInterface
  - | Arrows
  - | Generics
  - | ImplicitPrelude
  - | NamedFieldPuns
  - | PatternGuards
  - | GeneralizedNewtypeDeriving
  - | DeriveAnyClass
  - | ExtensibleRecords
  - | RestrictedTypeSynonyms
  - | HereDocuments
  - | MagicHash
  - | BinaryLiterals
  - | TypeFamilies
  - | StandaloneDeriving
  - | UnicodeSyntax
  - | UnliftedFFITypes
  - | LiberalTypeSynonyms
  - | TypeOperators
  - | ParallelArrays
  - | RecordWildCards
  - | RecordPuns
  - | DisambiguateRecordFields
  - | OverloadedStrings
  - | GADTs
  - | MonoPatBinds
  - | RelaxedPolyRec
  - | ExtendedDefaultRules
  - | UnboxedTuples
  - | DeriveDataTypeable
  - | ConstrainedClassMethods
  - | PackageImports
  - | LambdaCase
  - | EmptyCase
  - | ImpredicativeTypes
  - | NewQualifiedOperators
  - | PostfixOperators
  - | QuasiQuotes
  - | TransformListComp
  - | ViewPatterns
  - | XmlSyntax
  - | RegularPatterns
  - | TupleSections
  - | GHCForeignImportPrim
  - | NPlusKPatterns
  - | DoAndIfThenElse
  - | RebindableSyntax
  - | ExplicitForAll
  - | DatatypeContexts
  - | MonoLocalBinds
  - | DeriveFunctor
  - | DeriveGeneric
  - | DeriveTraversable
  - | DeriveFoldable
  - | NondecreasingIndentation
  - | InterruptibleFFI
  - | CApiFFI
  - | JavaScriptFFI
  - | ExplicitNamespaces
  - | DataKinds
  - | PolyKinds
  - | MultiWayIf
  - | SafeImports
  - | Safe
  - | Trustworthy
  - | DefaultSignatures
  - | ConstraintKinds
  - | RoleAnnotations
  - | PatternSynonyms
  - | PartialTypeSignatures
  - | NamedWildCards
  - | TypeApplications
  - | TypeFamilyDependencies
  - | OverloadedLabels
  - | DerivingStrategies
  - | UnboxedSums
- data Mode
  - = PageMode
  - | ZigZagMode
  - | LeftMode
  - | OneLineMode
- data Style = Style {
  - mode :: Mode
  - lineLength :: Int
  - ribbonsPerLine :: Float
  }
- style :: Style

# Documentation

type FullDataDecl = (ModuleName (), DataDecl) Source #

type FieldDecl = [(String, Type ())] Source #

type CtorDecl = Either (QualConDecl ()) (GadtDecl ()) Source #

type DataDecl = Decl () Source #

(?) :: Bool -> a -> a -> a infix 1 Source #

foralls :: Type () -> Type () Source #

tyApps :: Type () -> [Type ()] -> Type () Source #

fromTyApps :: Type () -> (Type (), [Type ()]) Source #

fromTyTuple :: Type l -> [Type l] Source #

fromTyParen :: Type () -> Type () Source #

fromTyParens :: Type () -> Type () Source #

tyRoot :: Type () -> String Source #

isTyFun :: Type () -> Bool Source #

isTyParen :: Type l -> Bool Source #

fromTyList :: Type l -> Maybe (Type l) Source #

(~=) :: Pretty a => a -> String -> Bool Source #

appP :: Exp () -> Exp () -> Exp () Source #

simplify :: Data a => a -> a Source #

isGuardFalse :: Match l -> Bool Source #

rename :: QName () -> QName () Source #

isAtom :: Exp l -> Bool Source #

paren :: Exp () -> Exp () Source #

sl :: SrcLoc Source #

noSl :: Data from => from -> from Source #

isIdent :: [Char] -> Bool Source #

title :: [Char] -> [Char] Source #

qname :: String -> QName () Source #

var :: String -> Exp () Source #

con :: String -> Exp () Source #

tyVar :: String -> Type () Source #

tyVarBind :: String -> TyVarBind () Source #

tyCon :: String -> Type () Source #

pVar :: String -> Pat () Source #

qvop :: String -> QOp () Source #

dataDeclType :: DataDecl -> Type () Source #

dataDeclFields :: DataDecl -> [String] Source #

moduleName :: Module l -> ModuleName l Source #

moduleDecls :: Module l -> [Decl l] Source #

moduleImports :: Module l -> [ImportDecl l] Source #

modulePragmas :: Module l -> [ModulePragma l] Source #

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

tyApp :: Type () -> [Type ()] -> Type () Source #

tyFun :: [Type ()] -> Type () Source #

apps :: Exp () -> [Exp ()] -> Exp () Source #

bind :: String -> [Pat ()] -> Exp () -> Decl () Source #

binds :: String -> [([Pat ()], Exp ())] -> Decl () Source #

isDataDecl :: Decl () -> Bool Source #

dataDeclName :: DataDecl -> String Source #

fromDeclHead :: DeclHead a -> (Name a, [TyVarBind a]) Source #

fromIParen :: InstRule a -> InstRule a Source #

fromInstHead :: InstHead a -> (QName a, [Type a]) Source #

dataDeclVars :: DataDecl -> [String] Source #

dataDeclVarsStar :: DataDecl -> [String] Source #

dataDeclArity :: DataDecl -> Int Source #

dataDeclCtors :: DataDecl -> [CtorDecl] Source #

ctorDeclName :: CtorDecl -> String Source #

ctorDeclName' :: CtorDecl -> Name () Source #

ctorDeclFields :: CtorDecl -> FieldDecl Source #

ctorDeclArity :: CtorDecl -> Int Source #

declName :: Decl () -> String Source #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Bind an identifier to an expression.

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

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

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

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

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

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

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

A function with a single clause

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

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

wildcard :: Pat () Source #

The wildcard pattern: `_`

noBinds :: Maybe (Binds ()) Source #

An empty binding group.

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

A `let` binding group as a statement.

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

A generator statement: pat `<-` exp

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

A qualifier expression statement.

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

Put parentheses around a pattern.

peList :: Pat () Source #

The empty list pattern.

eList :: Exp () Source #

The empty list expression.

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

A list expression.

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

An alternative with a single guard in a `case` expression.

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

An unguarded alternative in a `case` expression.

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

A `case` expression.

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

A `let` ... `in` block.

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

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

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

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

intP :: Integer -> Pat () Source #

A literal integer pattern.

charP :: Char -> Pat () Source #

A literal character pattern.

strP :: String -> Pat () Source #

A literal string pattern.

intE :: Integer -> Exp () Source #

A literal integer expression.

charE :: Char -> Exp () Source #

A literal character expression.

strE :: String -> Exp () Source #

A literal string expression.

function :: String -> Exp () Source #

A function with a given name.

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

A tuple pattern consisting of variables only.

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

A tuple expression consisting of variables only.

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

A tuple pattern.

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

A tuple expression.

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

A constructor pattern, with argument patterns.

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

Apply a function to a list of arguments.

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

Apply an operator infix.

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

A pattern variable.

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

A qualified variable as expression.

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

Use the given identifier as an operator.

sym :: String -> Name () Source #

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

name :: String -> Name () Source #

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

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

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

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

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 Methods exactP :: InjectivityInfo SrcSpanInfo -> EP ()
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 Methods exactP :: MaybePromotedName SrcSpanInfo -> EP ()
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] Source #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

data PragmasAndModuleName l Source #

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.

Constructors

PragmasAndModuleName l [ModulePragma l] (Maybe (ModuleName l)) |

Instances

Eq l => Eq (PragmasAndModuleName l) |
Instance details Defined in Language.Haskell.Exts.Parser Methods (==) :: PragmasAndModuleName l -> PragmasAndModuleName l -> Bool Source # (/=) :: PragmasAndModuleName l -> PragmasAndModuleName l -> Bool Source #
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) Source #

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

toConstr :: PragmasAndModuleName l -> Constr Source #

dataTypeOf :: PragmasAndModuleName l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (PragmasAndModuleName l) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

compare :: PragmasAndModuleName l -> PragmasAndModuleName l -> Ordering Source #

(<) :: PragmasAndModuleName l -> PragmasAndModuleName l -> Bool Source #

(<=) :: PragmasAndModuleName l -> PragmasAndModuleName l -> Bool Source #

(>) :: PragmasAndModuleName l -> PragmasAndModuleName l -> Bool Source #

(>=) :: PragmasAndModuleName l -> PragmasAndModuleName l -> Bool Source #

max :: PragmasAndModuleName l -> PragmasAndModuleName l -> PragmasAndModuleName l Source #

min :: PragmasAndModuleName l -> PragmasAndModuleName l -> PragmasAndModuleName l Source #

Show l => Show (PragmasAndModuleName l) |
Instance details Defined in Language.Haskell.Exts.Parser Methods showsPrec :: Int -> PragmasAndModuleName l -> ShowS Source # show :: PragmasAndModuleName l -> String Source # showList :: [PragmasAndModuleName l] -> ShowS Source #
Parseable (NonGreedy (PragmasAndModuleName SrcSpanInfo)) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

parse :: String -> ParseResult (NonGreedy (PragmasAndModuleName SrcSpanInfo)) Source #

parseWithMode :: ParseMode -> String -> ParseResult (NonGreedy (PragmasAndModuleName SrcSpanInfo)) Source #

parseWithComments :: ParseMode -> String -> ParseResult (NonGreedy (PragmasAndModuleName SrcSpanInfo), [Comment]) Source #

parser :: Maybe [Fixity] -> P (NonGreedy (PragmasAndModuleName SrcSpanInfo))

data PragmasAndModuleHead l Source #

Constructors

PragmasAndModuleHead l [ModulePragma l] (Maybe (ModuleHead l)) |

Instances

Eq l => Eq (PragmasAndModuleHead l) |
Instance details Defined in Language.Haskell.Exts.Parser Methods (==) :: PragmasAndModuleHead l -> PragmasAndModuleHead l -> Bool Source # (/=) :: PragmasAndModuleHead l -> PragmasAndModuleHead l -> Bool Source #
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) Source #

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

toConstr :: PragmasAndModuleHead l -> Constr Source #

dataTypeOf :: PragmasAndModuleHead l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (PragmasAndModuleHead l) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

compare :: PragmasAndModuleHead l -> PragmasAndModuleHead l -> Ordering Source #

(<) :: PragmasAndModuleHead l -> PragmasAndModuleHead l -> Bool Source #

(<=) :: PragmasAndModuleHead l -> PragmasAndModuleHead l -> Bool Source #

(>) :: PragmasAndModuleHead l -> PragmasAndModuleHead l -> Bool Source #

(>=) :: PragmasAndModuleHead l -> PragmasAndModuleHead l -> Bool Source #

max :: PragmasAndModuleHead l -> PragmasAndModuleHead l -> PragmasAndModuleHead l Source #

min :: PragmasAndModuleHead l -> PragmasAndModuleHead l -> PragmasAndModuleHead l Source #

Show l => Show (PragmasAndModuleHead l) |
Instance details Defined in Language.Haskell.Exts.Parser Methods showsPrec :: Int -> PragmasAndModuleHead l -> ShowS Source # show :: PragmasAndModuleHead l -> String Source # showList :: [PragmasAndModuleHead l] -> ShowS Source #
Parseable (NonGreedy (PragmasAndModuleHead SrcSpanInfo)) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

parse :: String -> ParseResult (NonGreedy (PragmasAndModuleHead SrcSpanInfo)) Source #

parseWithMode :: ParseMode -> String -> ParseResult (NonGreedy (PragmasAndModuleHead SrcSpanInfo)) Source #

parseWithComments :: ParseMode -> String -> ParseResult (NonGreedy (PragmasAndModuleHead SrcSpanInfo), [Comment]) Source #

parser :: Maybe [Fixity] -> P (NonGreedy (PragmasAndModuleHead SrcSpanInfo))

data ModuleHeadAndImports l Source #

Constructors

ModuleHeadAndImports l [ModulePragma l] (Maybe (ModuleHead l)) [ImportDecl l] |

Instances

Eq l => Eq (ModuleHeadAndImports l) |
Instance details Defined in Language.Haskell.Exts.Parser Methods (==) :: ModuleHeadAndImports l -> ModuleHeadAndImports l -> Bool Source # (/=) :: ModuleHeadAndImports l -> ModuleHeadAndImports l -> Bool Source #
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) Source #

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

toConstr :: ModuleHeadAndImports l -> Constr Source #

dataTypeOf :: ModuleHeadAndImports l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (ModuleHeadAndImports l) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

compare :: ModuleHeadAndImports l -> ModuleHeadAndImports l -> Ordering Source #

(<) :: ModuleHeadAndImports l -> ModuleHeadAndImports l -> Bool Source #

(<=) :: ModuleHeadAndImports l -> ModuleHeadAndImports l -> Bool Source #

(>) :: ModuleHeadAndImports l -> ModuleHeadAndImports l -> Bool Source #

(>=) :: ModuleHeadAndImports l -> ModuleHeadAndImports l -> Bool Source #

max :: ModuleHeadAndImports l -> ModuleHeadAndImports l -> ModuleHeadAndImports l Source #

min :: ModuleHeadAndImports l -> ModuleHeadAndImports l -> ModuleHeadAndImports l Source #

Show l => Show (ModuleHeadAndImports l) |
Instance details Defined in Language.Haskell.Exts.Parser Methods showsPrec :: Int -> ModuleHeadAndImports l -> ShowS Source # show :: ModuleHeadAndImports l -> String Source # showList :: [ModuleHeadAndImports l] -> ShowS Source #
Parseable (NonGreedy (ModuleHeadAndImports SrcSpanInfo)) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

parse :: String -> ParseResult (NonGreedy (ModuleHeadAndImports SrcSpanInfo)) Source #

parseWithMode :: ParseMode -> String -> ParseResult (NonGreedy (ModuleHeadAndImports SrcSpanInfo)) Source #

parseWithComments :: ParseMode -> String -> ParseResult (NonGreedy (ModuleHeadAndImports SrcSpanInfo), [Comment]) Source #

parser :: Maybe [Fixity] -> P (NonGreedy (ModuleHeadAndImports SrcSpanInfo))

newtype NonGreedy a Source #

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

- unNonGreedy :: a

Instances

Functor NonGreedy |
Instance details Defined in Language.Haskell.Exts.Parser Methods fmap :: (a -> b) -> NonGreedy a -> NonGreedy b Source # (<$) :: a -> NonGreedy b -> NonGreedy a Source #
Eq a => Eq (NonGreedy a) |
Instance details Defined in Language.Haskell.Exts.Parser Methods (==) :: NonGreedy a -> NonGreedy a -> Bool Source # (/=) :: NonGreedy a -> NonGreedy a -> Bool Source #
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) Source #

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

toConstr :: NonGreedy a -> Constr Source #

dataTypeOf :: NonGreedy a -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord a => Ord (NonGreedy a) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

compare :: NonGreedy a -> NonGreedy a -> Ordering Source #

(<) :: NonGreedy a -> NonGreedy a -> Bool Source #

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

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

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

max :: NonGreedy a -> NonGreedy a -> NonGreedy a Source #

min :: NonGreedy a -> NonGreedy a -> NonGreedy a Source #

Show a => Show (NonGreedy a) |
Instance details Defined in Language.Haskell.Exts.Parser Methods showsPrec :: Int -> NonGreedy a -> ShowS Source # show :: NonGreedy a -> String Source # showList :: [NonGreedy a] -> ShowS Source #
Parseable (NonGreedy (PragmasAndModuleName SrcSpanInfo)) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

parse :: String -> ParseResult (NonGreedy (PragmasAndModuleName SrcSpanInfo)) Source #

parseWithMode :: ParseMode -> String -> ParseResult (NonGreedy (PragmasAndModuleName SrcSpanInfo)) Source #

parseWithComments :: ParseMode -> String -> ParseResult (NonGreedy (PragmasAndModuleName SrcSpanInfo), [Comment]) Source #

parser :: Maybe [Fixity] -> P (NonGreedy (PragmasAndModuleName SrcSpanInfo))

Parseable (NonGreedy (PragmasAndModuleHead SrcSpanInfo)) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

parse :: String -> ParseResult (NonGreedy (PragmasAndModuleHead SrcSpanInfo)) Source #

parseWithMode :: ParseMode -> String -> ParseResult (NonGreedy (PragmasAndModuleHead SrcSpanInfo)) Source #

parseWithComments :: ParseMode -> String -> ParseResult (NonGreedy (PragmasAndModuleHead SrcSpanInfo), [Comment]) Source #

parser :: Maybe [Fixity] -> P (NonGreedy (PragmasAndModuleHead SrcSpanInfo))

Parseable (NonGreedy (ModuleHeadAndImports SrcSpanInfo)) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

parse :: String -> ParseResult (NonGreedy (ModuleHeadAndImports SrcSpanInfo)) Source #

parseWithMode :: ParseMode -> String -> ParseResult (NonGreedy (ModuleHeadAndImports SrcSpanInfo)) Source #

parseWithComments :: ParseMode -> String -> ParseResult (NonGreedy (ModuleHeadAndImports SrcSpanInfo), [Comment]) Source #

parser :: Maybe [Fixity] -> P (NonGreedy (ModuleHeadAndImports SrcSpanInfo))

Parseable (NonGreedy (ListOf (ModulePragma SrcSpanInfo))) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

parse :: String -> ParseResult (NonGreedy (ListOf (ModulePragma SrcSpanInfo))) Source #

parseWithMode :: ParseMode -> String -> ParseResult (NonGreedy (ListOf (ModulePragma SrcSpanInfo))) Source #

parseWithComments :: ParseMode -> String -> ParseResult (NonGreedy (ListOf (ModulePragma SrcSpanInfo)), [Comment]) Source #

parser :: Maybe [Fixity] -> P (NonGreedy (ListOf (ModulePragma SrcSpanInfo)))

data ListOf a Source #

`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 Source # (<$) :: a -> ListOf b -> ListOf a Source #
Eq a => Eq (ListOf a) |
Instance details Defined in Language.Haskell.Exts.Parser Methods (==) :: ListOf a -> ListOf a -> Bool Source # (/=) :: ListOf a -> ListOf a -> Bool Source #
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) Source #

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

toConstr :: ListOf a -> Constr Source #

dataTypeOf :: ListOf a -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord a => Ord (ListOf a) |
Instance details Defined in Language.Haskell.Exts.Parser Methods compare :: ListOf a -> ListOf a -> Ordering Source # (<) :: ListOf a -> ListOf a -> Bool Source # (<=) :: ListOf a -> ListOf a -> Bool Source # (>) :: ListOf a -> ListOf a -> Bool Source # (>=) :: ListOf a -> ListOf a -> Bool Source # max :: ListOf a -> ListOf a -> ListOf a Source # min :: ListOf a -> ListOf a -> ListOf a Source #
Show a => Show (ListOf a) |
Instance details Defined in Language.Haskell.Exts.Parser Methods showsPrec :: Int -> ListOf a -> ShowS Source # show :: ListOf a -> String Source # showList :: [ListOf a] -> ShowS Source #
Parseable (NonGreedy (ListOf (ModulePragma SrcSpanInfo))) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

parse :: String -> ParseResult (NonGreedy (ListOf (ModulePragma SrcSpanInfo))) Source #

parseWithMode :: ParseMode -> String -> ParseResult (NonGreedy (ListOf (ModulePragma SrcSpanInfo))) Source #

parseWithComments :: ParseMode -> String -> ParseResult (NonGreedy (ListOf (ModulePragma SrcSpanInfo)), [Comment]) Source #

parser :: Maybe [Fixity] -> P (NonGreedy (ListOf (ModulePragma SrcSpanInfo)))

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

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

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

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

data Token Source #

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 Source # (/=) :: Token -> Token -> Bool Source #
Show Token |
Instance details Defined in Language.Haskell.Exts.InternalLexer Methods showsPrec :: Int -> Token -> ShowS Source # show :: Token -> String Source # showList :: [Token] -> ShowS Source #

defaultParseMode :: ParseMode Source #

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

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

class Parseable ast where Source #

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

Parse a string with default mode.

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

Parse a string with an explicit `ParseMode`.

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

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

Methods

parse :: String -> ParseResult (NonGreedy (PragmasAndModuleName SrcSpanInfo)) Source #

parseWithMode :: ParseMode -> String -> ParseResult (NonGreedy (PragmasAndModuleName SrcSpanInfo)) Source #

parseWithComments :: ParseMode -> String -> ParseResult (NonGreedy (PragmasAndModuleName SrcSpanInfo), [Comment]) Source #

parser :: Maybe [Fixity] -> P (NonGreedy (PragmasAndModuleName SrcSpanInfo))

Parseable (NonGreedy (PragmasAndModuleHead SrcSpanInfo)) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

parse :: String -> ParseResult (NonGreedy (PragmasAndModuleHead SrcSpanInfo)) Source #

parseWithMode :: ParseMode -> String -> ParseResult (NonGreedy (PragmasAndModuleHead SrcSpanInfo)) Source #

parseWithComments :: ParseMode -> String -> ParseResult (NonGreedy (PragmasAndModuleHead SrcSpanInfo), [Comment]) Source #

parser :: Maybe [Fixity] -> P (NonGreedy (PragmasAndModuleHead SrcSpanInfo))

Parseable (NonGreedy (ModuleHeadAndImports SrcSpanInfo)) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

parse :: String -> ParseResult (NonGreedy (ModuleHeadAndImports SrcSpanInfo)) Source #

parseWithMode :: ParseMode -> String -> ParseResult (NonGreedy (ModuleHeadAndImports SrcSpanInfo)) Source #

parseWithComments :: ParseMode -> String -> ParseResult (NonGreedy (ModuleHeadAndImports SrcSpanInfo), [Comment]) Source #

parser :: Maybe [Fixity] -> P (NonGreedy (ModuleHeadAndImports SrcSpanInfo))

Parseable (NonGreedy (ListOf (ModulePragma SrcSpanInfo))) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

parse :: String -> ParseResult (NonGreedy (ListOf (ModulePragma SrcSpanInfo))) Source #

parseWithMode :: ParseMode -> String -> ParseResult (NonGreedy (ListOf (ModulePragma SrcSpanInfo))) Source #

parseWithComments :: ParseMode -> String -> ParseResult (NonGreedy (ListOf (ModulePragma SrcSpanInfo)), [Comment]) Source #

parser :: Maybe [Fixity] -> P (NonGreedy (ListOf (ModulePragma SrcSpanInfo)))

data ParseResult a Source #

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 Methods (>>=) :: ParseResult a -> (a -> ParseResult b) -> ParseResult b Source # (>>) :: ParseResult a -> ParseResult b -> ParseResult b Source # return :: a -> ParseResult a Source # fail :: String -> ParseResult a Source #
Functor ParseResult |
Instance details Defined in Language.Haskell.Exts.ParseMonad Methods fmap :: (a -> b) -> ParseResult a -> ParseResult b Source # (<$) :: a -> ParseResult b -> ParseResult a Source #
MonadFail ParseResult |
Instance details Defined in Language.Haskell.Exts.ParseMonad Methods fail :: String -> ParseResult a Source #
Applicative ParseResult |
Instance details Defined in Language.Haskell.Exts.ParseMonad Methods pure :: a -> ParseResult a Source # (<*>) :: ParseResult (a -> b) -> ParseResult a -> ParseResult b Source # liftA2 :: (a -> b -> c) -> ParseResult a -> ParseResult b -> ParseResult c Source # (*>) :: ParseResult a -> ParseResult b -> ParseResult b Source # (<*) :: ParseResult a -> ParseResult b -> ParseResult a Source #
Show a => Show (ParseResult a) |
Instance details Defined in Language.Haskell.Exts.ParseMonad Methods showsPrec :: Int -> ParseResult a -> ShowS Source # show :: ParseResult a -> String Source # showList :: [ParseResult a] -> ShowS Source #
Semigroup m => Semigroup (ParseResult m) |
Instance details Defined in Language.Haskell.Exts.ParseMonad Methods (<>) :: ParseResult m -> ParseResult m -> ParseResult m Source # sconcat :: NonEmpty (ParseResult m) -> ParseResult m Source # stimes :: Integral b => b -> ParseResult m -> ParseResult m Source #
(Monoid m, Semigroup m) => Monoid (ParseResult m) |
Instance details Defined in Language.Haskell.Exts.ParseMonad Methods mempty :: ParseResult m Source # mappend :: ParseResult m -> ParseResult m -> ParseResult m Source # mconcat :: [ParseResult m] -> ParseResult m Source #

data ParseMode Source #

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

- parseFilename :: String

  original name of the file being parsed

- baseLanguage :: Language

  base language (e.g. Haskell98, Haskell2010)

- extensions :: [Extension]

  list of extensions enabled for parsing

- ignoreLanguagePragmas :: Bool

  if `True`, the parser won't care about further extensions in LANGUAGE pragmas in source files

- ignoreLinePragmas :: Bool

  if `True`, the parser won't read line position information from LINE pragmas in source files

- fixities :: Maybe [Fixity]

  list of fixities to be aware of

- ignoreFunctionArity :: Bool

  Checks whether functions have a consistent arity

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

Associates an AST with Source Span Information with relevant Haddock comments

data Comment Source #

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 Source # (/=) :: Comment -> Comment -> Bool Source #
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 Source #

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

toConstr :: Comment -> Constr Source #

dataTypeOf :: Comment -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Show Comment |
Instance details Defined in Language.Haskell.Exts.Comments Methods showsPrec :: Int -> Comment -> ShowS Source # show :: Comment -> String Source # showList :: [Comment] -> ShowS Source #

data UnknownPragma Source #

An unknown pragma.

Constructors

UnknownPragma SrcSpan String |

Instances

Eq UnknownPragma |
Instance details Defined in Language.Haskell.Exts.Comments Methods (==) :: UnknownPragma -> UnknownPragma -> Bool Source # (/=) :: UnknownPragma -> UnknownPragma -> Bool Source #
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 Source #

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

toConstr :: UnknownPragma -> Constr Source #

dataTypeOf :: UnknownPragma -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Show UnknownPragma |
Instance details Defined in Language.Haskell.Exts.Comments Methods showsPrec :: Int -> UnknownPragma -> ShowS Source # show :: UnknownPragma -> String Source # showList :: [UnknownPragma] -> ShowS Source #

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

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

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

baseFixities :: [Fixity] Source #

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

All fixities defined in the Prelude.

data Fixity Source #

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 Source # (/=) :: Fixity -> Fixity -> Bool Source #
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 Source #

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

toConstr :: Fixity -> Constr Source #

dataTypeOf :: Fixity -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord Fixity |
Instance details Defined in Language.Haskell.Exts.Fixity Methods compare :: Fixity -> Fixity -> Ordering Source # (<) :: Fixity -> Fixity -> Bool Source # (<=) :: Fixity -> Fixity -> Bool Source # (>) :: Fixity -> Fixity -> Bool Source # (>=) :: Fixity -> Fixity -> Bool Source # max :: Fixity -> Fixity -> Fixity Source # min :: Fixity -> Fixity -> Fixity Source #
Show Fixity |
Instance details Defined in Language.Haskell.Exts.Fixity Methods showsPrec :: Int -> Fixity -> ShowS Source # show :: Fixity -> String Source # showList :: [Fixity] -> ShowS Source #

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

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

Methods

applyFixities Source #

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 Methods applyFixities :: Monad m => [Fixity] -> Module SrcSpanInfo -> m (Module SrcSpanInfo) Source #
AppFixity Decl |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Decl SrcSpanInfo -> m (Decl SrcSpanInfo) Source #
AppFixity PatternSynDirection |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> PatternSynDirection SrcSpanInfo -> m (PatternSynDirection SrcSpanInfo) Source #
AppFixity Annotation |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Annotation SrcSpanInfo -> m (Annotation SrcSpanInfo) Source #
AppFixity Binds |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Binds SrcSpanInfo -> m (Binds SrcSpanInfo) Source #
AppFixity IPBind |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> IPBind SrcSpanInfo -> m (IPBind SrcSpanInfo) Source #
AppFixity Match |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Match SrcSpanInfo -> m (Match SrcSpanInfo) Source #
AppFixity ClassDecl |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> ClassDecl SrcSpanInfo -> m (ClassDecl SrcSpanInfo) Source #
AppFixity InstDecl |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> InstDecl SrcSpanInfo -> m (InstDecl SrcSpanInfo) Source #
AppFixity Rhs |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Rhs SrcSpanInfo -> m (Rhs SrcSpanInfo) Source #
AppFixity GuardedRhs |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> GuardedRhs SrcSpanInfo -> m (GuardedRhs SrcSpanInfo) Source #
AppFixity Exp |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Exp SrcSpanInfo -> m (Exp SrcSpanInfo) Source #
AppFixity XAttr |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> XAttr SrcSpanInfo -> m (XAttr SrcSpanInfo) Source #
AppFixity Bracket |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Bracket SrcSpanInfo -> m (Bracket SrcSpanInfo) Source #
AppFixity Splice |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Splice SrcSpanInfo -> m (Splice SrcSpanInfo) Source #
AppFixity Pat |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Pat SrcSpanInfo -> m (Pat SrcSpanInfo) Source #
AppFixity PXAttr |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> PXAttr SrcSpanInfo -> m (PXAttr SrcSpanInfo) Source #
AppFixity RPat |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> RPat SrcSpanInfo -> m (RPat SrcSpanInfo) Source #
AppFixity PatField |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> PatField SrcSpanInfo -> m (PatField SrcSpanInfo) Source #
AppFixity Stmt |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Stmt SrcSpanInfo -> m (Stmt SrcSpanInfo) Source #
AppFixity QualStmt |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> QualStmt SrcSpanInfo -> m (QualStmt SrcSpanInfo) Source #
AppFixity FieldUpdate |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> FieldUpdate SrcSpanInfo -> m (FieldUpdate SrcSpanInfo) Source #
AppFixity Alt |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Alt SrcSpanInfo -> m (Alt SrcSpanInfo) Source #

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

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

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

pretty-print with the default style and `defaultMode`.

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

pretty-print with the default style and `defaultMode`.

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

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

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

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

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

data PPLayout Source #

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 Methods (==) :: PPLayout -> PPLayout -> Bool Source # (/=) :: PPLayout -> PPLayout -> Bool Source #

type Indent = Int Source #

data PPHsMode Source #

Pretty-printing parameters.

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

Constructors

PPHsMode |

Fields

- classIndent :: Indent

  indentation of a class or instance

- doIndent :: Indent

  indentation of a `do`-expression

- multiIfIndent :: Indent

  indentation of the body of a `case` expression

- caseIndent :: Indent

  indentation of the body of a multi-`if` expression

- letIndent :: Indent

  indentation of the declarations in a `let` expression

- whereIndent :: Indent

  indentation of the declarations in a `where` clause

- onsideIndent :: Indent

  indentation added for continuation lines that would otherwise be offside

- spacing :: Bool

  blank lines between statements?

- layout :: PPLayout

  Pretty-printing style to use

- linePragmas :: Bool

  add GHC-style `LINE` pragmas to output?

class Pretty a Source #

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 (GuardedAlts l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: GuardedAlts l -> Doc prettyPrec :: Int -> GuardedAlts l -> Doc
Pretty (GuardedAlt l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: GuardedAlt l -> Doc prettyPrec :: Int -> GuardedAlt l -> Doc

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

Test if two AST elements are equal modulo annotations.

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

unboxed_singleton_tycon :: l -> Type l Source #

list_tycon :: l -> Type l Source #

fun_tycon :: l -> Type l Source #

unit_tycon :: l -> Type l Source #

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

unboxed_singleton_tycon_name :: l -> QName l Source #

list_tycon_name :: l -> QName l Source #

fun_tycon_name :: l -> QName l Source #

unit_tycon_name :: l -> QName l Source #

anyclass_name :: l -> Name l Source #

stock_name :: l -> Name l Source #

role_name :: l -> Name l Source #

family_name :: l -> Name l Source #

forall_name :: l -> Name l Source #

capi_name :: l -> Name l Source #

javascript_name :: l -> Name l Source #

js_name :: l -> Name l Source #

jvm_name :: l -> Name l Source #

dotnet_name :: l -> Name l Source #

cplusplus_name :: l -> Name l Source #

ccall_name :: l -> Name l Source #

stdcall_name :: l -> Name l Source #

threadsafe_name :: l -> Name l Source #

interruptible_name :: l -> Name l Source #

unsafe_name :: l -> Name l Source #

safe_name :: l -> Name l Source #

export_name :: l -> Name l Source #

hole_name :: l -> QName l Source #

star_name :: l -> Name l Source #

dot_name :: l -> Name l Source #

bang_name :: l -> Name l Source #

minus_name :: l -> Name l Source #

hiding_name :: l -> Name l Source #

qualified_name :: l -> Name l Source #

as_name :: l -> Name l Source #

unboxed_singleton_con :: l -> Exp l Source #

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

unit_con :: l -> Exp l Source #

unboxed_singleton_con_name :: l -> QName l Source #

list_cons_name :: l -> QName l Source #

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

unit_con_name :: l -> QName l Source #

main_name :: l -> Name l Source #

main_mod :: l -> ModuleName l Source #

prelude_mod :: l -> ModuleName l Source #

data ModuleName l Source #

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 Source # (<$) :: a -> ModuleName b -> ModuleName a Source #
Foldable ModuleName |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: ModuleName a -> [a] Source #

null :: ModuleName a -> Bool Source #

length :: ModuleName a -> Int Source #

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

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

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

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

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

Traversable ModuleName |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> ModuleName a -> f (ModuleName b) Source # sequenceA :: Applicative f => ModuleName (f a) -> f (ModuleName a) Source # mapM :: Monad m => (a -> m b) -> ModuleName a -> m (ModuleName b) Source # sequence :: Monad m => ModuleName (m a) -> m (ModuleName a) Source #
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 Source # amap :: (l -> l) -> ModuleName l -> ModuleName l Source #
Eq l => Eq (ModuleName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: ModuleName l -> ModuleName l -> Bool Source # (/=) :: ModuleName l -> ModuleName l -> Bool Source #
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) Source #

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

toConstr :: ModuleName l -> Constr Source #

dataTypeOf :: ModuleName l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (ModuleName l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: ModuleName l -> ModuleName l -> Ordering Source #

(<) :: ModuleName l -> ModuleName l -> Bool Source #

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

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

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

max :: ModuleName l -> ModuleName l -> ModuleName l Source #

min :: ModuleName l -> ModuleName l -> ModuleName l Source #

Show l => Show (ModuleName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> ModuleName l -> ShowS Source # show :: ModuleName l -> String Source # showList :: [ModuleName l] -> ShowS Source #
Generic (ModuleName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ModuleName l) :: Type -> Type Source # Methods from :: ModuleName l -> Rep (ModuleName l) x Source # to :: Rep (ModuleName l) x -> ModuleName l Source #
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 Source #

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 Source # (<$) :: a -> SpecialCon b -> SpecialCon a Source #
Foldable SpecialCon |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: SpecialCon a -> [a] Source #

null :: SpecialCon a -> Bool Source #

length :: SpecialCon a -> Int Source #

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

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

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

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

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

Traversable SpecialCon |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> SpecialCon a -> f (SpecialCon b) Source # sequenceA :: Applicative f => SpecialCon (f a) -> f (SpecialCon a) Source # mapM :: Monad m => (a -> m b) -> SpecialCon a -> m (SpecialCon b) Source # sequence :: Monad m => SpecialCon (m a) -> m (SpecialCon a) Source #
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 Source # amap :: (l -> l) -> SpecialCon l -> SpecialCon l Source #
Eq l => Eq (SpecialCon l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: SpecialCon l -> SpecialCon l -> Bool Source # (/=) :: SpecialCon l -> SpecialCon l -> Bool Source #
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) Source #

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

toConstr :: SpecialCon l -> Constr Source #

dataTypeOf :: SpecialCon l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (SpecialCon l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: SpecialCon l -> SpecialCon l -> Ordering Source #

(<) :: SpecialCon l -> SpecialCon l -> Bool Source #

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

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

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

max :: SpecialCon l -> SpecialCon l -> SpecialCon l Source #

min :: SpecialCon l -> SpecialCon l -> SpecialCon l Source #

Show l => Show (SpecialCon l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> SpecialCon l -> ShowS Source # show :: SpecialCon l -> String Source # showList :: [SpecialCon l] -> ShowS Source #
Generic (SpecialCon l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (SpecialCon l) :: Type -> Type Source # Methods from :: SpecialCon l -> Rep (SpecialCon l) x Source # to :: Rep (SpecialCon l) x -> SpecialCon l Source #
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

type Rep (SpecialCon l) = D1 (MetaData "SpecialCon" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "UnitCon" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: (C1 (MetaCons "ListCon" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "FunCon" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)))) :+: ((C1 (MetaCons "TupleCon" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Boxed) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int))) :+: C1 (MetaCons "Cons" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))) :+: (C1 (MetaCons "UnboxedSingleCon" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "ExprHole" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)))))

data QName l Source #

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 Source # (<$) :: a -> QName b -> QName a Source #
Foldable QName |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: QName a -> [a] Source #

null :: QName a -> Bool Source #

length :: QName a -> Int Source #

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

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

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

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

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

Traversable QName |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> QName a -> f (QName b) Source # sequenceA :: Applicative f => QName (f a) -> f (QName a) Source # mapM :: Monad m => (a -> m b) -> QName a -> m (QName b) Source # sequence :: Monad m => QName (m a) -> m (QName a) Source #
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 Source # amap :: (l -> l) -> QName l -> QName l Source #
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 Source # (/=) :: QName l -> QName l -> Bool Source #
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) Source #

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

toConstr :: QName l -> Constr Source #

dataTypeOf :: QName l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (QName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: QName l -> QName l -> Ordering Source # (<) :: QName l -> QName l -> Bool Source # (<=) :: QName l -> QName l -> Bool Source # (>) :: QName l -> QName l -> Bool Source # (>=) :: QName l -> QName l -> Bool Source # max :: QName l -> QName l -> QName l Source # min :: QName l -> QName l -> QName l Source #
Show l => Show (QName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> QName l -> ShowS Source # show :: QName l -> String Source # showList :: [QName l] -> ShowS Source #
Generic (QName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (QName l) :: Type -> Type Source # Methods from :: QName l -> Rep (QName l) x Source # to :: Rep (QName l) x -> QName l Source #
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

type Rep (QName l) = D1 (MetaData "QName" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "Qual" 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 (Name l)))) :+: (C1 (MetaCons "UnQual" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))) :+: C1 (MetaCons "Special" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (SpecialCon l)))))

data Name l Source #

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 Source # (<$) :: a -> Name b -> Name a Source #
Foldable Name |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: Name a -> [a] Source #

null :: Name a -> Bool Source #

length :: Name a -> Int Source #

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

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

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

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

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

Traversable Name |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Name a -> f (Name b) Source # sequenceA :: Applicative f => Name (f a) -> f (Name a) Source # mapM :: Monad m => (a -> m b) -> Name a -> m (Name b) Source # sequence :: Monad m => Name (m a) -> m (Name a) Source #
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 Source # amap :: (l -> l) -> Name l -> Name l Source #
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 Source # (/=) :: Name l -> Name l -> Bool Source #
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) Source #

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

toConstr :: Name l -> Constr Source #

dataTypeOf :: Name l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (Name l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Name l -> Name l -> Ordering Source # (<) :: Name l -> Name l -> Bool Source # (<=) :: Name l -> Name l -> Bool Source # (>) :: Name l -> Name l -> Bool Source # (>=) :: Name l -> Name l -> Bool Source # max :: Name l -> Name l -> Name l Source # min :: Name l -> Name l -> Name l Source #
Show l => Show (Name l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Name l -> ShowS Source # show :: Name l -> String Source # showList :: [Name l] -> ShowS Source #
Generic (Name l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Name l) :: Type -> Type Source # Methods from :: Name l -> Rep (Name l) x Source # to :: Rep (Name l) x -> Name l Source #
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

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

data IPName l Source #

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 Source # (<$) :: a -> IPName b -> IPName a Source #
Foldable IPName |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: IPName a -> [a] Source #

null :: IPName a -> Bool Source #

length :: IPName a -> Int Source #

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

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

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

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

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

Traversable IPName |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> IPName a -> f (IPName b) Source # sequenceA :: Applicative f => IPName (f a) -> f (IPName a) Source # mapM :: Monad m => (a -> m b) -> IPName a -> m (IPName b) Source # sequence :: Monad m => IPName (m a) -> m (IPName a) Source #
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 Source # amap :: (l -> l) -> IPName l -> IPName l Source #
Eq l => Eq (IPName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: IPName l -> IPName l -> Bool Source # (/=) :: IPName l -> IPName l -> Bool Source #
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) Source #

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

toConstr :: IPName l -> Constr Source #

dataTypeOf :: IPName l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (IPName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: IPName l -> IPName l -> Ordering Source # (<) :: IPName l -> IPName l -> Bool Source # (<=) :: IPName l -> IPName l -> Bool Source # (>) :: IPName l -> IPName l -> Bool Source # (>=) :: IPName l -> IPName l -> Bool Source # max :: IPName l -> IPName l -> IPName l Source # min :: IPName l -> IPName l -> IPName l Source #
Show l => Show (IPName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> IPName l -> ShowS Source # show :: IPName l -> String Source # showList :: [IPName l] -> ShowS Source #
Generic (IPName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (IPName l) :: Type -> Type Source # Methods from :: IPName l -> Rep (IPName l) x Source # to :: Rep (IPName l) x -> IPName l Source #
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

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

data QOp l Source #

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 Source # (<$) :: a -> QOp b -> QOp a Source #
Foldable QOp |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: QOp a -> [a] Source #

null :: QOp a -> Bool Source #

length :: QOp a -> Int Source #

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

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

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

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

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

Traversable QOp |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> QOp a -> f (QOp b) Source # sequenceA :: Applicative f => QOp (f a) -> f (QOp a) Source # mapM :: Monad m => (a -> m b) -> QOp a -> m (QOp b) Source # sequence :: Monad m => QOp (m a) -> m (QOp a) Source #
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 Source # amap :: (l -> l) -> QOp l -> QOp l Source #
Eq l => Eq (QOp l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: QOp l -> QOp l -> Bool Source # (/=) :: QOp l -> QOp l -> Bool Source #
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) Source #

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

toConstr :: QOp l -> Constr Source #

dataTypeOf :: QOp l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (QOp l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: QOp l -> QOp l -> Ordering Source # (<) :: QOp l -> QOp l -> Bool Source # (<=) :: QOp l -> QOp l -> Bool Source # (>) :: QOp l -> QOp l -> Bool Source # (>=) :: QOp l -> QOp l -> Bool Source # max :: QOp l -> QOp l -> QOp l Source # min :: QOp l -> QOp l -> QOp l Source #
Show l => Show (QOp l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> QOp l -> ShowS Source # show :: QOp l -> String Source # showList :: [QOp l] -> ShowS Source #
Generic (QOp l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (QOp l) :: Type -> Type Source # Methods from :: QOp l -> Rep (QOp l) x Source # to :: Rep (QOp l) x -> QOp l Source #
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

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

data Op l Source #

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 Source # (<$) :: a -> Op b -> Op a Source #
Foldable Op |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: Op a -> [a] Source #

null :: Op a -> Bool Source #

length :: Op a -> Int Source #

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

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

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

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

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

Traversable Op |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Op a -> f (Op b) Source # sequenceA :: Applicative f => Op (f a) -> f (Op a) Source # mapM :: Monad m => (a -> m b) -> Op a -> m (Op b) Source # sequence :: Monad m => Op (m a) -> m (Op a) Source #
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 Source # amap :: (l -> l) -> Op l -> Op l Source #
Eq l => Eq (Op l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Op l -> Op l -> Bool Source # (/=) :: Op l -> Op l -> Bool Source #
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) Source #

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

toConstr :: Op l -> Constr Source #

dataTypeOf :: Op l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (Op l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Op l -> Op l -> Ordering Source # (<) :: Op l -> Op l -> Bool Source # (<=) :: Op l -> Op l -> Bool Source # (>) :: Op l -> Op l -> Bool Source # (>=) :: Op l -> Op l -> Bool Source # max :: Op l -> Op l -> Op l Source # min :: Op l -> Op l -> Op l Source #
Show l => Show (Op l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Op l -> ShowS Source # show :: Op l -> String Source # showList :: [Op l] -> ShowS Source #
Generic (Op l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Op l) :: Type -> Type Source # Methods from :: Op l -> Rep (Op l) x Source # to :: Rep (Op l) x -> Op l Source #
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

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

data CName l Source #

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 Source # (<$) :: a -> CName b -> CName a Source #
Foldable CName |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: CName a -> [a] Source #

null :: CName a -> Bool Source #

length :: CName a -> Int Source #

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

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

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

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

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

Traversable CName |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> CName a -> f (CName b) Source # sequenceA :: Applicative f => CName (f a) -> f (CName a) Source # mapM :: Monad m => (a -> m b) -> CName a -> m (CName b) Source # sequence :: Monad m => CName (m a) -> m (CName a) Source #
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 Source # amap :: (l -> l) -> CName l -> CName l Source #
Eq l => Eq (CName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: CName l -> CName l -> Bool Source # (/=) :: CName l -> CName l -> Bool Source #
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) Source #

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

toConstr :: CName l -> Constr Source #

dataTypeOf :: CName l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (CName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: CName l -> CName l -> Ordering Source # (<) :: CName l -> CName l -> Bool Source # (<=) :: CName l -> CName l -> Bool Source # (>) :: CName l -> CName l -> Bool Source # (>=) :: CName l -> CName l -> Bool Source # max :: CName l -> CName l -> CName l Source # min :: CName l -> CName l -> CName l Source #
Show l => Show (CName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> CName l -> ShowS Source # show :: CName l -> String Source # showList :: [CName l] -> ShowS Source #
Generic (CName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (CName l) :: Type -> Type Source # Methods from :: CName l -> Rep (CName l) x Source # to :: Rep (CName l) x -> CName l Source #
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

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

data Module l Source #

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 Source # (<$) :: a -> Module b -> Module a Source #
Foldable Module |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: Module a -> [a] Source #

null :: Module a -> Bool Source #

length :: Module a -> Int Source #

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

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

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

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

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

Traversable Module |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Module a -> f (Module b) Source # sequenceA :: Applicative f => Module (f a) -> f (Module a) Source # mapM :: Monad m => (a -> m b) -> Module a -> m (Module b) Source # sequence :: Monad m => Module (m a) -> m (Module a) Source #
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 Methods applyFixities :: Monad m => [Fixity] -> Module SrcSpanInfo -> m (Module SrcSpanInfo) Source #
Annotated Module |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Module l -> l Source # amap :: (l -> l) -> Module l -> Module l Source #
Eq l => Eq (Module l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Module l -> Module l -> Bool Source # (/=) :: Module l -> Module l -> Bool Source #
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) Source #

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

toConstr :: Module l -> Constr Source #

dataTypeOf :: Module l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (Module l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Module l -> Module l -> Ordering Source # (<) :: Module l -> Module l -> Bool Source # (<=) :: Module l -> Module l -> Bool Source # (>) :: Module l -> Module l -> Bool Source # (>=) :: Module l -> Module l -> Bool Source # max :: Module l -> Module l -> Module l Source # min :: Module l -> Module l -> Module l Source #
Show l => Show (Module l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Module l -> ShowS Source # show :: Module l -> String Source # showList :: [Module l] -> ShowS Source #
Generic (Module l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Module l) :: Type -> Type Source # Methods from :: Module l -> Rep (Module l) x Source # to :: Rep (Module l) x -> Module l Source #
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 Source #

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 Source # (<$) :: a -> ModuleHead b -> ModuleHead a Source #
Foldable ModuleHead |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: ModuleHead a -> [a] Source #

null :: ModuleHead a -> Bool Source #

length :: ModuleHead a -> Int Source #

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

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

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

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

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

Traversable ModuleHead |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> ModuleHead a -> f (ModuleHead b) Source # sequenceA :: Applicative f => ModuleHead (f a) -> f (ModuleHead a) Source # mapM :: Monad m => (a -> m b) -> ModuleHead a -> m (ModuleHead b) Source # sequence :: Monad m => ModuleHead (m a) -> m (ModuleHead a) Source #
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 Source # amap :: (l -> l) -> ModuleHead l -> ModuleHead l Source #
Eq l => Eq (ModuleHead l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: ModuleHead l -> ModuleHead l -> Bool Source # (/=) :: ModuleHead l -> ModuleHead l -> Bool Source #
Data l => Data (ModuleHead 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) -> ModuleHead l -> c (ModuleHead l) Source #

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

toConstr :: ModuleHead l -> Constr Source #

dataTypeOf :: ModuleHead l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (ModuleHead l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: ModuleHead l -> ModuleHead l -> Ordering Source #

(<) :: ModuleHead l -> ModuleHead l -> Bool Source #

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

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

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

max :: ModuleHead l -> ModuleHead l -> ModuleHead l Source #

min :: ModuleHead l -> ModuleHead l -> ModuleHead l Source #

Show l => Show (ModuleHead l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> ModuleHead l -> ShowS Source # show :: ModuleHead l -> String Source # showList :: [ModuleHead l] -> ShowS Source #
Generic (ModuleHead l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ModuleHead l) :: Type -> Type Source # Methods from :: ModuleHead l -> Rep (ModuleHead l) x Source # to :: Rep (ModuleHead l) x -> ModuleHead l Source #
Pretty (ModuleHead l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: ModuleHead l -> Doc prettyPrec :: Int -> ModuleHead l -> Doc
type Rep (ModuleHead l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (ModuleHead l) = D1 (MetaData "ModuleHead" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "ModuleHead" 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 (Maybe (WarningText l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ExportSpecList l))))))

data ExportSpecList l Source #

An explicit export specification.

Constructors

ExportSpecList l [ExportSpec l] |

Instances

Functor ExportSpecList |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> ExportSpecList a -> ExportSpecList b Source # (<$) :: a -> ExportSpecList b -> ExportSpecList a Source #
Foldable ExportSpecList |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ExportSpecList m -> m Source #

foldMap :: Monoid m => (a -> m) -> ExportSpecList a -> m Source #

foldr :: (a -> b -> b) -> b -> ExportSpecList a -> b Source #

foldr' :: (a -> b -> b) -> b -> ExportSpecList a -> b Source #

foldl :: (b -> a -> b) -> b -> ExportSpecList a -> b Source #

foldl' :: (b -> a -> b) -> b -> ExportSpecList a -> b Source #

foldr1 :: (a -> a -> a) -> ExportSpecList a -> a Source #

foldl1 :: (a -> a -> a) -> ExportSpecList a -> a Source #

toList :: ExportSpecList a -> [a] Source #

null :: ExportSpecList a -> Bool Source #

length :: ExportSpecList a -> Int Source #

elem :: Eq a => a -> ExportSpecList a -> Bool Source #

maximum :: Ord a => ExportSpecList a -> a Source #

minimum :: Ord a => ExportSpecList a -> a Source #

sum :: Num a => ExportSpecList a -> a Source #

product :: Num a => ExportSpecList a -> a Source #

Traversable ExportSpecList |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

sequenceA :: Applicative f => ExportSpecList (f a) -> f (ExportSpecList a) Source #

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

sequence :: Monad m => ExportSpecList (m a) -> m (ExportSpecList a) Source #

ExactP ExportSpecList |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: ExportSpecList SrcSpanInfo -> EP ()
Annotated ExportSpecList |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ExportSpecList l -> l Source # amap :: (l -> l) -> ExportSpecList l -> ExportSpecList l Source #
Eq l => Eq (ExportSpecList l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: ExportSpecList l -> ExportSpecList l -> Bool Source # (/=) :: ExportSpecList l -> ExportSpecList l -> Bool Source #
Data l => Data (ExportSpecList 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) -> ExportSpecList l -> c (ExportSpecList l) Source #

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

toConstr :: ExportSpecList l -> Constr Source #

dataTypeOf :: ExportSpecList l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (ExportSpecList l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: ExportSpecList l -> ExportSpecList l -> Ordering Source #

(<) :: ExportSpecList l -> ExportSpecList l -> Bool Source #

(<=) :: ExportSpecList l -> ExportSpecList l -> Bool Source #

(>) :: ExportSpecList l -> ExportSpecList l -> Bool Source #

(>=) :: ExportSpecList l -> ExportSpecList l -> Bool Source #

max :: ExportSpecList l -> ExportSpecList l -> ExportSpecList l Source #

min :: ExportSpecList l -> ExportSpecList l -> ExportSpecList l Source #

Show l => Show (ExportSpecList l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> ExportSpecList l -> ShowS Source # show :: ExportSpecList l -> String Source # showList :: [ExportSpecList l] -> ShowS Source #
Generic (ExportSpecList l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ExportSpecList l) :: Type -> Type Source # Methods from :: ExportSpecList l -> Rep (ExportSpecList l) x Source # to :: Rep (ExportSpecList l) x -> ExportSpecList l Source #
Pretty (ExportSpecList l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: ExportSpecList l -> Doc prettyPrec :: Int -> ExportSpecList l -> Doc
type Rep (ExportSpecList l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

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

data ExportSpec l Source #

An item in a module's export specification.

Constructors

EVar l (QName l) | variable.
EAbs l (Namespace l) (QName l) | `T`: a class or datatype exported abstractly, or a type synonym.
EThingWith l (EWildcard l) (QName l) [CName l] | `T(C_1,...,C_n)`: a class exported with some of its methods, or a datatype exported with some of its constructors.
EModuleContents l (ModuleName l) | `module M`: re-export a module.

Instances

Functor ExportSpec |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> ExportSpec a -> ExportSpec b Source # (<$) :: a -> ExportSpec b -> ExportSpec a Source #
Foldable ExportSpec |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ExportSpec m -> m Source #

foldMap :: Monoid m => (a -> m) -> ExportSpec a -> m Source #

foldr :: (a -> b -> b) -> b -> ExportSpec a -> b Source #

foldr' :: (a -> b -> b) -> b -> ExportSpec a -> b Source #

foldl :: (b -> a -> b) -> b -> ExportSpec a -> b Source #

foldl' :: (b -> a -> b) -> b -> ExportSpec a -> b Source #

foldr1 :: (a -> a -> a) -> ExportSpec a -> a Source #

foldl1 :: (a -> a -> a) -> ExportSpec a -> a Source #

toList :: ExportSpec a -> [a] Source #

null :: ExportSpec a -> Bool Source #

length :: ExportSpec a -> Int Source #

elem :: Eq a => a -> ExportSpec a -> Bool Source #

maximum :: Ord a => ExportSpec a -> a Source #

minimum :: Ord a => ExportSpec a -> a Source #

sum :: Num a => ExportSpec a -> a Source #

product :: Num a => ExportSpec a -> a Source #

Traversable ExportSpec |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> ExportSpec a -> f (ExportSpec b) Source # sequenceA :: Applicative f => ExportSpec (f a) -> f (ExportSpec a) Source # mapM :: Monad m => (a -> m b) -> ExportSpec a -> m (ExportSpec b) Source # sequence :: Monad m => ExportSpec (m a) -> m (ExportSpec a) Source #
ExactP ExportSpec |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: ExportSpec SrcSpanInfo -> EP ()
Annotated ExportSpec |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ExportSpec l -> l Source # amap :: (l -> l) -> ExportSpec l -> ExportSpec l Source #
Eq l => Eq (ExportSpec l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: ExportSpec l -> ExportSpec l -> Bool Source # (/=) :: ExportSpec l -> ExportSpec l -> Bool Source #
Data l => Data (ExportSpec 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) -> ExportSpec l -> c (ExportSpec l) Source #

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

toConstr :: ExportSpec l -> Constr Source #

dataTypeOf :: ExportSpec l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (ExportSpec l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: ExportSpec l -> ExportSpec l -> Ordering Source #

(<) :: ExportSpec l -> ExportSpec l -> Bool Source #

(<=) :: ExportSpec l -> ExportSpec l -> Bool Source #

(>) :: ExportSpec l -> ExportSpec l -> Bool Source #

(>=) :: ExportSpec l -> ExportSpec l -> Bool Source #

max :: ExportSpec l -> ExportSpec l -> ExportSpec l Source #

min :: ExportSpec l -> ExportSpec l -> ExportSpec l Source #

Show l => Show (ExportSpec l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> ExportSpec l -> ShowS Source # show :: ExportSpec l -> String Source # showList :: [ExportSpec l] -> ShowS Source #
Generic (ExportSpec l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ExportSpec l) :: Type -> Type Source # Methods from :: ExportSpec l -> Rep (ExportSpec l) x Source # to :: Rep (ExportSpec l) x -> ExportSpec l Source #
Pretty (ExportSpec l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: ExportSpec l -> Doc prettyPrec :: Int -> ExportSpec l -> Doc
type Rep (ExportSpec l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (ExportSpec l) = D1 (MetaData "ExportSpec" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "EVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))) :+: C1 (MetaCons "EAbs" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Namespace l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))))) :+: (C1 (MetaCons "EThingWith" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (EWildcard l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [CName l]))) :+: C1 (MetaCons "EModuleContents" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ModuleName l)))))

data EWildcard l Source #

Indicates the position of the wildcard in an export list

Constructors

NoWildcard l |
EWildcard l Int |

Instances

Functor EWildcard |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> EWildcard a -> EWildcard b Source # (<$) :: a -> EWildcard b -> EWildcard a Source #
Foldable EWildcard |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => EWildcard m -> m Source #

foldMap :: Monoid m => (a -> m) -> EWildcard a -> m Source #

foldr :: (a -> b -> b) -> b -> EWildcard a -> b Source #

foldr' :: (a -> b -> b) -> b -> EWildcard a -> b Source #

foldl :: (b -> a -> b) -> b -> EWildcard a -> b Source #

foldl' :: (b -> a -> b) -> b -> EWildcard a -> b Source #

foldr1 :: (a -> a -> a) -> EWildcard a -> a Source #

foldl1 :: (a -> a -> a) -> EWildcard a -> a Source #

toList :: EWildcard a -> [a] Source #

null :: EWildcard a -> Bool Source #

length :: EWildcard a -> Int Source #

elem :: Eq a => a -> EWildcard a -> Bool Source #

maximum :: Ord a => EWildcard a -> a Source #

minimum :: Ord a => EWildcard a -> a Source #

sum :: Num a => EWildcard a -> a Source #

product :: Num a => EWildcard a -> a Source #

Traversable EWildcard |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> EWildcard a -> f (EWildcard b) Source # sequenceA :: Applicative f => EWildcard (f a) -> f (EWildcard a) Source # mapM :: Monad m => (a -> m b) -> EWildcard a -> m (EWildcard b) Source # sequence :: Monad m => EWildcard (m a) -> m (EWildcard a) Source #
Annotated EWildcard |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: EWildcard l -> l Source # amap :: (l -> l) -> EWildcard l -> EWildcard l Source #
Eq l => Eq (EWildcard l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: EWildcard l -> EWildcard l -> Bool Source # (/=) :: EWildcard l -> EWildcard l -> Bool Source #
Data l => Data (EWildcard 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) -> EWildcard l -> c (EWildcard l) Source #

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

toConstr :: EWildcard l -> Constr Source #

dataTypeOf :: EWildcard l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (EWildcard l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: EWildcard l -> EWildcard l -> Ordering Source #

(<) :: EWildcard l -> EWildcard l -> Bool Source #

(<=) :: EWildcard l -> EWildcard l -> Bool Source #

(>) :: EWildcard l -> EWildcard l -> Bool Source #

(>=) :: EWildcard l -> EWildcard l -> Bool Source #

max :: EWildcard l -> EWildcard l -> EWildcard l Source #

min :: EWildcard l -> EWildcard l -> EWildcard l Source #

Show l => Show (EWildcard l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> EWildcard l -> ShowS Source # show :: EWildcard l -> String Source # showList :: [EWildcard l] -> ShowS Source #
Generic (EWildcard l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (EWildcard l) :: Type -> Type Source # Methods from :: EWildcard l -> Rep (EWildcard l) x Source # to :: Rep (EWildcard l) x -> EWildcard l Source #
type Rep (EWildcard l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

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

data Namespace l Source #

Namespaces for imports/exports.

Constructors

NoNamespace l |
TypeNamespace l |
PatternNamespace l |

Instances

Functor Namespace |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Namespace a -> Namespace b Source # (<$) :: a -> Namespace b -> Namespace a Source #
Foldable Namespace |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Namespace m -> m Source #

foldMap :: Monoid m => (a -> m) -> Namespace a -> m Source #

foldr :: (a -> b -> b) -> b -> Namespace a -> b Source #

foldr' :: (a -> b -> b) -> b -> Namespace a -> b Source #

foldl :: (b -> a -> b) -> b -> Namespace a -> b Source #

foldl' :: (b -> a -> b) -> b -> Namespace a -> b Source #

foldr1 :: (a -> a -> a) -> Namespace a -> a Source #

foldl1 :: (a -> a -> a) -> Namespace a -> a Source #

toList :: Namespace a -> [a] Source #

null :: Namespace a -> Bool Source #

length :: Namespace a -> Int Source #

elem :: Eq a => a -> Namespace a -> Bool Source #

maximum :: Ord a => Namespace a -> a Source #

minimum :: Ord a => Namespace a -> a Source #

sum :: Num a => Namespace a -> a Source #

product :: Num a => Namespace a -> a Source #

Traversable Namespace |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Namespace a -> f (Namespace b) Source # sequenceA :: Applicative f => Namespace (f a) -> f (Namespace a) Source # mapM :: Monad m => (a -> m b) -> Namespace a -> m (Namespace b) Source # sequence :: Monad m => Namespace (m a) -> m (Namespace a) Source #
ExactP Namespace |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Namespace SrcSpanInfo -> EP ()
Annotated Namespace |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Namespace l -> l Source # amap :: (l -> l) -> Namespace l -> Namespace l Source #
Eq l => Eq (Namespace l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Namespace l -> Namespace l -> Bool Source # (/=) :: Namespace l -> Namespace l -> Bool Source #
Data l => Data (Namespace 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) -> Namespace l -> c (Namespace l) Source #

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

toConstr :: Namespace l -> Constr Source #

dataTypeOf :: Namespace l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (Namespace l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Namespace l -> Namespace l -> Ordering Source #

(<) :: Namespace l -> Namespace l -> Bool Source #

(<=) :: Namespace l -> Namespace l -> Bool Source #

(>) :: Namespace l -> Namespace l -> Bool Source #

(>=) :: Namespace l -> Namespace l -> Bool Source #

max :: Namespace l -> Namespace l -> Namespace l Source #

min :: Namespace l -> Namespace l -> Namespace l Source #

Show l => Show (Namespace l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Namespace l -> ShowS Source # show :: Namespace l -> String Source # showList :: [Namespace l] -> ShowS Source #
Generic (Namespace l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Namespace l) :: Type -> Type Source # Methods from :: Namespace l -> Rep (Namespace l) x Source # to :: Rep (Namespace l) x -> Namespace l Source #
Pretty (Namespace l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Namespace l -> Doc prettyPrec :: Int -> Namespace l -> Doc
type Rep (Namespace l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

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

data ImportDecl l Source #

An import declaration.

Constructors

ImportDecl |

Fields

- importAnn :: l

  annotation, used by parser for position of the `import` keyword.

- importModule :: ModuleName l

  name of the module imported.

- importQualified :: Bool

  imported `qualified`?

- importSrc :: Bool

  imported with `{-# SOURCE #-}`?

- importSafe :: Bool

  Import `safe`?

- importPkg :: Maybe String

  imported with explicit package name

- importAs :: Maybe (ModuleName l)

  optional alias name in an `as` clause.

- importSpecs :: Maybe (ImportSpecList l)

  optional list of import specifications.

Instances

Functor ImportDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> ImportDecl a -> ImportDecl b Source # (<$) :: a -> ImportDecl b -> ImportDecl a Source #
Foldable ImportDecl |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ImportDecl m -> m Source #

foldMap :: Monoid m => (a -> m) -> ImportDecl a -> m Source #

foldr :: (a -> b -> b) -> b -> ImportDecl a -> b Source #

foldr' :: (a -> b -> b) -> b -> ImportDecl a -> b Source #

foldl :: (b -> a -> b) -> b -> ImportDecl a -> b Source #

foldl' :: (b -> a -> b) -> b -> ImportDecl a -> b Source #

foldr1 :: (a -> a -> a) -> ImportDecl a -> a Source #

foldl1 :: (a -> a -> a) -> ImportDecl a -> a Source #

toList :: ImportDecl a -> [a] Source #

null :: ImportDecl a -> Bool Source #

length :: ImportDecl a -> Int Source #

elem :: Eq a => a -> ImportDecl a -> Bool Source #

maximum :: Ord a => ImportDecl a -> a Source #

minimum :: Ord a => ImportDecl a -> a Source #

sum :: Num a => ImportDecl a -> a Source #

product :: Num a => ImportDecl a -> a Source #

Traversable ImportDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> ImportDecl a -> f (ImportDecl b) Source # sequenceA :: Applicative f => ImportDecl (f a) -> f (ImportDecl a) Source # mapM :: Monad m => (a -> m b) -> ImportDecl a -> m (ImportDecl b) Source # sequence :: Monad m => ImportDecl (m a) -> m (ImportDecl a) Source #
ExactP ImportDecl |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: ImportDecl SrcSpanInfo -> EP ()
Annotated ImportDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ImportDecl l -> l Source # amap :: (l -> l) -> ImportDecl l -> ImportDecl l Source #
Eq l => Eq (ImportDecl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: ImportDecl l -> ImportDecl l -> Bool Source # (/=) :: ImportDecl l -> ImportDecl l -> Bool Source #
Data l => Data (ImportDecl 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) -> ImportDecl l -> c (ImportDecl l) Source #

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

toConstr :: ImportDecl l -> Constr Source #

dataTypeOf :: ImportDecl l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (ImportDecl l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: ImportDecl l -> ImportDecl l -> Ordering Source #

(<) :: ImportDecl l -> ImportDecl l -> Bool Source #

(<=) :: ImportDecl l -> ImportDecl l -> Bool Source #

(>) :: ImportDecl l -> ImportDecl l -> Bool Source #

(>=) :: ImportDecl l -> ImportDecl l -> Bool Source #

max :: ImportDecl l -> ImportDecl l -> ImportDecl l Source #

min :: ImportDecl l -> ImportDecl l -> ImportDecl l Source #

Show l => Show (ImportDecl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> ImportDecl l -> ShowS Source # show :: ImportDecl l -> String Source # showList :: [ImportDecl l] -> ShowS Source #
Generic (ImportDecl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ImportDecl l) :: Type -> Type Source # Methods from :: ImportDecl l -> Rep (ImportDecl l) x Source # to :: Rep (ImportDecl l) x -> ImportDecl l Source #
Pretty (ImportDecl l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: ImportDecl l -> Doc prettyPrec :: Int -> ImportDecl l -> Doc
type Rep (ImportDecl l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (ImportDecl l) = D1 (MetaData "ImportDecl" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "ImportDecl" PrefixI True) (((S1 (MetaSel (Just "importAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Just "importModule") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ModuleName l))) :*: (S1 (MetaSel (Just "importQualified") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool) :*: S1 (MetaSel (Just "importSrc") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool))) :*: ((S1 (MetaSel (Just "importSafe") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool) :*: S1 (MetaSel (Just "importPkg") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe String))) :*: (S1 (MetaSel (Just "importAs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ModuleName l))) :*: S1 (MetaSel (Just "importSpecs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ImportSpecList l)))))))

data ImportSpecList l Source #

An explicit import specification list.

Constructors

ImportSpecList l Bool [ImportSpec l] |

Instances

Functor ImportSpecList |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> ImportSpecList a -> ImportSpecList b Source # (<$) :: a -> ImportSpecList b -> ImportSpecList a Source #
Foldable ImportSpecList |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ImportSpecList m -> m Source #

foldMap :: Monoid m => (a -> m) -> ImportSpecList a -> m Source #

foldr :: (a -> b -> b) -> b -> ImportSpecList a -> b Source #

foldr' :: (a -> b -> b) -> b -> ImportSpecList a -> b Source #

foldl :: (b -> a -> b) -> b -> ImportSpecList a -> b Source #

foldl' :: (b -> a -> b) -> b -> ImportSpecList a -> b Source #

foldr1 :: (a -> a -> a) -> ImportSpecList a -> a Source #

foldl1 :: (a -> a -> a) -> ImportSpecList a -> a Source #

toList :: ImportSpecList a -> [a] Source #

null :: ImportSpecList a -> Bool Source #

length :: ImportSpecList a -> Int Source #

elem :: Eq a => a -> ImportSpecList a -> Bool Source #

maximum :: Ord a => ImportSpecList a -> a Source #

minimum :: Ord a => ImportSpecList a -> a Source #

sum :: Num a => ImportSpecList a -> a Source #

product :: Num a => ImportSpecList a -> a Source #

Traversable ImportSpecList |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

sequenceA :: Applicative f => ImportSpecList (f a) -> f (ImportSpecList a) Source #

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

sequence :: Monad m => ImportSpecList (m a) -> m (ImportSpecList a) Source #

ExactP ImportSpecList |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: ImportSpecList SrcSpanInfo -> EP ()
Annotated ImportSpecList |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ImportSpecList l -> l Source # amap :: (l -> l) -> ImportSpecList l -> ImportSpecList l Source #
Eq l => Eq (ImportSpecList l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: ImportSpecList l -> ImportSpecList l -> Bool Source # (/=) :: ImportSpecList l -> ImportSpecList l -> Bool Source #
Data l => Data (ImportSpecList 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) -> ImportSpecList l -> c (ImportSpecList l) Source #

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

toConstr :: ImportSpecList l -> Constr Source #

dataTypeOf :: ImportSpecList l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (ImportSpecList l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: ImportSpecList l -> ImportSpecList l -> Ordering Source #

(<) :: ImportSpecList l -> ImportSpecList l -> Bool Source #

(<=) :: ImportSpecList l -> ImportSpecList l -> Bool Source #

(>) :: ImportSpecList l -> ImportSpecList l -> Bool Source #

(>=) :: ImportSpecList l -> ImportSpecList l -> Bool Source #

max :: ImportSpecList l -> ImportSpecList l -> ImportSpecList l Source #

min :: ImportSpecList l -> ImportSpecList l -> ImportSpecList l Source #

Show l => Show (ImportSpecList l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> ImportSpecList l -> ShowS Source # show :: ImportSpecList l -> String Source # showList :: [ImportSpecList l] -> ShowS Source #
Generic (ImportSpecList l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ImportSpecList l) :: Type -> Type Source # Methods from :: ImportSpecList l -> Rep (ImportSpecList l) x Source # to :: Rep (ImportSpecList l) x -> ImportSpecList l Source #
Pretty (ImportSpecList l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: ImportSpecList l -> Doc prettyPrec :: Int -> ImportSpecList l -> Doc
type Rep (ImportSpecList l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

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

data ImportSpec l Source #

An import specification, representing a single explicit item imported (or hidden) from a module.

Constructors

IVar l (Name l) | variable
IAbs l (Namespace l) (Name l) | `T`: the name of a class, datatype or type synonym.
IThingAll l (Name l) | `T(..)`: a class imported with all of its methods, or a datatype imported with all of its constructors.
IThingWith l (Name l) [CName l] | `T(C_1,...,C_n)`: a class imported with some of its methods, or a datatype imported with some of its constructors.

Instances

Functor ImportSpec |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> ImportSpec a -> ImportSpec b Source # (<$) :: a -> ImportSpec b -> ImportSpec a Source #
Foldable ImportSpec |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ImportSpec m -> m Source #

foldMap :: Monoid m => (a -> m) -> ImportSpec a -> m Source #

foldr :: (a -> b -> b) -> b -> ImportSpec a -> b Source #

foldr' :: (a -> b -> b) -> b -> ImportSpec a -> b Source #

foldl :: (b -> a -> b) -> b -> ImportSpec a -> b Source #

foldl' :: (b -> a -> b) -> b -> ImportSpec a -> b Source #

foldr1 :: (a -> a -> a) -> ImportSpec a -> a Source #

foldl1 :: (a -> a -> a) -> ImportSpec a -> a Source #

toList :: ImportSpec a -> [a] Source #

null :: ImportSpec a -> Bool Source #

length :: ImportSpec a -> Int Source #

elem :: Eq a => a -> ImportSpec a -> Bool Source #

maximum :: Ord a => ImportSpec a -> a Source #

minimum :: Ord a => ImportSpec a -> a Source #

sum :: Num a => ImportSpec a -> a Source #

product :: Num a => ImportSpec a -> a Source #

Traversable ImportSpec |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> ImportSpec a -> f (ImportSpec b) Source # sequenceA :: Applicative f => ImportSpec (f a) -> f (ImportSpec a) Source # mapM :: Monad m => (a -> m b) -> ImportSpec a -> m (ImportSpec b) Source # sequence :: Monad m => ImportSpec (m a) -> m (ImportSpec a) Source #
ExactP ImportSpec |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: ImportSpec SrcSpanInfo -> EP ()
Annotated ImportSpec |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ImportSpec l -> l Source # amap :: (l -> l) -> ImportSpec l -> ImportSpec l Source #
Eq l => Eq (ImportSpec l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: ImportSpec l -> ImportSpec l -> Bool Source # (/=) :: ImportSpec l -> ImportSpec l -> Bool Source #
Data l => Data (ImportSpec 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) -> ImportSpec l -> c (ImportSpec l) Source #

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

toConstr :: ImportSpec l -> Constr Source #

dataTypeOf :: ImportSpec l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (ImportSpec l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: ImportSpec l -> ImportSpec l -> Ordering Source #

(<) :: ImportSpec l -> ImportSpec l -> Bool Source #

(<=) :: ImportSpec l -> ImportSpec l -> Bool Source #

(>) :: ImportSpec l -> ImportSpec l -> Bool Source #

(>=) :: ImportSpec l -> ImportSpec l -> Bool Source #

max :: ImportSpec l -> ImportSpec l -> ImportSpec l Source #

min :: ImportSpec l -> ImportSpec l -> ImportSpec l Source #

Show l => Show (ImportSpec l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> ImportSpec l -> ShowS Source # show :: ImportSpec l -> String Source # showList :: [ImportSpec l] -> ShowS Source #
Generic (ImportSpec l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ImportSpec l) :: Type -> Type Source # Methods from :: ImportSpec l -> Rep (ImportSpec l) x Source # to :: Rep (ImportSpec l) x -> ImportSpec l Source #
Pretty (ImportSpec l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: ImportSpec l -> Doc prettyPrec :: Int -> ImportSpec l -> Doc
type Rep (ImportSpec l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (ImportSpec l) = D1 (MetaData "ImportSpec" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "IVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))) :+: C1 (MetaCons "IAbs" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Namespace l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))))) :+: (C1 (MetaCons "IThingAll" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))) :+: C1 (MetaCons "IThingWith" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [CName l])))))

data Assoc l Source #

Associativity of an operator.

Constructors

AssocNone l | non-associative operator (declared with `infix`)
AssocLeft l | left-associative operator (declared with `infixl`).
AssocRight l | right-associative operator (declared with `infixr`)

Instances

Functor Assoc |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Assoc a -> Assoc b Source # (<$) :: a -> Assoc b -> Assoc a Source #
Foldable Assoc |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Assoc m -> m Source #

foldMap :: Monoid m => (a -> m) -> Assoc a -> m Source #

foldr :: (a -> b -> b) -> b -> Assoc a -> b Source #

foldr' :: (a -> b -> b) -> b -> Assoc a -> b Source #

foldl :: (b -> a -> b) -> b -> Assoc a -> b Source #

foldl' :: (b -> a -> b) -> b -> Assoc a -> b Source #

foldr1 :: (a -> a -> a) -> Assoc a -> a Source #

foldl1 :: (a -> a -> a) -> Assoc a -> a Source #

toList :: Assoc a -> [a] Source #

null :: Assoc a -> Bool Source #

length :: Assoc a -> Int Source #

elem :: Eq a => a -> Assoc a -> Bool Source #

maximum :: Ord a => Assoc a -> a Source #

minimum :: Ord a => Assoc a -> a Source #

sum :: Num a => Assoc a -> a Source #

product :: Num a => Assoc a -> a Source #

Traversable Assoc |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Assoc a -> f (Assoc b) Source # sequenceA :: Applicative f => Assoc (f a) -> f (Assoc a) Source # mapM :: Monad m => (a -> m b) -> Assoc a -> m (Assoc b) Source # sequence :: Monad m => Assoc (m a) -> m (Assoc a) Source #
ExactP Assoc |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Assoc SrcSpanInfo -> EP ()
Annotated Assoc |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Assoc l -> l Source # amap :: (l -> l) -> Assoc l -> Assoc l Source #
Eq l => Eq (Assoc l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Assoc l -> Assoc l -> Bool Source # (/=) :: Assoc l -> Assoc l -> Bool Source #
Data l => Data (Assoc 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) -> Assoc l -> c (Assoc l) Source #

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

toConstr :: Assoc l -> Constr Source #

dataTypeOf :: Assoc l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (Assoc l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Assoc l -> Assoc l -> Ordering Source # (<) :: Assoc l -> Assoc l -> Bool Source # (<=) :: Assoc l -> Assoc l -> Bool Source # (>) :: Assoc l -> Assoc l -> Bool Source # (>=) :: Assoc l -> Assoc l -> Bool Source # max :: Assoc l -> Assoc l -> Assoc l Source # min :: Assoc l -> Assoc l -> Assoc l Source #
Show l => Show (Assoc l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Assoc l -> ShowS Source # show :: Assoc l -> String Source # showList :: [Assoc l] -> ShowS Source #
Generic (Assoc l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Assoc l) :: Type -> Type Source # Methods from :: Assoc l -> Rep (Assoc l) x Source # to :: Rep (Assoc l) x -> Assoc l Source #
Pretty (Assoc l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Assoc l -> Doc prettyPrec :: Int -> Assoc l -> Doc
type Rep (Assoc l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

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

data Decl l Source #

A top-level declaration.

Constructors

TypeDecl l (DeclHead l) (Type l) | A type declaration
TypeFamDecl l (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l)) | A type family declaration
ClosedTypeFamDecl l (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l)) [TypeEqn l] | A closed type family declaration
DataDecl l (DataOrNew l) (Maybe (Context l)) (DeclHead l) [QualConDecl l] [Deriving l] | A data OR newtype declaration
GDataDecl l (DataOrNew l) (Maybe (Context l)) (DeclHead l) (Maybe (Kind l)) [GadtDecl l] [Deriving l] | A data OR newtype declaration, GADT style
DataFamDecl l (Maybe (Context l)) (DeclHead l) (Maybe (ResultSig l)) | A data family declaration
TypeInsDecl l (Type l) (Type l) | A type family instance declaration
DataInsDecl l (DataOrNew l) (Type l) [QualConDecl l] [Deriving l] | A data family instance declaration
GDataInsDecl l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] [Deriving l] | A data family instance declaration, GADT style
ClassDecl l (Maybe (Context l)) (DeclHead l) [FunDep l] (Maybe [ClassDecl l]) | A declaration of a type class
InstDecl l (Maybe (Overlap l)) (InstRule l) (Maybe [InstDecl l]) | An declaration of a type class instance
DerivDecl l (Maybe (DerivStrategy l)) (Maybe (Overlap l)) (InstRule l) | A standalone deriving declaration
InfixDecl l (Assoc l) (Maybe Int) [Op l] | A declaration of operator fixity
DefaultDecl l [Type l] | A declaration of default types
SpliceDecl l (Exp l) | A Template Haskell splicing declaration
TypeSig l [Name l] (Type l) | A type signature declaration
PatSynSig l [Name l] (Maybe [TyVarBind l]) (Maybe (Context l)) (Maybe (Context l)) (Type l) | A pattern synonym signature declation
FunBind l [Match l] | A set of function binding clauses
PatBind l (Pat l) (Rhs l) (Maybe (Binds l)) | A pattern binding
PatSyn l (Pat l) (Pat l) (PatternSynDirection l) | A pattern synonym binding
ForImp l (CallConv l) (Maybe (Safety l)) (Maybe String) (Name l) (Type l) | A foreign import declaration
ForExp l (CallConv l) (Maybe String) (Name l) (Type l) | A foreign export declaration
RulePragmaDecl l [Rule l] | A RULES pragma
DeprPragmaDecl l [([Name l], String)] | A DEPRECATED pragma
WarnPragmaDecl l [([Name l], String)] | A WARNING pragma
InlineSig l Bool (Maybe (Activation l)) (QName l) | An INLINE pragma
InlineConlikeSig l (Maybe (Activation l)) (QName l) | An INLINE CONLIKE pragma
SpecSig l (Maybe (Activation l)) (QName l) [Type l] | A SPECIALISE pragma
SpecInlineSig l Bool (Maybe (Activation l)) (QName l) [Type l] | A SPECIALISE INLINE pragma
InstSig l (InstRule l) | A SPECIALISE instance pragma
AnnPragma l (Annotation l) | An ANN pragma
MinimalPragma l (Maybe (BooleanFormula l)) | A MINIMAL pragma
RoleAnnotDecl l (QName l) [Role l] | A role annotation
CompletePragma l [Name l] (Maybe (QName l)) | A COMPLETE pragma

Instances

Functor Decl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Decl a -> Decl b Source # (<$) :: a -> Decl b -> Decl a Source #
Foldable Decl |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Decl m -> m Source #

foldMap :: Monoid m => (a -> m) -> Decl a -> m Source #

foldr :: (a -> b -> b) -> b -> Decl a -> b Source #

foldr' :: (a -> b -> b) -> b -> Decl a -> b Source #

foldl :: (b -> a -> b) -> b -> Decl a -> b Source #

foldl' :: (b -> a -> b) -> b -> Decl a -> b Source #

foldr1 :: (a -> a -> a) -> Decl a -> a Source #

foldl1 :: (a -> a -> a) -> Decl a -> a Source #

toList :: Decl a -> [a] Source #

null :: Decl a -> Bool Source #

length :: Decl a -> Int Source #

elem :: Eq a => a -> Decl a -> Bool Source #

maximum :: Ord a => Decl a -> a Source #

minimum :: Ord a => Decl a -> a Source #

sum :: Num a => Decl a -> a Source #

product :: Num a => Decl a -> a Source #

Traversable Decl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Decl a -> f (Decl b) Source # sequenceA :: Applicative f => Decl (f a) -> f (Decl a) Source # mapM :: Monad m => (a -> m b) -> Decl a -> m (Decl b) Source # sequence :: Monad m => Decl (m a) -> m (Decl a) Source #
ExactP Decl |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Decl SrcSpanInfo -> EP ()
AppFixity Decl |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Decl SrcSpanInfo -> m (Decl SrcSpanInfo) Source #
Annotated Decl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Decl l -> l Source # amap :: (l -> l) -> Decl l -> Decl l Source #
Convert Dec (Decl ()) Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Dec -> Decl ()
Eq l => Eq (Decl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Decl l -> Decl l -> Bool Source # (/=) :: Decl l -> Decl l -> Bool Source #
Data l => Data (Decl 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) -> Decl l -> c (Decl l) Source #

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

toConstr :: Decl l -> Constr Source #

dataTypeOf :: Decl l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (Decl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Decl l -> Decl l -> Ordering Source # (<) :: Decl l -> Decl l -> Bool Source # (<=) :: Decl l -> Decl l -> Bool Source # (>) :: Decl l -> Decl l -> Bool Source # (>=) :: Decl l -> Decl l -> Bool Source # max :: Decl l -> Decl l -> Decl l Source # min :: Decl l -> Decl l -> Decl l Source #
Show l => Show (Decl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Decl l -> ShowS Source # show :: Decl l -> String Source # showList :: [Decl l] -> ShowS Source #
Generic (Decl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Decl l) :: Type -> Type Source # Methods from :: Decl l -> Rep (Decl l) x Source # to :: Rep (Decl l) x -> Decl l Source #
Pretty (Decl l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Decl l -> Doc prettyPrec :: Int -> Decl l -> Doc
PrettyDeclLike (Decl l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods wantsBlankline :: Decl l -> Bool
Convert (Decl ()) Dec Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Decl () -> Dec
type Rep (Decl l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Decl l) = D1 (MetaData "Decl" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (((((C1 (MetaCons "TypeDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: C1 (MetaCons "TypeFamDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ResultSig l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (InjectivityInfo l)))))) :+: (C1 (MetaCons "ClosedTypeFamDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ResultSig l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (InjectivityInfo l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [TypeEqn l])))) :+: C1 (MetaCons "DataDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DataOrNew l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Context l))))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [QualConDecl l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Deriving l])))))) :+: ((C1 (MetaCons "GDataDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DataOrNew l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Context l))))) :*: ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Kind l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [GadtDecl l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Deriving l])))) :+: C1 (MetaCons "DataFamDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Context l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ResultSig l)))))) :+: (C1 (MetaCons "TypeInsDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: C1 (MetaCons "DataInsDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DataOrNew l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [QualConDecl l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Deriving l]))))))) :+: (((C1 (MetaCons "GDataInsDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DataOrNew l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Kind l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [GadtDecl l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Deriving l])))) :+: C1 (MetaCons "ClassDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Context l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [FunDep l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe [ClassDecl l])))))) :+: (C1 (MetaCons "InstDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Overlap l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (InstRule l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe [InstDecl l])))) :+: C1 (MetaCons "DerivDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (DerivStrategy l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Overlap l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (InstRule l)))))) :+: ((C1 (MetaCons "InfixDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Assoc l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Int)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Op l]))) :+: C1 (MetaCons "DefaultDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type l]))) :+: (C1 (MetaCons "SpliceDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :+: (C1 (MetaCons "TypeSig" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: C1 (MetaCons "PatSynSig" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe [TyVarBind l])))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Context l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Context l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))))))))) :+: ((((C1 (MetaCons "FunBind" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Match l])) :+: C1 (MetaCons "PatBind" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Rhs l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Binds l)))))) :+: (C1 (MetaCons "PatSyn" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (PatternSynDirection l)))) :+: C1 (MetaCons "ForImp" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (CallConv l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Safety l))))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe String)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))))))) :+: ((C1 (MetaCons "ForExp" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (CallConv l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe String)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))))) :+: C1 (MetaCons "RulePragmaDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Rule l]))) :+: (C1 (MetaCons "DeprPragmaDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [([Name l], String)])) :+: C1 (MetaCons "WarnPragmaDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [([Name l], String)]))))) :+: (((C1 (MetaCons "InlineSig" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Activation l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)))) :+: C1 (MetaCons "InlineConlikeSig" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Activation l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))))) :+: (C1 (MetaCons "SpecSig" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Activation l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type l]))) :+: C1 (MetaCons "SpecInlineSig" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Activation l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type l])))))) :+: ((C1 (MetaCons "InstSig" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (InstRule l))) :+: C1 (MetaCons "AnnPragma" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Annotation l)))) :+: (C1 (MetaCons "MinimalPragma" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (BooleanFormula l)))) :+: (C1 (MetaCons "RoleAnnotDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Role l]))) :+: C1 (MetaCons "CompletePragma" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (QName l)))))))))))

data PatternSynDirection l Source #

Constructors

Unidirectional | A unidirectional pattern synonym with "<-"
ImplicitBidirectional | A bidirectional pattern synonym with "="
ExplicitBidirectional l [Decl l] | A birectional pattern synonym with the construction specified.

Instances

Functor PatternSynDirection |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> PatternSynDirection a -> PatternSynDirection b Source # (<$) :: a -> PatternSynDirection b -> PatternSynDirection a Source #
Foldable PatternSynDirection |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => PatternSynDirection m -> m Source #

foldMap :: Monoid m => (a -> m) -> PatternSynDirection a -> m Source #

foldr :: (a -> b -> b) -> b -> PatternSynDirection a -> b Source #

foldr' :: (a -> b -> b) -> b -> PatternSynDirection a -> b Source #

foldl :: (b -> a -> b) -> b -> PatternSynDirection a -> b Source #

foldl' :: (b -> a -> b) -> b -> PatternSynDirection a -> b Source #

foldr1 :: (a -> a -> a) -> PatternSynDirection a -> a Source #

foldl1 :: (a -> a -> a) -> PatternSynDirection a -> a Source #

toList :: PatternSynDirection a -> [a] Source #

null :: PatternSynDirection a -> Bool Source #

length :: PatternSynDirection a -> Int Source #

elem :: Eq a => a -> PatternSynDirection a -> Bool Source #

maximum :: Ord a => PatternSynDirection a -> a Source #

minimum :: Ord a => PatternSynDirection a -> a Source #

sum :: Num a => PatternSynDirection a -> a Source #

product :: Num a => PatternSynDirection a -> a Source #

Traversable PatternSynDirection |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

sequenceA :: Applicative f => PatternSynDirection (f a) -> f (PatternSynDirection a) Source #

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

sequence :: Monad m => PatternSynDirection (m a) -> m (PatternSynDirection a) Source #

AppFixity PatternSynDirection |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> PatternSynDirection SrcSpanInfo -> m (PatternSynDirection SrcSpanInfo) Source #
Eq l => Eq (PatternSynDirection l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: PatternSynDirection l -> PatternSynDirection l -> Bool Source # (/=) :: PatternSynDirection l -> PatternSynDirection l -> Bool Source #
Data l => Data (PatternSynDirection 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) -> PatternSynDirection l -> c (PatternSynDirection l) Source #

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

toConstr :: PatternSynDirection l -> Constr Source #

dataTypeOf :: PatternSynDirection l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (PatternSynDirection l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: PatternSynDirection l -> PatternSynDirection l -> Ordering Source #

(<) :: PatternSynDirection l -> PatternSynDirection l -> Bool Source #

(<=) :: PatternSynDirection l -> PatternSynDirection l -> Bool Source #

(>) :: PatternSynDirection l -> PatternSynDirection l -> Bool Source #

(>=) :: PatternSynDirection l -> PatternSynDirection l -> Bool Source #

max :: PatternSynDirection l -> PatternSynDirection l -> PatternSynDirection l Source #

min :: PatternSynDirection l -> PatternSynDirection l -> PatternSynDirection l Source #

Show l => Show (PatternSynDirection l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> PatternSynDirection l -> ShowS Source # show :: PatternSynDirection l -> String Source # showList :: [PatternSynDirection l] -> ShowS Source #
Generic (PatternSynDirection l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (PatternSynDirection l) :: Type -> Type Source # Methods from :: PatternSynDirection l -> Rep (PatternSynDirection l) x Source # to :: Rep (PatternSynDirection l) x -> PatternSynDirection l Source #
type Rep (PatternSynDirection l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (PatternSynDirection l) = D1 (MetaData "PatternSynDirection" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "Unidirectional" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "ImplicitBidirectional" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ExplicitBidirectional" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Decl l]))))

data TypeEqn l Source #

A type equation as found in closed type families.

Constructors

TypeEqn l (Type l) (Type l) |

Instances

Functor TypeEqn |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> TypeEqn a -> TypeEqn b Source # (<$) :: a -> TypeEqn b -> TypeEqn a Source #
Foldable TypeEqn |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => TypeEqn m -> m Source #

foldMap :: Monoid m => (a -> m) -> TypeEqn a -> m Source #

foldr :: (a -> b -> b) -> b -> TypeEqn a -> b Source #

foldr' :: (a -> b -> b) -> b -> TypeEqn a -> b Source #

foldl :: (b -> a -> b) -> b -> TypeEqn a -> b Source #

foldl' :: (b -> a -> b) -> b -> TypeEqn a -> b Source #

foldr1 :: (a -> a -> a) -> TypeEqn a -> a Source #

foldl1 :: (a -> a -> a) -> TypeEqn a -> a Source #

toList :: TypeEqn a -> [a] Source #

null :: TypeEqn a -> Bool Source #

length :: TypeEqn a -> Int Source #

elem :: Eq a => a -> TypeEqn a -> Bool Source #

maximum :: Ord a => TypeEqn a -> a Source #

minimum :: Ord a => TypeEqn a -> a Source #

sum :: Num a => TypeEqn a -> a Source #

product :: Num a => TypeEqn a -> a Source #

Traversable TypeEqn |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> TypeEqn a -> f (TypeEqn b) Source # sequenceA :: Applicative f => TypeEqn (f a) -> f (TypeEqn a) Source # mapM :: Monad m => (a -> m b) -> TypeEqn a -> m (TypeEqn b) Source # sequence :: Monad m => TypeEqn (m a) -> m (TypeEqn a) Source #
ExactP TypeEqn |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: TypeEqn SrcSpanInfo -> EP ()
Annotated TypeEqn |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: TypeEqn l -> l Source # amap :: (l -> l) -> TypeEqn l -> TypeEqn l Source #
Eq l => Eq (TypeEqn l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: TypeEqn l -> TypeEqn l -> Bool Source # (/=) :: TypeEqn l -> TypeEqn l -> Bool Source #
Data l => Data (TypeEqn 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) -> TypeEqn l -> c (TypeEqn l) Source #

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

toConstr :: TypeEqn l -> Constr Source #

dataTypeOf :: TypeEqn l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (TypeEqn l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: TypeEqn l -> TypeEqn l -> Ordering Source #

(<) :: TypeEqn l -> TypeEqn l -> Bool Source #

(<=) :: TypeEqn l -> TypeEqn l -> Bool Source #

(>) :: TypeEqn l -> TypeEqn l -> Bool Source #

(>=) :: TypeEqn l -> TypeEqn l -> Bool Source #

max :: TypeEqn l -> TypeEqn l -> TypeEqn l Source #

min :: TypeEqn l -> TypeEqn l -> TypeEqn l Source #

Show l => Show (TypeEqn l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> TypeEqn l -> ShowS Source # show :: TypeEqn l -> String Source # showList :: [TypeEqn l] -> ShowS Source #
Generic (TypeEqn l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (TypeEqn l) :: Type -> Type Source # Methods from :: TypeEqn l -> Rep (TypeEqn l) x Source # to :: Rep (TypeEqn l) x -> TypeEqn l Source #
Pretty (TypeEqn l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: TypeEqn l -> Doc prettyPrec :: Int -> TypeEqn l -> Doc
type Rep (TypeEqn l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

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

data Annotation l Source #

An annotation through an ANN pragma.

Constructors

Ann l (Name l) (Exp l) | An annotation for a declared name.
TypeAnn l (Name l) (Exp l) | An annotation for a declared type.
ModuleAnn l (Exp l) | An annotation for the defining module.

Instances

Functor Annotation |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Annotation a -> Annotation b Source # (<$) :: a -> Annotation b -> Annotation a Source #
Foldable Annotation |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Annotation m -> m Source #

foldMap :: Monoid m => (a -> m) -> Annotation a -> m Source #

foldr :: (a -> b -> b) -> b -> Annotation a -> b Source #

foldr' :: (a -> b -> b) -> b -> Annotation a -> b Source #

foldl :: (b -> a -> b) -> b -> Annotation a -> b Source #

foldl' :: (b -> a -> b) -> b -> Annotation a -> b Source #

foldr1 :: (a -> a -> a) -> Annotation a -> a Source #

foldl1 :: (a -> a -> a) -> Annotation a -> a Source #

toList :: Annotation a -> [a] Source #

null :: Annotation a -> Bool Source #

length :: Annotation a -> Int Source #

elem :: Eq a => a -> Annotation a -> Bool Source #

maximum :: Ord a => Annotation a -> a Source #

minimum :: Ord a => Annotation a -> a Source #

sum :: Num a => Annotation a -> a Source #

product :: Num a => Annotation a -> a Source #

Traversable Annotation |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Annotation a -> f (Annotation b) Source # sequenceA :: Applicative f => Annotation (f a) -> f (Annotation a) Source # mapM :: Monad m => (a -> m b) -> Annotation a -> m (Annotation b) Source # sequence :: Monad m => Annotation (m a) -> m (Annotation a) Source #
ExactP Annotation |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Annotation SrcSpanInfo -> EP ()
AppFixity Annotation |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Annotation SrcSpanInfo -> m (Annotation SrcSpanInfo) Source #
Annotated Annotation |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Annotation l -> l Source # amap :: (l -> l) -> Annotation l -> Annotation l Source #
Eq l => Eq (Annotation l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Annotation l -> Annotation l -> Bool Source # (/=) :: Annotation l -> Annotation l -> Bool Source #
Data l => Data (Annotation 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) -> Annotation l -> c (Annotation l) Source #

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

toConstr :: Annotation l -> Constr Source #

dataTypeOf :: Annotation l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (Annotation l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Annotation l -> Annotation l -> Ordering Source #

(<) :: Annotation l -> Annotation l -> Bool Source #

(<=) :: Annotation l -> Annotation l -> Bool Source #

(>) :: Annotation l -> Annotation l -> Bool Source #

(>=) :: Annotation l -> Annotation l -> Bool Source #

max :: Annotation l -> Annotation l -> Annotation l Source #

min :: Annotation l -> Annotation l -> Annotation l Source #

Show l => Show (Annotation l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Annotation l -> ShowS Source # show :: Annotation l -> String Source # showList :: [Annotation l] -> ShowS Source #
Generic (Annotation l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Annotation l) :: Type -> Type Source # Methods from :: Annotation l -> Rep (Annotation l) x Source # to :: Rep (Annotation l) x -> Annotation l Source #
Pretty (Annotation l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Annotation l -> Doc prettyPrec :: Int -> Annotation l -> Doc
type Rep (Annotation l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

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

data BooleanFormula l Source #

A boolean formula for MINIMAL pragmas.

Constructors

VarFormula l (Name l) | A variable.
AndFormula l [BooleanFormula l] | And boolean formulas.
OrFormula l [BooleanFormula l] | Or boolean formulas.
ParenFormula l (BooleanFormula l) | Parenthesized boolean formulas.

Instances

Functor BooleanFormula |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> BooleanFormula a -> BooleanFormula b Source # (<$) :: a -> BooleanFormula b -> BooleanFormula a Source #
Foldable BooleanFormula |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => BooleanFormula m -> m Source #

foldMap :: Monoid m => (a -> m) -> BooleanFormula a -> m Source #

foldr :: (a -> b -> b) -> b -> BooleanFormula a -> b Source #

foldr' :: (a -> b -> b) -> b -> BooleanFormula a -> b Source #

foldl :: (b -> a -> b) -> b -> BooleanFormula a -> b Source #

foldl' :: (b -> a -> b) -> b -> BooleanFormula a -> b Source #

foldr1 :: (a -> a -> a) -> BooleanFormula a -> a Source #

foldl1 :: (a -> a -> a) -> BooleanFormula a -> a Source #

toList :: BooleanFormula a -> [a] Source #

null :: BooleanFormula a -> Bool Source #

length :: BooleanFormula a -> Int Source #

elem :: Eq a => a -> BooleanFormula a -> Bool Source #

maximum :: Ord a => BooleanFormula a -> a Source #

minimum :: Ord a => BooleanFormula a -> a Source #

sum :: Num a => BooleanFormula a -> a Source #

product :: Num a => BooleanFormula a -> a Source #

Traversable BooleanFormula |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

sequenceA :: Applicative f => BooleanFormula (f a) -> f (BooleanFormula a) Source #

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

sequence :: Monad m => BooleanFormula (m a) -> m (BooleanFormula a) Source #

ExactP BooleanFormula |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: BooleanFormula SrcSpanInfo -> EP ()
Annotated BooleanFormula |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: BooleanFormula l -> l Source # amap :: (l -> l) -> BooleanFormula l -> BooleanFormula l Source #
Eq l => Eq (BooleanFormula l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: BooleanFormula l -> BooleanFormula l -> Bool Source # (/=) :: BooleanFormula l -> BooleanFormula l -> Bool Source #
Data l => Data (BooleanFormula 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) -> BooleanFormula l -> c (BooleanFormula l) Source #

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

toConstr :: BooleanFormula l -> Constr Source #

dataTypeOf :: BooleanFormula l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (BooleanFormula l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: BooleanFormula l -> BooleanFormula l -> Ordering Source #

(<) :: BooleanFormula l -> BooleanFormula l -> Bool Source #

(<=) :: BooleanFormula l -> BooleanFormula l -> Bool Source #

(>) :: BooleanFormula l -> BooleanFormula l -> Bool Source #

(>=) :: BooleanFormula l -> BooleanFormula l -> Bool Source #

max :: BooleanFormula l -> BooleanFormula l -> BooleanFormula l Source #

min :: BooleanFormula l -> BooleanFormula l -> BooleanFormula l Source #

Show l => Show (BooleanFormula l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> BooleanFormula l -> ShowS Source # show :: BooleanFormula l -> String Source # showList :: [BooleanFormula l] -> ShowS Source #
Generic (BooleanFormula l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (BooleanFormula l) :: Type -> Type Source # Methods from :: BooleanFormula l -> Rep (BooleanFormula l) x Source # to :: Rep (BooleanFormula l) x -> BooleanFormula l Source #
Pretty (BooleanFormula l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: BooleanFormula l -> Doc prettyPrec :: Int -> BooleanFormula l -> Doc
type Rep (BooleanFormula l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (BooleanFormula l) = D1 (MetaData "BooleanFormula" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "VarFormula" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))) :+: C1 (MetaCons "AndFormula" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [BooleanFormula l]))) :+: (C1 (MetaCons "OrFormula" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [BooleanFormula l])) :+: C1 (MetaCons "ParenFormula" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (BooleanFormula l)))))

data Role l Source #

Constructors

Nominal l |
Representational l |
Phantom l |
RoleWildcard l |

Instances

Functor Role |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Role a -> Role b Source # (<$) :: a -> Role b -> Role a Source #
Foldable Role |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Role m -> m Source #

foldMap :: Monoid m => (a -> m) -> Role a -> m Source #

foldr :: (a -> b -> b) -> b -> Role a -> b Source #

foldr' :: (a -> b -> b) -> b -> Role a -> b Source #

foldl :: (b -> a -> b) -> b -> Role a -> b Source #

foldl' :: (b -> a -> b) -> b -> Role a -> b Source #

foldr1 :: (a -> a -> a) -> Role a -> a Source #

foldl1 :: (a -> a -> a) -> Role a -> a Source #

toList :: Role a -> [a] Source #

null :: Role a -> Bool Source #

length :: Role a -> Int Source #

elem :: Eq a => a -> Role a -> Bool Source #

maximum :: Ord a => Role a -> a Source #

minimum :: Ord a => Role a -> a Source #

sum :: Num a => Role a -> a Source #

product :: Num a => Role a -> a Source #

Traversable Role |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Role a -> f (Role b) Source # sequenceA :: Applicative f => Role (f a) -> f (Role a) Source # mapM :: Monad m => (a -> m b) -> Role a -> m (Role b) Source # sequence :: Monad m => Role (m a) -> m (Role a) Source #
ExactP Role |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Role SrcSpanInfo -> EP ()
Annotated Role |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Role l -> l Source # amap :: (l -> l) -> Role l -> Role l Source #
Eq l => Eq (Role l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Role l -> Role l -> Bool Source # (/=) :: Role l -> Role l -> Bool Source #
Data l => Data (Role 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) -> Role l -> c (Role l) Source #

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

toConstr :: Role l -> Constr Source #

dataTypeOf :: Role l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (Role l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Role l -> Role l -> Ordering Source # (<) :: Role l -> Role l -> Bool Source # (<=) :: Role l -> Role l -> Bool Source # (>) :: Role l -> Role l -> Bool Source # (>=) :: Role l -> Role l -> Bool Source # max :: Role l -> Role l -> Role l Source # min :: Role l -> Role l -> Role l Source #
Show l => Show (Role l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Role l -> ShowS Source # show :: Role l -> String Source # showList :: [Role l] -> ShowS Source #
Generic (Role l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Role l) :: Type -> Type Source # Methods from :: Role l -> Rep (Role l) x Source # to :: Rep (Role l) x -> Role l Source #
Pretty (Role l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Role l -> Doc prettyPrec :: Int -> Role l -> Doc
type Rep (Role l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Role l) = D1 (MetaData "Role" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "Nominal" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "Representational" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))) :+: (C1 (MetaCons "Phantom" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "RoleWildcard" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))))

data DataOrNew l Source #

A flag stating whether a declaration is a data or newtype declaration.

Constructors

DataType l |
NewType l |

Instances

Functor DataOrNew |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> DataOrNew a -> DataOrNew b Source # (<$) :: a -> DataOrNew b -> DataOrNew a Source #
Foldable DataOrNew |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => DataOrNew m -> m Source #

foldMap :: Monoid m => (a -> m) -> DataOrNew a -> m Source #

foldr :: (a -> b -> b) -> b -> DataOrNew a -> b Source #

foldr' :: (a -> b -> b) -> b -> DataOrNew a -> b Source #

foldl :: (b -> a -> b) -> b -> DataOrNew a -> b Source #

foldl' :: (b -> a -> b) -> b -> DataOrNew a -> b Source #

foldr1 :: (a -> a -> a) -> DataOrNew a -> a Source #

foldl1 :: (a -> a -> a) -> DataOrNew a -> a Source #

toList :: DataOrNew a -> [a] Source #

null :: DataOrNew a -> Bool Source #

length :: DataOrNew a -> Int Source #

elem :: Eq a => a -> DataOrNew a -> Bool Source #

maximum :: Ord a => DataOrNew a -> a Source #

minimum :: Ord a => DataOrNew a -> a Source #

sum :: Num a => DataOrNew a -> a Source #

product :: Num a => DataOrNew a -> a Source #

Traversable DataOrNew |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> DataOrNew a -> f (DataOrNew b) Source # sequenceA :: Applicative f => DataOrNew (f a) -> f (DataOrNew a) Source # mapM :: Monad m => (a -> m b) -> DataOrNew a -> m (DataOrNew b) Source # sequence :: Monad m => DataOrNew (m a) -> m (DataOrNew a) Source #
ExactP DataOrNew |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: DataOrNew SrcSpanInfo -> EP ()
Annotated DataOrNew |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: DataOrNew l -> l Source # amap :: (l -> l) -> DataOrNew l -> DataOrNew l Source #
Eq l => Eq (DataOrNew l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: DataOrNew l -> DataOrNew l -> Bool Source # (/=) :: DataOrNew l -> DataOrNew l -> Bool Source #
Data l => Data (DataOrNew 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) -> DataOrNew l -> c (DataOrNew l) Source #

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

toConstr :: DataOrNew l -> Constr Source #

dataTypeOf :: DataOrNew l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (DataOrNew l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: DataOrNew l -> DataOrNew l -> Ordering Source #

(<) :: DataOrNew l -> DataOrNew l -> Bool Source #

(<=) :: DataOrNew l -> DataOrNew l -> Bool Source #

(>) :: DataOrNew l -> DataOrNew l -> Bool Source #

(>=) :: DataOrNew l -> DataOrNew l -> Bool Source #

max :: DataOrNew l -> DataOrNew l -> DataOrNew l Source #

min :: DataOrNew l -> DataOrNew l -> DataOrNew l Source #

Show l => Show (DataOrNew l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> DataOrNew l -> ShowS Source # show :: DataOrNew l -> String Source # showList :: [DataOrNew l] -> ShowS Source #
Generic (DataOrNew l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (DataOrNew l) :: Type -> Type Source # Methods from :: DataOrNew l -> Rep (DataOrNew l) x Source # to :: Rep (DataOrNew l) x -> DataOrNew l Source #
Pretty (DataOrNew l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: DataOrNew l -> Doc prettyPrec :: Int -> DataOrNew l -> Doc
type Rep (DataOrNew l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

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

data InjectivityInfo l Source #

Injectivity info for injective type families

Constructors

InjectivityInfo l (Name l) [Name l] |

Instances

Functor InjectivityInfo |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> InjectivityInfo a -> InjectivityInfo b Source # (<$) :: a -> InjectivityInfo b -> InjectivityInfo a Source #
Foldable InjectivityInfo |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => InjectivityInfo m -> m Source #

foldMap :: Monoid m => (a -> m) -> InjectivityInfo a -> m Source #

foldr :: (a -> b -> b) -> b -> InjectivityInfo a -> b Source #

foldr' :: (a -> b -> b) -> b -> InjectivityInfo a -> b Source #

foldl :: (b -> a -> b) -> b -> InjectivityInfo a -> b Source #

foldl' :: (b -> a -> b) -> b -> InjectivityInfo a -> b Source #

foldr1 :: (a -> a -> a) -> InjectivityInfo a -> a Source #

foldl1 :: (a -> a -> a) -> InjectivityInfo a -> a Source #

toList :: InjectivityInfo a -> [a] Source #

null :: InjectivityInfo a -> Bool Source #

length :: InjectivityInfo a -> Int Source #

elem :: Eq a => a -> InjectivityInfo a -> Bool Source #

maximum :: Ord a => InjectivityInfo a -> a Source #

minimum :: Ord a => InjectivityInfo a -> a Source #

sum :: Num a => InjectivityInfo a -> a Source #

product :: Num a => InjectivityInfo a -> a Source #

Traversable InjectivityInfo |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

sequenceA :: Applicative f => InjectivityInfo (f a) -> f (InjectivityInfo a) Source #

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

sequence :: Monad m => InjectivityInfo (m a) -> m (InjectivityInfo a) Source #

ExactP InjectivityInfo |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: InjectivityInfo SrcSpanInfo -> EP ()
Annotated InjectivityInfo |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: InjectivityInfo l -> l Source # amap :: (l -> l) -> InjectivityInfo l -> InjectivityInfo l Source #
Eq l => Eq (InjectivityInfo l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: InjectivityInfo l -> InjectivityInfo l -> Bool Source # (/=) :: InjectivityInfo l -> InjectivityInfo l -> Bool Source #
Data l => Data (InjectivityInfo 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) -> InjectivityInfo l -> c (InjectivityInfo l) Source #

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

toConstr :: InjectivityInfo l -> Constr Source #

dataTypeOf :: InjectivityInfo l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (InjectivityInfo l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: InjectivityInfo l -> InjectivityInfo l -> Ordering Source #

(<) :: InjectivityInfo l -> InjectivityInfo l -> Bool Source #

(<=) :: InjectivityInfo l -> InjectivityInfo l -> Bool Source #

(>) :: InjectivityInfo l -> InjectivityInfo l -> Bool Source #

(>=) :: InjectivityInfo l -> InjectivityInfo l -> Bool Source #

max :: InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l Source #

min :: InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l Source #

Show l => Show (InjectivityInfo l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> InjectivityInfo l -> ShowS Source # show :: InjectivityInfo l -> String Source # showList :: [InjectivityInfo l] -> ShowS Source #
Generic (InjectivityInfo l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (InjectivityInfo l) :: Type -> Type Source # Methods from :: InjectivityInfo l -> Rep (InjectivityInfo l) x Source # to :: Rep (InjectivityInfo l) x -> InjectivityInfo l Source #
Pretty (InjectivityInfo l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: InjectivityInfo l -> Doc prettyPrec :: Int -> InjectivityInfo l -> Doc
type Rep (InjectivityInfo l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

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

data ResultSig l Source #

Constructors

KindSig l (Kind l) |
TyVarSig l (TyVarBind l) |

Instances

Functor ResultSig |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> ResultSig a -> ResultSig b Source # (<$) :: a -> ResultSig b -> ResultSig a Source #
Foldable ResultSig |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ResultSig m -> m Source #

foldMap :: Monoid m => (a -> m) -> ResultSig a -> m Source #

foldr :: (a -> b -> b) -> b -> ResultSig a -> b Source #

foldr' :: (a -> b -> b) -> b -> ResultSig a -> b Source #

foldl :: (b -> a -> b) -> b -> ResultSig a -> b Source #

foldl' :: (b -> a -> b) -> b -> ResultSig a -> b Source #

foldr1 :: (a -> a -> a) -> ResultSig a -> a Source #

foldl1 :: (a -> a -> a) -> ResultSig a -> a Source #

toList :: ResultSig a -> [a] Source #

null :: ResultSig a -> Bool Source #

length :: ResultSig a -> Int Source #

elem :: Eq a => a -> ResultSig a -> Bool Source #

maximum :: Ord a => ResultSig a -> a Source #

minimum :: Ord a => ResultSig a -> a Source #

sum :: Num a => ResultSig a -> a Source #

product :: Num a => ResultSig a -> a Source #

Traversable ResultSig |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> ResultSig a -> f (ResultSig b) Source # sequenceA :: Applicative f => ResultSig (f a) -> f (ResultSig a) Source # mapM :: Monad m => (a -> m b) -> ResultSig a -> m (ResultSig b) Source # sequence :: Monad m => ResultSig (m a) -> m (ResultSig a) Source #
ExactP ResultSig |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: ResultSig SrcSpanInfo -> EP ()
Annotated ResultSig |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ResultSig l -> l Source # amap :: (l -> l) -> ResultSig l -> ResultSig l Source #
Eq l => Eq (ResultSig l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: ResultSig l -> ResultSig l -> Bool Source # (/=) :: ResultSig l -> ResultSig l -> Bool Source #
Data l => Data (ResultSig 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) -> ResultSig l -> c (ResultSig l) Source #

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

toConstr :: ResultSig l -> Constr Source #

dataTypeOf :: ResultSig l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (ResultSig l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: ResultSig l -> ResultSig l -> Ordering Source #

(<) :: ResultSig l -> ResultSig l -> Bool Source #

(<=) :: ResultSig l -> ResultSig l -> Bool Source #

(>) :: ResultSig l -> ResultSig l -> Bool Source #

(>=) :: ResultSig l -> ResultSig l -> Bool Source #

max :: ResultSig l -> ResultSig l -> ResultSig l Source #

min :: ResultSig l -> ResultSig l -> ResultSig l Source #

Show l => Show (ResultSig l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> ResultSig l -> ShowS Source # show :: ResultSig l -> String Source # showList :: [ResultSig l] -> ShowS Source #
Generic (ResultSig l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ResultSig l) :: Type -> Type Source # Methods from :: ResultSig l -> Rep (ResultSig l) x Source # to :: Rep (ResultSig l) x -> ResultSig l Source #
Pretty (ResultSig l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: ResultSig l -> Doc prettyPrec :: Int -> ResultSig l -> Doc
type Rep (ResultSig l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

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

data DeclHead l Source #

The head of a type or class declaration, which consists of the type or class name applied to some type variables

`class C a b` is represented as

    DHApp
       ()
       (DHApp
          () (DHead () (Ident () "C")) (UnkindedVar () (Ident () "a")))
       (UnkindedVar () (Ident () "b"))

(where the annotation type `l` is instantiated with `()`)

`class (a :< b) c` is represented as

    DHApp
       ()
       (DHParen
          ()
          (DHApp
             ()
             (DHInfix () (UnkindedVar () (Ident () "a")) (Symbol () ":<"))
             (UnkindedVar () (Ident () "b"))))
       (UnkindedVar () (Ident () "c"))

Constructors

DHead l (Name l) | type or class name
DHInfix l (TyVarBind l) (Name l) | infix application of the type/class name to the left operand
DHParen l (DeclHead l) | parenthesized declaration head
DHApp l (DeclHead l) (TyVarBind l) | application to one more type variable

Instances

Functor DeclHead |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> DeclHead a -> DeclHead b Source # (<$) :: a -> DeclHead b -> DeclHead a Source #
Foldable DeclHead |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => DeclHead m -> m Source #

foldMap :: Monoid m => (a -> m) -> DeclHead a -> m Source #

foldr :: (a -> b -> b) -> b -> DeclHead a -> b Source #

foldr' :: (a -> b -> b) -> b -> DeclHead a -> b Source #

foldl :: (b -> a -> b) -> b -> DeclHead a -> b Source #

foldl' :: (b -> a -> b) -> b -> DeclHead a -> b Source #

foldr1 :: (a -> a -> a) -> DeclHead a -> a Source #

foldl1 :: (a -> a -> a) -> DeclHead a -> a Source #

toList :: DeclHead a -> [a] Source #

null :: DeclHead a -> Bool Source #

length :: DeclHead a -> Int Source #

elem :: Eq a => a -> DeclHead a -> Bool Source #

maximum :: Ord a => DeclHead a -> a Source #

minimum :: Ord a => DeclHead a -> a Source #

sum :: Num a => DeclHead a -> a Source #

product :: Num a => DeclHead a -> a Source #

Traversable DeclHead |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> DeclHead a -> f (DeclHead b) Source # sequenceA :: Applicative f => DeclHead (f a) -> f (DeclHead a) Source # mapM :: Monad m => (a -> m b) -> DeclHead a -> m (DeclHead b) Source # sequence :: Monad m => DeclHead (m a) -> m (DeclHead a) Source #
ExactP DeclHead |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: DeclHead SrcSpanInfo -> EP ()
Annotated DeclHead |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: DeclHead l -> l Source # amap :: (l -> l) -> DeclHead l -> DeclHead l Source #
Eq l => Eq (DeclHead l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: DeclHead l -> DeclHead l -> Bool Source # (/=) :: DeclHead l -> DeclHead l -> Bool Source #
Data l => Data (DeclHead 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) -> DeclHead l -> c (DeclHead l) Source #

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

toConstr :: DeclHead l -> Constr Source #

dataTypeOf :: DeclHead l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (DeclHead l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: DeclHead l -> DeclHead l -> Ordering Source #

(<) :: DeclHead l -> DeclHead l -> Bool Source #

(<=) :: DeclHead l -> DeclHead l -> Bool Source #

(>) :: DeclHead l -> DeclHead l -> Bool Source #

(>=) :: DeclHead l -> DeclHead l -> Bool Source #

max :: DeclHead l -> DeclHead l -> DeclHead l Source #

min :: DeclHead l -> DeclHead l -> DeclHead l Source #

Show l => Show (DeclHead l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> DeclHead l -> ShowS Source # show :: DeclHead l -> String Source # showList :: [DeclHead l] -> ShowS Source #
Generic (DeclHead l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (DeclHead l) :: Type -> Type Source # Methods from :: DeclHead l -> Rep (DeclHead l) x Source # to :: Rep (DeclHead l) x -> DeclHead l Source #
Pretty (DeclHead l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: DeclHead l -> Doc prettyPrec :: Int -> DeclHead l -> Doc
type Rep (DeclHead l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (DeclHead l) = D1 (MetaData "DeclHead" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "DHead" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))) :+: C1 (MetaCons "DHInfix" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (TyVarBind l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))))) :+: (C1 (MetaCons "DHParen" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l))) :+: C1 (MetaCons "DHApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (TyVarBind l))))))

data InstRule l Source #

The instance declaration rule, which is, roughly, the part of the instance declaration before the `where` keyword.

Example: `instance Ord a => Ord (Maybe a)` is represented as

    IRule
       ()
       Nothing
       (Just
          (CxSingle
             ()
             (ClassA
                () (UnQual () (Ident () "Ord")) [ TyVar () (Ident () "a") ])))
       (IHApp
          ()
          (IHCon () (UnQual () (Ident () "Ord")))
          (TyParen
             ()
             (TyApp
                ()
                (TyCon () (UnQual () (Ident () "Maybe")))
                (TyVar () (Ident () "a")))))

An optional explicit forall after `instance` is supported: `instance forall a . Ord a => Ord (Maybe a) where` becomes

    IRule
       ()
       (Just [ UnkindedVar () (Ident () "a") ])
       ...

Constructors

IRule l (Maybe [TyVarBind l]) (Maybe (Context l)) (InstHead l) |
IParen l (InstRule l) |

Instances

Functor InstRule |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> InstRule a -> InstRule b Source # (<$) :: a -> InstRule b -> InstRule a Source #
Foldable InstRule |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => InstRule m -> m Source #

foldMap :: Monoid m => (a -> m) -> InstRule a -> m Source #

foldr :: (a -> b -> b) -> b -> InstRule a -> b Source #

foldr' :: (a -> b -> b) -> b -> InstRule a -> b Source #

foldl :: (b -> a -> b) -> b -> InstRule a -> b Source #

foldl' :: (b -> a -> b) -> b -> InstRule a -> b Source #

foldr1 :: (a -> a -> a) -> InstRule a -> a Source #

foldl1 :: (a -> a -> a) -> InstRule a -> a Source #

toList :: InstRule a -> [a] Source #

null :: InstRule a -> Bool Source #

length :: InstRule a -> Int Source #

elem :: Eq a => a -> InstRule a -> Bool Source #

maximum :: Ord a => InstRule a -> a Source #

minimum :: Ord a => InstRule a -> a Source #

sum :: Num a => InstRule a -> a Source #

product :: Num a => InstRule a -> a Source #

Traversable InstRule |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> InstRule a -> f (InstRule b) Source # sequenceA :: Applicative f => InstRule (f a) -> f (InstRule a) Source # mapM :: Monad m => (a -> m b) -> InstRule a -> m (InstRule b) Source # sequence :: Monad m => InstRule (m a) -> m (InstRule a) Source #
ExactP InstRule |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: InstRule SrcSpanInfo -> EP ()
Annotated InstRule |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: InstRule l -> l Source # amap :: (l -> l) -> InstRule l -> InstRule l Source #
Eq l => Eq (InstRule l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: InstRule l -> InstRule l -> Bool Source # (/=) :: InstRule l -> InstRule l -> Bool Source #
Data l => Data (InstRule 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) -> InstRule l -> c (InstRule l) Source #

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

toConstr :: InstRule l -> Constr Source #

dataTypeOf :: InstRule l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (InstRule l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: InstRule l -> InstRule l -> Ordering Source #

(<) :: InstRule l -> InstRule l -> Bool Source #

(<=) :: InstRule l -> InstRule l -> Bool Source #

(>) :: InstRule l -> InstRule l -> Bool Source #

(>=) :: InstRule l -> InstRule l -> Bool Source #

max :: InstRule l -> InstRule l -> InstRule l Source #

min :: InstRule l -> InstRule l -> InstRule l Source #

Show l => Show (InstRule l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> InstRule l -> ShowS Source # show :: InstRule l -> String Source # showList :: [InstRule l] -> ShowS Source #
Generic (InstRule l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (InstRule l) :: Type -> Type Source # Methods from :: InstRule l -> Rep (InstRule l) x Source # to :: Rep (InstRule l) x -> InstRule l Source #
Pretty (InstRule l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: InstRule l -> Doc prettyPrec :: Int -> InstRule l -> Doc
type Rep (InstRule l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (InstRule l) = D1 (MetaData "InstRule" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "IRule" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe [TyVarBind l]))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Context l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (InstHead l)))) :+: C1 (MetaCons "IParen" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (InstRule l))))

data InstHead l Source #

The instance head. The split between rule/head allow us to represent `instance (Bounded a => Bounded [a]) where` faithfully.

The structure of `InstHead` follows one of `DeclHead`.

For example, `instance C (Maybe a) Int where` is represented as

    IHApp
       ()
       (IHApp
          ()
          (IHCon () (UnQual () (Ident () "C")))
          (TyParen
             ()
             (TyApp
                ()
                (TyCon () (UnQual () (Ident () "Maybe")))
                (TyVar () (Ident () "a")))))
       (TyCon () (UnQual () (Ident () "Int")))))

Constructors

IHCon l (QName l) | type or class name
IHInfix l (Type l) (QName l) | infix application of the type/class name to the left operand
IHParen l (InstHead l) | parenthesized instance head
IHApp l (InstHead l) (Type l) | application to one more type

Instances

Functor InstHead |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> InstHead a -> InstHead b Source # (<$) :: a -> InstHead b -> InstHead a Source #
Foldable InstHead |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => InstHead m -> m Source #

foldMap :: Monoid m => (a -> m) -> InstHead a -> m Source #

foldr :: (a -> b -> b) -> b -> InstHead a -> b Source #

foldr' :: (a -> b -> b) -> b -> InstHead a -> b Source #

foldl :: (b -> a -> b) -> b -> InstHead a -> b Source #

foldl' :: (b -> a -> b) -> b -> InstHead a -> b Source #

foldr1 :: (a -> a -> a) -> InstHead a -> a Source #

foldl1 :: (a -> a -> a) -> InstHead a -> a Source #

toList :: InstHead a -> [a] Source #

null :: InstHead a -> Bool Source #

length :: InstHead a -> Int Source #

elem :: Eq a => a -> InstHead a -> Bool Source #

maximum :: Ord a => InstHead a -> a Source #

minimum :: Ord a => InstHead a -> a Source #

sum :: Num a => InstHead a -> a Source #

product :: Num a => InstHead a -> a Source #

Traversable InstHead |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> InstHead a -> f (InstHead b) Source # sequenceA :: Applicative f => InstHead (f a) -> f (InstHead a) Source # mapM :: Monad m => (a -> m b) -> InstHead a -> m (InstHead b) Source # sequence :: Monad m => InstHead (m a) -> m (InstHead a) Source #
ExactP InstHead |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: InstHead SrcSpanInfo -> EP ()
Annotated InstHead |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: InstHead l -> l Source # amap :: (l -> l) -> InstHead l -> InstHead l Source #
Eq l => Eq (InstHead l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: InstHead l -> InstHead l -> Bool Source # (/=) :: InstHead l -> InstHead l -> Bool Source #
Data l => Data (InstHead 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) -> InstHead l -> c (InstHead l) Source #

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

toConstr :: InstHead l -> Constr Source #

dataTypeOf :: InstHead l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (InstHead l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: InstHead l -> InstHead l -> Ordering Source #

(<) :: InstHead l -> InstHead l -> Bool Source #

(<=) :: InstHead l -> InstHead l -> Bool Source #

(>) :: InstHead l -> InstHead l -> Bool Source #

(>=) :: InstHead l -> InstHead l -> Bool Source #

max :: InstHead l -> InstHead l -> InstHead l Source #

min :: InstHead l -> InstHead l -> InstHead l Source #

Show l => Show (InstHead l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> InstHead l -> ShowS Source # show :: InstHead l -> String Source # showList :: [InstHead l] -> ShowS Source #
Generic (InstHead l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (InstHead l) :: Type -> Type Source # Methods from :: InstHead l -> Rep (InstHead l) x Source # to :: Rep (InstHead l) x -> InstHead l Source #
Pretty (InstHead l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: InstHead l -> Doc prettyPrec :: Int -> InstHead l -> Doc
type Rep (InstHead l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (InstHead l) = D1 (MetaData "InstHead" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "IHCon" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))) :+: C1 (MetaCons "IHInfix" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))))) :+: (C1 (MetaCons "IHParen" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (InstHead l))) :+: C1 (MetaCons "IHApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (InstHead l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))))))

data Deriving l Source #

A deriving clause following a data type declaration.

Constructors

Deriving l (Maybe (DerivStrategy l)) [InstRule l] |

Instances

Functor Deriving |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Deriving a -> Deriving b Source # (<$) :: a -> Deriving b -> Deriving a Source #
Foldable Deriving |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Deriving m -> m Source #

foldMap :: Monoid m => (a -> m) -> Deriving a -> m Source #

foldr :: (a -> b -> b) -> b -> Deriving a -> b Source #

foldr' :: (a -> b -> b) -> b -> Deriving a -> b Source #

foldl :: (b -> a -> b) -> b -> Deriving a -> b Source #

foldl' :: (b -> a -> b) -> b -> Deriving a -> b Source #

foldr1 :: (a -> a -> a) -> Deriving a -> a Source #

foldl1 :: (a -> a -> a) -> Deriving a -> a Source #

toList :: Deriving a -> [a] Source #

null :: Deriving a -> Bool Source #

length :: Deriving a -> Int Source #

elem :: Eq a => a -> Deriving a -> Bool Source #

maximum :: Ord a => Deriving a -> a Source #

minimum :: Ord a => Deriving a -> a Source #

sum :: Num a => Deriving a -> a Source #

product :: Num a => Deriving a -> a Source #

Traversable Deriving |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Deriving a -> f (Deriving b) Source # sequenceA :: Applicative f => Deriving (f a) -> f (Deriving a) Source # mapM :: Monad m => (a -> m b) -> Deriving a -> m (Deriving b) Source # sequence :: Monad m => Deriving (m a) -> m (Deriving a) Source #
ExactP Deriving |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Deriving SrcSpanInfo -> EP ()
Annotated Deriving |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Deriving l -> l Source # amap :: (l -> l) -> Deriving l -> Deriving l Source #
Eq l => Eq (Deriving l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Deriving l -> Deriving l -> Bool Source # (/=) :: Deriving l -> Deriving l -> Bool Source #
Data l => Data (Deriving 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) -> Deriving l -> c (Deriving l) Source #

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

toConstr :: Deriving l -> Constr Source #

dataTypeOf :: Deriving l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (Deriving l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Deriving l -> Deriving l -> Ordering Source #

(<) :: Deriving l -> Deriving l -> Bool Source #

(<=) :: Deriving l -> Deriving l -> Bool Source #

(>) :: Deriving l -> Deriving l -> Bool Source #

(>=) :: Deriving l -> Deriving l -> Bool Source #

max :: Deriving l -> Deriving l -> Deriving l Source #

min :: Deriving l -> Deriving l -> Deriving l Source #

Show l => Show (Deriving l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Deriving l -> ShowS Source # show :: Deriving l -> String Source # showList :: [Deriving l] -> ShowS Source #
Generic (Deriving l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Deriving l) :: Type -> Type Source # Methods from :: Deriving l -> Rep (Deriving l) x Source # to :: Rep (Deriving l) x -> Deriving l Source #
Pretty (Deriving l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Deriving l -> Doc prettyPrec :: Int -> Deriving l -> Doc
type Rep (Deriving l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

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

data DerivStrategy l Source #

Which technique the user explicitly requested when deriving an instance.

Constructors

DerivStock l | GHC's "standard" strategy, which is to implement a custom instance for the data type. This only works for certain types that GHC knows about (e.g., `Eq`, `Show`, `Functor` when `-XDeriveFunctor` is enabled, etc.)

DerivAnyclass l

    -XDeriveAnyClass

DerivNewtype l

    -XGeneralizedNewtypeDeriving

Instances

Functor DerivStrategy |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> DerivStrategy a -> DerivStrategy b Source # (<$) :: a -> DerivStrategy b -> DerivStrategy a Source #
Foldable DerivStrategy |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => DerivStrategy m -> m Source #

foldMap :: Monoid m => (a -> m) -> DerivStrategy a -> m Source #

foldr :: (a -> b -> b) -> b -> DerivStrategy a -> b Source #

foldr' :: (a -> b -> b) -> b -> DerivStrategy a -> b Source #

foldl :: (b -> a -> b) -> b -> DerivStrategy a -> b Source #

foldl' :: (b -> a -> b) -> b -> DerivStrategy a -> b Source #

foldr1 :: (a -> a -> a) -> DerivStrategy a -> a Source #

foldl1 :: (a -> a -> a) -> DerivStrategy a -> a Source #

toList :: DerivStrategy a -> [a] Source #

null :: DerivStrategy a -> Bool Source #

length :: DerivStrategy a -> Int Source #

elem :: Eq a => a -> DerivStrategy a -> Bool Source #

maximum :: Ord a => DerivStrategy a -> a Source #

minimum :: Ord a => DerivStrategy a -> a Source #

sum :: Num a => DerivStrategy a -> a Source #

product :: Num a => DerivStrategy a -> a Source #

Traversable DerivStrategy |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> DerivStrategy a -> f (DerivStrategy b) Source # sequenceA :: Applicative f => DerivStrategy (f a) -> f (DerivStrategy a) Source # mapM :: Monad m => (a -> m b) -> DerivStrategy a -> m (DerivStrategy b) Source # sequence :: Monad m => DerivStrategy (m a) -> m (DerivStrategy a) Source #
ExactP DerivStrategy |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: DerivStrategy SrcSpanInfo -> EP ()
Annotated DerivStrategy |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: DerivStrategy l -> l Source # amap :: (l -> l) -> DerivStrategy l -> DerivStrategy l Source #
Eq l => Eq (DerivStrategy l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: DerivStrategy l -> DerivStrategy l -> Bool Source # (/=) :: DerivStrategy l -> DerivStrategy l -> Bool Source #
Data l => Data (DerivStrategy 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) -> DerivStrategy l -> c (DerivStrategy l) Source #

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

toConstr :: DerivStrategy l -> Constr Source #

dataTypeOf :: DerivStrategy l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (DerivStrategy l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: DerivStrategy l -> DerivStrategy l -> Ordering Source #

(<) :: DerivStrategy l -> DerivStrategy l -> Bool Source #

(<=) :: DerivStrategy l -> DerivStrategy l -> Bool Source #

(>) :: DerivStrategy l -> DerivStrategy l -> Bool Source #

(>=) :: DerivStrategy l -> DerivStrategy l -> Bool Source #

max :: DerivStrategy l -> DerivStrategy l -> DerivStrategy l Source #

min :: DerivStrategy l -> DerivStrategy l -> DerivStrategy l Source #

Show l => Show (DerivStrategy l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> DerivStrategy l -> ShowS Source # show :: DerivStrategy l -> String Source # showList :: [DerivStrategy l] -> ShowS Source #
Generic (DerivStrategy l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (DerivStrategy l) :: Type -> Type Source # Methods from :: DerivStrategy l -> Rep (DerivStrategy l) x Source # to :: Rep (DerivStrategy l) x -> DerivStrategy l Source #
Pretty (DerivStrategy l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: DerivStrategy l -> Doc prettyPrec :: Int -> DerivStrategy l -> Doc
type Rep (DerivStrategy l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

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

data Binds l Source #

A binding group inside a `let` or `where` clause.

Constructors

BDecls l [Decl l] | An ordinary binding group
IPBinds l [IPBind l] | A binding group for implicit parameters

Instances

Functor Binds |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Binds a -> Binds b Source # (<$) :: a -> Binds b -> Binds a Source #
Foldable Binds |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Binds m -> m Source #

foldMap :: Monoid m => (a -> m) -> Binds a -> m Source #

foldr :: (a -> b -> b) -> b -> Binds a -> b Source #

foldr' :: (a -> b -> b) -> b -> Binds a -> b Source #

foldl :: (b -> a -> b) -> b -> Binds a -> b Source #

foldl' :: (b -> a -> b) -> b -> Binds a -> b Source #

foldr1 :: (a -> a -> a) -> Binds a -> a Source #

foldl1 :: (a -> a -> a) -> Binds a -> a Source #

toList :: Binds a -> [a] Source #

null :: Binds a -> Bool Source #

length :: Binds a -> Int Source #

elem :: Eq a => a -> Binds a -> Bool Source #

maximum :: Ord a => Binds a -> a Source #

minimum :: Ord a => Binds a -> a Source #

sum :: Num a => Binds a -> a Source #

product :: Num a => Binds a -> a Source #

Traversable Binds |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Binds a -> f (Binds b) Source # sequenceA :: Applicative f => Binds (f a) -> f (Binds a) Source # mapM :: Monad m => (a -> m b) -> Binds a -> m (Binds b) Source # sequence :: Monad m => Binds (m a) -> m (Binds a) Source #
ExactP Binds |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Binds SrcSpanInfo -> EP ()
AppFixity Binds |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Binds SrcSpanInfo -> m (Binds SrcSpanInfo) Source #
Annotated Binds |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Binds l -> l Source # amap :: (l -> l) -> Binds l -> Binds l Source #
Eq l => Eq (Binds l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Binds l -> Binds l -> Bool Source # (/=) :: Binds l -> Binds l -> Bool Source #
Data l => Data (Binds 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) -> Binds l -> c (Binds l) Source #

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

toConstr :: Binds l -> Constr Source #

dataTypeOf :: Binds l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (Binds l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Binds l -> Binds l -> Ordering Source # (<) :: Binds l -> Binds l -> Bool Source # (<=) :: Binds l -> Binds l -> Bool Source # (>) :: Binds l -> Binds l -> Bool Source # (>=) :: Binds l -> Binds l -> Bool Source # max :: Binds l -> Binds l -> Binds l Source # min :: Binds l -> Binds l -> Binds l Source #
Show l => Show (Binds l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Binds l -> ShowS Source # show :: Binds l -> String Source # showList :: [Binds l] -> ShowS Source #
Generic (Binds l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Binds l) :: Type -> Type Source # Methods from :: Binds l -> Rep (Binds l) x Source # to :: Rep (Binds l) x -> Binds l Source #
Convert (Maybe (Binds ())) [Dec] Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Maybe (Binds ()) -> [Dec]
Convert (Binds ()) [Dec] Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Binds () -> [Dec]
type Rep (Binds l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Binds l) = D1 (MetaData "Binds" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "BDecls" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Decl l])) :+: C1 (MetaCons "IPBinds" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [IPBind l])))

data IPBind l Source #

A binding of an implicit parameter.

Constructors

IPBind l (IPName l) (Exp l) |

Instances

Functor IPBind |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> IPBind a -> IPBind b Source # (<$) :: a -> IPBind b -> IPBind a Source #
Foldable IPBind |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => IPBind m -> m Source #

foldMap :: Monoid m => (a -> m) -> IPBind a -> m Source #

foldr :: (a -> b -> b) -> b -> IPBind a -> b Source #

foldr' :: (a -> b -> b) -> b -> IPBind a -> b Source #

foldl :: (b -> a -> b) -> b -> IPBind a -> b Source #

foldl' :: (b -> a -> b) -> b -> IPBind a -> b Source #

foldr1 :: (a -> a -> a) -> IPBind a -> a Source #

foldl1 :: (a -> a -> a) -> IPBind a -> a Source #

toList :: IPBind a -> [a] Source #

null :: IPBind a -> Bool Source #

length :: IPBind a -> Int Source #

elem :: Eq a => a -> IPBind a -> Bool Source #

maximum :: Ord a => IPBind a -> a Source #

minimum :: Ord a => IPBind a -> a Source #

sum :: Num a => IPBind a -> a Source #

product :: Num a => IPBind a -> a Source #

Traversable IPBind |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> IPBind a -> f (IPBind b) Source # sequenceA :: Applicative f => IPBind (f a) -> f (IPBind a) Source # mapM :: Monad m => (a -> m b) -> IPBind a -> m (IPBind b) Source # sequence :: Monad m => IPBind (m a) -> m (IPBind a) Source #
ExactP IPBind |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: IPBind SrcSpanInfo -> EP ()
AppFixity IPBind |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> IPBind SrcSpanInfo -> m (IPBind SrcSpanInfo) Source #
Annotated IPBind |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: IPBind l -> l Source # amap :: (l -> l) -> IPBind l -> IPBind l Source #
Eq l => Eq (IPBind l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: IPBind l -> IPBind l -> Bool Source # (/=) :: IPBind l -> IPBind l -> Bool Source #
Data l => Data (IPBind 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) -> IPBind l -> c (IPBind l) Source #

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

toConstr :: IPBind l -> Constr Source #

dataTypeOf :: IPBind l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (IPBind l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: IPBind l -> IPBind l -> Ordering Source # (<) :: IPBind l -> IPBind l -> Bool Source # (<=) :: IPBind l -> IPBind l -> Bool Source # (>) :: IPBind l -> IPBind l -> Bool Source # (>=) :: IPBind l -> IPBind l -> Bool Source # max :: IPBind l -> IPBind l -> IPBind l Source # min :: IPBind l -> IPBind l -> IPBind l Source #
Show l => Show (IPBind l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> IPBind l -> ShowS Source # show :: IPBind l -> String Source # showList :: [IPBind l] -> ShowS Source #
Generic (IPBind l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (IPBind l) :: Type -> Type Source # Methods from :: IPBind l -> Rep (IPBind l) x Source # to :: Rep (IPBind l) x -> IPBind l Source #
Pretty (IPBind l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: IPBind l -> Doc prettyPrec :: Int -> IPBind l -> Doc
PrettyDeclLike (IPBind l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods wantsBlankline :: IPBind l -> Bool
type Rep (IPBind l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

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

data Match l Source #

Clauses of a function binding.

Constructors

Match l (Name l) [Pat l] (Rhs l) (Maybe (Binds l)) | A clause defined with prefix notation, i.e. the function name followed by its argument patterns, the right-hand side and an optional where clause.
InfixMatch l (Pat l) (Name l) [Pat l] (Rhs l) (Maybe (Binds l)) | A clause defined with infix notation, i.e. first its first argument pattern, then the function name, then its following argument(s), the right-hand side and an optional where clause. Note that there can be more than two arguments to a function declared infix, hence the list of pattern arguments.

Instances

Functor Match |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Match a -> Match b Source # (<$) :: a -> Match b -> Match a Source #
Foldable Match |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Match m -> m Source #

foldMap :: Monoid m => (a -> m) -> Match a -> m Source #

foldr :: (a -> b -> b) -> b -> Match a -> b Source #

foldr' :: (a -> b -> b) -> b -> Match a -> b Source #

foldl :: (b -> a -> b) -> b -> Match a -> b Source #

foldl' :: (b -> a -> b) -> b -> Match a -> b Source #

foldr1 :: (a -> a -> a) -> Match a -> a Source #

foldl1 :: (a -> a -> a) -> Match a -> a Source #

toList :: Match a -> [a] Source #

null :: Match a -> Bool Source #

length :: Match a -> Int Source #

elem :: Eq a => a -> Match a -> Bool Source #

maximum :: Ord a => Match a -> a Source #

minimum :: Ord a => Match a -> a Source #

sum :: Num a => Match a -> a Source #

product :: Num a => Match a -> a Source #

Traversable Match |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Match a -> f (Match b) Source # sequenceA :: Applicative f => Match (f a) -> f (Match a) Source # mapM :: Monad m => (a -> m b) -> Match a -> m (Match b) Source # sequence :: Monad m => Match (m a) -> m (Match a) Source #
ExactP Match |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Match SrcSpanInfo -> EP ()
AppFixity Match |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Match SrcSpanInfo -> m (Match SrcSpanInfo) Source #
Annotated Match |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Match l -> l Source # amap :: (l -> l) -> Match l -> Match l Source #
Eq l => Eq (Match l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Match l -> Match l -> Bool Source # (/=) :: Match l -> Match l -> Bool Source #
Data l => Data (Match 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) -> Match l -> c (Match l) Source #

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

toConstr :: Match l -> Constr Source #

dataTypeOf :: Match l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (Match l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Match l -> Match l -> Ordering Source # (<) :: Match l -> Match l -> Bool Source # (<=) :: Match l -> Match l -> Bool Source # (>) :: Match l -> Match l -> Bool Source # (>=) :: Match l -> Match l -> Bool Source # max :: Match l -> Match l -> Match l Source # min :: Match l -> Match l -> Match l Source #
Show l => Show (Match l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Match l -> ShowS Source # show :: Match l -> String Source # showList :: [Match l] -> ShowS Source #
Generic (Match l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Match l) :: Type -> Type Source # Methods from :: Match l -> Rep (Match l) x Source # to :: Rep (Match l) x -> Match l Source #
Pretty (Match l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Match l -> Doc prettyPrec :: Int -> Match l -> Doc
Convert (Match ()) Clause Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Match () -> Clause
type Rep (Match l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Match l) = D1 (MetaData "Match" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "Match" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat l]) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Rhs l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Binds l)))))) :+: C1 (MetaCons "InfixMatch" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat l]) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Rhs l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Binds l)))))))

data QualConDecl l Source #

A single constructor declaration within a data type declaration, which may have an existential quantification binding.

Constructors

QualConDecl l (Maybe [TyVarBind l]) (Maybe (Context l)) (ConDecl l) |

Instances

Functor QualConDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> QualConDecl a -> QualConDecl b Source # (<$) :: a -> QualConDecl b -> QualConDecl a Source #
Foldable QualConDecl |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => QualConDecl m -> m Source #

foldMap :: Monoid m => (a -> m) -> QualConDecl a -> m Source #

foldr :: (a -> b -> b) -> b -> QualConDecl a -> b Source #

foldr' :: (a -> b -> b) -> b -> QualConDecl a -> b Source #

foldl :: (b -> a -> b) -> b -> QualConDecl a -> b Source #

foldl' :: (b -> a -> b) -> b -> QualConDecl a -> b Source #

foldr1 :: (a -> a -> a) -> QualConDecl a -> a Source #

foldl1 :: (a -> a -> a) -> QualConDecl a -> a Source #

toList :: QualConDecl a -> [a] Source #

null :: QualConDecl a -> Bool Source #

length :: QualConDecl a -> Int Source #

elem :: Eq a => a -> QualConDecl a -> Bool Source #

maximum :: Ord a => QualConDecl a -> a Source #

minimum :: Ord a => QualConDecl a -> a Source #

sum :: Num a => QualConDecl a -> a Source #

product :: Num a => QualConDecl a -> a Source #

Traversable QualConDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> QualConDecl a -> f (QualConDecl b) Source # sequenceA :: Applicative f => QualConDecl (f a) -> f (QualConDecl a) Source # mapM :: Monad m => (a -> m b) -> QualConDecl a -> m (QualConDecl b) Source # sequence :: Monad m => QualConDecl (m a) -> m (QualConDecl a) Source #
ExactP QualConDecl |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: QualConDecl SrcSpanInfo -> EP ()
Annotated QualConDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: QualConDecl l -> l Source # amap :: (l -> l) -> QualConDecl l -> QualConDecl l Source #
Convert Con (QualConDecl ()) Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Con -> QualConDecl ()
Eq l => Eq (QualConDecl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: QualConDecl l -> QualConDecl l -> Bool Source # (/=) :: QualConDecl l -> QualConDecl l -> Bool Source #
Data l => Data (QualConDecl 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) -> QualConDecl l -> c (QualConDecl l) Source #

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

toConstr :: QualConDecl l -> Constr Source #

dataTypeOf :: QualConDecl l -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (QualConDecl l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: QualConDecl l -> QualConDecl l -> Ordering Source #

(<) :: QualConDecl l -> QualConDecl l -> Bool Source #

(<=) :: QualConDecl l -> QualConDecl l -> Bool Source #

(>) :: QualConDecl l -> QualConDecl l -> Bool Source #

(>=) :: QualConDecl l -> QualConDecl l -> Bool Source #

max :: QualConDecl l -> QualConDecl l -> QualConDecl l Source #

min :: QualConDecl l -> QualConDecl l -> QualConDecl l Source #

Show l => Show (QualConDecl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> QualConDecl l -> ShowS Source # show :: QualConDecl l -> String Source # showList :: [QualConDecl l] -> ShowS Source #
Generic (QualConDecl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (QualConDecl l) :: Type -> Type Source # Methods from :: QualConDecl l -> Rep (QualConDecl l) x Source # to :: Rep (QualConDecl l) x -> QualConDecl l Source #
Pretty (QualConDecl l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: QualConDecl l -> Doc prettyPrec :: Int -> QualConDecl l -> Doc
Convert (QualConDecl ()) Con Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: QualConDecl () -> Con
type Rep (QualConDecl l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

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

data ConDecl l Source #

Declaration of an ordinary data constructor.

Constructors

ConDecl l (Name l) [Type l] | ordinary data constructor
InfixConDecl l (Type l) (Name l) (Type l) | infix data constructor
RecDecl l (Name l) [FieldDecl l] | record constructor

Instances

Functor ConDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> ConDecl a -> ConDecl b Source # (<$) :: a -> ConDecl b -> ConDecl a Source #
Foldable ConDecl |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ConDecl m -> m Source #

foldMap :: Monoid m => (a -> m) -> ConDecl a -> m Source #

foldr :: (a -> b -> b) -> b -> ConDecl a -> b Source #

foldr' :: (a -> b -> b) -> b -> ConDecl a -> b Source #

foldl :: (b -> a -> b) -> b -> ConDecl a -> b Source #

foldl' :: (b -> a -> b) -> b -> ConDecl a -> b Source #

foldr1 :: (a -> a -> a) -> ConDecl a -> a Source #

foldl1 :: (a -> a -> a) -> ConDecl a -> a Source #

toList :: ConDecl a -> [a] Source #

null :: ConDecl a -> Bool Source #

length :: ConDecl a -> Int Source #

elem :: Eq a => a -> ConDecl a -> Bool Source #

maximum :: Ord a => ConDecl a -> a Source #

minimum :: Ord a => ConDecl a -> a Source #

sum :: Num a => ConDecl a -> a Source #

product :: Num a => ConDecl a -> a Source #

Traversable ConDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> ConDecl a -> f (ConDecl b) Source # sequenceA :: Applicative f => ConDecl (f a) -> f (ConDecl a) Source # mapM :: Monad m => (a -> m b) -> ConDecl a -> m (ConDecl b) Source # sequence :: Monad m => ConDecl (m a) -> m (ConDecl a) Source #
ExactP ConDecl |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: ConDecl SrcSpanInfo -> EP ()
Annotated ConDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ConDecl l -> l Source # amap :: (l -> l) -> ConDecl l -> ConDecl l Source #
Convert Con (ConDecl ()) Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Con -> ConDecl ()
Eq l => Eq (ConDecl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: ConDecl l -> ConDecl l -> Bool Source # (/=) :: ConDecl l -> ConDecl l -> Bool Source #
Data l => Data (ConDecl 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) -> ConDecl l -> c (ConDecl l) Source #

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

toConstr :: ConDecl l -> Constr Source #

dataTypeOf :: ConDecl l -> DataType Source #

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

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

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

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

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

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

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

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

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

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l) Source #

Ord l => Ord (ConDecl l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: ConDecl l -> ConDecl l -> Ordering Source #

(<) :: ConDecl l -> ConDecl l -> Bool Source #

(<=) :: ConDecl l -> ConDecl l -> Bool Source #

(>) :: ConDecl l -> ConDecl l -> Bool Source #

(>=) :: ConDecl l -> ConDecl l -> Bool Source #

max :: ConDecl l -> ConDecl l -> ConDecl l Source #

min :: ConDecl l -> ConDecl l -> ConDecl l Source #

Show l => Show (ConDecl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> ConDecl l -> ShowS Source # show :: ConDecl l -> String Source # showList :: [ConDecl l] -> ShowS Source #
Generic (ConDecl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ConDecl l) :: Type -> Type Source # Methods from :: ConDecl l -> Rep (ConDecl l) x Source # to :: Rep (ConDecl l) x -> ConDecl l Source #
Pretty (ConDecl l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: ConDecl l -> Doc prettyPrec :: Int -> ConDecl l -> Doc
Convert (ConDecl ()) Con Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: ConDecl () -> Con
type Rep (ConDecl l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (ConDecl l) = D1 (MetaData "ConDecl" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "ConDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type l]))) :+: (C1 (MetaCons "InfixConDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: C1 (MetaCons "RecDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [FieldDecl l])))))

data GadtDecl l Source #

A single constructor declaration in a GADT data type declaration.

If the GADT is declared using the record syntax, e.g.

    data Ty where
      TCon :: { field1 :: Int, field2 :: Bool } -> Ty

then the fields are stored as a list of `FieldDecl`s, and the final type (`Ty` in the above example) is stored in the last `Type` field.

If the GADT is declared using the ordinary syntax, e.g.

    data Ty where
      TCon :: Int -> Bool -> Ty

then ``Maybe` [`FieldDecl` l]` is `Nothing`, and the whole constructor's type (such as `Int -> Bool -> Ty`) is stored in the last `Type` field.

Constructors

GadtDecl l (Name l) (Maybe [FieldDecl l]) (Type l) |

Instances

Functor GadtDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> GadtDecl a -> GadtDecl b Source # (<$) :: a -> GadtDecl b -> GadtDecl a Source #
Foldable GadtDecl |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => GadtDecl m -> m Source #

foldMap :: Monoid m => (a -> m) -> GadtDecl a -> m Source #

foldr :: (a -> b -> b) -> b -> GadtDecl a -> b Source #

foldr' :: (a -> b -> b) -> b -> GadtDecl a -> b Source #

foldl :: (b -> a -> b) -> b -> GadtDecl a -> b Source #

foldl' :: (b -> a -> b) -> b -> GadtDecl a -> b Source #

foldr1 :: (a -> a -> a) -> GadtDecl a -> a Source #

foldl1 :: (a -> a -> a) -> GadtDecl a -> a Source #

toList :: GadtDecl a -> [a] Source #

null :: GadtDecl a -> Bool Source #

length :: GadtDecl a -> Int Source #

elem :: Eq a => a -> GadtDecl a -> Bool Source #

maximum :: Ord a => GadtDecl a -> a Source #

minimum :: Ord a => GadtDecl a -> a Source #

sum :: Num a => GadtDecl a -> a Source #

product :: Num a => GadtDecl a -> a Source #

Traversable GadtDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> GadtDecl a -> f (GadtDecl b) Source # sequenceA :: Applicative f => GadtDecl (f a) -> f (GadtDecl a) Source # mapM :: Monad m => (a -> m b) -> GadtDecl a -> m (GadtDecl b) Source # sequence :: Monad m => GadtDecl (m a) -> m (GadtDecl a) Source #
ExactP GadtDecl |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: GadtDecl SrcSpanInfo -> EP ()
Annotated GadtDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: GadtDecl l -> l Source # amap :: (l -> l) -> GadtDecl l -> GadtDecl l Source #
Eq l => Eq (GadtDecl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: GadtDecl l -> GadtDecl l -> Bool Source # (/=) :: GadtDecl l -> GadtDecl l -> Bool Source #
Data l => Data (GadtDecl 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) -> GadtDecl l -> c (GadtDecl l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GadtDecl l) Source #

toConstr :: GadtDecl l -> Constr Source #

dataTypeOf :: GadtDecl l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GadtDecl l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GadtDecl l)) Source #

gmapT :: (forall b. Data b => b -> b) -> GadtDecl l -> GadtDecl l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> GadtDecl l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> GadtDecl l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l) Source #

Ord l => Ord (GadtDecl l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: GadtDecl l -> GadtDecl l -> Ordering Source #

(<) :: GadtDecl l -> GadtDecl l -> Bool Source #

(<=) :: GadtDecl l -> GadtDecl l -> Bool Source #

(>) :: GadtDecl l -> GadtDecl l -> Bool Source #

(>=) :: GadtDecl l -> GadtDecl l -> Bool Source #

max :: GadtDecl l -> GadtDecl l -> GadtDecl l Source #

min :: GadtDecl l -> GadtDecl l -> GadtDecl l Source #

Show l => Show (GadtDecl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> GadtDecl l -> ShowS Source # show :: GadtDecl l -> String Source # showList :: [GadtDecl l] -> ShowS Source #
Generic (GadtDecl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (GadtDecl l) :: Type -> Type Source # Methods from :: GadtDecl l -> Rep (GadtDecl l) x Source # to :: Rep (GadtDecl l) x -> GadtDecl l Source #
Pretty (GadtDecl l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: GadtDecl l -> Doc prettyPrec :: Int -> GadtDecl l -> Doc
type Rep (GadtDecl l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (GadtDecl l) = D1 (MetaData "GadtDecl" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "GadtDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe [FieldDecl l])) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))))

data ClassDecl l Source #

Declarations inside a class declaration.

Constructors

ClsDecl l (Decl l) | ordinary declaration
ClsDataFam l (Maybe (Context l)) (DeclHead l) (Maybe (ResultSig l)) | declaration of an associated data type
ClsTyFam l (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l)) | declaration of an associated type synonym
ClsTyDef l (TypeEqn l) | default choice for an associated type synonym
ClsDefSig l (Name l) (Type l) | default signature

Instances

Functor ClassDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> ClassDecl a -> ClassDecl b Source # (<$) :: a -> ClassDecl b -> ClassDecl a Source #
Foldable ClassDecl |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ClassDecl m -> m Source #

foldMap :: Monoid m => (a -> m) -> ClassDecl a -> m Source #

foldr :: (a -> b -> b) -> b -> ClassDecl a -> b Source #

foldr' :: (a -> b -> b) -> b -> ClassDecl a -> b Source #

foldl :: (b -> a -> b) -> b -> ClassDecl a -> b Source #

foldl' :: (b -> a -> b) -> b -> ClassDecl a -> b Source #

foldr1 :: (a -> a -> a) -> ClassDecl a -> a Source #

foldl1 :: (a -> a -> a) -> ClassDecl a -> a Source #

toList :: ClassDecl a -> [a] Source #

null :: ClassDecl a -> Bool Source #

length :: ClassDecl a -> Int Source #

elem :: Eq a => a -> ClassDecl a -> Bool Source #

maximum :: Ord a => ClassDecl a -> a Source #

minimum :: Ord a => ClassDecl a -> a Source #

sum :: Num a => ClassDecl a -> a Source #

product :: Num a => ClassDecl a -> a Source #

Traversable ClassDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> ClassDecl a -> f (ClassDecl b) Source # sequenceA :: Applicative f => ClassDecl (f a) -> f (ClassDecl a) Source # mapM :: Monad m => (a -> m b) -> ClassDecl a -> m (ClassDecl b) Source # sequence :: Monad m => ClassDecl (m a) -> m (ClassDecl a) Source #
ExactP ClassDecl |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: ClassDecl SrcSpanInfo -> EP ()
AppFixity ClassDecl |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> ClassDecl SrcSpanInfo -> m (ClassDecl SrcSpanInfo) Source #
Annotated ClassDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ClassDecl l -> l Source # amap :: (l -> l) -> ClassDecl l -> ClassDecl l Source #
Eq l => Eq (ClassDecl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: ClassDecl l -> ClassDecl l -> Bool Source # (/=) :: ClassDecl l -> ClassDecl l -> Bool Source #
Data l => Data (ClassDecl 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) -> ClassDecl l -> c (ClassDecl l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ClassDecl l) Source #

toConstr :: ClassDecl l -> Constr Source #

dataTypeOf :: ClassDecl l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ClassDecl l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ClassDecl l)) Source #

gmapT :: (forall b. Data b => b -> b) -> ClassDecl l -> ClassDecl l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ClassDecl l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ClassDecl l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l) Source #

Ord l => Ord (ClassDecl l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: ClassDecl l -> ClassDecl l -> Ordering Source #

(<) :: ClassDecl l -> ClassDecl l -> Bool Source #

(<=) :: ClassDecl l -> ClassDecl l -> Bool Source #

(>) :: ClassDecl l -> ClassDecl l -> Bool Source #

(>=) :: ClassDecl l -> ClassDecl l -> Bool Source #

max :: ClassDecl l -> ClassDecl l -> ClassDecl l Source #

min :: ClassDecl l -> ClassDecl l -> ClassDecl l Source #

Show l => Show (ClassDecl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> ClassDecl l -> ShowS Source # show :: ClassDecl l -> String Source # showList :: [ClassDecl l] -> ShowS Source #
Generic (ClassDecl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ClassDecl l) :: Type -> Type Source # Methods from :: ClassDecl l -> Rep (ClassDecl l) x Source # to :: Rep (ClassDecl l) x -> ClassDecl l Source #
Pretty (ClassDecl l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: ClassDecl l -> Doc prettyPrec :: Int -> ClassDecl l -> Doc
PrettyDeclLike (ClassDecl l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods wantsBlankline :: ClassDecl l -> Bool
type Rep (ClassDecl l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (ClassDecl l) = D1 (MetaData "ClassDecl" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "ClsDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Decl l))) :+: C1 (MetaCons "ClsDataFam" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Context l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ResultSig l)))))) :+: (C1 (MetaCons "ClsTyFam" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ResultSig l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (InjectivityInfo l))))) :+: (C1 (MetaCons "ClsTyDef" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (TypeEqn l))) :+: C1 (MetaCons "ClsDefSig" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))))))

data InstDecl l Source #

Declarations inside an instance declaration.

Constructors

InsDecl l (Decl l) | ordinary declaration
InsType l (Type l) (Type l) | an associated type definition
InsData l (DataOrNew l) (Type l) [QualConDecl l] [Deriving l] | an associated data type implementation
InsGData l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] [Deriving l] | an associated data type implemented using GADT style

Instances

Functor InstDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> InstDecl a -> InstDecl b Source # (<$) :: a -> InstDecl b -> InstDecl a Source #
Foldable InstDecl |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => InstDecl m -> m Source #

foldMap :: Monoid m => (a -> m) -> InstDecl a -> m Source #

foldr :: (a -> b -> b) -> b -> InstDecl a -> b Source #

foldr' :: (a -> b -> b) -> b -> InstDecl a -> b Source #

foldl :: (b -> a -> b) -> b -> InstDecl a -> b Source #

foldl' :: (b -> a -> b) -> b -> InstDecl a -> b Source #

foldr1 :: (a -> a -> a) -> InstDecl a -> a Source #

foldl1 :: (a -> a -> a) -> InstDecl a -> a Source #

toList :: InstDecl a -> [a] Source #

null :: InstDecl a -> Bool Source #

length :: InstDecl a -> Int Source #

elem :: Eq a => a -> InstDecl a -> Bool Source #

maximum :: Ord a => InstDecl a -> a Source #

minimum :: Ord a => InstDecl a -> a Source #

sum :: Num a => InstDecl a -> a Source #

product :: Num a => InstDecl a -> a Source #

Traversable InstDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> InstDecl a -> f (InstDecl b) Source # sequenceA :: Applicative f => InstDecl (f a) -> f (InstDecl a) Source # mapM :: Monad m => (a -> m b) -> InstDecl a -> m (InstDecl b) Source # sequence :: Monad m => InstDecl (m a) -> m (InstDecl a) Source #
ExactP InstDecl |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: InstDecl SrcSpanInfo -> EP ()
AppFixity InstDecl |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> InstDecl SrcSpanInfo -> m (InstDecl SrcSpanInfo) Source #
Annotated InstDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: InstDecl l -> l Source # amap :: (l -> l) -> InstDecl l -> InstDecl l Source #
Eq l => Eq (InstDecl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: InstDecl l -> InstDecl l -> Bool Source # (/=) :: InstDecl l -> InstDecl l -> Bool Source #
Data l => Data (InstDecl 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) -> InstDecl l -> c (InstDecl l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InstDecl l) Source #

toConstr :: InstDecl l -> Constr Source #

dataTypeOf :: InstDecl l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (InstDecl l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InstDecl l)) Source #

gmapT :: (forall b. Data b => b -> b) -> InstDecl l -> InstDecl l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InstDecl l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InstDecl l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> InstDecl l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> InstDecl l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l) Source #

Ord l => Ord (InstDecl l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: InstDecl l -> InstDecl l -> Ordering Source #

(<) :: InstDecl l -> InstDecl l -> Bool Source #

(<=) :: InstDecl l -> InstDecl l -> Bool Source #

(>) :: InstDecl l -> InstDecl l -> Bool Source #

(>=) :: InstDecl l -> InstDecl l -> Bool Source #

max :: InstDecl l -> InstDecl l -> InstDecl l Source #

min :: InstDecl l -> InstDecl l -> InstDecl l Source #

Show l => Show (InstDecl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> InstDecl l -> ShowS Source # show :: InstDecl l -> String Source # showList :: [InstDecl l] -> ShowS Source #
Generic (InstDecl l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (InstDecl l) :: Type -> Type Source # Methods from :: InstDecl l -> Rep (InstDecl l) x Source # to :: Rep (InstDecl l) x -> InstDecl l Source #
Pretty (InstDecl l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: InstDecl l -> Doc prettyPrec :: Int -> InstDecl l -> Doc
PrettyDeclLike (InstDecl l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods wantsBlankline :: InstDecl l -> Bool
type Rep (InstDecl l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (InstDecl l) = D1 (MetaData "InstDecl" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "InsDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Decl l))) :+: C1 (MetaCons "InsType" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))))) :+: (C1 (MetaCons "InsData" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DataOrNew l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [QualConDecl l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Deriving l])))) :+: C1 (MetaCons "InsGData" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DataOrNew l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Kind l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [GadtDecl l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Deriving l]))))))

data BangType l Source #

The type of a constructor argument or field, optionally including a strictness annotation.

Constructors

BangedTy l | strict component, marked with "`!`"
LazyTy l | lazy component, marked with "`~`"
NoStrictAnnot l | No strictness information

Instances

Functor BangType |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> BangType a -> BangType b Source # (<$) :: a -> BangType b -> BangType a Source #
Foldable BangType |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => BangType m -> m Source #

foldMap :: Monoid m => (a -> m) -> BangType a -> m Source #

foldr :: (a -> b -> b) -> b -> BangType a -> b Source #

foldr' :: (a -> b -> b) -> b -> BangType a -> b Source #

foldl :: (b -> a -> b) -> b -> BangType a -> b Source #

foldl' :: (b -> a -> b) -> b -> BangType a -> b Source #

foldr1 :: (a -> a -> a) -> BangType a -> a Source #

foldl1 :: (a -> a -> a) -> BangType a -> a Source #

toList :: BangType a -> [a] Source #

null :: BangType a -> Bool Source #

length :: BangType a -> Int Source #

elem :: Eq a => a -> BangType a -> Bool Source #

maximum :: Ord a => BangType a -> a Source #

minimum :: Ord a => BangType a -> a Source #

sum :: Num a => BangType a -> a Source #

product :: Num a => BangType a -> a Source #

Traversable BangType |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> BangType a -> f (BangType b) Source # sequenceA :: Applicative f => BangType (f a) -> f (BangType a) Source # mapM :: Monad m => (a -> m b) -> BangType a -> m (BangType b) Source # sequence :: Monad m => BangType (m a) -> m (BangType a) Source #
ExactP BangType |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: BangType SrcSpanInfo -> EP ()
Annotated BangType |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: BangType l -> l Source # amap :: (l -> l) -> BangType l -> BangType l Source #
Eq l => Eq (BangType l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: BangType l -> BangType l -> Bool Source # (/=) :: BangType l -> BangType l -> Bool Source #
Data l => Data (BangType 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) -> BangType l -> c (BangType l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (BangType l) Source #

toConstr :: BangType l -> Constr Source #

dataTypeOf :: BangType l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (BangType l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BangType l)) Source #

gmapT :: (forall b. Data b => b -> b) -> BangType l -> BangType l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BangType l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BangType l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> BangType l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> BangType l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BangType l -> m (BangType l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BangType l -> m (BangType l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BangType l -> m (BangType l) Source #

Ord l => Ord (BangType l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: BangType l -> BangType l -> Ordering Source #

(<) :: BangType l -> BangType l -> Bool Source #

(<=) :: BangType l -> BangType l -> Bool Source #

(>) :: BangType l -> BangType l -> Bool Source #

(>=) :: BangType l -> BangType l -> Bool Source #

max :: BangType l -> BangType l -> BangType l Source #

min :: BangType l -> BangType l -> BangType l Source #

Show l => Show (BangType l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> BangType l -> ShowS Source # show :: BangType l -> String Source # showList :: [BangType l] -> ShowS Source #
Generic (BangType l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (BangType l) :: Type -> Type Source # Methods from :: BangType l -> Rep (BangType l) x Source # to :: Rep (BangType l) x -> BangType l Source #
Pretty (BangType l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: BangType l -> Doc prettyPrec :: Int -> BangType l -> Doc
type Rep (BangType l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (BangType l) = D1 (MetaData "BangType" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "BangedTy" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: (C1 (MetaCons "LazyTy" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "NoStrictAnnot" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))))

data Unpackedness l Source #

Constructors

Unpack l | "`{-# UNPACK #-}`"
NoUnpack l | "`{-# NOUNPACK #-}`"
NoUnpackPragma l | No unpack pragma

Instances

Functor Unpackedness |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Unpackedness a -> Unpackedness b Source # (<$) :: a -> Unpackedness b -> Unpackedness a Source #
Foldable Unpackedness |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Unpackedness m -> m Source #

foldMap :: Monoid m => (a -> m) -> Unpackedness a -> m Source #

foldr :: (a -> b -> b) -> b -> Unpackedness a -> b Source #

foldr' :: (a -> b -> b) -> b -> Unpackedness a -> b Source #

foldl :: (b -> a -> b) -> b -> Unpackedness a -> b Source #

foldl' :: (b -> a -> b) -> b -> Unpackedness a -> b Source #

foldr1 :: (a -> a -> a) -> Unpackedness a -> a Source #

foldl1 :: (a -> a -> a) -> Unpackedness a -> a Source #

toList :: Unpackedness a -> [a] Source #

null :: Unpackedness a -> Bool Source #

length :: Unpackedness a -> Int Source #

elem :: Eq a => a -> Unpackedness a -> Bool Source #

maximum :: Ord a => Unpackedness a -> a Source #

minimum :: Ord a => Unpackedness a -> a Source #

sum :: Num a => Unpackedness a -> a Source #

product :: Num a => Unpackedness a -> a Source #

Traversable Unpackedness |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Unpackedness a -> f (Unpackedness b) Source # sequenceA :: Applicative f => Unpackedness (f a) -> f (Unpackedness a) Source # mapM :: Monad m => (a -> m b) -> Unpackedness a -> m (Unpackedness b) Source # sequence :: Monad m => Unpackedness (m a) -> m (Unpackedness a) Source #
ExactP Unpackedness |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Unpackedness SrcSpanInfo -> EP ()
Annotated Unpackedness |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Unpackedness l -> l Source # amap :: (l -> l) -> Unpackedness l -> Unpackedness l Source #
Eq l => Eq (Unpackedness l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Unpackedness l -> Unpackedness l -> Bool Source # (/=) :: Unpackedness l -> Unpackedness l -> Bool Source #
Data l => Data (Unpackedness 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) -> Unpackedness l -> c (Unpackedness l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Unpackedness l) Source #

toConstr :: Unpackedness l -> Constr Source #

dataTypeOf :: Unpackedness l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Unpackedness l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Unpackedness l)) Source #

gmapT :: (forall b. Data b => b -> b) -> Unpackedness l -> Unpackedness l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Unpackedness l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Unpackedness l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Unpackedness l -> m (Unpackedness l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Unpackedness l -> m (Unpackedness l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Unpackedness l -> m (Unpackedness l) Source #

Ord l => Ord (Unpackedness l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Unpackedness l -> Unpackedness l -> Ordering Source #

(<) :: Unpackedness l -> Unpackedness l -> Bool Source #

(<=) :: Unpackedness l -> Unpackedness l -> Bool Source #

(>) :: Unpackedness l -> Unpackedness l -> Bool Source #

(>=) :: Unpackedness l -> Unpackedness l -> Bool Source #

max :: Unpackedness l -> Unpackedness l -> Unpackedness l Source #

min :: Unpackedness l -> Unpackedness l -> Unpackedness l Source #

Show l => Show (Unpackedness l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Unpackedness l -> ShowS Source # show :: Unpackedness l -> String Source # showList :: [Unpackedness l] -> ShowS Source #
Generic (Unpackedness l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Unpackedness l) :: Type -> Type Source # Methods from :: Unpackedness l -> Rep (Unpackedness l) x Source # to :: Rep (Unpackedness l) x -> Unpackedness l Source #
Pretty (Unpackedness l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Unpackedness l -> Doc prettyPrec :: Int -> Unpackedness l -> Doc
type Rep (Unpackedness l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Unpackedness l) = D1 (MetaData "Unpackedness" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "Unpack" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: (C1 (MetaCons "NoUnpack" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "NoUnpackPragma" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))))

data Rhs l Source #

The right hand side of a function binding, pattern binding, or a case alternative.

Constructors

UnGuardedRhs l (Exp l) | unguarded right hand side (exp)
GuardedRhss l [GuardedRhs l] | guarded right hand side (gdrhs)

Instances

Functor Rhs |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Rhs a -> Rhs b Source # (<$) :: a -> Rhs b -> Rhs a Source #
Foldable Rhs |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Rhs m -> m Source #

foldMap :: Monoid m => (a -> m) -> Rhs a -> m Source #

foldr :: (a -> b -> b) -> b -> Rhs a -> b Source #

foldr' :: (a -> b -> b) -> b -> Rhs a -> b Source #

foldl :: (b -> a -> b) -> b -> Rhs a -> b Source #

foldl' :: (b -> a -> b) -> b -> Rhs a -> b Source #

foldr1 :: (a -> a -> a) -> Rhs a -> a Source #

foldl1 :: (a -> a -> a) -> Rhs a -> a Source #

toList :: Rhs a -> [a] Source #

null :: Rhs a -> Bool Source #

length :: Rhs a -> Int Source #

elem :: Eq a => a -> Rhs a -> Bool Source #

maximum :: Ord a => Rhs a -> a Source #

minimum :: Ord a => Rhs a -> a Source #

sum :: Num a => Rhs a -> a Source #

product :: Num a => Rhs a -> a Source #

Traversable Rhs |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Rhs a -> f (Rhs b) Source # sequenceA :: Applicative f => Rhs (f a) -> f (Rhs a) Source # mapM :: Monad m => (a -> m b) -> Rhs a -> m (Rhs b) Source # sequence :: Monad m => Rhs (m a) -> m (Rhs a) Source #
ExactP Rhs |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Rhs SrcSpanInfo -> EP ()
AppFixity Rhs |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Rhs SrcSpanInfo -> m (Rhs SrcSpanInfo) Source #
Annotated Rhs |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Rhs l -> l Source # amap :: (l -> l) -> Rhs l -> Rhs l Source #
Eq l => Eq (Rhs l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Rhs l -> Rhs l -> Bool Source # (/=) :: Rhs l -> Rhs l -> Bool Source #
Data l => Data (Rhs 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) -> Rhs l -> c (Rhs l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Rhs l) Source #

toConstr :: Rhs l -> Constr Source #

dataTypeOf :: Rhs l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Rhs l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rhs l)) Source #

gmapT :: (forall b. Data b => b -> b) -> Rhs l -> Rhs l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Rhs l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Rhs l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l) Source #

Ord l => Ord (Rhs l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Rhs l -> Rhs l -> Ordering Source # (<) :: Rhs l -> Rhs l -> Bool Source # (<=) :: Rhs l -> Rhs l -> Bool Source # (>) :: Rhs l -> Rhs l -> Bool Source # (>=) :: Rhs l -> Rhs l -> Bool Source # max :: Rhs l -> Rhs l -> Rhs l Source # min :: Rhs l -> Rhs l -> Rhs l Source #
Show l => Show (Rhs l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Rhs l -> ShowS Source # show :: Rhs l -> String Source # showList :: [Rhs l] -> ShowS Source #
Generic (Rhs l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Rhs l) :: Type -> Type Source # Methods from :: Rhs l -> Rep (Rhs l) x Source # to :: Rep (Rhs l) x -> Rhs l Source #
Pretty (Rhs l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Rhs l -> Doc prettyPrec :: Int -> Rhs l -> Doc
Convert (Rhs ()) Body Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Rhs () -> Body
type Rep (Rhs l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Rhs l) = D1 (MetaData "Rhs" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "UnGuardedRhs" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :+: C1 (MetaCons "GuardedRhss" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [GuardedRhs l])))

data GuardedRhs l Source #

A guarded right hand side `|` stmts `=` exp, or `|` stmts `->` exp for case alternatives. The guard is a series of statements when using pattern guards, otherwise it will be a single qualifier expression.

Constructors

GuardedRhs l [Stmt l] (Exp l) |

Instances

Functor GuardedRhs |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> GuardedRhs a -> GuardedRhs b Source # (<$) :: a -> GuardedRhs b -> GuardedRhs a Source #
Foldable GuardedRhs |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => GuardedRhs m -> m Source #

foldMap :: Monoid m => (a -> m) -> GuardedRhs a -> m Source #

foldr :: (a -> b -> b) -> b -> GuardedRhs a -> b Source #

foldr' :: (a -> b -> b) -> b -> GuardedRhs a -> b Source #

foldl :: (b -> a -> b) -> b -> GuardedRhs a -> b Source #

foldl' :: (b -> a -> b) -> b -> GuardedRhs a -> b Source #

foldr1 :: (a -> a -> a) -> GuardedRhs a -> a Source #

foldl1 :: (a -> a -> a) -> GuardedRhs a -> a Source #

toList :: GuardedRhs a -> [a] Source #

null :: GuardedRhs a -> Bool Source #

length :: GuardedRhs a -> Int Source #

elem :: Eq a => a -> GuardedRhs a -> Bool Source #

maximum :: Ord a => GuardedRhs a -> a Source #

minimum :: Ord a => GuardedRhs a -> a Source #

sum :: Num a => GuardedRhs a -> a Source #

product :: Num a => GuardedRhs a -> a Source #

Traversable GuardedRhs |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> GuardedRhs a -> f (GuardedRhs b) Source # sequenceA :: Applicative f => GuardedRhs (f a) -> f (GuardedRhs a) Source # mapM :: Monad m => (a -> m b) -> GuardedRhs a -> m (GuardedRhs b) Source # sequence :: Monad m => GuardedRhs (m a) -> m (GuardedRhs a) Source #
ExactP GuardedRhs |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: GuardedRhs SrcSpanInfo -> EP ()
AppFixity GuardedRhs |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> GuardedRhs SrcSpanInfo -> m (GuardedRhs SrcSpanInfo) Source #
Annotated GuardedRhs |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: GuardedRhs l -> l Source # amap :: (l -> l) -> GuardedRhs l -> GuardedRhs l Source #
Eq l => Eq (GuardedRhs l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: GuardedRhs l -> GuardedRhs l -> Bool Source # (/=) :: GuardedRhs l -> GuardedRhs l -> Bool Source #
Data l => Data (GuardedRhs 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) -> GuardedRhs l -> c (GuardedRhs l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GuardedRhs l) Source #

toConstr :: GuardedRhs l -> Constr Source #

dataTypeOf :: GuardedRhs l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GuardedRhs l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GuardedRhs l)) Source #

gmapT :: (forall b. Data b => b -> b) -> GuardedRhs l -> GuardedRhs l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> GuardedRhs l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> GuardedRhs l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l) Source #

Ord l => Ord (GuardedRhs l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: GuardedRhs l -> GuardedRhs l -> Ordering Source #

(<) :: GuardedRhs l -> GuardedRhs l -> Bool Source #

(<=) :: GuardedRhs l -> GuardedRhs l -> Bool Source #

(>) :: GuardedRhs l -> GuardedRhs l -> Bool Source #

(>=) :: GuardedRhs l -> GuardedRhs l -> Bool Source #

max :: GuardedRhs l -> GuardedRhs l -> GuardedRhs l Source #

min :: GuardedRhs l -> GuardedRhs l -> GuardedRhs l Source #

Show l => Show (GuardedRhs l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> GuardedRhs l -> ShowS Source # show :: GuardedRhs l -> String Source # showList :: [GuardedRhs l] -> ShowS Source #
Generic (GuardedRhs l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (GuardedRhs l) :: Type -> Type Source # Methods from :: GuardedRhs l -> Rep (GuardedRhs l) x Source # to :: Rep (GuardedRhs l) x -> GuardedRhs l Source #
Pretty (GuardedRhs l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: GuardedRhs l -> Doc prettyPrec :: Int -> GuardedRhs l -> Doc
Convert (GuardedRhs ()) (Guard, Exp) Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: GuardedRhs () -> (Guard, Exp)
type Rep (GuardedRhs l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (GuardedRhs l) = D1 (MetaData "GuardedRhs" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "GuardedRhs" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Stmt l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))))

data Type l Source #

A type qualified with a context. An unqualified type has an empty context.

Constructors

TyForall l (Maybe [TyVarBind l]) (Maybe (Context l)) (Type l) | qualified type
TyFun l (Type l) (Type l) | function type
TyTuple l Boxed [Type l] | tuple type, possibly boxed
TyUnboxedSum l [Type l] | unboxed tuple type
TyList l (Type l) | list syntax, e.g. [a], as opposed to [] a
TyParArray l (Type l) | parallel array syntax, e.g. [:a:]
TyApp l (Type l) (Type l) | application of a type constructor
TyVar l (Name l) | type variable
TyCon l (QName l) | named type or type constructor
TyParen l (Type l) | type surrounded by parentheses
TyInfix l (Type l) (MaybePromotedName l) (Type l) | infix type constructor
TyKind l (Type l) (Kind l) | type with explicit kind signature
TyPromoted l (Promoted l) | `'K`, a promoted data type (-XDataKinds).
TyEquals l (Type l) (Type l) | type equality predicate enabled by ConstraintKinds
TySplice l (Splice l) | template haskell splice type
TyBang l (BangType l) (Unpackedness l) (Type l) | Strict type marked with "`!`" or type marked with UNPACK pragma.
TyWildCard l (Maybe (Name l)) | Either an anonymous of named type wildcard

TyQuasiQuote l String String

    [$name| string |]

Instances

Functor Type |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Type a -> Type b Source # (<$) :: a -> Type b -> Type a Source #
Foldable Type |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Type m -> m Source #

foldMap :: Monoid m => (a -> m) -> Type a -> m Source #

foldr :: (a -> b -> b) -> b -> Type a -> b Source #

foldr' :: (a -> b -> b) -> b -> Type a -> b Source #

foldl :: (b -> a -> b) -> b -> Type a -> b Source #

foldl' :: (b -> a -> b) -> b -> Type a -> b Source #

foldr1 :: (a -> a -> a) -> Type a -> a Source #

foldl1 :: (a -> a -> a) -> Type a -> a Source #

toList :: Type a -> [a] Source #

null :: Type a -> Bool Source #

length :: Type a -> Int Source #

elem :: Eq a => a -> Type a -> Bool Source #

maximum :: Ord a => Type a -> a Source #

minimum :: Ord a => Type a -> a Source #

sum :: Num a => Type a -> a Source #

product :: Num a => Type a -> a Source #

Traversable Type |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Type a -> f (Type b) Source # sequenceA :: Applicative f => Type (f a) -> f (Type a) Source # mapM :: Monad m => (a -> m b) -> Type a -> m (Type b) Source # sequence :: Monad m => Type (m a) -> m (Type a) Source #
ExactP Type |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Type SrcSpanInfo -> EP ()
Annotated Type |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Type l -> l Source # amap :: (l -> l) -> Type l -> Type l Source #
Convert Type (Type ()) Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Type0 -> Type ()
Convert StrictType (Type ()) Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: StrictType -> Type ()
Eq l => Eq (Type l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Type l -> Type l -> Bool Source # (/=) :: Type l -> Type l -> Bool Source #
Data l => Data (Type 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) -> Type l -> c (Type l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Type l) Source #

toConstr :: Type l -> Constr Source #

dataTypeOf :: Type l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Type l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Type l)) Source #

gmapT :: (forall b. Data b => b -> b) -> Type l -> Type l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Type l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Type l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type l -> m (Type l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type l -> m (Type l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type l -> m (Type l) Source #

Ord l => Ord (Type l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Type l -> Type l -> Ordering Source # (<) :: Type l -> Type l -> Bool Source # (<=) :: Type l -> Type l -> Bool Source # (>) :: Type l -> Type l -> Bool Source # (>=) :: Type l -> Type l -> Bool Source # max :: Type l -> Type l -> Type l Source # min :: Type l -> Type l -> Type l Source #
Show l => Show (Type l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Type l -> ShowS Source # show :: Type l -> String Source # showList :: [Type l] -> ShowS Source #
Generic (Type l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Type l) :: Type -> Type Source # Methods from :: Type l -> Rep (Type l) x Source # to :: Rep (Type l) x -> Type l Source #
Pretty (Type l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Type l -> Doc prettyPrec :: Int -> Type l -> Doc
Convert (Type ()) Type Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Type () -> Type0
Convert (Type ()) StrictType Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Type () -> StrictType
Convert ([Name ()], Type ()) [VarStrictType] Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: ([Name ()], Type ()) -> [VarStrictType]
type Rep (Type l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Type l) = D1 (MetaData "Type" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((((C1 (MetaCons "TyForall" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe [TyVarBind l]))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Context l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: C1 (MetaCons "TyFun" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))))) :+: (C1 (MetaCons "TyTuple" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Boxed) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type l]))) :+: C1 (MetaCons "TyUnboxedSum" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type l])))) :+: ((C1 (MetaCons "TyList" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))) :+: C1 (MetaCons "TyParArray" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: (C1 (MetaCons "TyApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: (C1 (MetaCons "TyVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))) :+: C1 (MetaCons "TyCon" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))))))) :+: (((C1 (MetaCons "TyParen" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))) :+: C1 (MetaCons "TyInfix" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (MaybePromotedName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))))) :+: (C1 (MetaCons "TyKind" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Kind l)))) :+: C1 (MetaCons "TyPromoted" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Promoted l))))) :+: ((C1 (MetaCons "TyEquals" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: C1 (MetaCons "TySplice" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Splice l)))) :+: (C1 (MetaCons "TyBang" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (BangType l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Unpackedness l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: (C1 (MetaCons "TyWildCard" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Name l)))) :+: C1 (MetaCons "TyQuasiQuote" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))))))))

data MaybePromotedName l Source #

Constructors

PromotedName l (QName l) |
UnpromotedName l (QName l) |

Instances

Functor MaybePromotedName |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> MaybePromotedName a -> MaybePromotedName b Source # (<$) :: a -> MaybePromotedName b -> MaybePromotedName a Source #
Foldable MaybePromotedName |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => MaybePromotedName m -> m Source #

foldMap :: Monoid m => (a -> m) -> MaybePromotedName a -> m Source #

foldr :: (a -> b -> b) -> b -> MaybePromotedName a -> b Source #

foldr' :: (a -> b -> b) -> b -> MaybePromotedName a -> b Source #

foldl :: (b -> a -> b) -> b -> MaybePromotedName a -> b Source #

foldl' :: (b -> a -> b) -> b -> MaybePromotedName a -> b Source #

foldr1 :: (a -> a -> a) -> MaybePromotedName a -> a Source #

foldl1 :: (a -> a -> a) -> MaybePromotedName a -> a Source #

toList :: MaybePromotedName a -> [a] Source #

null :: MaybePromotedName a -> Bool Source #

length :: MaybePromotedName a -> Int Source #

elem :: Eq a => a -> MaybePromotedName a -> Bool Source #

maximum :: Ord a => MaybePromotedName a -> a Source #

minimum :: Ord a => MaybePromotedName a -> a Source #

sum :: Num a => MaybePromotedName a -> a Source #

product :: Num a => MaybePromotedName a -> a Source #

Traversable MaybePromotedName |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> MaybePromotedName a -> f (MaybePromotedName b) Source #

sequenceA :: Applicative f => MaybePromotedName (f a) -> f (MaybePromotedName a) Source #

mapM :: Monad m => (a -> m b) -> MaybePromotedName a -> m (MaybePromotedName b) Source #

sequence :: Monad m => MaybePromotedName (m a) -> m (MaybePromotedName a) Source #

ExactP MaybePromotedName |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: MaybePromotedName SrcSpanInfo -> EP ()
Annotated MaybePromotedName |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: MaybePromotedName l -> l Source # amap :: (l -> l) -> MaybePromotedName l -> MaybePromotedName l Source #
Eq l => Eq (MaybePromotedName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: MaybePromotedName l -> MaybePromotedName l -> Bool Source # (/=) :: MaybePromotedName l -> MaybePromotedName l -> Bool Source #
Data l => Data (MaybePromotedName 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) -> MaybePromotedName l -> c (MaybePromotedName l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (MaybePromotedName l) Source #

toConstr :: MaybePromotedName l -> Constr Source #

dataTypeOf :: MaybePromotedName l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (MaybePromotedName l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MaybePromotedName l)) Source #

gmapT :: (forall b. Data b => b -> b) -> MaybePromotedName l -> MaybePromotedName l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> MaybePromotedName l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MaybePromotedName l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MaybePromotedName l -> m (MaybePromotedName l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MaybePromotedName l -> m (MaybePromotedName l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MaybePromotedName l -> m (MaybePromotedName l) Source #

Ord l => Ord (MaybePromotedName l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: MaybePromotedName l -> MaybePromotedName l -> Ordering Source #

(<) :: MaybePromotedName l -> MaybePromotedName l -> Bool Source #

(<=) :: MaybePromotedName l -> MaybePromotedName l -> Bool Source #

(>) :: MaybePromotedName l -> MaybePromotedName l -> Bool Source #

(>=) :: MaybePromotedName l -> MaybePromotedName l -> Bool Source #

max :: MaybePromotedName l -> MaybePromotedName l -> MaybePromotedName l Source #

min :: MaybePromotedName l -> MaybePromotedName l -> MaybePromotedName l Source #

Show l => Show (MaybePromotedName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> MaybePromotedName l -> ShowS Source # show :: MaybePromotedName l -> String Source # showList :: [MaybePromotedName l] -> ShowS Source #
Generic (MaybePromotedName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (MaybePromotedName l) :: Type -> Type Source # Methods from :: MaybePromotedName l -> Rep (MaybePromotedName l) x Source # to :: Rep (MaybePromotedName l) x -> MaybePromotedName l Source #
Pretty (MaybePromotedName l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: MaybePromotedName l -> Doc prettyPrec :: Int -> MaybePromotedName l -> Doc
type Rep (MaybePromotedName l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (MaybePromotedName l) = D1 (MetaData "MaybePromotedName" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "PromotedName" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))) :+: C1 (MetaCons "UnpromotedName" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))))

data Promoted l Source #

Bools here are True if there was a leading quote which may be left out. For example `'[k1,k2]` means the same thing as `[k1,k2]`.

Constructors

PromotedInteger l Integer String | parsed value and raw string
PromotedString l String String | parsed value and raw string
PromotedCon l Bool (QName l) |
PromotedList l Bool [Type l] |
PromotedTuple l [Type l] |
PromotedUnit l |

Instances

Functor Promoted |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Promoted a -> Promoted b Source # (<$) :: a -> Promoted b -> Promoted a Source #
Foldable Promoted |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Promoted m -> m Source #

foldMap :: Monoid m => (a -> m) -> Promoted a -> m Source #

foldr :: (a -> b -> b) -> b -> Promoted a -> b Source #

foldr' :: (a -> b -> b) -> b -> Promoted a -> b Source #

foldl :: (b -> a -> b) -> b -> Promoted a -> b Source #

foldl' :: (b -> a -> b) -> b -> Promoted a -> b Source #

foldr1 :: (a -> a -> a) -> Promoted a -> a Source #

foldl1 :: (a -> a -> a) -> Promoted a -> a Source #

toList :: Promoted a -> [a] Source #

null :: Promoted a -> Bool Source #

length :: Promoted a -> Int Source #

elem :: Eq a => a -> Promoted a -> Bool Source #

maximum :: Ord a => Promoted a -> a Source #

minimum :: Ord a => Promoted a -> a Source #

sum :: Num a => Promoted a -> a Source #

product :: Num a => Promoted a -> a Source #

Traversable Promoted |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Promoted a -> f (Promoted b) Source # sequenceA :: Applicative f => Promoted (f a) -> f (Promoted a) Source # mapM :: Monad m => (a -> m b) -> Promoted a -> m (Promoted b) Source # sequence :: Monad m => Promoted (m a) -> m (Promoted a) Source #
ExactP Promoted |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Promoted SrcSpanInfo -> EP ()
Annotated Promoted |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Promoted l -> l Source # amap :: (l -> l) -> Promoted l -> Promoted l Source #
Eq l => Eq (Promoted l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Promoted l -> Promoted l -> Bool Source # (/=) :: Promoted l -> Promoted l -> Bool Source #
Data l => Data (Promoted 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) -> Promoted l -> c (Promoted l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Promoted l) Source #

toConstr :: Promoted l -> Constr Source #

dataTypeOf :: Promoted l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Promoted l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Promoted l)) Source #

gmapT :: (forall b. Data b => b -> b) -> Promoted l -> Promoted l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Promoted l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Promoted l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Promoted l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Promoted l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l) Source #

Ord l => Ord (Promoted l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Promoted l -> Promoted l -> Ordering Source #

(<) :: Promoted l -> Promoted l -> Bool Source #

(<=) :: Promoted l -> Promoted l -> Bool Source #

(>) :: Promoted l -> Promoted l -> Bool Source #

(>=) :: Promoted l -> Promoted l -> Bool Source #

max :: Promoted l -> Promoted l -> Promoted l Source #

min :: Promoted l -> Promoted l -> Promoted l Source #

Show l => Show (Promoted l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Promoted l -> ShowS Source # show :: Promoted l -> String Source # showList :: [Promoted l] -> ShowS Source #
Generic (Promoted l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Promoted l) :: Type -> Type Source # Methods from :: Promoted l -> Rep (Promoted l) x Source # to :: Rep (Promoted l) x -> Promoted l Source #
Pretty (Promoted l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Promoted l -> Doc prettyPrec :: Int -> Promoted l -> Doc
type Rep (Promoted l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Promoted l) = D1 (MetaData "Promoted" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "PromotedInteger" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: (C1 (MetaCons "PromotedString" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: C1 (MetaCons "PromotedCon" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)))))) :+: (C1 (MetaCons "PromotedList" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type l]))) :+: (C1 (MetaCons "PromotedTuple" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type l])) :+: C1 (MetaCons "PromotedUnit" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)))))

data Boxed Source #

Flag denoting whether a tuple is boxed or unboxed.

Constructors

Boxed |
Unboxed |

Instances

Eq Boxed |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Boxed -> Boxed -> Bool Source # (/=) :: Boxed -> Boxed -> Bool Source #
Data Boxed |

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) -> Boxed -> c Boxed Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Boxed Source #

toConstr :: Boxed -> Constr Source #

dataTypeOf :: Boxed -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Boxed) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Boxed) Source #

gmapT :: (forall b. Data b => b -> b) -> Boxed -> Boxed Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Boxed -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Boxed -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Boxed -> m Boxed Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Boxed -> m Boxed Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Boxed -> m Boxed Source #

Ord Boxed |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Boxed -> Boxed -> Ordering Source # (<) :: Boxed -> Boxed -> Bool Source # (<=) :: Boxed -> Boxed -> Bool Source # (>) :: Boxed -> Boxed -> Bool Source # (>=) :: Boxed -> Boxed -> Bool Source # max :: Boxed -> Boxed -> Boxed Source # min :: Boxed -> Boxed -> Boxed Source #
Show Boxed |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Boxed -> ShowS Source # show :: Boxed -> String Source # showList :: [Boxed] -> ShowS Source #
Generic Boxed |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep Boxed :: Type -> Type Source # Methods from :: Boxed -> Rep Boxed x Source # to :: Rep Boxed x -> Boxed Source #
type Rep Boxed |
Instance details Defined in Language.Haskell.Exts.Syntax type Rep Boxed = D1 (MetaData "Boxed" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "Boxed" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "Unboxed" PrefixI False) (U1 :: Type -> Type))

data TyVarBind l Source #

A type variable declaration, optionally with an explicit kind annotation.

Constructors

KindedVar l (Name l) (Kind l) | variable binding with kind annotation
UnkindedVar l (Name l) | ordinary variable binding

Instances

Functor TyVarBind |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> TyVarBind a -> TyVarBind b Source # (<$) :: a -> TyVarBind b -> TyVarBind a Source #
Foldable TyVarBind |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => TyVarBind m -> m Source #

foldMap :: Monoid m => (a -> m) -> TyVarBind a -> m Source #

foldr :: (a -> b -> b) -> b -> TyVarBind a -> b Source #

foldr' :: (a -> b -> b) -> b -> TyVarBind a -> b Source #

foldl :: (b -> a -> b) -> b -> TyVarBind a -> b Source #

foldl' :: (b -> a -> b) -> b -> TyVarBind a -> b Source #

foldr1 :: (a -> a -> a) -> TyVarBind a -> a Source #

foldl1 :: (a -> a -> a) -> TyVarBind a -> a Source #

toList :: TyVarBind a -> [a] Source #

null :: TyVarBind a -> Bool Source #

length :: TyVarBind a -> Int Source #

elem :: Eq a => a -> TyVarBind a -> Bool Source #

maximum :: Ord a => TyVarBind a -> a Source #

minimum :: Ord a => TyVarBind a -> a Source #

sum :: Num a => TyVarBind a -> a Source #

product :: Num a => TyVarBind a -> a Source #

Traversable TyVarBind |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> TyVarBind a -> f (TyVarBind b) Source # sequenceA :: Applicative f => TyVarBind (f a) -> f (TyVarBind a) Source # mapM :: Monad m => (a -> m b) -> TyVarBind a -> m (TyVarBind b) Source # sequence :: Monad m => TyVarBind (m a) -> m (TyVarBind a) Source #
ExactP TyVarBind |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: TyVarBind SrcSpanInfo -> EP ()
Annotated TyVarBind |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: TyVarBind l -> l Source # amap :: (l -> l) -> TyVarBind l -> TyVarBind l Source #
Convert Name (TyVarBind ()) Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Name -> TyVarBind ()
Convert TyVarBndr (TyVarBind ()) Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: TyVarBndr -> TyVarBind ()
Eq l => Eq (TyVarBind l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: TyVarBind l -> TyVarBind l -> Bool Source # (/=) :: TyVarBind l -> TyVarBind l -> Bool Source #
Data l => Data (TyVarBind 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) -> TyVarBind l -> c (TyVarBind l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyVarBind l) Source #

toConstr :: TyVarBind l -> Constr Source #

dataTypeOf :: TyVarBind l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyVarBind l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyVarBind l)) Source #

gmapT :: (forall b. Data b => b -> b) -> TyVarBind l -> TyVarBind l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> TyVarBind l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyVarBind l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l) Source #

Ord l => Ord (TyVarBind l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: TyVarBind l -> TyVarBind l -> Ordering Source #

(<) :: TyVarBind l -> TyVarBind l -> Bool Source #

(<=) :: TyVarBind l -> TyVarBind l -> Bool Source #

(>) :: TyVarBind l -> TyVarBind l -> Bool Source #

(>=) :: TyVarBind l -> TyVarBind l -> Bool Source #

max :: TyVarBind l -> TyVarBind l -> TyVarBind l Source #

min :: TyVarBind l -> TyVarBind l -> TyVarBind l Source #

Show l => Show (TyVarBind l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> TyVarBind l -> ShowS Source # show :: TyVarBind l -> String Source # showList :: [TyVarBind l] -> ShowS Source #
Generic (TyVarBind l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (TyVarBind l) :: Type -> Type Source # Methods from :: TyVarBind l -> Rep (TyVarBind l) x Source # to :: Rep (TyVarBind l) x -> TyVarBind l Source #
Pretty (TyVarBind l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: TyVarBind l -> Doc prettyPrec :: Int -> TyVarBind l -> Doc
Convert (TyVarBind ()) Name Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: TyVarBind () -> Name
Convert (TyVarBind ()) TyVarBndr Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: TyVarBind () -> TyVarBndr
type Rep (TyVarBind l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (TyVarBind l) = D1 (MetaData "TyVarBind" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "KindedVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Kind l)))) :+: C1 (MetaCons "UnkindedVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))))

data Kind l Source #

An explicit kind annotation.

Constructors

KindStar l | `*`, the kind of types
KindFn l (Kind l) (Kind l) | `->`, the kind of a type constructor
KindParen l (Kind l) | a parenthesised kind
KindVar l (QName l) | `k`, a kind variable (-XPolyKinds)

KindApp l (Kind l) (Kind l)

    k1 k2

KindTuple l [Kind l] | `'(k1,k2,k3)`, a promoted tuple
KindList l (Kind l) | `'[k1]`, a promoted list literal

Instances

Functor Kind |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Kind a -> Kind b Source # (<$) :: a -> Kind b -> Kind a Source #
Foldable Kind |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Kind m -> m Source #

foldMap :: Monoid m => (a -> m) -> Kind a -> m Source #

foldr :: (a -> b -> b) -> b -> Kind a -> b Source #

foldr' :: (a -> b -> b) -> b -> Kind a -> b Source #

foldl :: (b -> a -> b) -> b -> Kind a -> b Source #

foldl' :: (b -> a -> b) -> b -> Kind a -> b Source #

foldr1 :: (a -> a -> a) -> Kind a -> a Source #

foldl1 :: (a -> a -> a) -> Kind a -> a Source #

toList :: Kind a -> [a] Source #

null :: Kind a -> Bool Source #

length :: Kind a -> Int Source #

elem :: Eq a => a -> Kind a -> Bool Source #

maximum :: Ord a => Kind a -> a Source #

minimum :: Ord a => Kind a -> a Source #

sum :: Num a => Kind a -> a Source #

product :: Num a => Kind a -> a Source #

Traversable Kind |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Kind a -> f (Kind b) Source # sequenceA :: Applicative f => Kind (f a) -> f (Kind a) Source # mapM :: Monad m => (a -> m b) -> Kind a -> m (Kind b) Source # sequence :: Monad m => Kind (m a) -> m (Kind a) Source #
ExactP Kind |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Kind SrcSpanInfo -> EP ()
Annotated Kind |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Kind l -> l Source # amap :: (l -> l) -> Kind l -> Kind l Source #
Convert Kind (Kind ()) Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Kind -> Kind0 ()
Eq l => Eq (Kind l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Kind l -> Kind l -> Bool Source # (/=) :: Kind l -> Kind l -> Bool Source #
Data l => Data (Kind 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) -> Kind l -> c (Kind l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Kind l) Source #

toConstr :: Kind l -> Constr Source #

dataTypeOf :: Kind l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Kind l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Kind l)) Source #

gmapT :: (forall b. Data b => b -> b) -> Kind l -> Kind l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Kind l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Kind l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Kind l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Kind l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Kind l -> m (Kind l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Kind l -> m (Kind l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Kind l -> m (Kind l) Source #

Ord l => Ord (Kind l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Kind l -> Kind l -> Ordering Source # (<) :: Kind l -> Kind l -> Bool Source # (<=) :: Kind l -> Kind l -> Bool Source # (>) :: Kind l -> Kind l -> Bool Source # (>=) :: Kind l -> Kind l -> Bool Source # max :: Kind l -> Kind l -> Kind l Source # min :: Kind l -> Kind l -> Kind l Source #
Show l => Show (Kind l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Kind l -> ShowS Source # show :: Kind l -> String Source # showList :: [Kind l] -> ShowS Source #
Generic (Kind l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Kind l) :: Type -> Type Source # Methods from :: Kind l -> Rep (Kind l) x Source # to :: Rep (Kind l) x -> Kind l Source #
Pretty (Kind l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Kind l -> Doc prettyPrec :: Int -> Kind l -> Doc
Convert (Kind ()) Kind Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Kind0 () -> Kind
type Rep (Kind l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Kind l) = D1 (MetaData "Kind" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "KindStar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: (C1 (MetaCons "KindFn" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Kind l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Kind l)))) :+: C1 (MetaCons "KindParen" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Kind l))))) :+: ((C1 (MetaCons "KindVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))) :+: C1 (MetaCons "KindApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Kind l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Kind l))))) :+: (C1 (MetaCons "KindTuple" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Kind l])) :+: C1 (MetaCons "KindList" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Kind l))))))

data FunDep l Source #

A functional dependency, given on the form l1 l2 ... ln -> r2 r3 .. rn

Constructors

FunDep l [Name l] [Name l] |

Instances

Functor FunDep |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> FunDep a -> FunDep b Source # (<$) :: a -> FunDep b -> FunDep a Source #
Foldable FunDep |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => FunDep m -> m Source #

foldMap :: Monoid m => (a -> m) -> FunDep a -> m Source #

foldr :: (a -> b -> b) -> b -> FunDep a -> b Source #

foldr' :: (a -> b -> b) -> b -> FunDep a -> b Source #

foldl :: (b -> a -> b) -> b -> FunDep a -> b Source #

foldl' :: (b -> a -> b) -> b -> FunDep a -> b Source #

foldr1 :: (a -> a -> a) -> FunDep a -> a Source #

foldl1 :: (a -> a -> a) -> FunDep a -> a Source #

toList :: FunDep a -> [a] Source #

null :: FunDep a -> Bool Source #

length :: FunDep a -> Int Source #

elem :: Eq a => a -> FunDep a -> Bool Source #

maximum :: Ord a => FunDep a -> a Source #

minimum :: Ord a => FunDep a -> a Source #

sum :: Num a => FunDep a -> a Source #

product :: Num a => FunDep a -> a Source #

Traversable FunDep |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> FunDep a -> f (FunDep b) Source # sequenceA :: Applicative f => FunDep (f a) -> f (FunDep a) Source # mapM :: Monad m => (a -> m b) -> FunDep a -> m (FunDep b) Source # sequence :: Monad m => FunDep (m a) -> m (FunDep a) Source #
ExactP FunDep |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: FunDep SrcSpanInfo -> EP ()
Annotated FunDep |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: FunDep l -> l Source # amap :: (l -> l) -> FunDep l -> FunDep l Source #
Eq l => Eq (FunDep l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: FunDep l -> FunDep l -> Bool Source # (/=) :: FunDep l -> FunDep l -> Bool Source #
Data l => Data (FunDep 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) -> FunDep l -> c (FunDep l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FunDep l) Source #

toConstr :: FunDep l -> Constr Source #

dataTypeOf :: FunDep l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FunDep l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunDep l)) Source #

gmapT :: (forall b. Data b => b -> b) -> FunDep l -> FunDep l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> FunDep l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDep l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l) Source #

Ord l => Ord (FunDep l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: FunDep l -> FunDep l -> Ordering Source # (<) :: FunDep l -> FunDep l -> Bool Source # (<=) :: FunDep l -> FunDep l -> Bool Source # (>) :: FunDep l -> FunDep l -> Bool Source # (>=) :: FunDep l -> FunDep l -> Bool Source # max :: FunDep l -> FunDep l -> FunDep l Source # min :: FunDep l -> FunDep l -> FunDep l Source #
Show l => Show (FunDep l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> FunDep l -> ShowS Source # show :: FunDep l -> String Source # showList :: [FunDep l] -> ShowS Source #
Generic (FunDep l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (FunDep l) :: Type -> Type Source # Methods from :: FunDep l -> Rep (FunDep l) x Source # to :: Rep (FunDep l) x -> FunDep l Source #
Pretty (FunDep l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: FunDep l -> Doc prettyPrec :: Int -> FunDep l -> Doc
type Rep (FunDep l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (FunDep l) = D1 (MetaData "FunDep" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "FunDep" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name l]))))

data Context l Source #

A context is a set of assertions

Constructors

CxSingle l (Asst l) |
CxTuple l [Asst l] |
CxEmpty l |

Instances

Functor Context |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Context a -> Context b Source # (<$) :: a -> Context b -> Context a Source #
Foldable Context |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Context m -> m Source #

foldMap :: Monoid m => (a -> m) -> Context a -> m Source #

foldr :: (a -> b -> b) -> b -> Context a -> b Source #

foldr' :: (a -> b -> b) -> b -> Context a -> b Source #

foldl :: (b -> a -> b) -> b -> Context a -> b Source #

foldl' :: (b -> a -> b) -> b -> Context a -> b Source #

foldr1 :: (a -> a -> a) -> Context a -> a Source #

foldl1 :: (a -> a -> a) -> Context a -> a Source #

toList :: Context a -> [a] Source #

null :: Context a -> Bool Source #

length :: Context a -> Int Source #

elem :: Eq a => a -> Context a -> Bool Source #

maximum :: Ord a => Context a -> a Source #

minimum :: Ord a => Context a -> a Source #

sum :: Num a => Context a -> a Source #

product :: Num a => Context a -> a Source #

Traversable Context |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Context a -> f (Context b) Source # sequenceA :: Applicative f => Context (f a) -> f (Context a) Source # mapM :: Monad m => (a -> m b) -> Context a -> m (Context b) Source # sequence :: Monad m => Context (m a) -> m (Context a) Source #
ExactP Context |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Context SrcSpanInfo -> EP ()
Annotated Context |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Context l -> l Source # amap :: (l -> l) -> Context l -> Context l Source #
Convert Cxt (Context ()) Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Cxt -> Context ()
Eq l => Eq (Context l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Context l -> Context l -> Bool Source # (/=) :: Context l -> Context l -> Bool Source #
Data l => Data (Context 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) -> Context l -> c (Context l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Context l) Source #

toConstr :: Context l -> Constr Source #

dataTypeOf :: Context l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Context l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Context l)) Source #

gmapT :: (forall b. Data b => b -> b) -> Context l -> Context l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Context l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Context l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Context l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Context l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Context l -> m (Context l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Context l -> m (Context l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Context l -> m (Context l) Source #

Ord l => Ord (Context l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Context l -> Context l -> Ordering Source #

(<) :: Context l -> Context l -> Bool Source #

(<=) :: Context l -> Context l -> Bool Source #

(>) :: Context l -> Context l -> Bool Source #

(>=) :: Context l -> Context l -> Bool Source #

max :: Context l -> Context l -> Context l Source #

min :: Context l -> Context l -> Context l Source #

Show l => Show (Context l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Context l -> ShowS Source # show :: Context l -> String Source # showList :: [Context l] -> ShowS Source #
Generic (Context l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Context l) :: Type -> Type Source # Methods from :: Context l -> Rep (Context l) x Source # to :: Rep (Context l) x -> Context l Source #
Pretty (Context l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Context l -> Doc prettyPrec :: Int -> Context l -> Doc
Convert (Maybe (Context ())) Cxt Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Maybe (Context ()) -> Cxt
type Rep (Context l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Context l) = D1 (MetaData "Context" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "CxSingle" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Asst l))) :+: (C1 (MetaCons "CxTuple" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Asst l])) :+: C1 (MetaCons "CxEmpty" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))))

data Asst l Source #

Class assertions. In Haskell 98, the argument would be a tyvar, but this definition allows multiple parameters, and allows them to be types. Also extended with support for implicit parameters and equality constraints.

Constructors

ClassA l (QName l) [Type l] | ordinary class assertion
AppA l (Name l) [Type l] | constraint kind assertion, `Dict :: cxt a => Dict cxt`
InfixA l (Type l) (QName l) (Type l) | class assertion where the class name is given infix
IParam l (IPName l) (Type l) | implicit parameter assertion
EqualP l (Type l) (Type l) | type equality constraint
ParenA l (Asst l) | parenthesised class assertion
WildCardA l (Maybe (Name l)) | Context Wildcard

Instances

Functor Asst |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Asst a -> Asst b Source # (<$) :: a -> Asst b -> Asst a Source #
Foldable Asst |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Asst m -> m Source #

foldMap :: Monoid m => (a -> m) -> Asst a -> m Source #

foldr :: (a -> b -> b) -> b -> Asst a -> b Source #

foldr' :: (a -> b -> b) -> b -> Asst a -> b Source #

foldl :: (b -> a -> b) -> b -> Asst a -> b Source #

foldl' :: (b -> a -> b) -> b -> Asst a -> b Source #

foldr1 :: (a -> a -> a) -> Asst a -> a Source #

foldl1 :: (a -> a -> a) -> Asst a -> a Source #

toList :: Asst a -> [a] Source #

null :: Asst a -> Bool Source #

length :: Asst a -> Int Source #

elem :: Eq a => a -> Asst a -> Bool Source #

maximum :: Ord a => Asst a -> a Source #

minimum :: Ord a => Asst a -> a Source #

sum :: Num a => Asst a -> a Source #

product :: Num a => Asst a -> a Source #

Traversable Asst |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Asst a -> f (Asst b) Source # sequenceA :: Applicative f => Asst (f a) -> f (Asst a) Source # mapM :: Monad m => (a -> m b) -> Asst a -> m (Asst b) Source # sequence :: Monad m => Asst (m a) -> m (Asst a) Source #
ExactP Asst |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Asst SrcSpanInfo -> EP ()
Annotated Asst |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Asst l -> l Source # amap :: (l -> l) -> Asst l -> Asst l Source #
Convert Type (Asst ()) Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Type -> Asst ()
Eq l => Eq (Asst l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Asst l -> Asst l -> Bool Source # (/=) :: Asst l -> Asst l -> Bool Source #
Data l => Data (Asst 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) -> Asst l -> c (Asst l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Asst l) Source #

toConstr :: Asst l -> Constr Source #

dataTypeOf :: Asst l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Asst l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Asst l)) Source #

gmapT :: (forall b. Data b => b -> b) -> Asst l -> Asst l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Asst l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Asst l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Asst l -> m (Asst l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Asst l -> m (Asst l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Asst l -> m (Asst l) Source #

Ord l => Ord (Asst l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Asst l -> Asst l -> Ordering Source # (<) :: Asst l -> Asst l -> Bool Source # (<=) :: Asst l -> Asst l -> Bool Source # (>) :: Asst l -> Asst l -> Bool Source # (>=) :: Asst l -> Asst l -> Bool Source # max :: Asst l -> Asst l -> Asst l Source # min :: Asst l -> Asst l -> Asst l Source #
Show l => Show (Asst l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Asst l -> ShowS Source # show :: Asst l -> String Source # showList :: [Asst l] -> ShowS Source #
Generic (Asst l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Asst l) :: Type -> Type Source # Methods from :: Asst l -> Rep (Asst l) x Source # to :: Rep (Asst l) x -> Asst l Source #
Pretty (Asst l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Asst l -> Doc prettyPrec :: Int -> Asst l -> Doc
Convert (Asst ()) Type Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Asst () -> Type
type Rep (Asst l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Asst l) = D1 (MetaData "Asst" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "ClassA" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type l]))) :+: (C1 (MetaCons "AppA" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type l]))) :+: C1 (MetaCons "InfixA" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))))) :+: ((C1 (MetaCons "IParam" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (IPName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: C1 (MetaCons "EqualP" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))))) :+: (C1 (MetaCons "ParenA" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Asst l))) :+: C1 (MetaCons "WildCardA" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Name l)))))))

data Literal l Source #

literal Values of this type hold the abstract value of the literal, along with the precise string representation used. For example, `10`, `0o12` and `0xa` have the same value representation, but each carry a different string representation.

Constructors

Char l Char String | character literal
String l String String | string literal
Int l Integer String | integer literal
Frac l Rational String | floating point literal
PrimInt l Integer String | unboxed integer literal
PrimWord l Integer String | unboxed word literal
PrimFloat l Rational String | unboxed float literal
PrimDouble l Rational String | unboxed double literal
PrimChar l Char String | unboxed character literal
PrimString l String String | unboxed string literal

Instances

Functor Literal |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Literal a -> Literal b Source # (<$) :: a -> Literal b -> Literal a Source #
Foldable Literal |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Literal m -> m Source #

foldMap :: Monoid m => (a -> m) -> Literal a -> m Source #

foldr :: (a -> b -> b) -> b -> Literal a -> b Source #

foldr' :: (a -> b -> b) -> b -> Literal a -> b Source #

foldl :: (b -> a -> b) -> b -> Literal a -> b Source #

foldl' :: (b -> a -> b) -> b -> Literal a -> b Source #

foldr1 :: (a -> a -> a) -> Literal a -> a Source #

foldl1 :: (a -> a -> a) -> Literal a -> a Source #

toList :: Literal a -> [a] Source #

null :: Literal a -> Bool Source #

length :: Literal a -> Int Source #

elem :: Eq a => a -> Literal a -> Bool Source #

maximum :: Ord a => Literal a -> a Source #

minimum :: Ord a => Literal a -> a Source #

sum :: Num a => Literal a -> a Source #

product :: Num a => Literal a -> a Source #

Traversable Literal |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Literal a -> f (Literal b) Source # sequenceA :: Applicative f => Literal (f a) -> f (Literal a) Source # mapM :: Monad m => (a -> m b) -> Literal a -> m (Literal b) Source # sequence :: Monad m => Literal (m a) -> m (Literal a) Source #
ExactP Literal |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Literal SrcSpanInfo -> EP ()
Annotated Literal |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Literal l -> l Source # amap :: (l -> l) -> Literal l -> Literal l Source #
Eq l => Eq (Literal l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Literal l -> Literal l -> Bool Source # (/=) :: Literal l -> Literal l -> Bool Source #
Data l => Data (Literal 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) -> Literal l -> c (Literal l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Literal l) Source #

toConstr :: Literal l -> Constr Source #

dataTypeOf :: Literal l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Literal l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Literal l)) Source #

gmapT :: (forall b. Data b => b -> b) -> Literal l -> Literal l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Literal l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Literal l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Literal l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Literal l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Literal l -> m (Literal l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Literal l -> m (Literal l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Literal l -> m (Literal l) Source #

Ord l => Ord (Literal l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Literal l -> Literal l -> Ordering Source #

(<) :: Literal l -> Literal l -> Bool Source #

(<=) :: Literal l -> Literal l -> Bool Source #

(>) :: Literal l -> Literal l -> Bool Source #

(>=) :: Literal l -> Literal l -> Bool Source #

max :: Literal l -> Literal l -> Literal l Source #

min :: Literal l -> Literal l -> Literal l Source #

Show l => Show (Literal l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Literal l -> ShowS Source # show :: Literal l -> String Source # showList :: [Literal l] -> ShowS Source #
Generic (Literal l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Literal l) :: Type -> Type Source # Methods from :: Literal l -> Rep (Literal l) x Source # to :: Rep (Literal l) x -> Literal l Source #
Pretty (Literal l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Literal l -> Doc prettyPrec :: Int -> Literal l -> Doc
Convert (Literal ()) Lit Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Literal () -> Lit
type Rep (Literal l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Literal l) = D1 (MetaData "Literal" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (((C1 (MetaCons "Char" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Char) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: C1 (MetaCons "String" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))) :+: (C1 (MetaCons "Int" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: (C1 (MetaCons "Frac" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Rational) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: C1 (MetaCons "PrimInt" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))))) :+: ((C1 (MetaCons "PrimWord" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: C1 (MetaCons "PrimFloat" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Rational) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))) :+: (C1 (MetaCons "PrimDouble" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Rational) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: (C1 (MetaCons "PrimChar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Char) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: C1 (MetaCons "PrimString" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))))))

data Sign l Source #

An indication whether a literal pattern has been negated or not.

Constructors

Signless l |
Negative l |

Instances

Functor Sign |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Sign a -> Sign b Source # (<$) :: a -> Sign b -> Sign a Source #
Foldable Sign |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Sign m -> m Source #

foldMap :: Monoid m => (a -> m) -> Sign a -> m Source #

foldr :: (a -> b -> b) -> b -> Sign a -> b Source #

foldr' :: (a -> b -> b) -> b -> Sign a -> b Source #

foldl :: (b -> a -> b) -> b -> Sign a -> b Source #

foldl' :: (b -> a -> b) -> b -> Sign a -> b Source #

foldr1 :: (a -> a -> a) -> Sign a -> a Source #

foldl1 :: (a -> a -> a) -> Sign a -> a Source #

toList :: Sign a -> [a] Source #

null :: Sign a -> Bool Source #

length :: Sign a -> Int Source #

elem :: Eq a => a -> Sign a -> Bool Source #

maximum :: Ord a => Sign a -> a Source #

minimum :: Ord a => Sign a -> a Source #

sum :: Num a => Sign a -> a Source #

product :: Num a => Sign a -> a Source #

Traversable Sign |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Sign a -> f (Sign b) Source # sequenceA :: Applicative f => Sign (f a) -> f (Sign a) Source # mapM :: Monad m => (a -> m b) -> Sign a -> m (Sign b) Source # sequence :: Monad m => Sign (m a) -> m (Sign a) Source #
ExactP Sign |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Sign SrcSpanInfo -> EP ()
Annotated Sign |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Sign l -> l Source # amap :: (l -> l) -> Sign l -> Sign l Source #
Eq l => Eq (Sign l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Sign l -> Sign l -> Bool Source # (/=) :: Sign l -> Sign l -> Bool Source #
Data l => Data (Sign 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) -> Sign l -> c (Sign l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Sign l) Source #

toConstr :: Sign l -> Constr Source #

dataTypeOf :: Sign l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Sign l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sign l)) Source #

gmapT :: (forall b. Data b => b -> b) -> Sign l -> Sign l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Sign l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Sign l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sign l -> m (Sign l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sign l -> m (Sign l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sign l -> m (Sign l) Source #

Ord l => Ord (Sign l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Sign l -> Sign l -> Ordering Source # (<) :: Sign l -> Sign l -> Bool Source # (<=) :: Sign l -> Sign l -> Bool Source # (>) :: Sign l -> Sign l -> Bool Source # (>=) :: Sign l -> Sign l -> Bool Source # max :: Sign l -> Sign l -> Sign l Source # min :: Sign l -> Sign l -> Sign l Source #
Show l => Show (Sign l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Sign l -> ShowS Source # show :: Sign l -> String Source # showList :: [Sign l] -> ShowS Source #
Generic (Sign l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Sign l) :: Type -> Type Source # Methods from :: Sign l -> Rep (Sign l) x Source # to :: Rep (Sign l) x -> Sign l Source #
type Rep (Sign l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Sign l) = D1 (MetaData "Sign" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "Signless" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "Negative" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)))

data Exp l Source #

Haskell expressions.

Constructors

Var l (QName l) | variable
OverloadedLabel l String | Overloaded label #foo
IPVar l (IPName l) | implicit parameter variable
Con l (QName l) | data constructor
Lit l (Literal l) | literal constant
InfixApp l (Exp l) (QOp l) (Exp l) | infix application
App l (Exp l) (Exp l) | ordinary application
NegApp l (Exp l) | negation expression `-exp` (unary minus)
Lambda l [Pat l] (Exp l) | lambda expression
Let l (Binds l) (Exp l) | local declarations with `let` ... `in` ...
If l (Exp l) (Exp l) (Exp l) | `if` exp `then` exp `else` exp
MultiIf l [GuardedRhs l] | `if` `|` stmts `->` exp ...
Case l (Exp l) [Alt l] | `case` exp `of` alts
Do l [Stmt l] | `do`-expression: the last statement in the list should be an expression.
MDo l [Stmt l] | `mdo`-expression
Tuple l Boxed [Exp l] | tuple expression
UnboxedSum l Int Int (Exp l) | unboxed sum
TupleSection l Boxed [Maybe (Exp l)] | tuple section expression, e.g. `(,,3)`
List l [Exp l] | list expression
ParArray l [Exp l] | parallel array expression
Paren l (Exp l) | parenthesised expression
LeftSection l (Exp l) (QOp l) | left section `(`exp qop`)`
RightSection l (QOp l) (Exp l) | right section `(`qop exp`)`
RecConstr l (QName l) [FieldUpdate l] | record construction expression
RecUpdate l (Exp l) [FieldUpdate l] | record update expression
EnumFrom l (Exp l) | unbounded arithmetic sequence, incrementing by 1: `[from ..]`
EnumFromTo l (Exp l) (Exp l) | bounded arithmetic sequence, incrementing by 1 `[from .. to]`
EnumFromThen l (Exp l) (Exp l) | unbounded arithmetic sequence, with first two elements given `[from, then ..]`
EnumFromThenTo l (Exp l) (Exp l) (Exp l) | bounded arithmetic sequence, with first two elements given `[from, then .. to]`
ParArrayFromTo l (Exp l) (Exp l) | Parallel array bounded arithmetic sequence, incrementing by 1 `[:from .. to:]`
ParArrayFromThenTo l (Exp l) (Exp l) (Exp l) | bounded arithmetic sequence, with first two elements given `[:from, then .. to:]`
ListComp l (Exp l) [QualStmt l] | ordinary list comprehension
ParComp l (Exp l) [[QualStmt l]] | parallel list comprehension
ParArrayComp l (Exp l) [[QualStmt l]] | parallel array comprehension
ExpTypeSig l (Exp l) (Type l) | expression with explicit type signature
VarQuote l (QName l) | `'x` for template haskell reifying of expressions
TypQuote l (QName l) | `''T` for template haskell reifying of types
BracketExp l (Bracket l) | template haskell bracket expression
SpliceExp l (Splice l) | template haskell splice expression
QuasiQuote l String String | quasi-quotaion: `[$name| string |]`
TypeApp l (Type l) | Visible type application
XTag l (XName l) [XAttr l] (Maybe (Exp l)) [Exp l] | xml element, with attributes and children
XETag l (XName l) [XAttr l] (Maybe (Exp l)) | empty xml element, with attributes
XPcdata l String | PCDATA child element
XExpTag l (Exp l) | escaped haskell expression inside xml
XChildTag l [Exp l] | children of an xml element
CorePragma l String (Exp l) | CORE pragma
SCCPragma l String (Exp l) | SCC pragma
GenPragma l String (Int, Int) (Int, Int) (Exp l) | GENERATED pragma
Proc l (Pat l) (Exp l) | arrows proc: `proc` pat `->` exp
LeftArrApp l (Exp l) (Exp l) | arrow application (from left): exp `-<` exp
RightArrApp l (Exp l) (Exp l) | arrow application (from right): exp `>-` exp
LeftArrHighApp l (Exp l) (Exp l) | higher-order arrow application (from left): exp `-<<` exp
RightArrHighApp l (Exp l) (Exp l) | higher-order arrow application (from right): exp `>>-` exp
LCase l [Alt l] | `case` alts

Instances

Functor Exp |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Exp a -> Exp b Source # (<$) :: a -> Exp b -> Exp a Source #
Foldable Exp |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Exp m -> m Source #

foldMap :: Monoid m => (a -> m) -> Exp a -> m Source #

foldr :: (a -> b -> b) -> b -> Exp a -> b Source #

foldr' :: (a -> b -> b) -> b -> Exp a -> b Source #

foldl :: (b -> a -> b) -> b -> Exp a -> b Source #

foldl' :: (b -> a -> b) -> b -> Exp a -> b Source #

foldr1 :: (a -> a -> a) -> Exp a -> a Source #

foldl1 :: (a -> a -> a) -> Exp a -> a Source #

toList :: Exp a -> [a] Source #

null :: Exp a -> Bool Source #

length :: Exp a -> Int Source #

elem :: Eq a => a -> Exp a -> Bool Source #

maximum :: Ord a => Exp a -> a Source #

minimum :: Ord a => Exp a -> a Source #

sum :: Num a => Exp a -> a Source #

product :: Num a => Exp a -> a Source #

Traversable Exp |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Exp a -> f (Exp b) Source # sequenceA :: Applicative f => Exp (f a) -> f (Exp a) Source # mapM :: Monad m => (a -> m b) -> Exp a -> m (Exp b) Source # sequence :: Monad m => Exp (m a) -> m (Exp a) Source #
ExactP Exp |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Exp SrcSpanInfo -> EP ()
AppFixity Exp |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Exp SrcSpanInfo -> m (Exp SrcSpanInfo) Source #
Annotated Exp |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Exp l -> l Source # amap :: (l -> l) -> Exp l -> Exp l Source #
Eq l => Eq (Exp l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Exp l -> Exp l -> Bool Source # (/=) :: Exp l -> Exp l -> Bool Source #
Data l => Data (Exp 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) -> Exp l -> c (Exp l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Exp l) Source #

toConstr :: Exp l -> Constr Source #

dataTypeOf :: Exp l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Exp l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Exp l)) Source #

gmapT :: (forall b. Data b => b -> b) -> Exp l -> Exp l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Exp l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Exp l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Exp l -> m (Exp l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp l -> m (Exp l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp l -> m (Exp l) Source #

Ord l => Ord (Exp l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Exp l -> Exp l -> Ordering Source # (<) :: Exp l -> Exp l -> Bool Source # (<=) :: Exp l -> Exp l -> Bool Source # (>) :: Exp l -> Exp l -> Bool Source # (>=) :: Exp l -> Exp l -> Bool Source # max :: Exp l -> Exp l -> Exp l Source # min :: Exp l -> Exp l -> Exp l Source #
Show l => Show (Exp l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Exp l -> ShowS Source # show :: Exp l -> String Source # showList :: [Exp l] -> ShowS Source #
Generic (Exp l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Exp l) :: Type -> Type Source # Methods from :: Exp l -> Rep (Exp l) x Source # to :: Rep (Exp l) x -> Exp l Source #
Pretty (Exp l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Exp l -> Doc prettyPrec :: Int -> Exp l -> Doc
Convert (Exp ()) Exp Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Exp () -> Exp0
type Rep (Exp l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Exp l) = D1 (MetaData "Exp" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (((((C1 (MetaCons "Var" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))) :+: (C1 (MetaCons "OverloadedLabel" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) :+: C1 (MetaCons "IPVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (IPName l))))) :+: (C1 (MetaCons "Con" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))) :+: (C1 (MetaCons "Lit" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Literal l))) :+: C1 (MetaCons "InfixApp" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QOp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))))))) :+: ((C1 (MetaCons "App" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: (C1 (MetaCons "NegApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :+: C1 (MetaCons "Lambda" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))))) :+: ((C1 (MetaCons "Let" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Binds l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: C1 (MetaCons "If" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))))) :+: (C1 (MetaCons "MultiIf" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [GuardedRhs l])) :+: C1 (MetaCons "Case" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Alt l]))))))) :+: (((C1 (MetaCons "Do" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Stmt l])) :+: (C1 (MetaCons "MDo" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Stmt l])) :+: C1 (MetaCons "Tuple" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Boxed) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp l]))))) :+: ((C1 (MetaCons "UnboxedSum" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: C1 (MetaCons "TupleSection" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Boxed) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Maybe (Exp l)])))) :+: (C1 (MetaCons "List" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp l])) :+: C1 (MetaCons "ParArray" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp l]))))) :+: ((C1 (MetaCons "Paren" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :+: (C1 (MetaCons "LeftSection" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QOp l)))) :+: C1 (MetaCons "RightSection" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QOp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))))) :+: ((C1 (MetaCons "RecConstr" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [FieldUpdate l]))) :+: C1 (MetaCons "RecUpdate" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [FieldUpdate l])))) :+: (C1 (MetaCons "EnumFrom" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :+: C1 (MetaCons "EnumFromTo" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))))))))) :+: ((((C1 (MetaCons "EnumFromThen" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: (C1 (MetaCons "EnumFromThenTo" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: C1 (MetaCons "ParArrayFromTo" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))))) :+: ((C1 (MetaCons "ParArrayFromThenTo" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: C1 (MetaCons "ListComp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [QualStmt l])))) :+: (C1 (MetaCons "ParComp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [[QualStmt l]]))) :+: C1 (MetaCons "ParArrayComp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [[QualStmt l]])))))) :+: ((C1 (MetaCons "ExpTypeSig" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: (C1 (MetaCons "VarQuote" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))) :+: C1 (MetaCons "TypQuote" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))))) :+: ((C1 (MetaCons "BracketExp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Bracket l))) :+: C1 (MetaCons "SpliceExp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Splice l)))) :+: (C1 (MetaCons "QuasiQuote" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: C1 (MetaCons "TypeApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))))))) :+: (((C1 (MetaCons "XTag" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 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 "XETag" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 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))))) :+: C1 (MetaCons "XPcdata" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))) :+: ((C1 (MetaCons "XExpTag" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :+: C1 (MetaCons "XChildTag" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp l]))) :+: (C1 (MetaCons "CorePragma" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: C1 (MetaCons "SCCPragma" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))))))) :+: ((C1 (MetaCons "GenPragma" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Int, Int)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Int, Int)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))))) :+: (C1 (MetaCons "Proc" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: C1 (MetaCons "LeftArrApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))))) :+: ((C1 (MetaCons "RightArrApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: C1 (MetaCons "LeftArrHighApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))))) :+: (C1 (MetaCons "RightArrHighApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: C1 (MetaCons "LCase" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Alt l]))))))))

data XName l Source #

The name of an xml element or attribute, possibly qualified with a namespace.

Constructors

XName l String |
XDomName l String String |

Instances

Functor XName |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> XName a -> XName b Source # (<$) :: a -> XName b -> XName a Source #
Foldable XName |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => XName m -> m Source #

foldMap :: Monoid m => (a -> m) -> XName a -> m Source #

foldr :: (a -> b -> b) -> b -> XName a -> b Source #

foldr' :: (a -> b -> b) -> b -> XName a -> b Source #

foldl :: (b -> a -> b) -> b -> XName a -> b Source #

foldl' :: (b -> a -> b) -> b -> XName a -> b Source #

foldr1 :: (a -> a -> a) -> XName a -> a Source #

foldl1 :: (a -> a -> a) -> XName a -> a Source #

toList :: XName a -> [a] Source #

null :: XName a -> Bool Source #

length :: XName a -> Int Source #

elem :: Eq a => a -> XName a -> Bool Source #

maximum :: Ord a => XName a -> a Source #

minimum :: Ord a => XName a -> a Source #

sum :: Num a => XName a -> a Source #

product :: Num a => XName a -> a Source #

Traversable XName |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> XName a -> f (XName b) Source # sequenceA :: Applicative f => XName (f a) -> f (XName a) Source # mapM :: Monad m => (a -> m b) -> XName a -> m (XName b) Source # sequence :: Monad m => XName (m a) -> m (XName a) Source #
ExactP XName |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: XName SrcSpanInfo -> EP ()
Annotated XName |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: XName l -> l Source # amap :: (l -> l) -> XName l -> XName l Source #
Eq l => Eq (XName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: XName l -> XName l -> Bool Source # (/=) :: XName l -> XName l -> Bool Source #
Data l => Data (XName 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) -> XName l -> c (XName l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (XName l) Source #

toConstr :: XName l -> Constr Source #

dataTypeOf :: XName l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (XName l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XName l)) Source #

gmapT :: (forall b. Data b => b -> b) -> XName l -> XName l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> XName l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> XName l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> XName l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> XName l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> XName l -> m (XName l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> XName l -> m (XName l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> XName l -> m (XName l) Source #

Ord l => Ord (XName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: XName l -> XName l -> Ordering Source # (<) :: XName l -> XName l -> Bool Source # (<=) :: XName l -> XName l -> Bool Source # (>) :: XName l -> XName l -> Bool Source # (>=) :: XName l -> XName l -> Bool Source # max :: XName l -> XName l -> XName l Source # min :: XName l -> XName l -> XName l Source #
Show l => Show (XName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> XName l -> ShowS Source # show :: XName l -> String Source # showList :: [XName l] -> ShowS Source #
Generic (XName l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (XName l) :: Type -> Type Source # Methods from :: XName l -> Rep (XName l) x Source # to :: Rep (XName l) x -> XName l Source #
Pretty (XName l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: XName l -> Doc prettyPrec :: Int -> XName l -> Doc
type Rep (XName l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (XName l) = D1 (MetaData "XName" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "XName" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) :+: C1 (MetaCons "XDomName" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))))

data XAttr l Source #

An xml attribute, which is a name-expression pair.

Constructors

XAttr l (XName l) (Exp l) |

Instances

Functor XAttr |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> XAttr a -> XAttr b Source # (<$) :: a -> XAttr b -> XAttr a Source #
Foldable XAttr |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => XAttr m -> m Source #

foldMap :: Monoid m => (a -> m) -> XAttr a -> m Source #

foldr :: (a -> b -> b) -> b -> XAttr a -> b Source #

foldr' :: (a -> b -> b) -> b -> XAttr a -> b Source #

foldl :: (b -> a -> b) -> b -> XAttr a -> b Source #

foldl' :: (b -> a -> b) -> b -> XAttr a -> b Source #

foldr1 :: (a -> a -> a) -> XAttr a -> a Source #

foldl1 :: (a -> a -> a) -> XAttr a -> a Source #

toList :: XAttr a -> [a] Source #

null :: XAttr a -> Bool Source #

length :: XAttr a -> Int Source #

elem :: Eq a => a -> XAttr a -> Bool Source #

maximum :: Ord a => XAttr a -> a Source #

minimum :: Ord a => XAttr a -> a Source #

sum :: Num a => XAttr a -> a Source #

product :: Num a => XAttr a -> a Source #

Traversable XAttr |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> XAttr a -> f (XAttr b) Source # sequenceA :: Applicative f => XAttr (f a) -> f (XAttr a) Source # mapM :: Monad m => (a -> m b) -> XAttr a -> m (XAttr b) Source # sequence :: Monad m => XAttr (m a) -> m (XAttr a) Source #
ExactP XAttr |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: XAttr SrcSpanInfo -> EP ()
AppFixity XAttr |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> XAttr SrcSpanInfo -> m (XAttr SrcSpanInfo) Source #
Annotated XAttr |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: XAttr l -> l Source # amap :: (l -> l) -> XAttr l -> XAttr l Source #
Eq l => Eq (XAttr l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: XAttr l -> XAttr l -> Bool Source # (/=) :: XAttr l -> XAttr l -> Bool Source #
Data l => Data (XAttr 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) -> XAttr l -> c (XAttr l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (XAttr l) Source #

toConstr :: XAttr l -> Constr Source #

dataTypeOf :: XAttr l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (XAttr l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XAttr l)) Source #

gmapT :: (forall b. Data b => b -> b) -> XAttr l -> XAttr l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> XAttr l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> XAttr l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> XAttr l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> XAttr l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l) Source #

Ord l => Ord (XAttr l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: XAttr l -> XAttr l -> Ordering Source # (<) :: XAttr l -> XAttr l -> Bool Source # (<=) :: XAttr l -> XAttr l -> Bool Source # (>) :: XAttr l -> XAttr l -> Bool Source # (>=) :: XAttr l -> XAttr l -> Bool Source # max :: XAttr l -> XAttr l -> XAttr l Source # min :: XAttr l -> XAttr l -> XAttr l Source #
Show l => Show (XAttr l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> XAttr l -> ShowS Source # show :: XAttr l -> String Source # showList :: [XAttr l] -> ShowS Source #
Generic (XAttr l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (XAttr l) :: Type -> Type Source # Methods from :: XAttr l -> Rep (XAttr l) x Source # to :: Rep (XAttr l) x -> XAttr l Source #
Pretty (XAttr l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: XAttr l -> Doc prettyPrec :: Int -> XAttr l -> Doc
type Rep (XAttr l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (XAttr l) = D1 (MetaData "XAttr" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "XAttr" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (XName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))))

data Bracket l Source #

A template haskell bracket expression.

Constructors

ExpBracket l (Exp l) | expression bracket: `[| ... |]`
PatBracket l (Pat l) | pattern bracket: `[p| ... |]`
TypeBracket l (Type l) | type bracket: `[t| ... |]`
DeclBracket l [Decl l] | declaration bracket: `[d| ... |]`

Instances

Functor Bracket |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Bracket a -> Bracket b Source # (<$) :: a -> Bracket b -> Bracket a Source #
Foldable Bracket |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Bracket m -> m Source #

foldMap :: Monoid m => (a -> m) -> Bracket a -> m Source #

foldr :: (a -> b -> b) -> b -> Bracket a -> b Source #

foldr' :: (a -> b -> b) -> b -> Bracket a -> b Source #

foldl :: (b -> a -> b) -> b -> Bracket a -> b Source #

foldl' :: (b -> a -> b) -> b -> Bracket a -> b Source #

foldr1 :: (a -> a -> a) -> Bracket a -> a Source #

foldl1 :: (a -> a -> a) -> Bracket a -> a Source #

toList :: Bracket a -> [a] Source #

null :: Bracket a -> Bool Source #

length :: Bracket a -> Int Source #

elem :: Eq a => a -> Bracket a -> Bool Source #

maximum :: Ord a => Bracket a -> a Source #

minimum :: Ord a => Bracket a -> a Source #

sum :: Num a => Bracket a -> a Source #

product :: Num a => Bracket a -> a Source #

Traversable Bracket |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Bracket a -> f (Bracket b) Source # sequenceA :: Applicative f => Bracket (f a) -> f (Bracket a) Source # mapM :: Monad m => (a -> m b) -> Bracket a -> m (Bracket b) Source # sequence :: Monad m => Bracket (m a) -> m (Bracket a) Source #
ExactP Bracket |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Bracket SrcSpanInfo -> EP ()
AppFixity Bracket |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Bracket SrcSpanInfo -> m (Bracket SrcSpanInfo) Source #
Annotated Bracket |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Bracket l -> l Source # amap :: (l -> l) -> Bracket l -> Bracket l Source #
Eq l => Eq (Bracket l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Bracket l -> Bracket l -> Bool Source # (/=) :: Bracket l -> Bracket l -> Bool Source #
Data l => Data (Bracket 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) -> Bracket l -> c (Bracket l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Bracket l) Source #

toConstr :: Bracket l -> Constr Source #

dataTypeOf :: Bracket l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Bracket l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Bracket l)) Source #

gmapT :: (forall b. Data b => b -> b) -> Bracket l -> Bracket l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bracket l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bracket l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Bracket l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Bracket l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l) Source #

Ord l => Ord (Bracket l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Bracket l -> Bracket l -> Ordering Source #

(<) :: Bracket l -> Bracket l -> Bool Source #

(<=) :: Bracket l -> Bracket l -> Bool Source #

(>) :: Bracket l -> Bracket l -> Bool Source #

(>=) :: Bracket l -> Bracket l -> Bool Source #

max :: Bracket l -> Bracket l -> Bracket l Source #

min :: Bracket l -> Bracket l -> Bracket l Source #

Show l => Show (Bracket l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Bracket l -> ShowS Source # show :: Bracket l -> String Source # showList :: [Bracket l] -> ShowS Source #
Generic (Bracket l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Bracket l) :: Type -> Type Source # Methods from :: Bracket l -> Rep (Bracket l) x Source # to :: Rep (Bracket l) x -> Bracket l Source #
Pretty (Bracket l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Bracket l -> Doc prettyPrec :: Int -> Bracket l -> Doc
type Rep (Bracket l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Bracket l) = D1 (MetaData "Bracket" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "ExpBracket" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :+: C1 (MetaCons "PatBracket" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)))) :+: (C1 (MetaCons "TypeBracket" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))) :+: C1 (MetaCons "DeclBracket" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Decl l]))))

data Splice l Source #

A template haskell splice expression

Constructors

IdSplice l String | variable splice: `$var`
ParenSplice l (Exp l) | parenthesised expression splice: `$(exp)`

Instances

Functor Splice |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Splice a -> Splice b Source # (<$) :: a -> Splice b -> Splice a Source #
Foldable Splice |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Splice m -> m Source #

foldMap :: Monoid m => (a -> m) -> Splice a -> m Source #

foldr :: (a -> b -> b) -> b -> Splice a -> b Source #

foldr' :: (a -> b -> b) -> b -> Splice a -> b Source #

foldl :: (b -> a -> b) -> b -> Splice a -> b Source #

foldl' :: (b -> a -> b) -> b -> Splice a -> b Source #

foldr1 :: (a -> a -> a) -> Splice a -> a Source #

foldl1 :: (a -> a -> a) -> Splice a -> a Source #

toList :: Splice a -> [a] Source #

null :: Splice a -> Bool Source #

length :: Splice a -> Int Source #

elem :: Eq a => a -> Splice a -> Bool Source #

maximum :: Ord a => Splice a -> a Source #

minimum :: Ord a => Splice a -> a Source #

sum :: Num a => Splice a -> a Source #

product :: Num a => Splice a -> a Source #

Traversable Splice |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Splice a -> f (Splice b) Source # sequenceA :: Applicative f => Splice (f a) -> f (Splice a) Source # mapM :: Monad m => (a -> m b) -> Splice a -> m (Splice b) Source # sequence :: Monad m => Splice (m a) -> m (Splice a) Source #
ExactP Splice |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Splice SrcSpanInfo -> EP ()
AppFixity Splice |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Splice SrcSpanInfo -> m (Splice SrcSpanInfo) Source #
Annotated Splice |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Splice l -> l Source # amap :: (l -> l) -> Splice l -> Splice l Source #
Eq l => Eq (Splice l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Splice l -> Splice l -> Bool Source # (/=) :: Splice l -> Splice l -> Bool Source #
Data l => Data (Splice 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) -> Splice l -> c (Splice l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Splice l) Source #

toConstr :: Splice l -> Constr Source #

dataTypeOf :: Splice l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Splice l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Splice l)) Source #

gmapT :: (forall b. Data b => b -> b) -> Splice l -> Splice l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Splice l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Splice l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Splice l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Splice l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Splice l -> m (Splice l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Splice l -> m (Splice l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Splice l -> m (Splice l) Source #

Ord l => Ord (Splice l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Splice l -> Splice l -> Ordering Source # (<) :: Splice l -> Splice l -> Bool Source # (<=) :: Splice l -> Splice l -> Bool Source # (>) :: Splice l -> Splice l -> Bool Source # (>=) :: Splice l -> Splice l -> Bool Source # max :: Splice l -> Splice l -> Splice l Source # min :: Splice l -> Splice l -> Splice l Source #
Show l => Show (Splice l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Splice l -> ShowS Source # show :: Splice l -> String Source # showList :: [Splice l] -> ShowS Source #
Generic (Splice l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Splice l) :: Type -> Type Source # Methods from :: Splice l -> Rep (Splice l) x Source # to :: Rep (Splice l) x -> Splice l Source #
Pretty (Splice l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Splice l -> Doc prettyPrec :: Int -> Splice l -> Doc
type Rep (Splice l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Splice l) = D1 (MetaData "Splice" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "IdSplice" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) :+: C1 (MetaCons "ParenSplice" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))))

data Safety l Source #

The safety of a foreign function call.

Constructors

PlayRisky l | unsafe
PlaySafe l Bool | safe (`False`) or threadsafe (`True`)
PlayInterruptible l | interruptible

Instances

Functor Safety |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Safety a -> Safety b Source # (<$) :: a -> Safety b -> Safety a Source #
Foldable Safety |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Safety m -> m Source #

foldMap :: Monoid m => (a -> m) -> Safety a -> m Source #

foldr :: (a -> b -> b) -> b -> Safety a -> b Source #

foldr' :: (a -> b -> b) -> b -> Safety a -> b Source #

foldl :: (b -> a -> b) -> b -> Safety a -> b Source #

foldl' :: (b -> a -> b) -> b -> Safety a -> b Source #

foldr1 :: (a -> a -> a) -> Safety a -> a Source #

foldl1 :: (a -> a -> a) -> Safety a -> a Source #

toList :: Safety a -> [a] Source #

null :: Safety a -> Bool Source #

length :: Safety a -> Int Source #

elem :: Eq a => a -> Safety a -> Bool Source #

maximum :: Ord a => Safety a -> a Source #

minimum :: Ord a => Safety a -> a Source #

sum :: Num a => Safety a -> a Source #

product :: Num a => Safety a -> a Source #

Traversable Safety |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Safety a -> f (Safety b) Source # sequenceA :: Applicative f => Safety (f a) -> f (Safety a) Source # mapM :: Monad m => (a -> m b) -> Safety a -> m (Safety b) Source # sequence :: Monad m => Safety (m a) -> m (Safety a) Source #
ExactP Safety |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Safety SrcSpanInfo -> EP ()
Annotated Safety |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Safety l -> l Source # amap :: (l -> l) -> Safety l -> Safety l Source #
Eq l => Eq (Safety l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Safety l -> Safety l -> Bool Source # (/=) :: Safety l -> Safety l -> Bool Source #
Data l => Data (Safety 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) -> Safety l -> c (Safety l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Safety l) Source #

toConstr :: Safety l -> Constr Source #

dataTypeOf :: Safety l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Safety l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Safety l)) Source #

gmapT :: (forall b. Data b => b -> b) -> Safety l -> Safety l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Safety l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Safety l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Safety l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Safety l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Safety l -> m (Safety l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety l -> m (Safety l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety l -> m (Safety l) Source #

Ord l => Ord (Safety l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Safety l -> Safety l -> Ordering Source # (<) :: Safety l -> Safety l -> Bool Source # (<=) :: Safety l -> Safety l -> Bool Source # (>) :: Safety l -> Safety l -> Bool Source # (>=) :: Safety l -> Safety l -> Bool Source # max :: Safety l -> Safety l -> Safety l Source # min :: Safety l -> Safety l -> Safety l Source #
Show l => Show (Safety l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Safety l -> ShowS Source # show :: Safety l -> String Source # showList :: [Safety l] -> ShowS Source #
Generic (Safety l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Safety l) :: Type -> Type Source # Methods from :: Safety l -> Rep (Safety l) x Source # to :: Rep (Safety l) x -> Safety l Source #
Pretty (Safety l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Safety l -> Doc prettyPrec :: Int -> Safety l -> Doc
type Rep (Safety l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Safety l) = D1 (MetaData "Safety" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "PlayRisky" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: (C1 (MetaCons "PlaySafe" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool)) :+: C1 (MetaCons "PlayInterruptible" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))))

data CallConv l Source #

The calling convention of a foreign function call.

Constructors

StdCall l |
CCall l |
CPlusPlus l |
DotNet l |
Jvm l |
Js l |
JavaScript l |
CApi l |

Instances

Functor CallConv |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> CallConv a -> CallConv b Source # (<$) :: a -> CallConv b -> CallConv a Source #
Foldable CallConv |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => CallConv m -> m Source #

foldMap :: Monoid m => (a -> m) -> CallConv a -> m Source #

foldr :: (a -> b -> b) -> b -> CallConv a -> b Source #

foldr' :: (a -> b -> b) -> b -> CallConv a -> b Source #

foldl :: (b -> a -> b) -> b -> CallConv a -> b Source #

foldl' :: (b -> a -> b) -> b -> CallConv a -> b Source #

foldr1 :: (a -> a -> a) -> CallConv a -> a Source #

foldl1 :: (a -> a -> a) -> CallConv a -> a Source #

toList :: CallConv a -> [a] Source #

null :: CallConv a -> Bool Source #

length :: CallConv a -> Int Source #

elem :: Eq a => a -> CallConv a -> Bool Source #

maximum :: Ord a => CallConv a -> a Source #

minimum :: Ord a => CallConv a -> a Source #

sum :: Num a => CallConv a -> a Source #

product :: Num a => CallConv a -> a Source #

Traversable CallConv |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> CallConv a -> f (CallConv b) Source # sequenceA :: Applicative f => CallConv (f a) -> f (CallConv a) Source # mapM :: Monad m => (a -> m b) -> CallConv a -> m (CallConv b) Source # sequence :: Monad m => CallConv (m a) -> m (CallConv a) Source #
ExactP CallConv |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: CallConv SrcSpanInfo -> EP ()
Annotated CallConv |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: CallConv l -> l Source # amap :: (l -> l) -> CallConv l -> CallConv l Source #
Eq l => Eq (CallConv l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: CallConv l -> CallConv l -> Bool Source # (/=) :: CallConv l -> CallConv l -> Bool Source #
Data l => Data (CallConv 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) -> CallConv l -> c (CallConv l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CallConv l) Source #

toConstr :: CallConv l -> Constr Source #

dataTypeOf :: CallConv l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (CallConv l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CallConv l)) Source #

gmapT :: (forall b. Data b => b -> b) -> CallConv l -> CallConv l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CallConv l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CallConv l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> CallConv l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CallConv l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l) Source #

Ord l => Ord (CallConv l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: CallConv l -> CallConv l -> Ordering Source #

(<) :: CallConv l -> CallConv l -> Bool Source #

(<=) :: CallConv l -> CallConv l -> Bool Source #

(>) :: CallConv l -> CallConv l -> Bool Source #

(>=) :: CallConv l -> CallConv l -> Bool Source #

max :: CallConv l -> CallConv l -> CallConv l Source #

min :: CallConv l -> CallConv l -> CallConv l Source #

Show l => Show (CallConv l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> CallConv l -> ShowS Source # show :: CallConv l -> String Source # showList :: [CallConv l] -> ShowS Source #
Generic (CallConv l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (CallConv l) :: Type -> Type Source # Methods from :: CallConv l -> Rep (CallConv l) x Source # to :: Rep (CallConv l) x -> CallConv l Source #
Pretty (CallConv l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: CallConv l -> Doc prettyPrec :: Int -> CallConv l -> Doc
type Rep (CallConv l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (CallConv l) = D1 (MetaData "CallConv" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (((C1 (MetaCons "StdCall" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "CCall" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))) :+: (C1 (MetaCons "CPlusPlus" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "DotNet" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)))) :+: ((C1 (MetaCons "Jvm" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "Js" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))) :+: (C1 (MetaCons "JavaScript" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "CApi" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)))))

data ModulePragma l Source #

A top level options pragma, preceding the module header.

Constructors

LanguagePragma l [Name l] | LANGUAGE pragma
OptionsPragma l (Maybe Tool) String | OPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHC
AnnModulePragma l (Annotation l) | ANN pragma with module scope

Instances

Functor ModulePragma |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> ModulePragma a -> ModulePragma b Source # (<$) :: a -> ModulePragma b -> ModulePragma a Source #
Foldable ModulePragma |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ModulePragma m -> m Source #

foldMap :: Monoid m => (a -> m) -> ModulePragma a -> m Source #

foldr :: (a -> b -> b) -> b -> ModulePragma a -> b Source #

foldr' :: (a -> b -> b) -> b -> ModulePragma a -> b Source #

foldl :: (b -> a -> b) -> b -> ModulePragma a -> b Source #

foldl' :: (b -> a -> b) -> b -> ModulePragma a -> b Source #

foldr1 :: (a -> a -> a) -> ModulePragma a -> a Source #

foldl1 :: (a -> a -> a) -> ModulePragma a -> a Source #

toList :: ModulePragma a -> [a] Source #

null :: ModulePragma a -> Bool Source #

length :: ModulePragma a -> Int Source #

elem :: Eq a => a -> ModulePragma a -> Bool Source #

maximum :: Ord a => ModulePragma a -> a Source #

minimum :: Ord a => ModulePragma a -> a Source #

sum :: Num a => ModulePragma a -> a Source #

product :: Num a => ModulePragma a -> a Source #

Traversable ModulePragma |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> ModulePragma a -> f (ModulePragma b) Source # sequenceA :: Applicative f => ModulePragma (f a) -> f (ModulePragma a) Source # mapM :: Monad m => (a -> m b) -> ModulePragma a -> m (ModulePragma b) Source # sequence :: Monad m => ModulePragma (m a) -> m (ModulePragma a) Source #
ExactP ModulePragma |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: ModulePragma SrcSpanInfo -> EP ()
Annotated ModulePragma |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ModulePragma l -> l Source # amap :: (l -> l) -> ModulePragma l -> ModulePragma l Source #
Eq l => Eq (ModulePragma l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: ModulePragma l -> ModulePragma l -> Bool Source # (/=) :: ModulePragma l -> ModulePragma l -> Bool Source #
Data l => Data (ModulePragma 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) -> ModulePragma l -> c (ModulePragma l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ModulePragma l) Source #

toConstr :: ModulePragma l -> Constr Source #

dataTypeOf :: ModulePragma l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ModulePragma l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ModulePragma l)) Source #

gmapT :: (forall b. Data b => b -> b) -> ModulePragma l -> ModulePragma l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ModulePragma l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModulePragma l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModulePragma l -> m (ModulePragma l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModulePragma l -> m (ModulePragma l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModulePragma l -> m (ModulePragma l) Source #

Ord l => Ord (ModulePragma l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: ModulePragma l -> ModulePragma l -> Ordering Source #

(<) :: ModulePragma l -> ModulePragma l -> Bool Source #

(<=) :: ModulePragma l -> ModulePragma l -> Bool Source #

(>) :: ModulePragma l -> ModulePragma l -> Bool Source #

(>=) :: ModulePragma l -> ModulePragma l -> Bool Source #

max :: ModulePragma l -> ModulePragma l -> ModulePragma l Source #

min :: ModulePragma l -> ModulePragma l -> ModulePragma l Source #

Show l => Show (ModulePragma l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> ModulePragma l -> ShowS Source # show :: ModulePragma l -> String Source # showList :: [ModulePragma l] -> ShowS Source #
Generic (ModulePragma l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ModulePragma l) :: Type -> Type Source # Methods from :: ModulePragma l -> Rep (ModulePragma l) x Source # to :: Rep (ModulePragma l) x -> ModulePragma l Source #
Parseable (NonGreedy (ListOf (ModulePragma SrcSpanInfo))) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

parse :: String -> ParseResult (NonGreedy (ListOf (ModulePragma SrcSpanInfo))) Source #

parseWithMode :: ParseMode -> String -> ParseResult (NonGreedy (ListOf (ModulePragma SrcSpanInfo))) Source #

parseWithComments :: ParseMode -> String -> ParseResult (NonGreedy (ListOf (ModulePragma SrcSpanInfo)), [Comment]) Source #

parser :: Maybe [Fixity] -> P (NonGreedy (ListOf (ModulePragma SrcSpanInfo)))

Pretty (ModulePragma l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: ModulePragma l -> Doc prettyPrec :: Int -> ModulePragma l -> Doc
type Rep (ModulePragma l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (ModulePragma l) = D1 (MetaData "ModulePragma" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "LanguagePragma" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name l])) :+: (C1 (MetaCons "OptionsPragma" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Tool)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: C1 (MetaCons "AnnModulePragma" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Annotation l)))))

data Tool Source #

Recognised tools for OPTIONS pragmas.

Constructors

GHC |
HUGS |
NHC98 |
YHC |
HADDOCK |
UnknownTool String |

Instances

Eq Tool |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Tool -> Tool -> Bool Source # (/=) :: Tool -> Tool -> Bool Source #
Data Tool |

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) -> Tool -> c Tool Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Tool Source #

toConstr :: Tool -> Constr Source #

dataTypeOf :: Tool -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Tool) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tool) Source #

gmapT :: (forall b. Data b => b -> b) -> Tool -> Tool Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Tool -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Tool -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Tool -> m Tool Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Tool -> m Tool Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Tool -> m Tool Source #

Ord Tool |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Tool -> Tool -> Ordering Source # (<) :: Tool -> Tool -> Bool Source # (<=) :: Tool -> Tool -> Bool Source # (>) :: Tool -> Tool -> Bool Source # (>=) :: Tool -> Tool -> Bool Source # max :: Tool -> Tool -> Tool Source # min :: Tool -> Tool -> Tool Source #
Show Tool |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Tool -> ShowS Source # show :: Tool -> String Source # showList :: [Tool] -> ShowS Source #
Generic Tool |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep Tool :: Type -> Type Source # Methods from :: Tool -> Rep Tool x Source # to :: Rep Tool x -> Tool Source #
Pretty Tool |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Tool -> Doc prettyPrec :: Int -> Tool -> Doc
type Rep Tool |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep Tool = D1 (MetaData "Tool" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "GHC" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "HUGS" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "NHC98" PrefixI False) (U1 :: Type -> Type))) :+: (C1 (MetaCons "YHC" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "HADDOCK" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "UnknownTool" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))))

data Overlap l Source #

Recognised overlaps for overlap pragmas.

Constructors

NoOverlap l | NO_OVERLAP pragma
Overlap l | OVERLAP pragma
Overlapping l |
Overlaps l |
Overlappable l |
Incoherent l | INCOHERENT pragma

Instances

Functor Overlap |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Overlap a -> Overlap b Source # (<$) :: a -> Overlap b -> Overlap a Source #
Foldable Overlap |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Overlap m -> m Source #

foldMap :: Monoid m => (a -> m) -> Overlap a -> m Source #

foldr :: (a -> b -> b) -> b -> Overlap a -> b Source #

foldr' :: (a -> b -> b) -> b -> Overlap a -> b Source #

foldl :: (b -> a -> b) -> b -> Overlap a -> b Source #

foldl' :: (b -> a -> b) -> b -> Overlap a -> b Source #

foldr1 :: (a -> a -> a) -> Overlap a -> a Source #

foldl1 :: (a -> a -> a) -> Overlap a -> a Source #

toList :: Overlap a -> [a] Source #

null :: Overlap a -> Bool Source #

length :: Overlap a -> Int Source #

elem :: Eq a => a -> Overlap a -> Bool Source #

maximum :: Ord a => Overlap a -> a Source #

minimum :: Ord a => Overlap a -> a Source #

sum :: Num a => Overlap a -> a Source #

product :: Num a => Overlap a -> a Source #

Traversable Overlap |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Overlap a -> f (Overlap b) Source # sequenceA :: Applicative f => Overlap (f a) -> f (Overlap a) Source # mapM :: Monad m => (a -> m b) -> Overlap a -> m (Overlap b) Source # sequence :: Monad m => Overlap (m a) -> m (Overlap a) Source #
ExactP Overlap |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Overlap SrcSpanInfo -> EP ()
Annotated Overlap |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Overlap l -> l Source # amap :: (l -> l) -> Overlap l -> Overlap l Source #
Eq l => Eq (Overlap l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Overlap l -> Overlap l -> Bool Source # (/=) :: Overlap l -> Overlap l -> Bool Source #
Data l => Data (Overlap 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) -> Overlap l -> c (Overlap l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Overlap l) Source #

toConstr :: Overlap l -> Constr Source #

dataTypeOf :: Overlap l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Overlap l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Overlap l)) Source #

gmapT :: (forall b. Data b => b -> b) -> Overlap l -> Overlap l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Overlap l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Overlap l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Overlap l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Overlap l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l) Source #

Ord l => Ord (Overlap l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Overlap l -> Overlap l -> Ordering Source #

(<) :: Overlap l -> Overlap l -> Bool Source #

(<=) :: Overlap l -> Overlap l -> Bool Source #

(>) :: Overlap l -> Overlap l -> Bool Source #

(>=) :: Overlap l -> Overlap l -> Bool Source #

max :: Overlap l -> Overlap l -> Overlap l Source #

min :: Overlap l -> Overlap l -> Overlap l Source #

Show l => Show (Overlap l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Overlap l -> ShowS Source # show :: Overlap l -> String Source # showList :: [Overlap l] -> ShowS Source #
Generic (Overlap l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Overlap l) :: Type -> Type Source # Methods from :: Overlap l -> Rep (Overlap l) x Source # to :: Rep (Overlap l) x -> Overlap l Source #
Pretty (Overlap l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Overlap l -> Doc prettyPrec :: Int -> Overlap l -> Doc
type Rep (Overlap l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Overlap l) = D1 (MetaData "Overlap" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "NoOverlap" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: (C1 (MetaCons "Overlap" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "Overlapping" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)))) :+: (C1 (MetaCons "Overlaps" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: (C1 (MetaCons "Overlappable" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "Incoherent" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)))))

data Activation l Source #

Activation clause of a RULES pragma.

Constructors

ActiveFrom l Int |
ActiveUntil l Int |

Instances

Functor Activation |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Activation a -> Activation b Source # (<$) :: a -> Activation b -> Activation a Source #
Foldable Activation |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Activation m -> m Source #

foldMap :: Monoid m => (a -> m) -> Activation a -> m Source #

foldr :: (a -> b -> b) -> b -> Activation a -> b Source #

foldr' :: (a -> b -> b) -> b -> Activation a -> b Source #

foldl :: (b -> a -> b) -> b -> Activation a -> b Source #

foldl' :: (b -> a -> b) -> b -> Activation a -> b Source #

foldr1 :: (a -> a -> a) -> Activation a -> a Source #

foldl1 :: (a -> a -> a) -> Activation a -> a Source #

toList :: Activation a -> [a] Source #

null :: Activation a -> Bool Source #

length :: Activation a -> Int Source #

elem :: Eq a => a -> Activation a -> Bool Source #

maximum :: Ord a => Activation a -> a Source #

minimum :: Ord a => Activation a -> a Source #

sum :: Num a => Activation a -> a Source #

product :: Num a => Activation a -> a Source #

Traversable Activation |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Activation a -> f (Activation b) Source # sequenceA :: Applicative f => Activation (f a) -> f (Activation a) Source # mapM :: Monad m => (a -> m b) -> Activation a -> m (Activation b) Source # sequence :: Monad m => Activation (m a) -> m (Activation a) Source #
ExactP Activation |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Activation SrcSpanInfo -> EP ()
Annotated Activation |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Activation l -> l Source # amap :: (l -> l) -> Activation l -> Activation l Source #
Eq l => Eq (Activation l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Activation l -> Activation l -> Bool Source # (/=) :: Activation l -> Activation l -> Bool Source #
Data l => Data (Activation 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) -> Activation l -> c (Activation l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Activation l) Source #

toConstr :: Activation l -> Constr Source #

dataTypeOf :: Activation l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Activation l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Activation l)) Source #

gmapT :: (forall b. Data b => b -> b) -> Activation l -> Activation l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Activation l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Activation l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Activation l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Activation l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Activation l -> m (Activation l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Activation l -> m (Activation l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Activation l -> m (Activation l) Source #

Ord l => Ord (Activation l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Activation l -> Activation l -> Ordering Source #

(<) :: Activation l -> Activation l -> Bool Source #

(<=) :: Activation l -> Activation l -> Bool Source #

(>) :: Activation l -> Activation l -> Bool Source #

(>=) :: Activation l -> Activation l -> Bool Source #

max :: Activation l -> Activation l -> Activation l Source #

min :: Activation l -> Activation l -> Activation l Source #

Show l => Show (Activation l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Activation l -> ShowS Source # show :: Activation l -> String Source # showList :: [Activation l] -> ShowS Source #
Generic (Activation l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Activation l) :: Type -> Type Source # Methods from :: Activation l -> Rep (Activation l) x Source # to :: Rep (Activation l) x -> Activation l Source #
Pretty (Activation l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Activation l -> Doc prettyPrec :: Int -> Activation l -> Doc
type Rep (Activation l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Activation l) = D1 (MetaData "Activation" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "ActiveFrom" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)) :+: C1 (MetaCons "ActiveUntil" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))

data Rule l Source #

The body of a RULES pragma.

Constructors

Rule l String (Maybe (Activation l)) (Maybe [RuleVar l]) (Exp l) (Exp l) |

Instances

Functor Rule |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Rule a -> Rule b Source # (<$) :: a -> Rule b -> Rule a Source #
Foldable Rule |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Rule m -> m Source #

foldMap :: Monoid m => (a -> m) -> Rule a -> m Source #

foldr :: (a -> b -> b) -> b -> Rule a -> b Source #

foldr' :: (a -> b -> b) -> b -> Rule a -> b Source #

foldl :: (b -> a -> b) -> b -> Rule a -> b Source #

foldl' :: (b -> a -> b) -> b -> Rule a -> b Source #

foldr1 :: (a -> a -> a) -> Rule a -> a Source #

foldl1 :: (a -> a -> a) -> Rule a -> a Source #

toList :: Rule a -> [a] Source #

null :: Rule a -> Bool Source #

length :: Rule a -> Int Source #

elem :: Eq a => a -> Rule a -> Bool Source #

maximum :: Ord a => Rule a -> a Source #

minimum :: Ord a => Rule a -> a Source #

sum :: Num a => Rule a -> a Source #

product :: Num a => Rule a -> a Source #

Traversable Rule |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Rule a -> f (Rule b) Source # sequenceA :: Applicative f => Rule (f a) -> f (Rule a) Source # mapM :: Monad m => (a -> m b) -> Rule a -> m (Rule b) Source # sequence :: Monad m => Rule (m a) -> m (Rule a) Source #
ExactP Rule |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Rule SrcSpanInfo -> EP ()
Annotated Rule |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Rule l -> l Source # amap :: (l -> l) -> Rule l -> Rule l Source #
Eq l => Eq (Rule l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Rule l -> Rule l -> Bool Source # (/=) :: Rule l -> Rule l -> Bool Source #
Data l => Data (Rule 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) -> Rule l -> c (Rule l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Rule l) Source #

toConstr :: Rule l -> Constr Source #

dataTypeOf :: Rule l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Rule l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rule l)) Source #

gmapT :: (forall b. Data b => b -> b) -> Rule l -> Rule l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Rule l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Rule l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Rule l -> m (Rule l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Rule l -> m (Rule l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Rule l -> m (Rule l) Source #

Ord l => Ord (Rule l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Rule l -> Rule l -> Ordering Source # (<) :: Rule l -> Rule l -> Bool Source # (<=) :: Rule l -> Rule l -> Bool Source # (>) :: Rule l -> Rule l -> Bool Source # (>=) :: Rule l -> Rule l -> Bool Source # max :: Rule l -> Rule l -> Rule l Source # min :: Rule l -> Rule l -> Rule l Source #
Show l => Show (Rule l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Rule l -> ShowS Source # show :: Rule l -> String Source # showList :: [Rule l] -> ShowS Source #
Generic (Rule l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Rule l) :: Type -> Type Source # Methods from :: Rule l -> Rep (Rule l) x Source # to :: Rep (Rule l) x -> Rule l Source #
Pretty (Rule l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Rule l -> Doc prettyPrec :: Int -> Rule l -> Doc
type Rep (Rule l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Rule l) = D1 (MetaData "Rule" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "Rule" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Activation l))))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe [RuleVar l])) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))))))

data RuleVar l Source #

Variables used in a RULES pragma, optionally annotated with types

Constructors

RuleVar l (Name l) |
TypedRuleVar l (Name l) (Type l) |

Instances

Functor RuleVar |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> RuleVar a -> RuleVar b Source # (<$) :: a -> RuleVar b -> RuleVar a Source #
Foldable RuleVar |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => RuleVar m -> m Source #

foldMap :: Monoid m => (a -> m) -> RuleVar a -> m Source #

foldr :: (a -> b -> b) -> b -> RuleVar a -> b Source #

foldr' :: (a -> b -> b) -> b -> RuleVar a -> b Source #

foldl :: (b -> a -> b) -> b -> RuleVar a -> b Source #

foldl' :: (b -> a -> b) -> b -> RuleVar a -> b Source #

foldr1 :: (a -> a -> a) -> RuleVar a -> a Source #

foldl1 :: (a -> a -> a) -> RuleVar a -> a Source #

toList :: RuleVar a -> [a] Source #

null :: RuleVar a -> Bool Source #

length :: RuleVar a -> Int Source #

elem :: Eq a => a -> RuleVar a -> Bool Source #

maximum :: Ord a => RuleVar a -> a Source #

minimum :: Ord a => RuleVar a -> a Source #

sum :: Num a => RuleVar a -> a Source #

product :: Num a => RuleVar a -> a Source #

Traversable RuleVar |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> RuleVar a -> f (RuleVar b) Source # sequenceA :: Applicative f => RuleVar (f a) -> f (RuleVar a) Source # mapM :: Monad m => (a -> m b) -> RuleVar a -> m (RuleVar b) Source # sequence :: Monad m => RuleVar (m a) -> m (RuleVar a) Source #
ExactP RuleVar |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: RuleVar SrcSpanInfo -> EP ()
Annotated RuleVar |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: RuleVar l -> l Source # amap :: (l -> l) -> RuleVar l -> RuleVar l Source #
Eq l => Eq (RuleVar l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: RuleVar l -> RuleVar l -> Bool Source # (/=) :: RuleVar l -> RuleVar l -> Bool Source #
Data l => Data (RuleVar 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) -> RuleVar l -> c (RuleVar l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleVar l) Source #

toConstr :: RuleVar l -> Constr Source #

dataTypeOf :: RuleVar l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleVar l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RuleVar l)) Source #

gmapT :: (forall b. Data b => b -> b) -> RuleVar l -> RuleVar l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleVar l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleVar l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> RuleVar l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleVar l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l) Source #

Ord l => Ord (RuleVar l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: RuleVar l -> RuleVar l -> Ordering Source #

(<) :: RuleVar l -> RuleVar l -> Bool Source #

(<=) :: RuleVar l -> RuleVar l -> Bool Source #

(>) :: RuleVar l -> RuleVar l -> Bool Source #

(>=) :: RuleVar l -> RuleVar l -> Bool Source #

max :: RuleVar l -> RuleVar l -> RuleVar l Source #

min :: RuleVar l -> RuleVar l -> RuleVar l Source #

Show l => Show (RuleVar l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> RuleVar l -> ShowS Source # show :: RuleVar l -> String Source # showList :: [RuleVar l] -> ShowS Source #
Generic (RuleVar l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (RuleVar l) :: Type -> Type Source # Methods from :: RuleVar l -> Rep (RuleVar l) x Source # to :: Rep (RuleVar l) x -> RuleVar l Source #
Pretty (RuleVar l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: RuleVar l -> Doc prettyPrec :: Int -> RuleVar l -> Doc
type Rep (RuleVar l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (RuleVar l) = D1 (MetaData "RuleVar" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "RuleVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))) :+: C1 (MetaCons "TypedRuleVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))))

data WarningText l Source #

Warning text to optionally use in the module header of e.g. a deprecated module.

Constructors

DeprText l String |
WarnText l String |

Instances

Functor WarningText |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> WarningText a -> WarningText b Source # (<$) :: a -> WarningText b -> WarningText a Source #
Foldable WarningText |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => WarningText m -> m Source #

foldMap :: Monoid m => (a -> m) -> WarningText a -> m Source #

foldr :: (a -> b -> b) -> b -> WarningText a -> b Source #

foldr' :: (a -> b -> b) -> b -> WarningText a -> b Source #

foldl :: (b -> a -> b) -> b -> WarningText a -> b Source #

foldl' :: (b -> a -> b) -> b -> WarningText a -> b Source #

foldr1 :: (a -> a -> a) -> WarningText a -> a Source #

foldl1 :: (a -> a -> a) -> WarningText a -> a Source #

toList :: WarningText a -> [a] Source #

null :: WarningText a -> Bool Source #

length :: WarningText a -> Int Source #

elem :: Eq a => a -> WarningText a -> Bool Source #

maximum :: Ord a => WarningText a -> a Source #

minimum :: Ord a => WarningText a -> a Source #

sum :: Num a => WarningText a -> a Source #

product :: Num a => WarningText a -> a Source #

Traversable WarningText |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> WarningText a -> f (WarningText b) Source # sequenceA :: Applicative f => WarningText (f a) -> f (WarningText a) Source # mapM :: Monad m => (a -> m b) -> WarningText a -> m (WarningText b) Source # sequence :: Monad m => WarningText (m a) -> m (WarningText a) Source #
ExactP WarningText |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: WarningText SrcSpanInfo -> EP ()
Annotated WarningText |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: WarningText l -> l Source # amap :: (l -> l) -> WarningText l -> WarningText l Source #
Eq l => Eq (WarningText l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: WarningText l -> WarningText l -> Bool Source # (/=) :: WarningText l -> WarningText l -> Bool Source #
Data l => Data (WarningText 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) -> WarningText l -> c (WarningText l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarningText l) Source #

toConstr :: WarningText l -> Constr Source #

dataTypeOf :: WarningText l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WarningText l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WarningText l)) Source #

gmapT :: (forall b. Data b => b -> b) -> WarningText l -> WarningText l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarningText l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarningText l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> WarningText l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> WarningText l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarningText l -> m (WarningText l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarningText l -> m (WarningText l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarningText l -> m (WarningText l) Source #

Ord l => Ord (WarningText l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: WarningText l -> WarningText l -> Ordering Source #

(<) :: WarningText l -> WarningText l -> Bool Source #

(<=) :: WarningText l -> WarningText l -> Bool Source #

(>) :: WarningText l -> WarningText l -> Bool Source #

(>=) :: WarningText l -> WarningText l -> Bool Source #

max :: WarningText l -> WarningText l -> WarningText l Source #

min :: WarningText l -> WarningText l -> WarningText l Source #

Show l => Show (WarningText l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> WarningText l -> ShowS Source # show :: WarningText l -> String Source # showList :: [WarningText l] -> ShowS Source #
Generic (WarningText l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (WarningText l) :: Type -> Type Source # Methods from :: WarningText l -> Rep (WarningText l) x Source # to :: Rep (WarningText l) x -> WarningText l Source #
type Rep (WarningText l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (WarningText l) = D1 (MetaData "WarningText" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "DeprText" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) :+: C1 (MetaCons "WarnText" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))

data Pat l Source #

A pattern, to be matched against a value.

Constructors

PVar l (Name l) | variable
PLit l (Sign l) (Literal l) | literal constant
PNPlusK l (Name l) Integer | n+k pattern
PInfixApp l (Pat l) (QName l) (Pat l) | pattern with an infix data constructor
PApp l (QName l) [Pat l] | data constructor and argument patterns
PTuple l Boxed [Pat l] | tuple pattern
PUnboxedSum l Int Int (Pat l) | unboxed sum
PList l [Pat l] | list pattern
PParen l (Pat l) | parenthesized pattern
PRec l (QName l) [PatField l] | labelled pattern, record style
PAsPat l (Name l) (Pat l) | `@`-pattern
PWildCard l | wildcard pattern: `_`
PIrrPat l (Pat l) | irrefutable pattern: `~pat`
PatTypeSig l (Pat l) (Type l) | pattern with type signature
PViewPat l (Exp l) (Pat l) | view patterns of the form `(exp -> pat)`
PRPat l [RPat l] | regular list pattern
PXTag l (XName l) [PXAttr l] (Maybe (Pat l)) [Pat l] | XML element pattern
PXETag l (XName l) [PXAttr l] (Maybe (Pat l)) | XML singleton element pattern
PXPcdata l String | XML PCDATA pattern
PXPatTag l (Pat l) | XML embedded pattern
PXRPats l [RPat l] | XML regular list pattern
PSplice l (Splice l) | template haskell splice pattern
PQuasiQuote l String String | quasi quote pattern: `[$name| string |]`
PBangPat l (Pat l) | strict (bang) pattern: `f !x = ...`

Instances

Functor Pat |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Pat a -> Pat b Source # (<$) :: a -> Pat b -> Pat a Source #
Foldable Pat |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Pat m -> m Source #

foldMap :: Monoid m => (a -> m) -> Pat a -> m Source #

foldr :: (a -> b -> b) -> b -> Pat a -> b Source #

foldr' :: (a -> b -> b) -> b -> Pat a -> b Source #

foldl :: (b -> a -> b) -> b -> Pat a -> b Source #

foldl' :: (b -> a -> b) -> b -> Pat a -> b Source #

foldr1 :: (a -> a -> a) -> Pat a -> a Source #

foldl1 :: (a -> a -> a) -> Pat a -> a Source #

toList :: Pat a -> [a] Source #

null :: Pat a -> Bool Source #

length :: Pat a -> Int Source #

elem :: Eq a => a -> Pat a -> Bool Source #

maximum :: Ord a => Pat a -> a Source #

minimum :: Ord a => Pat a -> a Source #

sum :: Num a => Pat a -> a Source #

product :: Num a => Pat a -> a Source #

Traversable Pat |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Pat a -> f (Pat b) Source # sequenceA :: Applicative f => Pat (f a) -> f (Pat a) Source # mapM :: Monad m => (a -> m b) -> Pat a -> m (Pat b) Source # sequence :: Monad m => Pat (m a) -> m (Pat a) Source #
ExactP Pat |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Pat SrcSpanInfo -> EP ()
AppFixity Pat |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Pat SrcSpanInfo -> m (Pat SrcSpanInfo) Source #
Annotated Pat |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Pat l -> l Source # amap :: (l -> l) -> Pat l -> Pat l Source #
Eq l => Eq (Pat l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Pat l -> Pat l -> Bool Source # (/=) :: Pat l -> Pat l -> Bool Source #
Data l => Data (Pat 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) -> Pat l -> c (Pat l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Pat l) Source #

toConstr :: Pat l -> Constr Source #

dataTypeOf :: Pat l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Pat l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Pat l)) Source #

gmapT :: (forall b. Data b => b -> b) -> Pat l -> Pat l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Pat l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Pat l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pat l -> m (Pat l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat l -> m (Pat l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat l -> m (Pat l) Source #

Ord l => Ord (Pat l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Pat l -> Pat l -> Ordering Source # (<) :: Pat l -> Pat l -> Bool Source # (<=) :: Pat l -> Pat l -> Bool Source # (>) :: Pat l -> Pat l -> Bool Source # (>=) :: Pat l -> Pat l -> Bool Source # max :: Pat l -> Pat l -> Pat l Source # min :: Pat l -> Pat l -> Pat l Source #
Show l => Show (Pat l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Pat l -> ShowS Source # show :: Pat l -> String Source # showList :: [Pat l] -> ShowS Source #
Generic (Pat l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Pat l) :: Type -> Type Source # Methods from :: Pat l -> Rep (Pat l) x Source # to :: Rep (Pat l) x -> Pat l Source #
Pretty (Pat l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Pat l -> Doc prettyPrec :: Int -> Pat l -> Doc
Convert (Pat ()) Pat Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Pat () -> Pat0
type Rep (Pat l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Pat l) = D1 (MetaData "Pat" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((((C1 (MetaCons "PVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))) :+: (C1 (MetaCons "PLit" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Sign l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Literal l)))) :+: C1 (MetaCons "PNPlusK" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer))))) :+: (C1 (MetaCons "PInfixApp" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)))) :+: (C1 (MetaCons "PApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat l]))) :+: C1 (MetaCons "PTuple" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Boxed) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat l])))))) :+: ((C1 (MetaCons "PUnboxedSum" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)))) :+: (C1 (MetaCons "PList" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat l])) :+: C1 (MetaCons "PParen" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l))))) :+: (C1 (MetaCons "PRec" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [PatField l]))) :+: (C1 (MetaCons "PAsPat" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)))) :+: C1 (MetaCons "PWildCard" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)))))) :+: (((C1 (MetaCons "PIrrPat" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l))) :+: (C1 (MetaCons "PatTypeSig" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: C1 (MetaCons "PViewPat" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)))))) :+: (C1 (MetaCons "PRPat" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [RPat l])) :+: (C1 (MetaCons "PXTag" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (XName l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [PXAttr l]) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Pat l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat l])))) :+: C1 (MetaCons "PXETag" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (XName l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [PXAttr l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Pat l)))))))) :+: ((C1 (MetaCons "PXPcdata" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) :+: (C1 (MetaCons "PXPatTag" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l))) :+: C1 (MetaCons "PXRPats" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [RPat l])))) :+: (C1 (MetaCons "PSplice" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Splice l))) :+: (C1 (MetaCons "PQuasiQuote" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: C1 (MetaCons "PBangPat" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l))))))))

data PXAttr l Source #

An XML attribute in a pattern.

Constructors

PXAttr l (XName l) (Pat l) |

Instances

Functor PXAttr |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> PXAttr a -> PXAttr b Source # (<$) :: a -> PXAttr b -> PXAttr a Source #
Foldable PXAttr |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => PXAttr m -> m Source #

foldMap :: Monoid m => (a -> m) -> PXAttr a -> m Source #

foldr :: (a -> b -> b) -> b -> PXAttr a -> b Source #

foldr' :: (a -> b -> b) -> b -> PXAttr a -> b Source #

foldl :: (b -> a -> b) -> b -> PXAttr a -> b Source #

foldl' :: (b -> a -> b) -> b -> PXAttr a -> b Source #

foldr1 :: (a -> a -> a) -> PXAttr a -> a Source #

foldl1 :: (a -> a -> a) -> PXAttr a -> a Source #

toList :: PXAttr a -> [a] Source #

null :: PXAttr a -> Bool Source #

length :: PXAttr a -> Int Source #

elem :: Eq a => a -> PXAttr a -> Bool Source #

maximum :: Ord a => PXAttr a -> a Source #

minimum :: Ord a => PXAttr a -> a Source #

sum :: Num a => PXAttr a -> a Source #

product :: Num a => PXAttr a -> a Source #

Traversable PXAttr |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> PXAttr a -> f (PXAttr b) Source # sequenceA :: Applicative f => PXAttr (f a) -> f (PXAttr a) Source # mapM :: Monad m => (a -> m b) -> PXAttr a -> m (PXAttr b) Source # sequence :: Monad m => PXAttr (m a) -> m (PXAttr a) Source #
ExactP PXAttr |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: PXAttr SrcSpanInfo -> EP ()
AppFixity PXAttr |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> PXAttr SrcSpanInfo -> m (PXAttr SrcSpanInfo) Source #
Annotated PXAttr |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: PXAttr l -> l Source # amap :: (l -> l) -> PXAttr l -> PXAttr l Source #
Eq l => Eq (PXAttr l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: PXAttr l -> PXAttr l -> Bool Source # (/=) :: PXAttr l -> PXAttr l -> Bool Source #
Data l => Data (PXAttr 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) -> PXAttr l -> c (PXAttr l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (PXAttr l) Source #

toConstr :: PXAttr l -> Constr Source #

dataTypeOf :: PXAttr l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (PXAttr l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PXAttr l)) Source #

gmapT :: (forall b. Data b => b -> b) -> PXAttr l -> PXAttr l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PXAttr l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PXAttr l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> PXAttr l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PXAttr l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l) Source #

Ord l => Ord (PXAttr l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: PXAttr l -> PXAttr l -> Ordering Source # (<) :: PXAttr l -> PXAttr l -> Bool Source # (<=) :: PXAttr l -> PXAttr l -> Bool Source # (>) :: PXAttr l -> PXAttr l -> Bool Source # (>=) :: PXAttr l -> PXAttr l -> Bool Source # max :: PXAttr l -> PXAttr l -> PXAttr l Source # min :: PXAttr l -> PXAttr l -> PXAttr l Source #
Show l => Show (PXAttr l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> PXAttr l -> ShowS Source # show :: PXAttr l -> String Source # showList :: [PXAttr l] -> ShowS Source #
Generic (PXAttr l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (PXAttr l) :: Type -> Type Source # Methods from :: PXAttr l -> Rep (PXAttr l) x Source # to :: Rep (PXAttr l) x -> PXAttr l Source #
Pretty (PXAttr l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: PXAttr l -> Doc prettyPrec :: Int -> PXAttr l -> Doc
type Rep (PXAttr l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (PXAttr l) = D1 (MetaData "PXAttr" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "PXAttr" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (XName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)))))

data RPatOp l Source #

A regular pattern operator.

Constructors

RPStar l | `*` = 0 or more
RPStarG l | `*!` = 0 or more, greedy
RPPlus l | `+` = 1 or more
RPPlusG l | `+!` = 1 or more, greedy
RPOpt l | `?` = 0 or 1
RPOptG l | `?!` = 0 or 1, greedy

Instances

Functor RPatOp |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> RPatOp a -> RPatOp b Source # (<$) :: a -> RPatOp b -> RPatOp a Source #
Foldable RPatOp |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => RPatOp m -> m Source #

foldMap :: Monoid m => (a -> m) -> RPatOp a -> m Source #

foldr :: (a -> b -> b) -> b -> RPatOp a -> b Source #

foldr' :: (a -> b -> b) -> b -> RPatOp a -> b Source #

foldl :: (b -> a -> b) -> b -> RPatOp a -> b Source #

foldl' :: (b -> a -> b) -> b -> RPatOp a -> b Source #

foldr1 :: (a -> a -> a) -> RPatOp a -> a Source #

foldl1 :: (a -> a -> a) -> RPatOp a -> a Source #

toList :: RPatOp a -> [a] Source #

null :: RPatOp a -> Bool Source #

length :: RPatOp a -> Int Source #

elem :: Eq a => a -> RPatOp a -> Bool Source #

maximum :: Ord a => RPatOp a -> a Source #

minimum :: Ord a => RPatOp a -> a Source #

sum :: Num a => RPatOp a -> a Source #

product :: Num a => RPatOp a -> a Source #

Traversable RPatOp |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> RPatOp a -> f (RPatOp b) Source # sequenceA :: Applicative f => RPatOp (f a) -> f (RPatOp a) Source # mapM :: Monad m => (a -> m b) -> RPatOp a -> m (RPatOp b) Source # sequence :: Monad m => RPatOp (m a) -> m (RPatOp a) Source #
ExactP RPatOp |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: RPatOp SrcSpanInfo -> EP ()
Annotated RPatOp |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: RPatOp l -> l Source # amap :: (l -> l) -> RPatOp l -> RPatOp l Source #
Eq l => Eq (RPatOp l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: RPatOp l -> RPatOp l -> Bool Source # (/=) :: RPatOp l -> RPatOp l -> Bool Source #
Data l => Data (RPatOp 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) -> RPatOp l -> c (RPatOp l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RPatOp l) Source #

toConstr :: RPatOp l -> Constr Source #

dataTypeOf :: RPatOp l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RPatOp l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPatOp l)) Source #

gmapT :: (forall b. Data b => b -> b) -> RPatOp l -> RPatOp l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RPatOp l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RPatOp l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> RPatOp l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RPatOp l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l) Source #

Ord l => Ord (RPatOp l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: RPatOp l -> RPatOp l -> Ordering Source # (<) :: RPatOp l -> RPatOp l -> Bool Source # (<=) :: RPatOp l -> RPatOp l -> Bool Source # (>) :: RPatOp l -> RPatOp l -> Bool Source # (>=) :: RPatOp l -> RPatOp l -> Bool Source # max :: RPatOp l -> RPatOp l -> RPatOp l Source # min :: RPatOp l -> RPatOp l -> RPatOp l Source #
Show l => Show (RPatOp l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> RPatOp l -> ShowS Source # show :: RPatOp l -> String Source # showList :: [RPatOp l] -> ShowS Source #
Generic (RPatOp l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (RPatOp l) :: Type -> Type Source # Methods from :: RPatOp l -> Rep (RPatOp l) x Source # to :: Rep (RPatOp l) x -> RPatOp l Source #
Pretty (RPatOp l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: RPatOp l -> Doc prettyPrec :: Int -> RPatOp l -> Doc
type Rep (RPatOp l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (RPatOp l) = D1 (MetaData "RPatOp" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "RPStar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: (C1 (MetaCons "RPStarG" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "RPPlus" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)))) :+: (C1 (MetaCons "RPPlusG" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: (C1 (MetaCons "RPOpt" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "RPOptG" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)))))

data RPat l Source #

An entity in a regular pattern.

Constructors

RPOp l (RPat l) (RPatOp l) | operator pattern, e.g. pat*
RPEither l (RPat l) (RPat l) | choice pattern, e.g. (1 | 2)
RPSeq l [RPat l] | sequence pattern, e.g. (| 1, 2, 3 |)
RPGuard l (Pat l) [Stmt l] | guarded pattern, e.g. (| p | p < 3 |)
RPCAs l (Name l) (RPat l) | non-linear variable binding, e.g. (foo@:(1 | 2))*
RPAs l (Name l) (RPat l) | linear variable binding, e.g. foo@(1 | 2)
RPParen l (RPat l) | parenthesised pattern, e.g. (2*)
RPPat l (Pat l) | an ordinary pattern

Instances

Functor RPat |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> RPat a -> RPat b Source # (<$) :: a -> RPat b -> RPat a Source #
Foldable RPat |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => RPat m -> m Source #

foldMap :: Monoid m => (a -> m) -> RPat a -> m Source #

foldr :: (a -> b -> b) -> b -> RPat a -> b Source #

foldr' :: (a -> b -> b) -> b -> RPat a -> b Source #

foldl :: (b -> a -> b) -> b -> RPat a -> b Source #

foldl' :: (b -> a -> b) -> b -> RPat a -> b Source #

foldr1 :: (a -> a -> a) -> RPat a -> a Source #

foldl1 :: (a -> a -> a) -> RPat a -> a Source #

toList :: RPat a -> [a] Source #

null :: RPat a -> Bool Source #

length :: RPat a -> Int Source #

elem :: Eq a => a -> RPat a -> Bool Source #

maximum :: Ord a => RPat a -> a Source #

minimum :: Ord a => RPat a -> a Source #

sum :: Num a => RPat a -> a Source #

product :: Num a => RPat a -> a Source #

Traversable RPat |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> RPat a -> f (RPat b) Source # sequenceA :: Applicative f => RPat (f a) -> f (RPat a) Source # mapM :: Monad m => (a -> m b) -> RPat a -> m (RPat b) Source # sequence :: Monad m => RPat (m a) -> m (RPat a) Source #
ExactP RPat |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: RPat SrcSpanInfo -> EP ()
AppFixity RPat |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> RPat SrcSpanInfo -> m (RPat SrcSpanInfo) Source #
Annotated RPat |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: RPat l -> l Source # amap :: (l -> l) -> RPat l -> RPat l Source #
Eq l => Eq (RPat l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: RPat l -> RPat l -> Bool Source # (/=) :: RPat l -> RPat l -> Bool Source #
Data l => Data (RPat 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) -> RPat l -> c (RPat l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RPat l) Source #

toConstr :: RPat l -> Constr Source #

dataTypeOf :: RPat l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RPat l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPat l)) Source #

gmapT :: (forall b. Data b => b -> b) -> RPat l -> RPat l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> RPat l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RPat l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RPat l -> m (RPat l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RPat l -> m (RPat l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RPat l -> m (RPat l) Source #

Ord l => Ord (RPat l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: RPat l -> RPat l -> Ordering Source # (<) :: RPat l -> RPat l -> Bool Source # (<=) :: RPat l -> RPat l -> Bool Source # (>) :: RPat l -> RPat l -> Bool Source # (>=) :: RPat l -> RPat l -> Bool Source # max :: RPat l -> RPat l -> RPat l Source # min :: RPat l -> RPat l -> RPat l Source #
Show l => Show (RPat l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> RPat l -> ShowS Source # show :: RPat l -> String Source # showList :: [RPat l] -> ShowS Source #
Generic (RPat l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (RPat l) :: Type -> Type Source # Methods from :: RPat l -> Rep (RPat l) x Source # to :: Rep (RPat l) x -> RPat l Source #
Pretty (RPat l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: RPat l -> Doc prettyPrec :: Int -> RPat l -> Doc
type Rep (RPat l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (RPat l) = D1 (MetaData "RPat" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (((C1 (MetaCons "RPOp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (RPat l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (RPatOp l)))) :+: C1 (MetaCons "RPEither" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (RPat l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (RPat l))))) :+: (C1 (MetaCons "RPSeq" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [RPat l])) :+: C1 (MetaCons "RPGuard" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Stmt l]))))) :+: ((C1 (MetaCons "RPCAs" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (RPat l)))) :+: C1 (MetaCons "RPAs" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (RPat l))))) :+: (C1 (MetaCons "RPParen" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (RPat l))) :+: C1 (MetaCons "RPPat" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l))))))

data PatField l Source #

An fpat in a labeled record pattern.

Constructors

PFieldPat l (QName l) (Pat l) | ordinary label-pattern pair
PFieldPun l (QName l) | record field pun
PFieldWildcard l | record field wildcard

Instances

Functor PatField |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> PatField a -> PatField b Source # (<$) :: a -> PatField b -> PatField a Source #
Foldable PatField |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => PatField m -> m Source #

foldMap :: Monoid m => (a -> m) -> PatField a -> m Source #

foldr :: (a -> b -> b) -> b -> PatField a -> b Source #

foldr' :: (a -> b -> b) -> b -> PatField a -> b Source #

foldl :: (b -> a -> b) -> b -> PatField a -> b Source #

foldl' :: (b -> a -> b) -> b -> PatField a -> b Source #

foldr1 :: (a -> a -> a) -> PatField a -> a Source #

foldl1 :: (a -> a -> a) -> PatField a -> a Source #

toList :: PatField a -> [a] Source #

null :: PatField a -> Bool Source #

length :: PatField a -> Int Source #

elem :: Eq a => a -> PatField a -> Bool Source #

maximum :: Ord a => PatField a -> a Source #

minimum :: Ord a => PatField a -> a Source #

sum :: Num a => PatField a -> a Source #

product :: Num a => PatField a -> a Source #

Traversable PatField |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> PatField a -> f (PatField b) Source # sequenceA :: Applicative f => PatField (f a) -> f (PatField a) Source # mapM :: Monad m => (a -> m b) -> PatField a -> m (PatField b) Source # sequence :: Monad m => PatField (m a) -> m (PatField a) Source #
ExactP PatField |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: PatField SrcSpanInfo -> EP ()
AppFixity PatField |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> PatField SrcSpanInfo -> m (PatField SrcSpanInfo) Source #
Annotated PatField |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: PatField l -> l Source # amap :: (l -> l) -> PatField l -> PatField l Source #
Eq l => Eq (PatField l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: PatField l -> PatField l -> Bool Source # (/=) :: PatField l -> PatField l -> Bool Source #
Data l => Data (PatField 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) -> PatField l -> c (PatField l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (PatField l) Source #

toConstr :: PatField l -> Constr Source #

dataTypeOf :: PatField l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (PatField l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PatField l)) Source #

gmapT :: (forall b. Data b => b -> b) -> PatField l -> PatField l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PatField l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PatField l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> PatField l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PatField l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PatField l -> m (PatField l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PatField l -> m (PatField l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PatField l -> m (PatField l) Source #

Ord l => Ord (PatField l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: PatField l -> PatField l -> Ordering Source #

(<) :: PatField l -> PatField l -> Bool Source #

(<=) :: PatField l -> PatField l -> Bool Source #

(>) :: PatField l -> PatField l -> Bool Source #

(>=) :: PatField l -> PatField l -> Bool Source #

max :: PatField l -> PatField l -> PatField l Source #

min :: PatField l -> PatField l -> PatField l Source #

Show l => Show (PatField l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> PatField l -> ShowS Source # show :: PatField l -> String Source # showList :: [PatField l] -> ShowS Source #
Generic (PatField l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (PatField l) :: Type -> Type Source # Methods from :: PatField l -> Rep (PatField l) x Source # to :: Rep (PatField l) x -> PatField l Source #
Pretty (PatField l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: PatField l -> Doc prettyPrec :: Int -> PatField l -> Doc
Convert (PatField ()) FieldPat Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: PatField () -> FieldPat
type Rep (PatField l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (PatField l) = D1 (MetaData "PatField" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "PFieldPat" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)))) :+: (C1 (MetaCons "PFieldPun" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))) :+: C1 (MetaCons "PFieldWildcard" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))))

data Stmt l Source #

A statement, representing both a stmt in a `do`-expression, an ordinary qual in a list comprehension, as well as a stmt in a pattern guard.

Constructors

Generator l (Pat l) (Exp l) | a generator: pat `<-` exp
Qualifier l (Exp l) | an exp by itself: in a `do`-expression, an action whose result is discarded; in a list comprehension and pattern guard, a guard expression
LetStmt l (Binds l) | local bindings
RecStmt l [Stmt l] | a recursive binding group for arrows

Instances

Functor Stmt |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Stmt a -> Stmt b Source # (<$) :: a -> Stmt b -> Stmt a Source #
Foldable Stmt |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Stmt m -> m Source #

foldMap :: Monoid m => (a -> m) -> Stmt a -> m Source #

foldr :: (a -> b -> b) -> b -> Stmt a -> b Source #

foldr' :: (a -> b -> b) -> b -> Stmt a -> b Source #

foldl :: (b -> a -> b) -> b -> Stmt a -> b Source #

foldl' :: (b -> a -> b) -> b -> Stmt a -> b Source #

foldr1 :: (a -> a -> a) -> Stmt a -> a Source #

foldl1 :: (a -> a -> a) -> Stmt a -> a Source #

toList :: Stmt a -> [a] Source #

null :: Stmt a -> Bool Source #

length :: Stmt a -> Int Source #

elem :: Eq a => a -> Stmt a -> Bool Source #

maximum :: Ord a => Stmt a -> a Source #

minimum :: Ord a => Stmt a -> a Source #

sum :: Num a => Stmt a -> a Source #

product :: Num a => Stmt a -> a Source #

Traversable Stmt |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Stmt a -> f (Stmt b) Source # sequenceA :: Applicative f => Stmt (f a) -> f (Stmt a) Source # mapM :: Monad m => (a -> m b) -> Stmt a -> m (Stmt b) Source # sequence :: Monad m => Stmt (m a) -> m (Stmt a) Source #
ExactP Stmt |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Stmt SrcSpanInfo -> EP ()
AppFixity Stmt |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Stmt SrcSpanInfo -> m (Stmt SrcSpanInfo) Source #
Annotated Stmt |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Stmt l -> l Source # amap :: (l -> l) -> Stmt l -> Stmt l Source #
Eq l => Eq (Stmt l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Stmt l -> Stmt l -> Bool Source # (/=) :: Stmt l -> Stmt l -> Bool Source #
Data l => Data (Stmt 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) -> Stmt l -> c (Stmt l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Stmt l) Source #

toConstr :: Stmt l -> Constr Source #

dataTypeOf :: Stmt l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Stmt l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Stmt l)) Source #

gmapT :: (forall b. Data b => b -> b) -> Stmt l -> Stmt l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Stmt l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Stmt l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l) Source #

Ord l => Ord (Stmt l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Stmt l -> Stmt l -> Ordering Source # (<) :: Stmt l -> Stmt l -> Bool Source # (<=) :: Stmt l -> Stmt l -> Bool Source # (>) :: Stmt l -> Stmt l -> Bool Source # (>=) :: Stmt l -> Stmt l -> Bool Source # max :: Stmt l -> Stmt l -> Stmt l Source # min :: Stmt l -> Stmt l -> Stmt l Source #
Show l => Show (Stmt l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Stmt l -> ShowS Source # show :: Stmt l -> String Source # showList :: [Stmt l] -> ShowS Source #
Generic (Stmt l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Stmt l) :: Type -> Type Source # Methods from :: Stmt l -> Rep (Stmt l) x Source # to :: Rep (Stmt l) x -> Stmt l Source #
Pretty (Stmt l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Stmt l -> Doc prettyPrec :: Int -> Stmt l -> Doc
Convert [Stmt ()] Guard Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: [Stmt ()] -> Guard
Convert (Stmt ()) Stmt Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Stmt0 () -> Stmt
type Rep (Stmt l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Stmt l) = D1 (MetaData "Stmt" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "Generator" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: C1 (MetaCons "Qualifier" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: (C1 (MetaCons "LetStmt" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Binds l))) :+: C1 (MetaCons "RecStmt" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Stmt l]))))

data QualStmt l Source #

A general transqual in a list comprehension, which could potentially be a transform of the kind enabled by TransformListComp.

Constructors

QualStmt l (Stmt l) | an ordinary statement
ThenTrans l (Exp l) | `then` exp
ThenBy l (Exp l) (Exp l) | `then` exp `by` exp
GroupBy l (Exp l) | `then` `group` `by` exp
GroupUsing l (Exp l) | `then` `group` `using` exp
GroupByUsing l (Exp l) (Exp l) | `then` `group` `by` exp `using` exp

Instances

Functor QualStmt |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> QualStmt a -> QualStmt b Source # (<$) :: a -> QualStmt b -> QualStmt a Source #
Foldable QualStmt |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => QualStmt m -> m Source #

foldMap :: Monoid m => (a -> m) -> QualStmt a -> m Source #

foldr :: (a -> b -> b) -> b -> QualStmt a -> b Source #

foldr' :: (a -> b -> b) -> b -> QualStmt a -> b Source #

foldl :: (b -> a -> b) -> b -> QualStmt a -> b Source #

foldl' :: (b -> a -> b) -> b -> QualStmt a -> b Source #

foldr1 :: (a -> a -> a) -> QualStmt a -> a Source #

foldl1 :: (a -> a -> a) -> QualStmt a -> a Source #

toList :: QualStmt a -> [a] Source #

null :: QualStmt a -> Bool Source #

length :: QualStmt a -> Int Source #

elem :: Eq a => a -> QualStmt a -> Bool Source #

maximum :: Ord a => QualStmt a -> a Source #

minimum :: Ord a => QualStmt a -> a Source #

sum :: Num a => QualStmt a -> a Source #

product :: Num a => QualStmt a -> a Source #

Traversable QualStmt |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> QualStmt a -> f (QualStmt b) Source # sequenceA :: Applicative f => QualStmt (f a) -> f (QualStmt a) Source # mapM :: Monad m => (a -> m b) -> QualStmt a -> m (QualStmt b) Source # sequence :: Monad m => QualStmt (m a) -> m (QualStmt a) Source #
ExactP QualStmt |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: QualStmt SrcSpanInfo -> EP ()
AppFixity QualStmt |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> QualStmt SrcSpanInfo -> m (QualStmt SrcSpanInfo) Source #
Annotated QualStmt |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: QualStmt l -> l Source # amap :: (l -> l) -> QualStmt l -> QualStmt l Source #
Eq l => Eq (QualStmt l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: QualStmt l -> QualStmt l -> Bool Source # (/=) :: QualStmt l -> QualStmt l -> Bool Source #
Data l => Data (QualStmt 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) -> QualStmt l -> c (QualStmt l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (QualStmt l) Source #

toConstr :: QualStmt l -> Constr Source #

dataTypeOf :: QualStmt l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (QualStmt l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QualStmt l)) Source #

gmapT :: (forall b. Data b => b -> b) -> QualStmt l -> QualStmt l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QualStmt l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QualStmt l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> QualStmt l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> QualStmt l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l) Source #

Ord l => Ord (QualStmt l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: QualStmt l -> QualStmt l -> Ordering Source #

(<) :: QualStmt l -> QualStmt l -> Bool Source #

(<=) :: QualStmt l -> QualStmt l -> Bool Source #

(>) :: QualStmt l -> QualStmt l -> Bool Source #

(>=) :: QualStmt l -> QualStmt l -> Bool Source #

max :: QualStmt l -> QualStmt l -> QualStmt l Source #

min :: QualStmt l -> QualStmt l -> QualStmt l Source #

Show l => Show (QualStmt l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> QualStmt l -> ShowS Source # show :: QualStmt l -> String Source # showList :: [QualStmt l] -> ShowS Source #
Generic (QualStmt l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (QualStmt l) :: Type -> Type Source # Methods from :: QualStmt l -> Rep (QualStmt l) x Source # to :: Rep (QualStmt l) x -> QualStmt l Source #
Pretty (QualStmt l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: QualStmt l -> Doc prettyPrec :: Int -> QualStmt l -> Doc
Convert (QualStmt ()) Stmt Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: QualStmt () -> Stmt
type Rep (QualStmt l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (QualStmt l) = D1 (MetaData "QualStmt" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "QualStmt" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Stmt l))) :+: (C1 (MetaCons "ThenTrans" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :+: C1 (MetaCons "ThenBy" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))))) :+: (C1 (MetaCons "GroupBy" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :+: (C1 (MetaCons "GroupUsing" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :+: C1 (MetaCons "GroupByUsing" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))))))

data FieldUpdate l Source #

An fbind in a labeled construction or update expression.

Constructors

FieldUpdate l (QName l) (Exp l) | ordinary label-expresion pair
FieldPun l (QName l) | record field pun
FieldWildcard l | record field wildcard

Instances

Functor FieldUpdate |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> FieldUpdate a -> FieldUpdate b Source # (<$) :: a -> FieldUpdate b -> FieldUpdate a Source #
Foldable FieldUpdate |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => FieldUpdate m -> m Source #

foldMap :: Monoid m => (a -> m) -> FieldUpdate a -> m Source #

foldr :: (a -> b -> b) -> b -> FieldUpdate a -> b Source #

foldr' :: (a -> b -> b) -> b -> FieldUpdate a -> b Source #

foldl :: (b -> a -> b) -> b -> FieldUpdate a -> b Source #

foldl' :: (b -> a -> b) -> b -> FieldUpdate a -> b Source #

foldr1 :: (a -> a -> a) -> FieldUpdate a -> a Source #

foldl1 :: (a -> a -> a) -> FieldUpdate a -> a Source #

toList :: FieldUpdate a -> [a] Source #

null :: FieldUpdate a -> Bool Source #

length :: FieldUpdate a -> Int Source #

elem :: Eq a => a -> FieldUpdate a -> Bool Source #

maximum :: Ord a => FieldUpdate a -> a Source #

minimum :: Ord a => FieldUpdate a -> a Source #

sum :: Num a => FieldUpdate a -> a Source #

product :: Num a => FieldUpdate a -> a Source #

Traversable FieldUpdate |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> FieldUpdate a -> f (FieldUpdate b) Source # sequenceA :: Applicative f => FieldUpdate (f a) -> f (FieldUpdate a) Source # mapM :: Monad m => (a -> m b) -> FieldUpdate a -> m (FieldUpdate b) Source # sequence :: Monad m => FieldUpdate (m a) -> m (FieldUpdate a) Source #
ExactP FieldUpdate |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: FieldUpdate SrcSpanInfo -> EP ()
AppFixity FieldUpdate |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> FieldUpdate SrcSpanInfo -> m (FieldUpdate SrcSpanInfo) Source #
Annotated FieldUpdate |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: FieldUpdate l -> l Source # amap :: (l -> l) -> FieldUpdate l -> FieldUpdate l Source #
Eq l => Eq (FieldUpdate l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: FieldUpdate l -> FieldUpdate l -> Bool Source # (/=) :: FieldUpdate l -> FieldUpdate l -> Bool Source #
Data l => Data (FieldUpdate 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) -> FieldUpdate l -> c (FieldUpdate l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldUpdate l) Source #

toConstr :: FieldUpdate l -> Constr Source #

dataTypeOf :: FieldUpdate l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FieldUpdate l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FieldUpdate l)) Source #

gmapT :: (forall b. Data b => b -> b) -> FieldUpdate l -> FieldUpdate l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> FieldUpdate l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldUpdate l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldUpdate l -> m (FieldUpdate l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldUpdate l -> m (FieldUpdate l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldUpdate l -> m (FieldUpdate l) Source #

Ord l => Ord (FieldUpdate l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: FieldUpdate l -> FieldUpdate l -> Ordering Source #

(<) :: FieldUpdate l -> FieldUpdate l -> Bool Source #

(<=) :: FieldUpdate l -> FieldUpdate l -> Bool Source #

(>) :: FieldUpdate l -> FieldUpdate l -> Bool Source #

(>=) :: FieldUpdate l -> FieldUpdate l -> Bool Source #

max :: FieldUpdate l -> FieldUpdate l -> FieldUpdate l Source #

min :: FieldUpdate l -> FieldUpdate l -> FieldUpdate l Source #

Show l => Show (FieldUpdate l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> FieldUpdate l -> ShowS Source # show :: FieldUpdate l -> String Source # showList :: [FieldUpdate l] -> ShowS Source #
Generic (FieldUpdate l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (FieldUpdate l) :: Type -> Type Source # Methods from :: FieldUpdate l -> Rep (FieldUpdate l) x Source # to :: Rep (FieldUpdate l) x -> FieldUpdate l Source #
Pretty (FieldUpdate l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: FieldUpdate l -> Doc prettyPrec :: Int -> FieldUpdate l -> Doc
Convert (FieldUpdate ()) FieldExp Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: FieldUpdate () -> FieldExp
type Rep (FieldUpdate l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (FieldUpdate l) = D1 (MetaData "FieldUpdate" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "FieldUpdate" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: (C1 (MetaCons "FieldPun" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))) :+: C1 (MetaCons "FieldWildcard" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))))

data Alt l Source #

An alt alternative in a `case` expression.

Constructors

Alt l (Pat l) (Rhs l) (Maybe (Binds l)) |

Instances

Functor Alt |
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Alt a -> Alt b Source # (<$) :: a -> Alt b -> Alt a Source #
Foldable Alt |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Alt m -> m Source #

foldMap :: Monoid m => (a -> m) -> Alt a -> m Source #

foldr :: (a -> b -> b) -> b -> Alt a -> b Source #

foldr' :: (a -> b -> b) -> b -> Alt a -> b Source #

foldl :: (b -> a -> b) -> b -> Alt a -> b Source #

foldl' :: (b -> a -> b) -> b -> Alt a -> b Source #

foldr1 :: (a -> a -> a) -> Alt a -> a Source #

foldl1 :: (a -> a -> a) -> Alt a -> a Source #

toList :: Alt a -> [a] Source #

null :: Alt a -> Bool Source #

length :: Alt a -> Int Source #

elem :: Eq a => a -> Alt a -> Bool Source #

maximum :: Ord a => Alt a -> a Source #

minimum :: Ord a => Alt a -> a Source #

sum :: Num a => Alt a -> a Source #

product :: Num a => Alt a -> a Source #

Traversable Alt |
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Alt a -> f (Alt b) Source # sequenceA :: Applicative f => Alt (f a) -> f (Alt a) Source # mapM :: Monad m => (a -> m b) -> Alt a -> m (Alt b) Source # sequence :: Monad m => Alt (m a) -> m (Alt a) Source #
ExactP Alt |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Alt SrcSpanInfo -> EP ()
AppFixity Alt |
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Alt SrcSpanInfo -> m (Alt SrcSpanInfo) Source #
Annotated Alt |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Alt l -> l Source # amap :: (l -> l) -> Alt l -> Alt l Source #
Eq l => Eq (Alt l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Alt l -> Alt l -> Bool Source # (/=) :: Alt l -> Alt l -> Bool Source #
Data l => Data (Alt 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) -> Alt l -> c (Alt l) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alt l) Source #

toConstr :: Alt l -> Constr Source #

dataTypeOf :: Alt l -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Alt l)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt l)) Source #

gmapT :: (forall b. Data b => b -> b) -> Alt l -> Alt l Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Alt l -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt l -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt l -> m (Alt l) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt l -> m (Alt l) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt l -> m (Alt l) Source #

Ord l => Ord (Alt l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Alt l -> Alt l -> Ordering Source # (<) :: Alt l -> Alt l -> Bool Source # (<=) :: Alt l -> Alt l -> Bool Source # (>) :: Alt l -> Alt l -> Bool Source # (>=) :: Alt l -> Alt l -> Bool Source # max :: Alt l -> Alt l -> Alt l Source # min :: Alt l -> Alt l -> Alt l Source #
Show l => Show (Alt l) |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Alt l -> ShowS Source # show :: Alt l -> String Source # showList :: [Alt l] -> ShowS Source #
Generic (Alt l) |
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Alt l) :: Type -> Type Source # Methods from :: Alt l -> Rep (Alt l) x Source # to :: Rep (Alt l) x -> Alt l Source #
Pretty (Alt l) |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Alt l -> Doc prettyPrec :: Int -> Alt l -> Doc
Convert (Alt ()) Match Source # |
Instance details Defined in Language.Haskell.Convert Methods conv :: Alt () -> Match
type Rep (Alt l) |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Alt l) = D1 (MetaData "Alt" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "Alt" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Rhs l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Binds l))))))

class Functor ast => Annotated (ast :: Type -> Type) where Source #

AST nodes are annotated, and this class allows manipulation of the annotations.

Methods

ann :: ast l -> l Source #

Retrieve the annotation of an AST node.

amap :: (l -> l) -> ast l -> ast l Source #

Change the annotation of an AST node. Note that only the annotation of the node itself is affected, and not the annotations of any child nodes. if all nodes in the AST tree are to be affected, use `fmap`.

Instances

Annotated PExp |
Instance details Defined in Language.Haskell.Exts.ParseSyntax Methods ann :: PExp l -> l Source # amap :: (l -> l) -> PExp l -> PExp l Source #
Annotated PFieldUpdate |
Instance details Defined in Language.Haskell.Exts.ParseSyntax Methods ann :: PFieldUpdate l -> l Source # amap :: (l -> l) -> PFieldUpdate l -> PFieldUpdate l Source #
Annotated ParseXAttr |
Instance details Defined in Language.Haskell.Exts.ParseSyntax Methods ann :: ParseXAttr l -> l Source # amap :: (l -> l) -> ParseXAttr l -> ParseXAttr l Source #
Annotated PContext |
Instance details Defined in Language.Haskell.Exts.ParseSyntax Methods ann :: PContext l -> l Source # amap :: (l -> l) -> PContext l -> PContext l Source #
Annotated PType |
Instance details Defined in Language.Haskell.Exts.ParseSyntax Methods ann :: PType l -> l Source # amap :: (l -> l) -> PType l -> PType l Source #
Annotated PAsst |
Instance details Defined in Language.Haskell.Exts.ParseSyntax Methods ann :: PAsst l -> l Source # amap :: (l -> l) -> PAsst l -> PAsst l Source #
Annotated ModuleName |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ModuleName l -> l Source # amap :: (l -> l) -> ModuleName l -> ModuleName l Source #
Annotated SpecialCon |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: SpecialCon l -> l Source # amap :: (l -> l) -> SpecialCon l -> SpecialCon l Source #
Annotated QName |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: QName l -> l Source # amap :: (l -> l) -> QName l -> QName l Source #
Annotated Name |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Name l -> l Source # amap :: (l -> l) -> Name l -> Name l Source #
Annotated IPName |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: IPName l -> l Source # amap :: (l -> l) -> IPName l -> IPName l Source #
Annotated QOp |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: QOp l -> l Source # amap :: (l -> l) -> QOp l -> QOp l Source #
Annotated Op |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Op l -> l Source # amap :: (l -> l) -> Op l -> Op l Source #
Annotated CName |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: CName l -> l Source # amap :: (l -> l) -> CName l -> CName l Source #
Annotated Module |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Module l -> l Source # amap :: (l -> l) -> Module l -> Module l Source #
Annotated ModuleHead |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ModuleHead l -> l Source # amap :: (l -> l) -> ModuleHead l -> ModuleHead l Source #
Annotated ExportSpecList |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ExportSpecList l -> l Source # amap :: (l -> l) -> ExportSpecList l -> ExportSpecList l Source #
Annotated ExportSpec |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ExportSpec l -> l Source # amap :: (l -> l) -> ExportSpec l -> ExportSpec l Source #
Annotated EWildcard |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: EWildcard l -> l Source # amap :: (l -> l) -> EWildcard l -> EWildcard l Source #
Annotated Namespace |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Namespace l -> l Source # amap :: (l -> l) -> Namespace l -> Namespace l Source #
Annotated ImportDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ImportDecl l -> l Source # amap :: (l -> l) -> ImportDecl l -> ImportDecl l Source #
Annotated ImportSpecList |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ImportSpecList l -> l Source # amap :: (l -> l) -> ImportSpecList l -> ImportSpecList l Source #
Annotated ImportSpec |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ImportSpec l -> l Source # amap :: (l -> l) -> ImportSpec l -> ImportSpec l Source #
Annotated Assoc |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Assoc l -> l Source # amap :: (l -> l) -> Assoc l -> Assoc l Source #
Annotated Decl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Decl l -> l Source # amap :: (l -> l) -> Decl l -> Decl l Source #
Annotated TypeEqn |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: TypeEqn l -> l Source # amap :: (l -> l) -> TypeEqn l -> TypeEqn l Source #
Annotated Annotation |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Annotation l -> l Source # amap :: (l -> l) -> Annotation l -> Annotation l Source #
Annotated BooleanFormula |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: BooleanFormula l -> l Source # amap :: (l -> l) -> BooleanFormula l -> BooleanFormula l Source #
Annotated Role |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Role l -> l Source # amap :: (l -> l) -> Role l -> Role l Source #
Annotated DataOrNew |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: DataOrNew l -> l Source # amap :: (l -> l) -> DataOrNew l -> DataOrNew l Source #
Annotated InjectivityInfo |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: InjectivityInfo l -> l Source # amap :: (l -> l) -> InjectivityInfo l -> InjectivityInfo l Source #
Annotated ResultSig |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ResultSig l -> l Source # amap :: (l -> l) -> ResultSig l -> ResultSig l Source #
Annotated DeclHead |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: DeclHead l -> l Source # amap :: (l -> l) -> DeclHead l -> DeclHead l Source #
Annotated InstRule |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: InstRule l -> l Source # amap :: (l -> l) -> InstRule l -> InstRule l Source #
Annotated InstHead |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: InstHead l -> l Source # amap :: (l -> l) -> InstHead l -> InstHead l Source #
Annotated Deriving |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Deriving l -> l Source # amap :: (l -> l) -> Deriving l -> Deriving l Source #
Annotated DerivStrategy |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: DerivStrategy l -> l Source # amap :: (l -> l) -> DerivStrategy l -> DerivStrategy l Source #
Annotated Binds |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Binds l -> l Source # amap :: (l -> l) -> Binds l -> Binds l Source #
Annotated IPBind |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: IPBind l -> l Source # amap :: (l -> l) -> IPBind l -> IPBind l Source #
Annotated Match |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Match l -> l Source # amap :: (l -> l) -> Match l -> Match l Source #
Annotated QualConDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: QualConDecl l -> l Source # amap :: (l -> l) -> QualConDecl l -> QualConDecl l Source #
Annotated ConDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ConDecl l -> l Source # amap :: (l -> l) -> ConDecl l -> ConDecl l Source #
Annotated FieldDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: FieldDecl l -> l Source # amap :: (l -> l) -> FieldDecl l -> FieldDecl l Source #
Annotated GadtDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: GadtDecl l -> l Source # amap :: (l -> l) -> GadtDecl l -> GadtDecl l Source #
Annotated ClassDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ClassDecl l -> l Source # amap :: (l -> l) -> ClassDecl l -> ClassDecl l Source #
Annotated InstDecl |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: InstDecl l -> l Source # amap :: (l -> l) -> InstDecl l -> InstDecl l Source #
Annotated BangType |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: BangType l -> l Source # amap :: (l -> l) -> BangType l -> BangType l Source #
Annotated Unpackedness |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Unpackedness l -> l Source # amap :: (l -> l) -> Unpackedness l -> Unpackedness l Source #
Annotated Rhs |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Rhs l -> l Source # amap :: (l -> l) -> Rhs l -> Rhs l Source #
Annotated GuardedRhs |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: GuardedRhs l -> l Source # amap :: (l -> l) -> GuardedRhs l -> GuardedRhs l Source #
Annotated Type |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Type l -> l Source # amap :: (l -> l) -> Type l -> Type l Source #
Annotated MaybePromotedName |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: MaybePromotedName l -> l Source # amap :: (l -> l) -> MaybePromotedName l -> MaybePromotedName l Source #
Annotated Promoted |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Promoted l -> l Source # amap :: (l -> l) -> Promoted l -> Promoted l Source #
Annotated TyVarBind |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: TyVarBind l -> l Source # amap :: (l -> l) -> TyVarBind l -> TyVarBind l Source #
Annotated Kind |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Kind l -> l Source # amap :: (l -> l) -> Kind l -> Kind l Source #
Annotated FunDep |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: FunDep l -> l Source # amap :: (l -> l) -> FunDep l -> FunDep l Source #
Annotated Context |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Context l -> l Source # amap :: (l -> l) -> Context l -> Context l Source #
Annotated Asst |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Asst l -> l Source # amap :: (l -> l) -> Asst l -> Asst l Source #
Annotated Literal |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Literal l -> l Source # amap :: (l -> l) -> Literal l -> Literal l Source #
Annotated Sign |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Sign l -> l Source # amap :: (l -> l) -> Sign l -> Sign l Source #
Annotated Exp |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Exp l -> l Source # amap :: (l -> l) -> Exp l -> Exp l Source #
Annotated XName |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: XName l -> l Source # amap :: (l -> l) -> XName l -> XName l Source #
Annotated XAttr |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: XAttr l -> l Source # amap :: (l -> l) -> XAttr l -> XAttr l Source #
Annotated Bracket |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Bracket l -> l Source # amap :: (l -> l) -> Bracket l -> Bracket l Source #
Annotated Splice |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Splice l -> l Source # amap :: (l -> l) -> Splice l -> Splice l Source #
Annotated Safety |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Safety l -> l Source # amap :: (l -> l) -> Safety l -> Safety l Source #
Annotated CallConv |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: CallConv l -> l Source # amap :: (l -> l) -> CallConv l -> CallConv l Source #
Annotated ModulePragma |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ModulePragma l -> l Source # amap :: (l -> l) -> ModulePragma l -> ModulePragma l Source #
Annotated Overlap |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Overlap l -> l Source # amap :: (l -> l) -> Overlap l -> Overlap l Source #
Annotated Activation |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Activation l -> l Source # amap :: (l -> l) -> Activation l -> Activation l Source #
Annotated Rule |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Rule l -> l Source # amap :: (l -> l) -> Rule l -> Rule l Source #
Annotated RuleVar |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: RuleVar l -> l Source # amap :: (l -> l) -> RuleVar l -> RuleVar l Source #
Annotated WarningText |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: WarningText l -> l Source # amap :: (l -> l) -> WarningText l -> WarningText l Source #
Annotated Pat |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Pat l -> l Source # amap :: (l -> l) -> Pat l -> Pat l Source #
Annotated PXAttr |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: PXAttr l -> l Source # amap :: (l -> l) -> PXAttr l -> PXAttr l Source #
Annotated RPatOp |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: RPatOp l -> l Source # amap :: (l -> l) -> RPatOp l -> RPatOp l Source #
Annotated RPat |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: RPat l -> l Source # amap :: (l -> l) -> RPat l -> RPat l Source #
Annotated PatField |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: PatField l -> l Source # amap :: (l -> l) -> PatField l -> PatField l Source #
Annotated Stmt |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Stmt l -> l Source # amap :: (l -> l) -> Stmt l -> Stmt l Source #
Annotated QualStmt |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: QualStmt l -> l Source # amap :: (l -> l) -> QualStmt l -> QualStmt l Source #
Annotated FieldUpdate |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: FieldUpdate l -> l Source # amap :: (l -> l) -> FieldUpdate l -> FieldUpdate l Source #
Annotated Alt |
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Alt l -> l Source # amap :: (l -> l) -> Alt l -> Alt l Source #
Annotated GuardedAlt |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods ann :: GuardedAlt l -> l Source # amap :: (l -> l) -> GuardedAlt l -> GuardedAlt l Source #
Annotated GuardedAlts |
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods ann :: GuardedAlts l -> l Source # amap :: (l -> l) -> GuardedAlts l -> GuardedAlts l Source #

(<^^>) :: SrcSpan -> SrcSpan -> SrcSpanInfo infixl 6 Source #

Merge two `SrcSpan`s and lift them to a `SrcInfoSpan` with no positional information for entities.

(<**) :: SrcSpanInfo -> [SrcSpan] -> SrcSpanInfo infixl 4 Source #

Add more positional information for entities of a span.

(<?+>) :: Maybe SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo infixl 4 Source #

Optionally combine the second argument with the first, or return it unchanged if the first argument is `Nothing`.

(<+?>) :: SrcSpanInfo -> Maybe SrcSpanInfo -> SrcSpanInfo infixl 4 Source #

Optionally combine the first argument with the second, or return it unchanged if the second argument is `Nothing`.

(<++>) :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo infixl 5 Source #

Short name for `combSpanInfo`

combSpanMaybe :: SrcSpanInfo -> Maybe SrcSpanInfo -> SrcSpanInfo Source #

Like '(+?)', but it also concatenates the `srcInfoPoints`.

combSpanInfo :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo Source #

Combine two `SrcSpanInfo`s into one that spans the combined source area of the two arguments, leaving positional information blank.

infoSpan :: SrcSpan -> [SrcSpan] -> SrcSpanInfo Source #

Generate a `SrcSpanInfo` with the supplied positional information for entities.

noSrcSpan :: SrcSpanInfo Source #

A bogus `SrcSpanInfo`, the location is `noLoc`. `noSrcSpan = noInfoSpan (mkSrcSpan noLoc noLoc)`

noInfoSpan :: SrcSpan -> SrcSpanInfo Source #

Generate a `SrcSpanInfo` with no positional information for entities.

spanSize :: SrcSpan -> (Int, Int) Source #

isNullSpan :: SrcSpan -> Bool Source #

Test if a given span starts and ends at the same location.

mergeSrcSpan :: SrcSpan -> SrcSpan -> SrcSpan Source #

Merge two source spans into a single span from the start of the first to the end of the second. Assumes that the two spans relate to the same source file.

mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan Source #

Combine two locations in the source to denote a span.

srcSpanEnd :: SrcSpan -> (Int, Int) Source #

Returns `srcSpanEndLine` and `srcSpanEndColumn` in a pair.

srcSpanStart :: SrcSpan -> (Int, Int) Source #

Returns `srcSpanStartLine` and `srcSpanStartColumn` in a pair.

noLoc :: SrcLoc Source #

data SrcLoc Source #

A single position in the source.

Constructors

SrcLoc |

Fields

- srcFilename :: String
- srcLine :: Int
- srcColumn :: Int

Instances

Eq SrcLoc |
Instance details Defined in Language.Haskell.Exts.SrcLoc Methods (==) :: SrcLoc -> SrcLoc -> Bool Source # (/=) :: SrcLoc -> SrcLoc -> Bool Source #
Data SrcLoc |

Instance details

Defined in Language.Haskell.Exts.SrcLoc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcLoc -> c SrcLoc Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcLoc Source #

toConstr :: SrcLoc -> Constr Source #

dataTypeOf :: SrcLoc -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcLoc) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcLoc) Source #

gmapT :: (forall b. Data b => b -> b) -> SrcLoc -> SrcLoc Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcLoc -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcLoc -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> SrcLoc -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcLoc -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc Source #

Ord SrcLoc |
Instance details Defined in Language.Haskell.Exts.SrcLoc Methods compare :: SrcLoc -> SrcLoc -> Ordering Source # (<) :: SrcLoc -> SrcLoc -> Bool Source # (<=) :: SrcLoc -> SrcLoc -> Bool Source # (>) :: SrcLoc -> SrcLoc -> Bool Source # (>=) :: SrcLoc -> SrcLoc -> Bool Source # max :: SrcLoc -> SrcLoc -> SrcLoc Source # min :: SrcLoc -> SrcLoc -> SrcLoc Source #
Show SrcLoc |
Instance details Defined in Language.Haskell.Exts.SrcLoc Methods showsPrec :: Int -> SrcLoc -> ShowS Source # show :: SrcLoc -> String Source # showList :: [SrcLoc] -> ShowS Source #
Generic SrcLoc |
Instance details Defined in Language.Haskell.Exts.SrcLoc Associated Types type Rep SrcLoc :: Type -> Type Source # Methods from :: SrcLoc -> Rep SrcLoc x Source # to :: Rep SrcLoc x -> SrcLoc Source #
Pretty SrcLoc |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: SrcLoc -> Doc prettyPrec :: Int -> SrcLoc -> Doc
SrcInfo SrcLoc |
Instance details Defined in Language.Haskell.Exts.SrcLoc Methods toSrcInfo :: SrcLoc -> [SrcSpan] -> SrcLoc -> SrcLoc Source # fromSrcInfo :: SrcSpanInfo -> SrcLoc Source # getPointLoc :: SrcLoc -> SrcLoc Source # fileName :: SrcLoc -> String Source # startLine :: SrcLoc -> Int Source # startColumn :: SrcLoc -> Int Source #
type Rep SrcLoc |

Instance details

Defined in Language.Haskell.Exts.SrcLoc

type Rep SrcLoc = D1 (MetaData "SrcLoc" "Language.Haskell.Exts.SrcLoc" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "SrcLoc" PrefixI True) (S1 (MetaSel (Just "srcFilename") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: (S1 (MetaSel (Just "srcLine") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int) :*: S1 (MetaSel (Just "srcColumn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int))))

data SrcSpan Source #

A portion of the source, spanning one or more lines and zero or more columns.

Constructors

SrcSpan |

Fields

- srcSpanFilename :: String
- srcSpanStartLine :: Int
- srcSpanStartColumn :: Int
- srcSpanEndLine :: Int
- srcSpanEndColumn :: Int

Instances

Eq SrcSpan |
Instance details Defined in Language.Haskell.Exts.SrcLoc Methods (==) :: SrcSpan -> SrcSpan -> Bool Source # (/=) :: SrcSpan -> SrcSpan -> Bool Source #
Data SrcSpan |

Instance details

Defined in Language.Haskell.Exts.SrcLoc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcSpan -> c SrcSpan Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcSpan Source #

toConstr :: SrcSpan -> Constr Source #

dataTypeOf :: SrcSpan -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcSpan) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcSpan) Source #

gmapT :: (forall b. Data b => b -> b) -> SrcSpan -> SrcSpan Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpan -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpan -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> SrcSpan -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcSpan -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan Source #

Ord SrcSpan |
Instance details Defined in Language.Haskell.Exts.SrcLoc Methods compare :: SrcSpan -> SrcSpan -> Ordering Source # (<) :: SrcSpan -> SrcSpan -> Bool Source # (<=) :: SrcSpan -> SrcSpan -> Bool Source # (>) :: SrcSpan -> SrcSpan -> Bool Source # (>=) :: SrcSpan -> SrcSpan -> Bool Source # max :: SrcSpan -> SrcSpan -> SrcSpan Source # min :: SrcSpan -> SrcSpan -> SrcSpan Source #
Show SrcSpan |
Instance details Defined in Language.Haskell.Exts.SrcLoc Methods showsPrec :: Int -> SrcSpan -> ShowS Source # show :: SrcSpan -> String Source # showList :: [SrcSpan] -> ShowS Source #
Generic SrcSpan |
Instance details Defined in Language.Haskell.Exts.SrcLoc Associated Types type Rep SrcSpan :: Type -> Type Source # Methods from :: SrcSpan -> Rep SrcSpan x Source # to :: Rep SrcSpan x -> SrcSpan Source #
Pretty SrcSpan |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: SrcSpan -> Doc prettyPrec :: Int -> SrcSpan -> Doc
SrcInfo SrcSpan |
Instance details Defined in Language.Haskell.Exts.SrcLoc Methods toSrcInfo :: SrcLoc -> [SrcSpan] -> SrcLoc -> SrcSpan Source # fromSrcInfo :: SrcSpanInfo -> SrcSpan Source # getPointLoc :: SrcSpan -> SrcLoc Source # fileName :: SrcSpan -> String Source # startLine :: SrcSpan -> Int Source # startColumn :: SrcSpan -> Int Source #
type Rep SrcSpan |

Instance details

Defined in Language.Haskell.Exts.SrcLoc

type Rep SrcSpan = D1 (MetaData "SrcSpan" "Language.Haskell.Exts.SrcLoc" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "SrcSpan" PrefixI True) ((S1 (MetaSel (Just "srcSpanFilename") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Just "srcSpanStartLine") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)) :*: (S1 (MetaSel (Just "srcSpanStartColumn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int) :*: (S1 (MetaSel (Just "srcSpanEndLine") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int) :*: S1 (MetaSel (Just "srcSpanEndColumn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))))

data Loc a Source #

An entity located in the source.

Constructors

Loc |

Fields

- loc :: SrcSpan
- unLoc :: a

Instances

Eq a => Eq (Loc a) |
Instance details Defined in Language.Haskell.Exts.SrcLoc Methods (==) :: Loc a -> Loc a -> Bool Source # (/=) :: Loc a -> Loc a -> Bool Source #
Ord a => Ord (Loc a) |
Instance details Defined in Language.Haskell.Exts.SrcLoc Methods compare :: Loc a -> Loc a -> Ordering Source # (<) :: Loc a -> Loc a -> Bool Source # (<=) :: Loc a -> Loc a -> Bool Source # (>) :: Loc a -> Loc a -> Bool Source # (>=) :: Loc a -> Loc a -> Bool Source # max :: Loc a -> Loc a -> Loc a Source # min :: Loc a -> Loc a -> Loc a Source #
Show a => Show (Loc a) |
Instance details Defined in Language.Haskell.Exts.SrcLoc Methods showsPrec :: Int -> Loc a -> ShowS Source # show :: Loc a -> String Source # showList :: [Loc a] -> ShowS Source #
Generic (Loc a) |
Instance details Defined in Language.Haskell.Exts.SrcLoc Associated Types type Rep (Loc a) :: Type -> Type Source # Methods from :: Loc a -> Rep (Loc a) x Source # to :: Rep (Loc a) x -> Loc a Source #
type Rep (Loc a) |

Instance details

Defined in Language.Haskell.Exts.SrcLoc

type Rep (Loc a) = D1 (MetaData "Loc" "Language.Haskell.Exts.SrcLoc" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "Loc" PrefixI True) (S1 (MetaSel (Just "loc") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SrcSpan) :*: S1 (MetaSel (Just "unLoc") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

data SrcSpanInfo Source #

A portion of the source, extended with information on the position of entities within the span.

Constructors

SrcSpanInfo |

Fields

- srcInfoSpan :: SrcSpan
- srcInfoPoints :: [SrcSpan]

Instances

Eq SrcSpanInfo |
Instance details Defined in Language.Haskell.Exts.SrcLoc Methods (==) :: SrcSpanInfo -> SrcSpanInfo -> Bool Source # (/=) :: SrcSpanInfo -> SrcSpanInfo -> Bool Source #
Data SrcSpanInfo |

Instance details

Defined in Language.Haskell.Exts.SrcLoc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcSpanInfo -> c SrcSpanInfo Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcSpanInfo Source #

toConstr :: SrcSpanInfo -> Constr Source #

dataTypeOf :: SrcSpanInfo -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcSpanInfo) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcSpanInfo) Source #

gmapT :: (forall b. Data b => b -> b) -> SrcSpanInfo -> SrcSpanInfo Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpanInfo -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpanInfo -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> SrcSpanInfo -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcSpanInfo -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcSpanInfo -> m SrcSpanInfo Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcSpanInfo -> m SrcSpanInfo Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcSpanInfo -> m SrcSpanInfo Source #

Ord SrcSpanInfo |

Instance details

Defined in Language.Haskell.Exts.SrcLoc

Methods

compare :: SrcSpanInfo -> SrcSpanInfo -> Ordering Source #

(<) :: SrcSpanInfo -> SrcSpanInfo -> Bool Source #

(<=) :: SrcSpanInfo -> SrcSpanInfo -> Bool Source #

(>) :: SrcSpanInfo -> SrcSpanInfo -> Bool Source #

(>=) :: SrcSpanInfo -> SrcSpanInfo -> Bool Source #

max :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo Source #

min :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo Source #

Show SrcSpanInfo |
Instance details Defined in Language.Haskell.Exts.SrcLoc Methods showsPrec :: Int -> SrcSpanInfo -> ShowS Source # show :: SrcSpanInfo -> String Source # showList :: [SrcSpanInfo] -> ShowS Source #
Generic SrcSpanInfo |
Instance details Defined in Language.Haskell.Exts.SrcLoc Associated Types type Rep SrcSpanInfo :: Type -> Type Source # Methods from :: SrcSpanInfo -> Rep SrcSpanInfo x Source # to :: Rep SrcSpanInfo x -> SrcSpanInfo Source #
SrcInfo SrcSpanInfo |
Instance details Defined in Language.Haskell.Exts.SrcLoc Methods toSrcInfo :: SrcLoc -> [SrcSpan] -> SrcLoc -> SrcSpanInfo Source # fromSrcInfo :: SrcSpanInfo -> SrcSpanInfo Source # getPointLoc :: SrcSpanInfo -> SrcLoc Source # fileName :: SrcSpanInfo -> String Source # startLine :: SrcSpanInfo -> Int Source # startColumn :: SrcSpanInfo -> Int Source #
Parseable (NonGreedy (PragmasAndModuleName SrcSpanInfo)) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

parse :: String -> ParseResult (NonGreedy (PragmasAndModuleName SrcSpanInfo)) Source #

parseWithMode :: ParseMode -> String -> ParseResult (NonGreedy (PragmasAndModuleName SrcSpanInfo)) Source #

parseWithComments :: ParseMode -> String -> ParseResult (NonGreedy (PragmasAndModuleName SrcSpanInfo), [Comment]) Source #

parser :: Maybe [Fixity] -> P (NonGreedy (PragmasAndModuleName SrcSpanInfo))

Parseable (NonGreedy (PragmasAndModuleHead SrcSpanInfo)) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

parse :: String -> ParseResult (NonGreedy (PragmasAndModuleHead SrcSpanInfo)) Source #

parseWithMode :: ParseMode -> String -> ParseResult (NonGreedy (PragmasAndModuleHead SrcSpanInfo)) Source #

parseWithComments :: ParseMode -> String -> ParseResult (NonGreedy (PragmasAndModuleHead SrcSpanInfo), [Comment]) Source #

parser :: Maybe [Fixity] -> P (NonGreedy (PragmasAndModuleHead SrcSpanInfo))

Parseable (NonGreedy (ModuleHeadAndImports SrcSpanInfo)) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

parse :: String -> ParseResult (NonGreedy (ModuleHeadAndImports SrcSpanInfo)) Source #

parseWithMode :: ParseMode -> String -> ParseResult (NonGreedy (ModuleHeadAndImports SrcSpanInfo)) Source #

parseWithComments :: ParseMode -> String -> ParseResult (NonGreedy (ModuleHeadAndImports SrcSpanInfo), [Comment]) Source #

parser :: Maybe [Fixity] -> P (NonGreedy (ModuleHeadAndImports SrcSpanInfo))

Parseable (NonGreedy (ListOf (ModulePragma SrcSpanInfo))) |

Instance details

Defined in Language.Haskell.Exts.Parser

Methods

parse :: String -> ParseResult (NonGreedy (ListOf (ModulePragma SrcSpanInfo))) Source #

parseWithMode :: ParseMode -> String -> ParseResult (NonGreedy (ListOf (ModulePragma SrcSpanInfo))) Source #

parseWithComments :: ParseMode -> String -> ParseResult (NonGreedy (ListOf (ModulePragma SrcSpanInfo)), [Comment]) Source #

parser :: Maybe [Fixity] -> P (NonGreedy (ListOf (ModulePragma SrcSpanInfo)))

type Rep SrcSpanInfo |

Instance details

Defined in Language.Haskell.Exts.SrcLoc

type Rep SrcSpanInfo = D1 (MetaData "SrcSpanInfo" "Language.Haskell.Exts.SrcLoc" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "SrcSpanInfo" PrefixI True) (S1 (MetaSel (Just "srcInfoSpan") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SrcSpan) :*: S1 (MetaSel (Just "srcInfoPoints") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [SrcSpan])))

class SrcInfo si where Source #

A class to work over all kinds of source location information.

Minimal complete definition

toSrcInfo, fromSrcInfo, fileName, startLine, startColumn

Methods

toSrcInfo :: SrcLoc -> [SrcSpan] -> SrcLoc -> si Source #

fromSrcInfo :: SrcSpanInfo -> si Source #

getPointLoc :: si -> SrcLoc Source #

fileName :: si -> String Source #

startLine :: si -> Int Source #

startColumn :: si -> Int Source #

Instances

SrcInfo SrcLoc |
Instance details Defined in Language.Haskell.Exts.SrcLoc Methods toSrcInfo :: SrcLoc -> [SrcSpan] -> SrcLoc -> SrcLoc Source # fromSrcInfo :: SrcSpanInfo -> SrcLoc Source # getPointLoc :: SrcLoc -> SrcLoc Source # fileName :: SrcLoc -> String Source # startLine :: SrcLoc -> Int Source # startColumn :: SrcLoc -> Int Source #
SrcInfo SrcSpan |
Instance details Defined in Language.Haskell.Exts.SrcLoc Methods toSrcInfo :: SrcLoc -> [SrcSpan] -> SrcLoc -> SrcSpan Source # fromSrcInfo :: SrcSpanInfo -> SrcSpan Source # getPointLoc :: SrcSpan -> SrcLoc Source # fileName :: SrcSpan -> String Source # startLine :: SrcSpan -> Int Source # startColumn :: SrcSpan -> Int Source #
SrcInfo SrcSpanInfo |
Instance details Defined in Language.Haskell.Exts.SrcLoc Methods toSrcInfo :: SrcLoc -> [SrcSpan] -> SrcLoc -> SrcSpanInfo Source # fromSrcInfo :: SrcSpanInfo -> SrcSpanInfo Source # getPointLoc :: SrcSpanInfo -> SrcLoc Source # fileName :: SrcSpanInfo -> String Source # startLine :: SrcSpanInfo -> Int Source # startColumn :: SrcSpanInfo -> Int Source #

toExtensionList :: Language -> [Extension] -> [KnownExtension] Source #

prettyExtension :: Extension -> String Source #

Pretty print an extension. Disabled extensions are prefixed with 'No'.

parseExtension :: String -> Extension Source #

Parse an enabled or disabled extension; returns `UnknownExtension` if the parse fails.

classifyExtension :: String -> Extension Source #

A clever version of read that returns an `UnknownExtension` if the string is not recognised.

deprecatedExtensions :: [(Extension, Maybe Extension)] Source #

Extensions that have been deprecated, possibly paired with another extension that replaces it.

knownExtensions :: [Extension] Source #

List of all known extensions, both "yes" and "no" versions.

ghcDefault :: [Extension] Source #

glasgowExts :: [Extension] Source #

The list of extensions enabled by GHC's portmanteau -fglasgow-exts flag.

impliesExts :: [KnownExtension] -> [KnownExtension] Source #

Certain extensions imply other extensions, and this function makes the implication explicit. This also handles deprecated extensions, which imply their replacements. The returned value is the transitive closure of implied extensions.

prettyLanguage :: Language -> String Source #

classifyLanguage :: String -> Language Source #

knownLanguages :: [Language] Source #

data Language Source #

Constructors

Haskell98 | The Haskell 98 language as defined by the Haskell 98 report. http://haskell.org/onlinereport/
Haskell2010 | The Haskell 2010 language as defined by the Haskell 2010 report. http://www.haskell.org/onlinereport/haskell2010
HaskellAllDisabled | The minimal language resulting from disabling all recognized extensions - including ones that are part of all known language definitions e.g. MonomorphismRestriction.
UnknownLanguage String | An unknown language, identified by its name.

Instances

Eq Language |
Instance details Defined in Language.Haskell.Exts.Extension Methods (==) :: Language -> Language -> Bool Source # (/=) :: Language -> Language -> Bool Source #
Data Language |

Instance details

Defined in Language.Haskell.Exts.Extension

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Language -> c Language Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Language Source #

toConstr :: Language -> Constr Source #

dataTypeOf :: Language -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Language) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Language) Source #

gmapT :: (forall b. Data b => b -> b) -> Language -> Language Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Language -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Language -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Language -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Language -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Language -> m Language Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Language -> m Language Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Language -> m Language Source #

Ord Language |
Instance details Defined in Language.Haskell.Exts.Extension Methods compare :: Language -> Language -> Ordering Source # (<) :: Language -> Language -> Bool Source # (<=) :: Language -> Language -> Bool Source # (>) :: Language -> Language -> Bool Source # (>=) :: Language -> Language -> Bool Source # max :: Language -> Language -> Language Source # min :: Language -> Language -> Language Source #
Read Language |
Instance details Defined in Language.Haskell.Exts.Extension Methods readsPrec :: Int -> ReadS Language Source # readList :: ReadS [Language] Source # readPrec :: ReadPrec Language Source # readListPrec :: ReadPrec [Language] Source #
Show Language |
Instance details Defined in Language.Haskell.Exts.Extension Methods showsPrec :: Int -> Language -> ShowS Source # show :: Language -> String Source # showList :: [Language] -> ShowS Source #

data Extension Source #

This represents language extensions beyond a base `Language` definition (such as `Haskell98`) that are supported by some implementations, usually in some special mode.

Constructors

EnableExtension KnownExtension | Enable a known extension
DisableExtension KnownExtension | Disable a known extension
UnknownExtension String | An unknown extension, identified by the name of its `LANGUAGE` pragma.

Instances

Eq Extension |
Instance details Defined in Language.Haskell.Exts.Extension Methods (==) :: Extension -> Extension -> Bool Source # (/=) :: Extension -> Extension -> Bool Source #
Ord Extension |

Instance details

Defined in Language.Haskell.Exts.Extension

Methods

compare :: Extension -> Extension -> Ordering Source #

(<) :: Extension -> Extension -> Bool Source #

(<=) :: Extension -> Extension -> Bool Source #

(>) :: Extension -> Extension -> Bool Source #

(>=) :: Extension -> Extension -> Bool Source #

max :: Extension -> Extension -> Extension Source #

min :: Extension -> Extension -> Extension Source #

Read Extension |
Instance details Defined in Language.Haskell.Exts.Extension Methods readsPrec :: Int -> ReadS Extension Source # readList :: ReadS [Extension] Source # readPrec :: ReadPrec Extension Source # readListPrec :: ReadPrec [Extension] Source #
Show Extension |
Instance details Defined in Language.Haskell.Exts.Extension Methods showsPrec :: Int -> Extension -> ShowS Source # show :: Extension -> String Source # showList :: [Extension] -> ShowS Source #

data KnownExtension Source #

Constructors

OverlappingInstances

GHC § 7.6.3.4
  Allow overlapping class instances, provided there is a unique most specific instance for each use.

UndecidableInstances

GHC § 7.6.3.3
  Ignore structural rules guaranteeing the termination of class instance resolution. Termination is guaranteed by a fixed-depth recursion stack, and compilation may fail if this depth is exceeded.

IncoherentInstances

GHC § 7.6.3.4
  Implies `OverlappingInstances`. Allow the implementation to choose an instance even when it is possible that further instantiation of types will lead to a more specific instance being applicable.

InstanceSigs

GHC § 7.6.3.5
  Allow type signatures in instances.

DoRec

GHC § 7.3.8
  Deprecated in GHC. Allows recursive bindings in `do` blocks, using the `rec` keyword.

RecursiveDo

GHC § 7.3.8.2
  Allows recursive bindings using `mdo`, a variant of `do`, and `rec`.

ParallelListComp

GHC § 7.3.9
  Provide syntax for writing list comprehensions which iterate over several lists together, like the `zipWith` family of functions.

MultiParamTypeClasses

GHC § 7.6.1.1
  Allow multiple parameters in a type class.

MonomorphismRestriction

GHC § 7.17
  Enable the dreaded monomorphism restriction.

FunctionalDependencies

GHC § 7.6.2
  Allow a specification attached to a multi-parameter type class which indicates that some parameters are entirely determined by others. The implementation will check that this property holds for the declared instances, and will use this property to reduce ambiguity in instance resolution.

Rank2Types

GHC § 7.8.5
  Like `RankNTypes` but does not allow a higher-rank type to itself appear on the left of a function arrow.

RankNTypes

GHC § 7.8.5
  Allow a universally-quantified type to occur on the left of a function arrow.

PolymorphicComponents

GHC § 7.8.5
  Allow data constructors to have polymorphic arguments. Unlike `RankNTypes`, does not allow this for ordinary functions.

ExistentialQuantification

GHC § 7.4.4
  Allow existentially-quantified data constructors.

ScopedTypeVariables

GHC § 7.8.7
  Cause a type variable in a signature, which has an explicit `forall` quantifier, to scope over the definition of the accompanying value declaration.

PatternSignatures | Deprecated, use `ScopedTypeVariables` instead.

ImplicitParams

GHC § 7.8.3
  Enable implicit function parameters with dynamic scope.

FlexibleContexts

GHC § 7.8.2
  Relax some restrictions on the form of the context of a type signature.

FlexibleInstances

GHC § 7.6.3.2
  Relax some restrictions on the form of the context of an instance declaration.

EmptyDataDecls

GHC § 7.4.1
  Allow data type declarations with no constructors.

CPP

GHC § 4.10.3
  Run the C preprocessor on Haskell source code.

KindSignatures

GHC § 7.8.4
  Allow an explicit kind signature giving the kind of types over which a type variable ranges.

BangPatterns

GHC § 7.11
  Enable a form of pattern which forces evaluation before an attempted match, and a form of strict `let`/`where` binding.

TypeSynonymInstances

GHC § 7.6.3.1
  Allow type synonyms in instance heads.

TemplateHaskell

GHC § 7.9
  Enable Template Haskell, a system for compile-time metaprogramming.

ForeignFunctionInterface

GHC § 8
  Enable the Foreign Function Interface. In GHC, implements the standard Haskell 98 Foreign Function Interface Addendum, plus some GHC-specific extensions.

Arrows

GHC § 7.10
  Enable arrow notation.

Generics

GHC § 7.16
  Enable generic type classes, with default instances defined in terms of the algebraic structure of a type.

ImplicitPrelude

GHC § 7.3.11
  Enable the implicit importing of the module `Prelude`. When disabled, when desugaring certain built-in syntax into ordinary identifiers, use whatever is in scope rather than the `Prelude` -- version.

NamedFieldPuns

GHC § 7.3.15
  Enable syntax for implicitly binding local names corresponding to the field names of a record. Puns bind specific names, unlike `RecordWildCards`.

PatternGuards

GHC § 7.3.5
  Enable a form of guard which matches a pattern and binds variables.

GeneralizedNewtypeDeriving

GHC § 7.5.4
  Allow a type declared with `newtype` to use `deriving` for any class with an instance for the underlying type.

DeriveAnyClass

GHC § 9.6.10
  Allow use of any typeclass in deriving clauses.

ExtensibleRecords

Hugs § 7.1
  Enable the "Trex" extensible records system.

RestrictedTypeSynonyms

Hugs § 7.2
  Enable type synonyms which are transparent in some definitions and opaque elsewhere, as a way of implementing abstract datatypes.

HereDocuments

Hugs § 7.3
  Enable an alternate syntax for string literals, with string templating.

MagicHash

GHC § 7.3.2
  Allow the character `#` as a postfix modifier on identifiers. Also enables literal syntax for unboxed values.

BinaryLiterals | Binary integer literals

TypeFamilies

GHC § 7.7
  Allow data types and type synonyms which are indexed by types, i.e. ad-hoc polymorphism for types.

StandaloneDeriving

GHC § 7.5.2
  Allow a standalone declaration which invokes the type class `deriving` mechanism.

UnicodeSyntax

GHC § 7.3.1
  Allow certain Unicode characters to stand for certain ASCII character sequences, e.g. keywords and punctuation.

UnliftedFFITypes

GHC § 8.1.1
  Allow the use of unboxed types as foreign types, e.g. in `foreign import` and `foreign export`.

LiberalTypeSynonyms

GHC § 7.4.3
  Defer validity checking of types until after expanding type synonyms, relaxing the constraints on how synonyms may be used.

TypeOperators

GHC § 7.4.2
  Allow the name of a type constructor, type class, or type variable to be an infix operator.

ParallelArrays

GHC § 7.26.5
  Parallel arrays for Data Parallel Haskell.

RecordWildCards

GHC § 7.3.16
  Enable syntax for implicitly binding local names corresponding to the field names of a record. A wildcard binds all unmentioned names, unlike `NamedFieldPuns`.

RecordPuns | Deprecated, use `NamedFieldPuns` instead.

DisambiguateRecordFields

GHC § 7.3.14
  Allow a record field name to be disambiguated by the type of the record it's in.

OverloadedStrings

GHC § 7.6.4
  Enable overloading of string literals using a type class, much like integer literals.

GADTs

GHC § 7.4.6
  Enable generalized algebraic data types, in which type variables may be instantiated on a per-constructor basis. Implies GADTSyntax.

MonoPatBinds

GHC § 7.17.2
  Make pattern bindings monomorphic.

RelaxedPolyRec

GHC § 7.8.8
  Relax the requirements on mutually-recursive polymorphic functions.

ExtendedDefaultRules

GHC § 2.4.5
  Allow default instantiation of polymorphic types in more situations.

UnboxedTuples

GHC § 7.2.2
  Enable unboxed tuples.

DeriveDataTypeable

GHC § 7.5.3
  Enable `deriving` for classes `Data.Typeable.Typeable` and `Data.Generics.Data`.

ConstrainedClassMethods

GHC § 7.6.1.3
  Allow a class method's type to place additional constraints on a class type variable.

PackageImports

GHC § 7.3.18
  Allow imports to be qualified by the package name the module is intended to be imported from, e.g.

    import "network" Network.Socket

LambdaCase |

EmptyCase

GHC § 7.3.20
  Allow case expressions with no alternatives.

ImpredicativeTypes

GHC § 7.8.6
  Deprecated in GHC 6.12 and will be removed in GHC 7. Allow a type variable to be instantiated at a polymorphic type.

NewQualifiedOperators

GHC § 7.3.3
  Change the syntax for qualified infix operators.

PostfixOperators

GHC § 7.3.12
  Relax the interpretation of left operator sections to allow unary postfix operators.

QuasiQuotes

GHC § 7.9.5
  Enable quasi-quotation, a mechanism for defining new concrete syntax for expressions and patterns.

TransformListComp

GHC § 7.3.10
  Enable generalized list comprehensions, supporting operations such as sorting and grouping.

ViewPatterns

GHC § 7.3.6
  Enable view patterns, which match a value by applying a function and matching on the result.

XmlSyntax | Allow concrete XML syntax to be used in expressions and patterns, as per the Haskell Server Pages extension language: http://www.haskell.org/haskellwiki/HSP. The ideas behind it are discussed in the paper "Haskell Server Pages through Dynamic Loading" by Niklas Broberg, from Haskell Workshop '05.
RegularPatterns | Allow regular pattern matching over lists, as discussed in the paper "Regular Expression Patterns" by Niklas Broberg, Andreas Farre and Josef Svenningsson, from ICFP '04.
TupleSections | Enables the use of tuple sections, e.g. `(, True)` desugars into `x -> (x, True)`.
GHCForeignImportPrim | Allows GHC primops, written in C--, to be imported into a Haskell file.
NPlusKPatterns | Support for patterns of the form `n + k`, where `k` is an integer literal.
DoAndIfThenElse | Improve the layout rule when `if` expressions are used in a `do` block.
RebindableSyntax | Makes much of the Haskell sugar be desugared into calls to the function with a particular name that is in scope.
ExplicitForAll | Make `forall` a keyword in types, which can be used to give the generalisation explicitly.
DatatypeContexts | Allow contexts to be put on datatypes, e.g. the `Eq a` in `data Eq a => Set a = NilSet | ConsSet a (Set a)`.
MonoLocalBinds | Local (`let` and `where`) bindings are monomorphic.
DeriveFunctor | Enable `deriving` for the `Data.Functor.Functor` class.

DeriveGeneric

GHC § 7.5.3
  Enable `deriving` for the `Generic` and `Generic1` classes.

DeriveTraversable | Enable `deriving` for the `Data.Traversable.Traversable` class.
DeriveFoldable | Enable `deriving` for the `Data.Foldable.Foldable` class.
NondecreasingIndentation | Enable non-decreasing indentation for 'do' blocks.

InterruptibleFFI

GHC § 8.1.4
  Enable interruptible FFI.

CApiFFI

GHC § 8.1.5
  Enable the `capi` calling convention in the foreign function interface.

JavaScriptFFI | GHCJS FFI extension with convenient import patterns, asynchronous FFI and a JSVal FFI type

ExplicitNamespaces

GHC § 7.3.27
  Enable explicit namespaces in import/export.

DataKinds |
PolyKinds |

MultiWayIf

GHC § 7.3.16
  Enable the multi-way if-expressions extension to accept conditional expressions with multiple branches.

SafeImports

GHC § 7.20.3
  Allow imports to be qualified with a safe keyword that requires the imported module be trusted as according to the Safe Haskell definition of trust.

    import safe Network.Socket

Safe

GHC § 7.20
  Compile a module in the Safe, Safe Haskell mode -- a restricted form of the Haskell language to ensure type safety.

Trustworthy

GHC § 7.20
  Compile a module in the Trustworthy, Safe Haskell mode -- no restrictions apply but the module is marked as trusted as long as the package the module resides in is trusted.

DefaultSignatures

GHC § 7.6.1.4
  Allow default signatures in class definitions. They apply to default methods implemented in this class.

ConstraintKinds

GHC § 7.40
  Allow type classimplicit parameterequality constraints to be used as types with the special kind Constraint. Also generalise the (ctxt => ty) syntax so that any type of kind Constraint can occur before the arrow.

RoleAnnotations

GHC § 7.25.3
  Allow role annotations.

PatternSynonyms

GHC § 7.3.8
  Enable giving names to parametrized pattern schemes

PartialTypeSignatures

GHC § 7.15
  Allow partial specified type signatures. Note that this extension does not affect parsing. It only affects whether the program is able to be run with partial signatures.

NamedWildCards

GHC § 7.15.1.2
  This extension treats type variables which start with an underscore as wildcards. For example, `foo :: _x` is equivalent to `foo :: _`.

TypeApplications |
TypeFamilyDependencies |
OverloadedLabels |
DerivingStrategies | Allow multiple `deriving` clauses, each optionally qualified with a strategy.
UnboxedSums |

Instances

Bounded KnownExtension |
Instance details Defined in Language.Haskell.Exts.Extension Methods minBound :: KnownExtension Source # maxBound :: KnownExtension Source #
Enum KnownExtension |

Instance details

Defined in Language.Haskell.Exts.Extension

Methods

succ :: KnownExtension -> KnownExtension Source #

pred :: KnownExtension -> KnownExtension Source #

toEnum :: Int -> KnownExtension Source #

fromEnum :: KnownExtension -> Int Source #

enumFrom :: KnownExtension -> [KnownExtension] Source #

enumFromThen :: KnownExtension -> KnownExtension -> [KnownExtension] Source #

enumFromTo :: KnownExtension -> KnownExtension -> [KnownExtension] Source #

enumFromThenTo :: KnownExtension -> KnownExtension -> KnownExtension -> [KnownExtension] Source #

Eq KnownExtension |
Instance details Defined in Language.Haskell.Exts.Extension Methods (==) :: KnownExtension -> KnownExtension -> Bool Source # (/=) :: KnownExtension -> KnownExtension -> Bool Source #
Data KnownExtension |

Instance details

Defined in Language.Haskell.Exts.Extension

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> KnownExtension -> c KnownExtension Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c KnownExtension Source #

toConstr :: KnownExtension -> Constr Source #

dataTypeOf :: KnownExtension -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c KnownExtension) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KnownExtension) Source #

gmapT :: (forall b. Data b => b -> b) -> KnownExtension -> KnownExtension Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> KnownExtension -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> KnownExtension -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> KnownExtension -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> KnownExtension -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> KnownExtension -> m KnownExtension Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> KnownExtension -> m KnownExtension Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> KnownExtension -> m KnownExtension Source #

Ord KnownExtension |

Instance details

Defined in Language.Haskell.Exts.Extension

Methods

compare :: KnownExtension -> KnownExtension -> Ordering Source #

(<) :: KnownExtension -> KnownExtension -> Bool Source #

(<=) :: KnownExtension -> KnownExtension -> Bool Source #

(>) :: KnownExtension -> KnownExtension -> Bool Source #

(>=) :: KnownExtension -> KnownExtension -> Bool Source #

max :: KnownExtension -> KnownExtension -> KnownExtension Source #

min :: KnownExtension -> KnownExtension -> KnownExtension Source #

Read KnownExtension |
Instance details Defined in Language.Haskell.Exts.Extension Methods readsPrec :: Int -> ReadS KnownExtension Source # readList :: ReadS [KnownExtension] Source # readPrec :: ReadPrec KnownExtension Source # readListPrec :: ReadPrec [KnownExtension] Source #
Show KnownExtension |
Instance details Defined in Language.Haskell.Exts.Extension Methods showsPrec :: Int -> KnownExtension -> ShowS Source # show :: KnownExtension -> String Source # showList :: [KnownExtension] -> ShowS Source #

data Mode Source #

Rendering mode.

Constructors

PageMode | Normal rendering (`lineLength` and `ribbonsPerLine` respected').
ZigZagMode | With zig-zag cuts.
LeftMode | No indentation, infinitely long lines (`lineLength` ignored), but explicit new lines, i.e., `text "one" $$ text "two"`, are respected.
OneLineMode | All on one line, `lineLength` ignored and explicit new lines (`$$`) are turned into spaces.

Instances

Eq Mode |
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (==) :: Mode -> Mode -> Bool Source # (/=) :: Mode -> Mode -> Bool Source #
Show Mode |
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> Mode -> ShowS Source # show :: Mode -> String Source # showList :: [Mode] -> ShowS Source #
Generic Mode |
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep Mode :: Type -> Type Source # Methods from :: Mode -> Rep Mode x Source # to :: Rep Mode x -> Mode Source #
type Rep Mode |

Instance details

Defined in Text.PrettyPrint.Annotated.HughesPJ

type Rep Mode = D1 (MetaData "Mode" "Text.PrettyPrint.Annotated.HughesPJ" "pretty-1.1.3.6" False) ((C1 (MetaCons "PageMode" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ZigZagMode" PrefixI False) (U1 :: Type -> Type)) :+: (C1 (MetaCons "LeftMode" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "OneLineMode" PrefixI False) (U1 :: Type -> Type)))

data Style Source #

A rendering style. Allows us to specify constraints to choose among the many different rendering options.

Constructors

Style |

Fields

- mode :: Mode

  The rendering mode.

- lineLength :: Int

  Maximum length of a line, in characters.

- ribbonsPerLine :: Float

  Ratio of line length to ribbon length. A ribbon refers to the characters on a line excluding indentation. So a `lineLength` of 100, with a `ribbonsPerLine` of `2.0` would only allow up to 50 characters of ribbon to be displayed on a line, while allowing it to be indented up to 50 characters.

Instances

Eq Style |
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (==) :: Style -> Style -> Bool Source # (/=) :: Style -> Style -> Bool Source #
Show Style |
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> Style -> ShowS Source # show :: Style -> String Source # showList :: [Style] -> ShowS Source #
Generic Style |
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep Style :: Type -> Type Source # Methods from :: Style -> Rep Style x Source # to :: Rep Style x -> Style Source #
type Rep Style |

Instance details

Defined in Text.PrettyPrint.Annotated.HughesPJ

type Rep Style = D1 (MetaData "Style" "Text.PrettyPrint.Annotated.HughesPJ" "pretty-1.1.3.6" False) (C1 (MetaCons "Style" PrefixI True) (S1 (MetaSel (Just "mode") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Mode) :*: (S1 (MetaSel (Just "lineLength") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int) :*: S1 (MetaSel (Just "ribbonsPerLine") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Float))))

style :: Style Source #

The default style (`mode=PageMode, lineLength=100, ribbonsPerLine=1.5`).