Language.Haskell.TH.Lens · lens-5.3.5

Traversals

8 declarations

classclass HasName t where

#

Has a Name

Methods

name :: Lens' t Name
Extract (or modify) the Name of something

Instances7HasName, …

HasName ConDefined in lens-5.3.5 · Language.Haskell.TH.Lens
On template-haskell-2.11.0.0 or later, if a GadtC or RecGadtC has multiple Names, the leftmost Name will be chosen.
HasName ForeignDefined in lens-5.3.5 · Language.Haskell.TH.Lens
HasName InjectivityAnnDefined in lens-5.3.5 · Language.Haskell.TH.Lens
HasName NameDefined in lens-5.3.5 · Language.Haskell.TH.Lens
HasName RuleBndrDefined in lens-5.3.5 · Language.Haskell.TH.Lens
HasName TypeFamilyHeadDefined in lens-5.3.5 · Language.Haskell.TH.Lens
HasName (TyVarBndr_ flag)Defined in lens-5.3.5 · Language.Haskell.TH.Lens

classclass HasTypes t where

#

Contains some amount of Types inside

Methods

types :: Traversal' t Type
Traverse all the types

Instances5HasTypes

HasTypes ConDefined in lens-5.3.5 · Language.Haskell.TH.Lens
HasTypes ForeignDefined in lens-5.3.5 · Language.Haskell.TH.Lens
HasTypes TySynEqnDefined in lens-5.3.5 · Language.Haskell.TH.Lens
HasTypes TypeDefined in lens-5.3.5 · Language.Haskell.TH.Lens
HasTypes t => HasTypes [t]Defined in lens-5.3.5 · Language.Haskell.TH.Lens

classclass HasTypeVars t where

#

Provides for the extraction of free type variables, and alpha renaming.

Methods

typeVarsEx :: Set Name -> Traversal' t Name
When performing substitution into this traversal you're not allowed to substitute in a name that is bound internally or you'll violate the Traversal laws, when in doubt generate your names with newName.

Instances7HasTypeVars, …

HasTypeVars NConDefined in lens-5.3.5 · Control.Lens.Internal.PrismTH
HasTypeVars ConDefined in lens-5.3.5 · Language.Haskell.TH.Lens
HasTypeVars NameDefined in lens-5.3.5 · Language.Haskell.TH.Lens
HasTypeVars TypeDefined in lens-5.3.5 · Language.Haskell.TH.Lens
HasTypeVars (TyVarBndr_ flag)Defined in lens-5.3.5 · Language.Haskell.TH.Lens
HasTypeVars t => HasTypeVars (Maybe t)Defined in lens-5.3.5 · Language.Haskell.TH.Lens
HasTypeVars t => HasTypeVars [t]Defined in lens-5.3.5 · Language.Haskell.TH.Lens

classclass SubstType t where

#

Provides substitution for types

Methods

substType :: Map Name Type -> t -> t
Perform substitution for types

Instances2SubstType

SubstType TypeDefined in lens-5.3.5 · Language.Haskell.TH.Lens
SubstType t => SubstType [t]Defined in lens-5.3.5 · Language.Haskell.TH.Lens

valuetypeVars :: HasTypeVars t => Traversal' t Name

#

Traverse free type variables

valuesubstTypeVars :: HasTypeVars t => Map Name Name -> t -> t

#

Substitute using a map of names in for free type variables

valueconFields :: Traversal' Con BangType

#

Provides a Traversal of the types of each field of a constructor.

valueconNamedFields :: Traversal' Con VarBangType

#

Traversal of the types of the named fields of a constructor.

Lenses

0 declarations

Loc Lenses

valuelocFileName :: Lens' Loc String

#

valuelocPackage :: Lens' Loc String

#

valuelocModule :: Lens' Loc String

#

valuelocStart :: Lens' Loc CharPos

#

valuelocEnd :: Lens' Loc CharPos

#

FunDep Lenses

valuefunDepInputs :: Lens' FunDep [Name]

#

valuefunDepOutputs :: Lens' FunDep [Name]

#

Match Lenses

valuematchPattern :: Lens' Match Pat

#

valuematchBody :: Lens' Match Body

#

valuematchDeclarations :: Lens' Match [Dec]

#

Fixity Lenses

valuefixityPrecedence :: Lens' Fixity Int

#

valuefixityDirection :: Lens' Fixity FixityDirection

#

Clause Lenses

valueclausePattern :: Lens' Clause [Pat]

#

valueclauseBody :: Lens' Clause Body

#

valueclauseDecs :: Lens' Clause [Dec]

#

FieldExp Lenses

valuefieldExpName :: Lens' FieldExp Name

#

valuefieldExpExpression :: Lens' FieldExp Exp

#

FieldPat Lenses

valuefieldPatName :: Lens' FieldPat Name

#

valuefieldPatPattern :: Lens' FieldPat Pat

#

TySynEqn Lenses

valuetySynEqnLHS :: Lens' TySynEqn Type

#

valuetySynEqnPatterns :: Lens' TySynEqn [Type]

#

valuetySynEqnResult :: Lens' TySynEqn Type

#

InjectivityAnn Lenses

valueinjectivityAnnOutput :: Lens' InjectivityAnn Name

#

valueinjectivityAnnInputs :: Lens' InjectivityAnn [Name]

#

TypeFamilyHead Lenses

valuetypeFamilyHeadName :: Lens' TypeFamilyHead Name

#

valuetypeFamilyHeadTyVarBndrs :: Lens' TypeFamilyHead [TyVarBndrVis]

#

valuetypeFamilyHeadResultSig :: Lens' TypeFamilyHead FamilyResultSig

#

valuetypeFamilyHeadInjectivityAnn :: Lens' TypeFamilyHead (Maybe InjectivityAnn)

#

Bang Lenses

valuebangSourceUnpackedness :: Lens' Bang SourceUnpackedness

#

valuebangSourceStrictness :: Lens' Bang SourceStrictness

#

DerivClause Lenses

valuederivClauseStrategy :: Lens' DerivClause (Maybe DerivStrategy)

#

valuederivClauseCxt :: Lens' DerivClause Cxt

#

Prisms

0 declarations

Info Prisms

value_ClassI :: Prism' Info (Dec, [InstanceDec])

#

value_ClassOpI :: Prism' Info (Name, Type, ParentName)

#

value_TyConI :: Prism' Info Dec

#

value_FamilyI :: Prism' Info (Dec, [InstanceDec])

#

value_PrimTyConI :: Prism' Info (Name, Arity, Unlifted)

#

value_DataConI :: Prism' Info (Name, Type, ParentName)

#

value_VarI :: Prism' Info (Name, Type, Maybe Dec)

#

value_TyVarI :: Prism' Info (Name, Type)

#

value_PatSynI :: Prism' Info (Name, PatSynType)

#

Dec Prisms

value_FunD :: Prism' Dec (Name, [Clause])

#

value_ValD :: Prism' Dec (Pat, Body, [Dec])

#

value_DataD :: DataPrism' [TyVarBndrVis] [Con]

#

_DataD :: Prism' Dec (Cxt, Name, [TyVarBndrUnit], Maybe Kind, [Con], [DerivClause]) -- template-haskell-2.12+
_DataD :: Prism' Dec (Cxt, Name, [Type],          Maybe Kind, [Con], Cxt)           -- Earlier versions

value_NewtypeD :: DataPrism' [TyVarBndrVis] Con

#

_NewtypeD :: Prism' Dec (Cxt, Name, [TyVarBndrUnit], Maybe Kind, Con, [DerivClause]) -- template-haskell-2.12+
_NewtypeD :: Prism' Dec (Cxt, Name, [Type],          Maybe Kind, Con, Cxt)           -- Earlier versions

value_TySynD :: Prism' Dec (Name, [TyVarBndrVis], Type)

#

value_ClassD :: Prism' Dec (Cxt, Name, [TyVarBndrVis], [FunDep], [Dec])

#

value_InstanceD :: Prism' Dec (Maybe Overlap, Cxt, Type, [Dec])

#

value_SigD :: Prism' Dec (Name, Type)

#

value_ForeignD :: Prism' Dec Foreign

#

value_InfixD :: Prism' Dec (Fixity, NamespaceSpecifier, Name)

#

_InfixD :: Prism' Dec (Fixity, NamespaceSpecifier, Name) -- template-haskell-2.22+
_InfixD :: Prism' Dec (Fixity, Name)                     -- Earlier versions

value_PragmaD :: Prism' Dec Pragma

#

value_DataInstD :: Prism' Dec (Cxt, Maybe [TyVarBndrUnit], Type, Maybe Kind, [Con], [DerivClause])

#

_DataInstD :: Prism' Dec (Cxt, Maybe [TyVarBndrUnit], Type, Maybe Kind, [Con], [DerivClause]) -- template-haskell-2.15+
_DataInstD :: Prism' Dec (Cxt, Name, [Type],                Maybe Kind, [Con], [DerivClause]) -- template-haskell-2.12 through 2.14
_DataInstD :: Prism' Dec (Cxt, Name, [Type],                Maybe Kind, [Con], Cxt)           -- Earlier versions

value_NewtypeInstD :: Prism' Dec (Cxt, Maybe [TyVarBndrUnit], Type, Maybe Kind, Con, [DerivClause])

#

_NewtypeInstD :: Prism' Dec (Cxt, Maybe [TyVarBndrUnit], Type, Maybe Kind, Con, [DerivClause]) -- template-haskell-2.15+
_NewtypeInstD :: Prism' Dec (Cxt, Name, [Type],                Maybe Kind, Con, [DerivClause]) -- template-haskell-2.12 through 2.14
_NewtypeInstD :: Prism' Dec (Cxt, Name, [Type],                Maybe Kind, Con, Cxt)           -- Earlier versions

value_TySynInstD :: Prism' Dec TySynEqn

#

_TySynInstD :: Prism' Dec TySynEqn             -- template-haskell-2.15+
_TySynInstD :: Prism' Dec (Name, TySynEqn)     -- template-haskell-2.9 through 2.14
_TySynInstD :: Prism' Dec (Name, [Type], Type) -- Earlier versions

value_ClosedTypeFamilyD :: Prism' Dec (TypeFamilyHead, [TySynEqn])

#

value_RoleAnnotD :: Prism' Dec (Name, [Role])

#

value_StandaloneDerivD :: Prism' Dec (Maybe DerivStrategy, Cxt, Type)

#

_StandaloneDerivD :: Prism' Dec (Maybe DerivStrategy, Cxt, Type) -- template-haskell-2.12+
_StandaloneDerivD :: Prism' Dec                      (Cxt, Type) -- Earlier versions

value_DefaultSigD :: Prism' Dec (Name, Type)

#

value_DataFamilyD :: Prism' Dec (Name, [TyVarBndrVis], Maybe Kind)

#

value_OpenTypeFamilyD :: Prism' Dec TypeFamilyHead

#

value_PatSynD :: Prism' Dec (Name, PatSynArgs, PatSynDir, Pat)

#

value_PatSynSigD :: Prism' Dec (Name, PatSynType)

#

value_ImplicitParamBindD :: Prism' Dec (String, Exp)

#

value_DefaultD :: Prism' Dec [Type]

#

value_TypeDataD :: Prism' Dec (Name, [TyVarBndrVis], Maybe Kind, [Con])

#

PatSynDir Prisms

value_Unidir :: Prism' PatSynDir ()

#

value_ImplBidir :: Prism' PatSynDir ()

#

value_ExplBidir :: Prism' PatSynDir [Clause]

#

PatSynArgs Prisms

value_PrefixPatSyn :: Prism' PatSynArgs [Name]

#

value_InfixPatSyn :: Prism' PatSynArgs (Name, Name)

#

value_RecordPatSyn :: Prism' PatSynArgs [Name]

#

Con Prisms

value_NormalC :: Prism' Con (Name, [BangType])

#

value_RecC :: Prism' Con (Name, [VarBangType])

#

value_InfixC :: Prism' Con (BangType, Name, BangType)

#

value_ForallC :: Prism' Con ([TyVarBndrSpec], Cxt, Con)

#

value_GadtC :: Prism' Con ([Name], [BangType], Type)

#

value_RecGadtC :: Prism' Con ([Name], [VarBangType], Type)

#

NamespaceSpecifier Prisms

value_NoNamespaceSpecifier :: Prism' NamespaceSpecifier ()

#

value_TypeNamespaceSpecifier :: Prism' NamespaceSpecifier ()

#

value_DataNamespaceSpecifier :: Prism' NamespaceSpecifier ()

#

Overlap Prisms

value_Overlappable :: Prism' Overlap ()

#

value_Overlapping :: Prism' Overlap ()

#

value_Overlaps :: Prism' Overlap ()

#

value_Incoherent :: Prism' Overlap ()

#

SourceUnpackedness Prisms

value_NoSourceUnpackedness :: Prism' SourceUnpackedness ()

#

value_SourceNoUnpack :: Prism' SourceUnpackedness ()

#

value_SourceUnpack :: Prism' SourceUnpackedness ()

#

SourceStrictness Prisms

value_NoSourceStrictness :: Prism' SourceStrictness ()

#

value_SourceLazy :: Prism' SourceStrictness ()

#

value_SourceStrict :: Prism' SourceStrictness ()

#

DecidedStrictness Prisms

value_DecidedLazy :: Prism' DecidedStrictness ()

#

value_DecidedStrict :: Prism' DecidedStrictness ()

#

value_DecidedUnpack :: Prism' DecidedStrictness ()

#

Foreign Prisms

value_ImportF :: Prism' Foreign (Callconv, Safety, String, Name, Type)

#

value_ExportF :: Prism' Foreign (Callconv, String, Name, Type)

#

Callconv Prisms

value_CCall :: Prism' Callconv ()

#

value_StdCall :: Prism' Callconv ()

#

value_CApi :: Prism' Callconv ()

#

value_Prim :: Prism' Callconv ()

#

value_JavaScript :: Prism' Callconv ()

#

Safety Prisms

value_Unsafe :: Prism' Safety ()

#

value_Safe :: Prism' Safety ()

#

value_Interruptible :: Prism' Safety ()

#

Pragma Prisms

value_InlineP :: Prism' Pragma (Name, Inline, RuleMatch, Phases)

#

value_SpecialiseP :: Prism' Pragma (Name, Type, Maybe Inline, Phases)

#

value_SpecialiseInstP :: Prism' Pragma Type

#

value_RuleP :: Prism' Pragma (String, Maybe [TyVarBndrUnit], [RuleBndr], Exp, Exp, Phases)

#

_RuleP :: Prism' Pragma (String, Maybe [TyVarBndrUnit], [RuleBndr], Exp, Exp, Phases) -- template-haskell-2.15+
_RuleP :: Prism' Pragma (String,                        [RuleBndr], Exp, Exp, Phases) -- Earlier versions

value_AnnP :: Prism' Pragma (AnnTarget, Exp)

#

value_LineP :: Prism' Pragma (Int, String)

#

value_CompleteP :: Prism' Pragma ([Name], Maybe Name)

#

value_OpaqueP :: Prism' Pragma Name

#

value_SCCP :: Prism' Pragma (Name, Maybe String)

#

Inline Prisms

value_NoInline :: Prism' Inline ()

#

value_Inline :: Prism' Inline ()

#

value_Inlinable :: Prism' Inline ()

#

RuleMatch Prisms

value_ConLike :: Prism' RuleMatch ()

#

value_FunLike :: Prism' RuleMatch ()

#

Phases Prisms

value_AllPhases :: Prism' Phases ()

#

value_FromPhase :: Prism' Phases Int

#

value_BeforePhase :: Prism' Phases Int

#

RuleBndr Prisms

value_RuleVar :: Prism' RuleBndr Name

#

value_TypedRuleVar :: Prism' RuleBndr (Name, Type)

#

AnnTarget Prisms

value_ModuleAnnotation :: Prism' AnnTarget ()

#

value_TypeAnnotation :: Prism' AnnTarget Name

#

value_ValueAnnotation :: Prism' AnnTarget Name

#

FunDep Prisms TODO make a lens

value_FunDep :: Iso' FunDep ([Name], [Name])

#

FixityDirection Prisms

value_InfixL :: Prism' FixityDirection ()

#

value_InfixR :: Prism' FixityDirection ()

#

value_InfixN :: Prism' FixityDirection ()

#

Exp Prisms

value_VarE :: Prism' Exp Name

#

value_ConE :: Prism' Exp Name

#

value_LitE :: Prism' Exp Lit

#

value_AppE :: Prism' Exp (Exp, Exp)

#

value_AppTypeE :: Prism' Exp (Exp, Type)

#

value_InfixE :: Prism' Exp (Maybe Exp, Exp, Maybe Exp)

#

value_UInfixE :: Prism' Exp (Exp, Exp, Exp)

#

value_ParensE :: Prism' Exp Exp

#

value_LamE :: Prism' Exp ([Pat], Exp)

#

value_LamCaseE :: Prism' Exp [Match]

#

value_TupE :: Prism' Exp [Maybe Exp]

#

_TupE :: Prism' Exp [Maybe Exp] -- template-haskell-2.16+
_TupE :: Prism' Exp [Exp]       -- Earlier versions

value_UnboxedTupE :: Prism' Exp [Maybe Exp]

#

_UnboxedTupE :: Prism' Exp [Maybe Exp] -- template-haskell-2.16+
_UnboxedTupE :: Prism' Exp [Exp]       -- Earlier versions

value_UnboxedSumE :: Prism' Exp (Exp, SumAlt, SumArity)

#

value_CondE :: Prism' Exp (Exp, Exp, Exp)

#

value_MultiIfE :: Prism' Exp [(Guard, Exp)]

#

value_LetE :: Prism' Exp ([Dec], Exp)

#

value_CaseE :: Prism' Exp (Exp, [Match])

#

value_DoE :: Prism' Exp (Maybe ModName, [Stmt])

#

_DoE :: Prism' Exp (Maybe ModName, [Stmt]) -- template-haskell-2.17+
_DoE :: Prism' Exp [Stmt]                  -- Earlier versions

value_CompE :: Prism' Exp [Stmt]

#

value_ArithSeqE :: Prism' Exp Range

#

value_ListE :: Prism' Exp [Exp]

#

value_SigE :: Prism' Exp (Exp, Type)

#

value_RecConE :: Prism' Exp (Name, [FieldExp])

#

value_RecUpdE :: Prism' Exp (Exp, [FieldExp])

#

value_StaticE :: Prism' Exp Exp

#

value_UnboundVarE :: Prism' Exp Name

#

value_LabelE :: Prism' Exp String

#

value_MDoE :: Prism' Exp (Maybe ModName, [Stmt])

#

_MDoE :: Prism' Exp (Maybe ModName, [Stmt]) -- template-haskell-2.17+
_MDoE :: Prism' Exp [Stmt]                  -- Earlier versions

value_ImplicitParamVarE :: Prism' Exp String

#

value_GetFieldE :: Prism' Exp (Exp, String)

#

value_ProjectionE :: Prism' Exp (NonEmpty String)

#

value_LamCasesE :: Prism' Exp [Clause]

#

value_TypedBracketE :: Prism' Exp Exp

#

value_TypedSpliceE :: Prism' Exp Exp

#

value_TypeE :: Prism' Exp Type

#

Body Prisms

value_GuardedB :: Prism' Body [(Guard, Exp)]

#

value_NormalB :: Prism' Body Exp

#

Guard Prisms

value_NormalG :: Prism' Guard Exp

#

value_PatG :: Prism' Guard [Stmt]

#

Stmt Prisms

value_BindS :: Prism' Stmt (Pat, Exp)

#

value_LetS :: Prism' Stmt [Dec]

#

value_NoBindS :: Prism' Stmt Exp

#

value_ParS :: Prism' Stmt [[Stmt]]

#

value_RecS :: Prism' Stmt [Stmt]

#

Range Prisms

value_FromR :: Prism' Range Exp

#

value_FromThenR :: Prism' Range (Exp, Exp)

#

value_FromToR :: Prism' Range (Exp, Exp)

#

value_FromThenToR :: Prism' Range (Exp, Exp, Exp)

#

Lit Prisms

value_CharL :: Prism' Lit Char

#

value_StringL :: Prism' Lit String

#

value_IntegerL :: Prism' Lit Integer

#

value_RationalL :: Prism' Lit Rational

#

value_IntPrimL :: Prism' Lit Integer

#

value_WordPrimL :: Prism' Lit Integer

#

value_FloatPrimL :: Prism' Lit Rational

#

value_DoublePrimL :: Prism' Lit Rational

#

value_StringPrimL :: Prism' Lit [Word8]

#

value_CharPrimL :: Prism' Lit Char

#

value_BytesPrimL :: Prism' Lit Bytes

#

Pat Prisms

value_LitP :: Prism' Pat Lit

#

value_VarP :: Prism' Pat Name

#

value_TupP :: Prism' Pat [Pat]

#

value_UnboxedTupP :: Prism' Pat [Pat]

#

value_UnboxedSumP :: Prism' Pat (Pat, SumAlt, SumArity)

#

value_ConP :: Prism' Pat (Name, [Type], [Pat])

#

_ConP :: Prism' Pat (Name, [Type], [Pat]) -- template-haskell-2.18+
_ConP :: Prism' Pat (Name,         [Pat]) -- Earlier versions

value_InfixP :: Prism' Pat (Pat, Name, Pat)

#

value_UInfixP :: Prism' Pat (Pat, Name, Pat)

#

value_ParensP :: Prism' Pat Pat

#

value_TildeP :: Prism' Pat Pat

#

value_BangP :: Prism' Pat Pat

#

value_AsP :: Prism' Pat (Name, Pat)

#

value_WildP :: Prism' Pat ()

#

value_RecP :: Prism' Pat (Name, [FieldPat])

#

value_ListP :: Prism' Pat [Pat]

#

value_SigP :: Prism' Pat (Pat, Type)

#

value_ViewP :: Prism' Pat (Exp, Pat)

#

value_TypeP :: Prism' Pat Type

#

value_InvisP :: Prism' Pat Type

#

Type Prisms

value_ForallT :: Prism' Type ([TyVarBndrSpec], Cxt, Type)

#

value_AppT :: Prism' Type (Type, Type)

#

value_SigT :: Prism' Type (Type, Kind)

#

value_VarT :: Prism' Type Name

#

value_ConT :: Prism' Type Name

#

value_PromotedT :: Prism' Type Name

#

value_TupleT :: Prism' Type Int

#

value_UnboxedTupleT :: Prism' Type Int

#

value_UnboxedSumT :: Prism' Type SumArity

#

value_ArrowT :: Prism' Type ()

#

value_EqualityT :: Prism' Type ()

#

value_ListT :: Prism' Type ()

#

value_PromotedTupleT :: Prism' Type Int

#

value_PromotedNilT :: Prism' Type ()

#

value_PromotedConsT :: Prism' Type ()

#

value_StarT :: Prism' Type ()

#

value_ConstraintT :: Prism' Type ()

#

value_LitT :: Prism' Type TyLit

#

value_InfixT :: Prism' Type (Type, Name, Type)

#

value_UInfixT :: Prism' Type (Type, Name, Type)

#

value_ParensT :: Prism' Type Type

#

value_WildCardT :: Prism' Type ()

#

value_AppKindT :: Prism' Type (Type, Kind)

#

value_ImplicitParamT :: Prism' Type (String, Type)

#

value_ForallVisT :: Prism' Type ([TyVarBndrUnit], Type)

#

value_MulArrowT :: Prism' Type ()

#

value_PromotedInfixT :: Prism' Type (Type, Name, Type)

#

value_PromotedUInfixT :: Prism' Type (Type, Name, Type)

#

Specificity Prisms

value_SpecifiedSpec :: Prism' Specificity ()

#

value_InferredSpec :: Prism' Specificity ()

#

BndrVis Prisms

value_BndrReq :: Prism' BndrVis ()

#

value_BndrInvis :: Prism' BndrVis ()

#

TyVarBndr Prisms

value_PlainTV

:: (Choice p, Applicative f)
=> p (Name, flag) (f (Name, flag))
-> p (TyVarBndr flag) (f (TyVarBndr flag))

#

_PlainTV :: Prism' (TyVarBndr flag) (Name, flag) -- template-haskell-2.17+
_PlainTV :: Prism'  TyVarBndr        Name        -- Earlier versions

value_KindedTV

:: (Choice p, Applicative f)
=> p (Name, flag, Kind) (f (Name, flag, Kind))
-> p (TyVarBndr flag) (f (TyVarBndr flag))

#

_KindedTV :: Prism' (TyVarBndr flag) (Name, flag, Kind) -- template-haskell-2.17+
_KindedTV :: Prism'  TyVarBndr       (Name,       Kind) -- Earlier versions