    {-# LANGUAGE CPP #-}
    #if defined(__GLASGOW_HASKELL__)
    {-# LANGUAGE Trustworthy #-}
    #endif
    {-# LANGUAGE Rank2Types #-}

    #if __GLASGOW_HASKELL__ >= 800
    {-# OPTIONS_GHC -Wno-trustworthy-safe #-}
    #endif

    #ifndef MIN_VERSION_template_haskell
    #define MIN_VERSION_template_haskell(x,y,z) 1
    #endif
    -----------------------------------------------------------------------------
    -- |
    -- Module      :  Language.Haskell.TH.Lens
    -- Copyright   :  (C) 2012-2016 Edward Kmett
    -- License     :  BSD-style (see the file LICENSE)
    -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
    -- Stability   :  experimental
    -- Portability :  TemplateHaskell
    --
    -- Lenses, Prisms, and Traversals for working with Template Haskell.
    --
    -- Beware that the API offered in this module is subject to change, as it
    -- mirrors the API exposed by the @template-haskell@ package, which
    -- frequently changes between different releases of GHC. An effort is made
    -- to identify the functions in this module which have different type
    -- signatures when compiled with different versions of @template-haskell@.
    ----------------------------------------------------------------------------
    module Language.Haskell.TH.Lens
      (
      -- * Traversals
        HasName(..)
      , HasTypes(..)
      , HasTypeVars(..)
      , SubstType(..)
      , typeVars      -- :: HasTypeVars t => Traversal' t Name
      , substTypeVars -- :: HasTypeVars t => Map Name Name -> t -> t
      , conFields
      , conNamedFields
      -- * Lenses
      -- ** Loc Lenses
      , locFileName
      , locPackage
      , locModule
      , locStart
      , locEnd
      -- ** FunDep Lenses
      , funDepInputs
      , funDepOutputs
      -- ** Match Lenses
      , matchPattern
      , matchBody
      , matchDeclarations
      -- ** Fixity Lenses
      , fixityPrecedence
      , fixityDirection
      -- ** Clause Lenses
      , clausePattern
      , clauseBody
      , clauseDecs
      -- ** FieldExp Lenses
      , fieldExpName
      , fieldExpExpression
      -- ** FieldPat Lenses
      , fieldPatName
      , fieldPatPattern
    #if MIN_VERSION_template_haskell(2,9,0)
      -- ** TySynEqn Lenses
    # if MIN_VERSION_template_haskell(2,15,0)
      , tySynEqnLHS
    # endif
      , tySynEqnPatterns
      , tySynEqnResult
    #endif
    #if MIN_VERSION_template_haskell(2,11,0)
      -- ** InjectivityAnn Lenses
      , injectivityAnnOutput
      , injectivityAnnInputs
      -- ** TypeFamilyHead Lenses
      , typeFamilyHeadName
      , typeFamilyHeadTyVarBndrs
      , typeFamilyHeadResultSig
      , typeFamilyHeadInjectivityAnn
      -- ** Bang Lenses
      , bangSourceUnpackedness
      , bangSourceStrictness
    #endif
    #if MIN_VERSION_template_haskell(2,12,0)
      -- ** DerivClause Lenses
      , derivClauseStrategy
      , derivClauseCxt
    #endif
      -- * Prisms
      -- ** Info Prisms
      , _ClassI
      , _ClassOpI
      , _TyConI
      , _FamilyI
      , _PrimTyConI
      , _DataConI
      , _VarI
      , _TyVarI
    #if MIN_VERSION_template_haskell(2,12,0)
      , _PatSynI
    #endif
      -- ** Dec Prisms
      , _FunD
      , _ValD
      , _DataD
      , _NewtypeD
      , _TySynD
      , _ClassD
      , _InstanceD
      , _SigD
      , _ForeignD
    #if MIN_VERSION_template_haskell(2,8,0)
      , _InfixD
    #endif
      , _PragmaD
      , _DataInstD
      , _NewtypeInstD
      , _TySynInstD
    #if MIN_VERSION_template_haskell(2,9,0)
      , _ClosedTypeFamilyD
      , _RoleAnnotD
    #endif
    #if MIN_VERSION_template_haskell(2,10,0)
      , _StandaloneDerivD
      , _DefaultSigD
    #endif
    #if MIN_VERSION_template_haskell(2,11,0)
      , _DataFamilyD
      , _OpenTypeFamilyD
    #else
      , _FamilyD
    #endif
    #if MIN_VERSION_template_haskell(2,12,0)
      , _PatSynD
      , _PatSynSigD
    #endif
    #if MIN_VERSION_template_haskell(2,15,0)
      , _ImplicitParamBindD
    #endif
    #if MIN_VERSION_template_haskell(2,12,0)
      -- ** PatSynDir Prisms
      , _Unidir
      , _ImplBidir
      , _ExplBidir
      -- ** PatSynArgs Prisms
      , _PrefixPatSyn
      , _InfixPatSyn
      , _RecordPatSyn
    #endif
      -- ** Con Prisms
      , _NormalC
      , _RecC
      , _InfixC
      , _ForallC
    #if MIN_VERSION_template_haskell(2,11,0)
      , _GadtC
      , _RecGadtC
    #endif
    #if MIN_VERSION_template_haskell(2,11,0)
      -- ** Overlap Prisms
      ,_Overlappable
      ,_Overlapping
      ,_Overlaps
      ,_Incoherent
    #endif
    #if MIN_VERSION_template_haskell(2,11,0)
      -- ** SourceUnpackedness Prisms
      , _NoSourceUnpackedness
      , _SourceNoUnpack
      , _SourceUnpack
      -- ** SourceStrictness Prisms
      , _NoSourceStrictness
      , _SourceLazy
      , _SourceStrict
      -- ** DecidedStrictness Prisms
      , _DecidedLazy
      , _DecidedStrict
      , _DecidedUnpack
    #else
      -- ** Strict Prisms
      , _IsStrict
      , _NotStrict
      , _Unpacked
    #endif
      -- ** Foreign Prisms
      , _ImportF
      , _ExportF
      -- ** Callconv Prisms
      , _CCall
      , _StdCall
    #if MIN_VERSION_template_haskell(2,10,0)
      , _CApi
      , _Prim
      , _JavaScript
    #endif
      -- ** Safety Prisms
      , _Unsafe
      , _Safe
      , _Interruptible
      -- ** Pragma Prisms
      , _InlineP
      , _SpecialiseP
    #if MIN_VERSION_template_haskell(2,8,0)
      , _SpecialiseInstP
      , _RuleP
    #if MIN_VERSION_template_haskell(2,9,0)
      , _AnnP
    #endif
    #if MIN_VERSION_template_haskell(2,10,0)
      , _LineP
    #endif
    #if MIN_VERSION_template_haskell(2,12,0)
      , _CompleteP
    #endif
      -- ** Inline Prisms
      , _NoInline
      , _Inline
      , _Inlinable
      -- ** RuleMatch Prisms
      , _ConLike
      , _FunLike
      -- ** Phases Prisms
      , _AllPhases
      , _FromPhase
      , _BeforePhase
      -- ** RuleBndr Prisms
      , _RuleVar
      , _TypedRuleVar
    #endif
    #if MIN_VERSION_template_haskell(2,9,0)
      -- ** AnnTarget Prisms
      , _ModuleAnnotation
      , _TypeAnnotation
      , _ValueAnnotation
    #endif
      -- ** FunDep Prisms TODO make a lens
      , _FunDep
    #if !(MIN_VERSION_template_haskell(2,13,0))
      -- ** FamFlavour Prisms
      , _TypeFam
      , _DataFam
    #endif
      -- ** FixityDirection Prisms
      , _InfixL
      , _InfixR
      , _InfixN
      -- ** Exp Prisms
      , _VarE
      , _ConE
      , _LitE
      , _AppE
    #if MIN_VERSION_template_haskell(2,12,0)
      , _AppTypeE
    #endif
      , _InfixE
      , _UInfixE
      , _ParensE
      , _LamE
    #if MIN_VERSION_template_haskell(2,8,0)
      , _LamCaseE
    #endif
      , _TupE
      , _UnboxedTupE
    #if MIN_VERSION_template_haskell(2,12,0)
      , _UnboxedSumE
    #endif
      , _CondE
    #if MIN_VERSION_template_haskell(2,8,0)
      , _MultiIfE
    #endif
      , _LetE
      , _CaseE
      , _DoE
      , _CompE
      , _ArithSeqE
      , _ListE
      , _SigE
      , _RecConE
      , _RecUpdE
    #if MIN_VERSION_template_haskell(2,10,0)
      , _StaticE
    #endif
    #if MIN_VERSION_template_haskell(2,11,0)
      , _UnboundVarE
    #endif
    #if MIN_VERSION_template_haskell(2,13,0)
      , _LabelE
    #endif
    #if MIN_VERSION_template_haskell(2,15,0)
      , _MDoE
      , _ImplicitParamVarE
    #endif
      -- ** Body Prisms
      , _GuardedB
      , _NormalB
      -- ** Guard Prisms
      , _NormalG
      , _PatG
      -- ** Stmt Prisms
      , _BindS
      , _LetS
      , _NoBindS
      , _ParS
    #if MIN_VERSION_template_haskell(2,15,0)
      , _RecS
    #endif
      -- ** Range Prisms
      , _FromR
      , _FromThenR
      , _FromToR
      , _FromThenToR
      -- ** Lit Prisms
      , _CharL
      , _StringL
      , _IntegerL
      , _RationalL
      , _IntPrimL
      , _WordPrimL
      , _FloatPrimL
      , _DoublePrimL
      , _StringPrimL
    #if MIN_VERSION_template_haskell(2,11,0)
      , _CharPrimL
    #endif
      -- ** Pat Prisms
      , _LitP
      , _VarP
      , _TupP
      , _UnboxedTupP
    #if MIN_VERSION_template_haskell(2,12,0)
      , _UnboxedSumP
    #endif
      , _ConP
      , _InfixP
      , _UInfixP
      , _ParensP
      , _TildeP
      , _BangP
      , _AsP
      , _WildP
      , _RecP
      , _ListP
      , _SigP
      , _ViewP
      -- ** Type Prisms
      , _ForallT
      , _AppT
      , _SigT
      , _VarT
      , _ConT
    #if MIN_VERSION_template_haskell(2,8,0)
      , _PromotedT
    #endif
      , _TupleT
      , _UnboxedTupleT
    #if MIN_VERSION_template_haskell(2,12,0)
      , _UnboxedSumT
    #endif
      , _ArrowT
    #if MIN_VERSION_template_haskell(2,10,0)
      , _EqualityT
    #endif
      , _ListT
    #if MIN_VERSION_template_haskell(2,8,0)
      , _PromotedTupleT
      , _PromotedNilT
      , _PromotedConsT
      , _StarT
      , _ConstraintT
      , _LitT
    #endif
    #if MIN_VERSION_template_haskell(2,11,0)
      , _InfixT
      , _UInfixT
      , _ParensT
      , _WildCardT
    #endif
    #if MIN_VERSION_template_haskell(2,15,0)
      , _AppKindT
      , _ImplicitParamT
    #endif
      -- ** TyVarBndr Prisms
      , _PlainTV
      , _KindedTV
    #if MIN_VERSION_template_haskell(2,11,0)
      -- ** FamilyResultSig Prisms
      , _NoSig
      , _KindSig
      , _TyVarSig
    #endif
    #if MIN_VERSION_template_haskell(2,8,0)
      -- ** TyLit Prisms
      , _NumTyLit
      , _StrTyLit
    #endif
    #if !MIN_VERSION_template_haskell(2,10,0)
      -- ** Pred Prisms
      , _ClassP
      , _EqualP
    #endif
    #if MIN_VERSION_template_haskell(2,9,0)
      -- ** Role Prisms
      , _NominalR
      , _RepresentationalR
      , _PhantomR
      , _InferR
    #endif
    #if MIN_VERSION_template_haskell(2,12,0)
      -- ** DerivStrategy Prisms
      , _StockStrategy
      , _AnyclassStrategy
      , _NewtypeStrategy
    #endif
      ) where

    import Control.Applicative
    import Control.Lens.At
    import Control.Lens.Getter
    import Control.Lens.Setter
    import Control.Lens.Fold
    import Control.Lens.Iso (Iso', iso)
    import Control.Lens.Lens
    import Control.Lens.Prism
    import Control.Lens.Tuple
    import Control.Lens.Traversal
    import Data.Map as Map hiding (toList,map)
    import Data.Maybe (fromMaybe)
    import Data.Monoid
    import Data.Set as Set hiding (toList,map)
    import Data.Set.Lens
    import Language.Haskell.TH
    import Language.Haskell.TH.Syntax
    #if MIN_VERSION_template_haskell(2,8,0)
    import Data.Word
    #endif
    #if MIN_VERSION_template_haskell(2,15,0)
    import Control.Lens.Internal.TH (unfoldType)
    import Data.Foldable as F (foldl')
    #endif
    import Prelude

    -- | Has a 'Name'
    class HasName t where
      -- | Extract (or modify) the 'Name' of something
      name :: Lens' t Name

    instance HasName TyVarBndr where
      name :: (Name -> f Name) -> TyVarBndr -> f TyVarBndr
    name f :: Name -> f Name
    f (PlainTV n :: Name
    n) = Name -> TyVarBndr
    PlainTV (Name -> TyVarBndr) -> f Name -> f TyVarBndr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> f Name
    f Name
    n
      name f :: Name -> f Name
    f (KindedTV n :: Name
    n k :: Kind
    k) = (Name -> Kind -> TyVarBndr
    `KindedTV` Kind
    k) (Name -> TyVarBndr) -> f Name -> f TyVarBndr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> f Name
    f Name
    n

    instance HasName Name where
      name :: (Name -> f Name) -> Name -> f Name
    name = (Name -> f Name) -> Name -> f Name
    forall a. a -> a
    id

    -- | On @template-haskell-2.11.0.0@ or later, if a 'GadtC' or 'RecGadtC' has
    -- multiple 'Name's, the leftmost 'Name' will be chosen.
    instance HasName Con where
      name :: (Name -> f Name) -> Con -> f Con
    name f :: Name -> f Name
    f (NormalC n :: Name
    n tys :: [BangType]
    tys)       = (Name -> [BangType] -> Con
    `NormalC` [BangType]
    tys) (Name -> Con) -> f Name -> f Con
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> f Name
    f Name
    n
      name f :: Name -> f Name
    f (RecC n :: Name
    n tys :: [VarBangType]
    tys)          = (Name -> [VarBangType] -> Con
    `RecC` [VarBangType]
    tys) (Name -> Con) -> f Name -> f Con
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> f Name
    f Name
    n
      name f :: Name -> f Name
    f (InfixC l :: BangType
    l n :: Name
    n r :: BangType
    r)        = (\n' :: Name
    n' -> BangType -> Name -> BangType -> Con
    InfixC BangType
    l Name
    n' BangType
    r) (Name -> Con) -> f Name -> f Con
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> f Name
    f Name
    n
      name f :: Name -> f Name
    f (ForallC bds :: [TyVarBndr]
    bds ctx :: Cxt
    ctx con :: Con
    con) = [TyVarBndr] -> Cxt -> Con -> Con
    ForallC [TyVarBndr]
    bds Cxt
    ctx (Con -> Con) -> f Con -> f Con
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Name -> f Name) -> Con -> f Con
    forall t. HasName t => Lens' t Name
    name Name -> f Name
    f Con
    con
    #if MIN_VERSION_template_haskell(2,11,0)
      name f :: Name -> f Name
    f (GadtC ns :: [Name]
    ns argTys :: [BangType]
    argTys retTy :: Kind
    retTy) =
        (\n :: Name
    n -> [Name] -> [BangType] -> Kind -> Con
    GadtC [Name
    n] [BangType]
    argTys Kind
    retTy) (Name -> Con) -> f Name -> f Con
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> f Name
    f ([Name] -> Name
    forall a. [a] -> a
    head [Name]
    ns)
      name f :: Name -> f Name
    f (RecGadtC ns :: [Name]
    ns argTys :: [VarBangType]
    argTys retTy :: Kind
    retTy) =
        (\n :: Name
    n -> [Name] -> [VarBangType] -> Kind -> Con
    RecGadtC [Name
    n] [VarBangType]
    argTys Kind
    retTy) (Name -> Con) -> f Name -> f Con
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> f Name
    f ([Name] -> Name
    forall a. [a] -> a
    head [Name]
    ns)
    #endif

    instance HasName Foreign where
      name :: (Name -> f Name) -> Foreign -> f Foreign
    name f :: Name -> f Name
    f (ImportF cc :: Callconv
    cc saf :: Safety
    saf str :: String
    str n :: Name
    n ty :: Kind
    ty) =
        (\n' :: Name
    n' -> Callconv -> Safety -> String -> Name -> Kind -> Foreign
    ImportF Callconv
    cc Safety
    saf String
    str Name
    n' Kind
    ty) (Name -> Foreign) -> f Name -> f Foreign
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> f Name
    f Name
    n
      name f :: Name -> f Name
    f (ExportF cc :: Callconv
    cc str :: String
    str n :: Name
    n ty :: Kind
    ty) =
        (\n' :: Name
    n' -> Callconv -> String -> Name -> Kind -> Foreign
    ExportF Callconv
    cc String
    str Name
    n' Kind
    ty) (Name -> Foreign) -> f Name -> f Foreign
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> f Name
    f Name
    n

    #if MIN_VERSION_template_haskell(2,8,0)
    instance HasName RuleBndr where
      name :: (Name -> f Name) -> RuleBndr -> f RuleBndr
    name f :: Name -> f Name
    f (RuleVar n :: Name
    n) = Name -> RuleBndr
    RuleVar (Name -> RuleBndr) -> f Name -> f RuleBndr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> f Name
    f Name
    n
      name f :: Name -> f Name
    f (TypedRuleVar n :: Name
    n ty :: Kind
    ty) = (Name -> Kind -> RuleBndr
    `TypedRuleVar` Kind
    ty) (Name -> RuleBndr) -> f Name -> f RuleBndr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> f Name
    f Name
    n
    #endif

    #if MIN_VERSION_template_haskell(2,11,0)
    instance HasName TypeFamilyHead where
      name :: (Name -> f Name) -> TypeFamilyHead -> f TypeFamilyHead
    name f :: Name -> f Name
    f (TypeFamilyHead n :: Name
    n tvbs :: [TyVarBndr]
    tvbs frs :: FamilyResultSig
    frs mia :: Maybe InjectivityAnn
    mia) =
        (\n' :: Name
    n' -> Name
    -> [TyVarBndr]
    -> FamilyResultSig
    -> Maybe InjectivityAnn
    -> TypeFamilyHead
    TypeFamilyHead Name
    n' [TyVarBndr]
    tvbs FamilyResultSig
    frs Maybe InjectivityAnn
    mia) (Name -> TypeFamilyHead) -> f Name -> f TypeFamilyHead
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> f Name
    f Name
    n

    instance HasName InjectivityAnn where
      name :: (Name -> f Name) -> InjectivityAnn -> f InjectivityAnn
    name f :: Name -> f Name
    f (InjectivityAnn n :: Name
    n deps :: [Name]
    deps) = (Name -> [Name] -> InjectivityAnn
    `InjectivityAnn` [Name]
    deps) (Name -> InjectivityAnn) -> f Name -> f InjectivityAnn
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> f Name
    f Name
    n
    #endif

    -- | Contains some amount of `Type`s inside
    class HasTypes t where
      -- | Traverse all the types
      types :: Traversal' t Type

    instance HasTypes Type where
      types :: (Kind -> f Kind) -> Kind -> f Kind
    types = (Kind -> f Kind) -> Kind -> f Kind
    forall a. a -> a
    id

    instance HasTypes Con where
      types :: (Kind -> f Kind) -> Con -> f Con
    types f :: Kind -> f Kind
    f (NormalC n :: Name
    n t :: [BangType]
    t)      = Name -> [BangType] -> Con
    NormalC Name
    n ([BangType] -> Con) -> f [BangType] -> f Con
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (BangType -> f BangType) -> [BangType] -> f [BangType]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse ((Kind -> f Kind) -> BangType -> f BangType
    forall s t a b. Field2 s t a b => Lens s t a b
    _2 ((Kind -> f Kind) -> Kind -> f Kind
    forall t. HasTypes t => Traversal' t Kind
    types Kind -> f Kind
    f)) [BangType]
    t
      types f :: Kind -> f Kind
    f (RecC n :: Name
    n t :: [VarBangType]
    t)         = Name -> [VarBangType] -> Con
    RecC Name
    n ([VarBangType] -> Con) -> f [VarBangType] -> f Con
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (VarBangType -> f VarBangType) -> [VarBangType] -> f [VarBangType]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse ((Kind -> f Kind) -> VarBangType -> f VarBangType
    forall s t a b. Field3 s t a b => Lens s t a b
    _3 ((Kind -> f Kind) -> Kind -> f Kind
    forall t. HasTypes t => Traversal' t Kind
    types Kind -> f Kind
    f)) [VarBangType]
    t
      types f :: Kind -> f Kind
    f (InfixC t1 :: BangType
    t1 n :: Name
    n t2 :: BangType
    t2) = BangType -> Name -> BangType -> Con
    InfixC (BangType -> Name -> BangType -> Con)
    -> f BangType -> f (Name -> BangType -> Con)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Kind -> f Kind) -> BangType -> f BangType
    forall s t a b. Field2 s t a b => Lens s t a b
    _2 ((Kind -> f Kind) -> Kind -> f Kind
    forall t. HasTypes t => Traversal' t Kind
    types Kind -> f Kind
    f) BangType
    t1
                                           f (Name -> BangType -> Con) -> f Name -> f (BangType -> Con)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Name -> f Name
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Name
    n f (BangType -> Con) -> f BangType -> f Con
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Kind -> f Kind) -> BangType -> f BangType
    forall s t a b. Field2 s t a b => Lens s t a b
    _2 ((Kind -> f Kind) -> Kind -> f Kind
    forall t. HasTypes t => Traversal' t Kind
    types Kind -> f Kind
    f) BangType
    t2
      types f :: Kind -> f Kind
    f (ForallC vb :: [TyVarBndr]
    vb ctx :: Cxt
    ctx con :: Con
    con)    = [TyVarBndr] -> Cxt -> Con -> Con
    ForallC [TyVarBndr]
    vb Cxt
    ctx (Con -> Con) -> f Con -> f Con
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Kind -> f Kind) -> Con -> f Con
    forall t. HasTypes t => Traversal' t Kind
    types Kind -> f Kind
    f Con
    con
    #if MIN_VERSION_template_haskell(2,11,0)
      types f :: Kind -> f Kind
    f (GadtC ns :: [Name]
    ns argTys :: [BangType]
    argTys retTy :: Kind
    retTy) =
        [Name] -> [BangType] -> Kind -> Con
    GadtC    [Name]
    ns ([BangType] -> Kind -> Con) -> f [BangType] -> f (Kind -> Con)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (BangType -> f BangType) -> [BangType] -> f [BangType]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse ((Kind -> f Kind) -> BangType -> f BangType
    forall s t a b. Field2 s t a b => Lens s t a b
    _2 ((Kind -> f Kind) -> Kind -> f Kind
    forall t. HasTypes t => Traversal' t Kind
    types Kind -> f Kind
    f)) [BangType]
    argTys f (Kind -> Con) -> f Kind -> f Con
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Kind -> f Kind) -> Kind -> f Kind
    forall t. HasTypes t => Traversal' t Kind
    types Kind -> f Kind
    f Kind
    retTy
      types f :: Kind -> f Kind
    f (RecGadtC ns :: [Name]
    ns argTys :: [VarBangType]
    argTys retTy :: Kind
    retTy) =
        [Name] -> [VarBangType] -> Kind -> Con
    RecGadtC [Name]
    ns ([VarBangType] -> Kind -> Con)
    -> f [VarBangType] -> f (Kind -> Con)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (VarBangType -> f VarBangType) -> [VarBangType] -> f [VarBangType]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse ((Kind -> f Kind) -> VarBangType -> f VarBangType
    forall s t a b. Field3 s t a b => Lens s t a b
    _3 ((Kind -> f Kind) -> Kind -> f Kind
    forall t. HasTypes t => Traversal' t Kind
    types Kind -> f Kind
    f)) [VarBangType]
    argTys f (Kind -> Con) -> f Kind -> f Con
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Kind -> f Kind) -> Kind -> f Kind
    forall t. HasTypes t => Traversal' t Kind
    types Kind -> f Kind
    f Kind
    retTy
    #endif

    instance HasTypes Foreign where
      types :: (Kind -> f Kind) -> Foreign -> f Foreign
    types f :: Kind -> f Kind
    f (ImportF cc :: Callconv
    cc saf :: Safety
    saf str :: String
    str n :: Name
    n t :: Kind
    t) = Callconv -> Safety -> String -> Name -> Kind -> Foreign
    ImportF Callconv
    cc Safety
    saf String
    str Name
    n (Kind -> Foreign) -> f Kind -> f Foreign
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Kind -> f Kind) -> Kind -> f Kind
    forall t. HasTypes t => Traversal' t Kind
    types Kind -> f Kind
    f Kind
    t
      types f :: Kind -> f Kind
    f (ExportF cc :: Callconv
    cc     str :: String
    str n :: Name
    n t :: Kind
    t) = Callconv -> String -> Name -> Kind -> Foreign
    ExportF Callconv
    cc     String
    str Name
    n (Kind -> Foreign) -> f Kind -> f Foreign
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Kind -> f Kind) -> Kind -> f Kind
    forall t. HasTypes t => Traversal' t Kind
    types Kind -> f Kind
    f Kind
    t

    #if MIN_VERSION_template_haskell(2,9,0)
    instance HasTypes TySynEqn where
    #if MIN_VERSION_template_haskell(2,15,0)
      types :: (Kind -> f Kind) -> TySynEqn -> f TySynEqn
    types f :: Kind -> f Kind
    f (TySynEqn mtvbs :: Maybe [TyVarBndr]
    mtvbs lhs :: Kind
    lhs rhs :: Kind
    rhs) = Maybe [TyVarBndr] -> Kind -> Kind -> TySynEqn
    TySynEqn (Maybe [TyVarBndr] -> Kind -> Kind -> TySynEqn)
    -> f (Maybe [TyVarBndr]) -> f (Kind -> Kind -> TySynEqn)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ([TyVarBndr] -> f [TyVarBndr])
    -> Maybe [TyVarBndr] -> f (Maybe [TyVarBndr])
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse ((TyVarBndr -> f TyVarBndr) -> [TyVarBndr] -> f [TyVarBndr]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse TyVarBndr -> f TyVarBndr
    go) Maybe [TyVarBndr]
    mtvbs
                                                  f (Kind -> Kind -> TySynEqn) -> f Kind -> f (Kind -> TySynEqn)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Kind -> f Kind) -> Kind -> f Kind
    forall t. HasTypes t => Traversal' t Kind
    types Kind -> f Kind
    f Kind
    lhs
                                                  f (Kind -> TySynEqn) -> f Kind -> f TySynEqn
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Kind -> f Kind) -> Kind -> f Kind
    forall t. HasTypes t => Traversal' t Kind
    types Kind -> f Kind
    f Kind
    rhs
        where
          go :: TyVarBndr -> f TyVarBndr
    go tvb :: TyVarBndr
    tvb@PlainTV{} = TyVarBndr -> f TyVarBndr
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TyVarBndr
    tvb
          go (KindedTV n :: Name
    n k :: Kind
    k)  = Name -> Kind -> TyVarBndr
    KindedTV Name
    n (Kind -> TyVarBndr) -> f Kind -> f TyVarBndr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Kind -> f Kind
    f Kind
    k
    #else
      types f (TySynEqn lhss rhs) = TySynEqn <$> traverse (types f) lhss
                                             <*> types f rhs
    #endif
    #endif

    instance HasTypes t => HasTypes [t] where
      types :: (Kind -> f Kind) -> [t] -> f [t]
    types = (t -> f t) -> [t] -> f [t]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse ((t -> f t) -> [t] -> f [t])
    -> ((Kind -> f Kind) -> t -> f t)
    -> (Kind -> f Kind)
    -> [t]
    -> f [t]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Kind -> f Kind) -> t -> f t
    forall t. HasTypes t => Traversal' t Kind
    types

    -- | Provides for the extraction of free type variables, and alpha renaming.
    class HasTypeVars t where
      -- | 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'.
      typeVarsEx :: Set Name -> Traversal' t Name

    instance HasTypeVars TyVarBndr where
      typeVarsEx :: Set Name -> Traversal' TyVarBndr Name
    typeVarsEx s :: Set Name
    s f :: Name -> f Name
    f b :: TyVarBndr
    b
        | Set Name
    sSet Name -> Getting Bool (Set Name) Bool -> Bool
    forall s a. s -> Getting a s a -> a
    ^.Index (Set Name) -> Lens' (Set Name) Bool
    forall m. Contains m => Index m -> Lens' m Bool
    contains (TyVarBndr
    bTyVarBndr -> Getting Name TyVarBndr Name -> Name
    forall s a. s -> Getting a s a -> a
    ^.Getting Name TyVarBndr Name
    forall t. HasName t => Lens' t Name
    name) = TyVarBndr -> f TyVarBndr
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TyVarBndr
    b
        | Bool
    otherwise             = (Name -> f Name) -> TyVarBndr -> f TyVarBndr
    forall t. HasName t => Lens' t Name
    name Name -> f Name
    f TyVarBndr
    b

    instance HasTypeVars Name where
      typeVarsEx :: Set Name -> Traversal' Name Name
    typeVarsEx s :: Set Name
    s f :: Name -> f Name
    f n :: Name
    n
        | Set Name
    sSet Name -> Getting Bool (Set Name) Bool -> Bool
    forall s a. s -> Getting a s a -> a
    ^.Index (Set Name) -> Lens' (Set Name) Bool
    forall m. Contains m => Index m -> Lens' m Bool
    contains Name
    Index (Set Name)
    n = Name -> f Name
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Name
    n
        | Bool
    otherwise     = Name -> f Name
    f Name
    n

    instance HasTypeVars Type where
      typeVarsEx :: Set Name -> Traversal' Kind Name
    typeVarsEx s :: Set Name
    s f :: Name -> f Name
    f (VarT n :: Name
    n)             = Name -> Kind
    VarT (Name -> Kind) -> f Name -> f Kind
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Set Name -> (Name -> f Name) -> Name -> f Name
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f Name
    n
      typeVarsEx s :: Set Name
    s f :: Name -> f Name
    f (AppT l :: Kind
    l r :: Kind
    r)           = Kind -> Kind -> Kind
    AppT (Kind -> Kind -> Kind) -> f Kind -> f (Kind -> Kind)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Set Name -> (Name -> f Name) -> Kind -> f Kind
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f Kind
    l f (Kind -> Kind) -> f Kind -> f Kind
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Set Name -> (Name -> f Name) -> Kind -> f Kind
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f Kind
    r
    #if MIN_VERSION_template_haskell(2,8,0)
      typeVarsEx s :: Set Name
    s f :: Name -> f Name
    f (SigT t :: Kind
    t k :: Kind
    k)           = Kind -> Kind -> Kind
    SigT (Kind -> Kind -> Kind) -> f Kind -> f (Kind -> Kind)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Set Name -> (Name -> f Name) -> Kind -> f Kind
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f Kind
    t
                                                 f (Kind -> Kind) -> f Kind -> f Kind
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Set Name -> (Name -> f Name) -> Kind -> f Kind
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f Kind
    k
    #else
      typeVarsEx s f (SigT t k)           = (`SigT` k) <$> typeVarsEx s f t
    #endif
      typeVarsEx s :: Set Name
    s f :: Name -> f Name
    f (ForallT bs :: [TyVarBndr]
    bs ctx :: Cxt
    ctx ty :: Kind
    ty)  = [TyVarBndr] -> Cxt -> Kind -> Kind
    ForallT [TyVarBndr]
    bs (Cxt -> Kind -> Kind) -> f Cxt -> f (Kind -> Kind)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Set Name -> (Name -> f Name) -> Cxt -> f Cxt
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s' Name -> f Name
    f Cxt
    ctx f (Kind -> Kind) -> f Kind -> f Kind
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Set Name -> (Name -> f Name) -> Kind -> f Kind
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s' Name -> f Name
    f Kind
    ty
           where s' :: Set Name
    s' = Set Name
    s Set Name -> Set Name -> Set Name
    forall a. Ord a => Set a -> Set a -> Set a
    `Set.union` Getting (Set Name) [TyVarBndr] Name -> [TyVarBndr] -> Set Name
    forall a s. Getting (Set a) s a -> s -> Set a
    setOf Getting (Set Name) [TyVarBndr] Name
    forall t. HasTypeVars t => Traversal' t Name
    typeVars [TyVarBndr]
    bs
    #if MIN_VERSION_template_haskell(2,11,0)
      typeVarsEx s :: Set Name
    s f :: Name -> f Name
    f (InfixT  t1 :: Kind
    t1 n :: Name
    n t2 :: Kind
    t2)    = Kind -> Name -> Kind -> Kind
    InfixT  (Kind -> Name -> Kind -> Kind)
    -> f Kind -> f (Name -> Kind -> Kind)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Set Name -> (Name -> f Name) -> Kind -> f Kind
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f Kind
    t1
                                                    f (Name -> Kind -> Kind) -> f Name -> f (Kind -> Kind)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Name -> f Name
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Name
    n
                                                    f (Kind -> Kind) -> f Kind -> f Kind
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Set Name -> (Name -> f Name) -> Kind -> f Kind
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f Kind
    t2
      typeVarsEx s :: Set Name
    s f :: Name -> f Name
    f (UInfixT t1 :: Kind
    t1 n :: Name
    n t2 :: Kind
    t2)    = Kind -> Name -> Kind -> Kind
    UInfixT (Kind -> Name -> Kind -> Kind)
    -> f Kind -> f (Name -> Kind -> Kind)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Set Name -> (Name -> f Name) -> Kind -> f Kind
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f Kind
    t1
                                                    f (Name -> Kind -> Kind) -> f Name -> f (Kind -> Kind)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Name -> f Name
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Name
    n
                                                    f (Kind -> Kind) -> f Kind -> f Kind
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Set Name -> (Name -> f Name) -> Kind -> f Kind
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f Kind
    t2
      typeVarsEx s :: Set Name
    s f :: Name -> f Name
    f (ParensT t :: Kind
    t)          = Kind -> Kind
    ParensT (Kind -> Kind) -> f Kind -> f Kind
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Set Name -> (Name -> f Name) -> Kind -> f Kind
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f Kind
    t
    #endif
    #if MIN_VERSION_template_haskell(2,15,0)
      typeVarsEx s :: Set Name
    s f :: Name -> f Name
    f (AppKindT t :: Kind
    t k :: Kind
    k)       = Kind -> Kind -> Kind
    AppKindT (Kind -> Kind -> Kind) -> f Kind -> f (Kind -> Kind)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Set Name -> (Name -> f Name) -> Kind -> f Kind
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f Kind
    t
                                                     f (Kind -> Kind) -> f Kind -> f Kind
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Set Name -> (Name -> f Name) -> Kind -> f Kind
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f Kind
    k
      typeVarsEx s :: Set Name
    s f :: Name -> f Name
    f (ImplicitParamT n :: String
    n t :: Kind
    t) = String -> Kind -> Kind
    ImplicitParamT String
    n (Kind -> Kind) -> f Kind -> f Kind
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Set Name -> (Name -> f Name) -> Kind -> f Kind
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f Kind
    t
    #endif
      typeVarsEx _ _ t :: Kind
    t                    = Kind -> f Kind
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Kind
    t

    #if !MIN_VERSION_template_haskell(2,10,0)
    instance HasTypeVars Pred where
      typeVarsEx s f (ClassP n ts) = ClassP n <$> typeVarsEx s f ts
      typeVarsEx s f (EqualP l r)  = EqualP <$> typeVarsEx s f l <*> typeVarsEx s f r
    #endif

    instance HasTypeVars Con where
      typeVarsEx :: Set Name -> Traversal' Con Name
    typeVarsEx s :: Set Name
    s f :: Name -> f Name
    f (NormalC n :: Name
    n ts :: [BangType]
    ts) = Name -> [BangType] -> Con
    NormalC Name
    n ([BangType] -> Con) -> f [BangType] -> f Con
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> LensLike f [BangType] [BangType] Kind Kind
    -> LensLike f [BangType] [BangType] Kind Kind
    forall (f :: * -> *) s t a b.
    LensLike f s t a b -> LensLike f s t a b
    traverseOf ((BangType -> f BangType) -> [BangType] -> f [BangType]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse ((BangType -> f BangType) -> [BangType] -> f [BangType])
    -> ((Kind -> f Kind) -> BangType -> f BangType)
    -> LensLike f [BangType] [BangType] Kind Kind
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Kind -> f Kind) -> BangType -> f BangType
    forall s t a b. Field2 s t a b => Lens s t a b
    _2) (Set Name -> (Name -> f Name) -> Kind -> f Kind
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f) [BangType]
    ts
      typeVarsEx s :: Set Name
    s f :: Name -> f Name
    f (RecC n :: Name
    n ts :: [VarBangType]
    ts) = Name -> [VarBangType] -> Con
    RecC Name
    n ([VarBangType] -> Con) -> f [VarBangType] -> f Con
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> LensLike f [VarBangType] [VarBangType] Kind Kind
    -> LensLike f [VarBangType] [VarBangType] Kind Kind
    forall (f :: * -> *) s t a b.
    LensLike f s t a b -> LensLike f s t a b
    traverseOf ((VarBangType -> f VarBangType) -> [VarBangType] -> f [VarBangType]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse ((VarBangType -> f VarBangType)
     -> [VarBangType] -> f [VarBangType])
    -> ((Kind -> f Kind) -> VarBangType -> f VarBangType)
    -> LensLike f [VarBangType] [VarBangType] Kind Kind
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Kind -> f Kind) -> VarBangType -> f VarBangType
    forall s t a b. Field3 s t a b => Lens s t a b
    _3) (Set Name -> (Name -> f Name) -> Kind -> f Kind
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f) [VarBangType]
    ts
      typeVarsEx s :: Set Name
    s f :: Name -> f Name
    f (InfixC l :: BangType
    l n :: Name
    n r :: BangType
    r) = BangType -> Name -> BangType -> Con
    InfixC (BangType -> Name -> BangType -> Con)
    -> f BangType -> f (Name -> BangType -> Con)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> BangType -> f BangType
    forall b a. HasTypeVars b => (a, b) -> f (a, b)
    g BangType
    l f (Name -> BangType -> Con) -> f Name -> f (BangType -> Con)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Name -> f Name
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Name
    n f (BangType -> Con) -> f BangType -> f Con
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> BangType -> f BangType
    forall b a. HasTypeVars b => (a, b) -> f (a, b)
    g BangType
    r
           where g :: (a, b) -> f (a, b)
    g (i :: a
    i, t :: b
    t) = (,) a
    i (b -> (a, b)) -> f b -> f (a, b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Set Name -> (Name -> f Name) -> b -> f b
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f b
    t
      typeVarsEx s :: Set Name
    s f :: Name -> f Name
    f (ForallC bs :: [TyVarBndr]
    bs ctx :: Cxt
    ctx c :: Con
    c) = [TyVarBndr] -> Cxt -> Con -> Con
    ForallC [TyVarBndr]
    bs (Cxt -> Con -> Con) -> f Cxt -> f (Con -> Con)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Set Name -> (Name -> f Name) -> Cxt -> f Cxt
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s' Name -> f Name
    f Cxt
    ctx f (Con -> Con) -> f Con -> f Con
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Set Name -> (Name -> f Name) -> Con -> f Con
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s' Name -> f Name
    f Con
    c
           where s' :: Set Name
    s' = Set Name
    s Set Name -> Set Name -> Set Name
    forall a. Ord a => Set a -> Set a -> Set a
    `Set.union` Getting (Set Name) [TyVarBndr] Name -> [TyVarBndr] -> Set Name
    forall a s. Getting (Set a) s a -> s -> Set a
    setOf Getting (Set Name) [TyVarBndr] Name
    forall t. HasTypeVars t => Traversal' t Name
    typeVars [TyVarBndr]
    bs
    #if MIN_VERSION_template_haskell(2,11,0)
      typeVarsEx s :: Set Name
    s f :: Name -> f Name
    f (GadtC ns :: [Name]
    ns argTys :: [BangType]
    argTys retTy :: Kind
    retTy) =
        [Name] -> [BangType] -> Kind -> Con
    GadtC [Name]
    ns ([BangType] -> Kind -> Con) -> f [BangType] -> f (Kind -> Con)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> LensLike f [BangType] [BangType] Kind Kind
    -> LensLike f [BangType] [BangType] Kind Kind
    forall (f :: * -> *) s t a b.
    LensLike f s t a b -> LensLike f s t a b
    traverseOf ((BangType -> f BangType) -> [BangType] -> f [BangType]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse ((BangType -> f BangType) -> [BangType] -> f [BangType])
    -> ((Kind -> f Kind) -> BangType -> f BangType)
    -> LensLike f [BangType] [BangType] Kind Kind
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Kind -> f Kind) -> BangType -> f BangType
    forall s t a b. Field2 s t a b => Lens s t a b
    _2) (Set Name -> (Name -> f Name) -> Kind -> f Kind
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f) [BangType]
    argTys
                 f (Kind -> Con) -> f Kind -> f Con
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Set Name -> (Name -> f Name) -> Kind -> f Kind
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f Kind
    retTy
      typeVarsEx s :: Set Name
    s f :: Name -> f Name
    f (RecGadtC ns :: [Name]
    ns argTys :: [VarBangType]
    argTys retTy :: Kind
    retTy) =
        [Name] -> [VarBangType] -> Kind -> Con
    RecGadtC [Name]
    ns ([VarBangType] -> Kind -> Con)
    -> f [VarBangType] -> f (Kind -> Con)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> LensLike f [VarBangType] [VarBangType] Kind Kind
    -> LensLike f [VarBangType] [VarBangType] Kind Kind
    forall (f :: * -> *) s t a b.
    LensLike f s t a b -> LensLike f s t a b
    traverseOf ((VarBangType -> f VarBangType) -> [VarBangType] -> f [VarBangType]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse ((VarBangType -> f VarBangType)
     -> [VarBangType] -> f [VarBangType])
    -> ((Kind -> f Kind) -> VarBangType -> f VarBangType)
    -> LensLike f [VarBangType] [VarBangType] Kind Kind
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Kind -> f Kind) -> VarBangType -> f VarBangType
    forall s t a b. Field3 s t a b => Lens s t a b
    _3) (Set Name -> (Name -> f Name) -> Kind -> f Kind
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f) [VarBangType]
    argTys
                    f (Kind -> Con) -> f Kind -> f Con
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Set Name -> (Name -> f Name) -> Kind -> f Kind
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s Name -> f Name
    f Kind
    retTy
    #endif

    instance HasTypeVars t => HasTypeVars [t] where
      typeVarsEx :: Set Name -> Traversal' [t] Name
    typeVarsEx s :: Set Name
    s = (t -> f t) -> [t] -> f [t]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse ((t -> f t) -> [t] -> f [t])
    -> ((Name -> f Name) -> t -> f t)
    -> (Name -> f Name)
    -> [t]
    -> f [t]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Set Name -> Traversal' t Name
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s

    instance HasTypeVars t => HasTypeVars (Maybe t) where
      typeVarsEx :: Set Name -> Traversal' (Maybe t) Name
    typeVarsEx s :: Set Name
    s = (t -> f t) -> Maybe t -> f (Maybe t)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse ((t -> f t) -> Maybe t -> f (Maybe t))
    -> ((Name -> f Name) -> t -> f t)
    -> (Name -> f Name)
    -> Maybe t
    -> f (Maybe t)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Set Name -> Traversal' t Name
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    s

    -- | Traverse /free/ type variables
    typeVars :: HasTypeVars t => Traversal' t Name
    typeVars :: Traversal' t Name
    typeVars = Set Name -> Traversal' t Name
    forall t. HasTypeVars t => Set Name -> Traversal' t Name
    typeVarsEx Set Name
    forall a. Monoid a => a
    mempty

    -- | Substitute using a map of names in for /free/ type variables
    substTypeVars :: HasTypeVars t => Map Name Name -> t -> t
    substTypeVars :: Map Name Name -> t -> t
    substTypeVars m :: Map Name Name
    m = ASetter t t Name Name -> (Name -> Name) -> t -> t
    forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
    over ASetter t t Name Name
    forall t. HasTypeVars t => Traversal' t Name
    typeVars ((Name -> Name) -> t -> t) -> (Name -> Name) -> t -> t
    forall a b. (a -> b) -> a -> b
    $ \n :: Name
    n -> Name -> Maybe Name -> Name
    forall a. a -> Maybe a -> a
    fromMaybe Name
    n (Map Name Name
    mMap Name Name
    -> Getting (Maybe Name) (Map Name Name) (Maybe Name) -> Maybe Name
    forall s a. s -> Getting a s a -> a
    ^.Index (Map Name Name)
    -> Lens' (Map Name Name) (Maybe (IxValue (Map Name Name)))
    forall m. At m => Index m -> Lens' m (Maybe (IxValue m))
    at Name
    Index (Map Name Name)
    n)

    -- | Provides substitution for types
    class SubstType t where
      -- | Perform substitution for types
      substType :: Map Name Type -> t -> t

    instance SubstType Type where
      substType :: Map Name Kind -> Kind -> Kind
    substType m :: Map Name Kind
    m t :: Kind
    t@(VarT n :: Name
    n)           = Kind -> Maybe Kind -> Kind
    forall a. a -> Maybe a -> a
    fromMaybe Kind
    t (Map Name Kind
    mMap Name Kind
    -> Getting (Maybe Kind) (Map Name Kind) (Maybe Kind) -> Maybe Kind
    forall s a. s -> Getting a s a -> a
    ^.Index (Map Name Kind)
    -> Lens' (Map Name Kind) (Maybe (IxValue (Map Name Kind)))
    forall m. At m => Index m -> Lens' m (Maybe (IxValue m))
    at Name
    Index (Map Name Kind)
    n)
      substType m :: Map Name Kind
    m (ForallT bs :: [TyVarBndr]
    bs ctx :: Cxt
    ctx ty :: Kind
    ty)  = [TyVarBndr] -> Cxt -> Kind -> Kind
    ForallT [TyVarBndr]
    bs (Map Name Kind -> Cxt -> Cxt
    forall t. SubstType t => Map Name Kind -> t -> t
    substType Map Name Kind
    m' Cxt
    ctx) (Map Name Kind -> Kind -> Kind
    forall t. SubstType t => Map Name Kind -> t -> t
    substType Map Name Kind
    m' Kind
    ty)
        where m' :: Map Name Kind
    m' = Getting (Endo (Map Name Kind)) [TyVarBndr] Name
    -> (Name -> Map Name Kind -> Map Name Kind)
    -> Map Name Kind
    -> [TyVarBndr]
    -> Map Name Kind
    forall r s a. Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
    foldrOf Getting (Endo (Map Name Kind)) [TyVarBndr] Name
    forall t. HasTypeVars t => Traversal' t Name
    typeVars Name -> Map Name Kind -> Map Name Kind
    forall k a. Ord k => k -> Map k a -> Map k a
    Map.delete Map Name Kind
    m [TyVarBndr]
    bs
    #if MIN_VERSION_template_haskell(2,8,0)
      substType m :: Map Name Kind
    m (SigT t :: Kind
    t k :: Kind
    k)           = Kind -> Kind -> Kind
    SigT (Map Name Kind -> Kind -> Kind
    forall t. SubstType t => Map Name Kind -> t -> t
    substType Map Name Kind
    m Kind
    t) (Map Name Kind -> Kind -> Kind
    forall t. SubstType t => Map Name Kind -> t -> t
    substType Map Name Kind
    m Kind
    k)
    #else
      substType m (SigT t k)           = SigT (substType m t) k
    #endif
      substType m :: Map Name Kind
    m (AppT l :: Kind
    l r :: Kind
    r)           = Kind -> Kind -> Kind
    AppT (Map Name Kind -> Kind -> Kind
    forall t. SubstType t => Map Name Kind -> t -> t
    substType Map Name Kind
    m Kind
    l) (Map Name Kind -> Kind -> Kind
    forall t. SubstType t => Map Name Kind -> t -> t
    substType Map Name Kind
    m Kind
    r)
    #if MIN_VERSION_template_haskell(2,11,0)
      substType m :: Map Name Kind
    m (InfixT  t1 :: Kind
    t1 n :: Name
    n t2 :: Kind
    t2)    = Kind -> Name -> Kind -> Kind
    InfixT  (Map Name Kind -> Kind -> Kind
    forall t. SubstType t => Map Name Kind -> t -> t
    substType Map Name Kind
    m Kind
    t1) Name
    n (Map Name Kind -> Kind -> Kind
    forall t. SubstType t => Map Name Kind -> t -> t
    substType Map Name Kind
    m Kind
    t2)
      substType m :: Map Name Kind
    m (UInfixT t1 :: Kind
    t1 n :: Name
    n t2 :: Kind
    t2)    = Kind -> Name -> Kind -> Kind
    UInfixT (Map Name Kind -> Kind -> Kind
    forall t. SubstType t => Map Name Kind -> t -> t
    substType Map Name Kind
    m Kind
    t1) Name
    n (Map Name Kind -> Kind -> Kind
    forall t. SubstType t => Map Name Kind -> t -> t
    substType Map Name Kind
    m Kind
    t2)
      substType m :: Map Name Kind
    m (ParensT t :: Kind
    t)          = Kind -> Kind
    ParensT (Map Name Kind -> Kind -> Kind
    forall t. SubstType t => Map Name Kind -> t -> t
    substType Map Name Kind
    m Kind
    t)
    #endif
    #if MIN_VERSION_template_haskell(2,15,0)
      substType m :: Map Name Kind
    m (AppKindT t :: Kind
    t k :: Kind
    k)       = Kind -> Kind -> Kind
    AppKindT (Map Name Kind -> Kind -> Kind
    forall t. SubstType t => Map Name Kind -> t -> t
    substType Map Name Kind
    m Kind
    t) (Map Name Kind -> Kind -> Kind
    forall t. SubstType t => Map Name Kind -> t -> t
    substType Map Name Kind
    m Kind
    k)
      substType m :: Map Name Kind
    m (ImplicitParamT n :: String
    n t :: Kind
    t) = String -> Kind -> Kind
    ImplicitParamT String
    n (Map Name Kind -> Kind -> Kind
    forall t. SubstType t => Map Name Kind -> t -> t
    substType Map Name Kind
    m Kind
    t)
    #endif
      substType _ t :: Kind
    t                   = Kind
    t

    instance SubstType t => SubstType [t] where
      substType :: Map Name Kind -> [t] -> [t]
    substType = (t -> t) -> [t] -> [t]
    forall a b. (a -> b) -> [a] -> [b]
    map ((t -> t) -> [t] -> [t])
    -> (Map Name Kind -> t -> t) -> Map Name Kind -> [t] -> [t]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Map Name Kind -> t -> t
    forall t. SubstType t => Map Name Kind -> t -> t
    substType

    #if !MIN_VERSION_template_haskell(2,10,0)
    instance SubstType Pred where
      substType m (ClassP n ts) = ClassP n (substType m ts)
      substType m (EqualP l r)  = substType m (EqualP l r)
    #endif

    -- | Provides a 'Traversal' of the types of each field of a constructor.
    --
    -- @
    -- conFields :: 'Traversal'' 'Con' 'BangType'   -- template-haskell-2.11+
    -- conFields :: 'Traversal'' 'Con' 'StrictType' -- Earlier versions
    -- @
    conFields :: Traversal' Con
    #if MIN_VERSION_template_haskell(2,11,0)
                                BangType
    #else
                                StrictType
    #endif
    conFields :: (BangType -> f BangType) -> Con -> f Con
    conFields f :: BangType -> f BangType
    f (NormalC n :: Name
    n fs :: [BangType]
    fs)      = Name -> [BangType] -> Con
    NormalC Name
    n ([BangType] -> Con) -> f [BangType] -> f Con
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (BangType -> f BangType) -> [BangType] -> f [BangType]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse BangType -> f BangType
    f [BangType]
    fs
    conFields f :: BangType -> f BangType
    f (RecC n :: Name
    n fs :: [VarBangType]
    fs)         = Name -> [VarBangType] -> Con
    RecC Name
    n ([VarBangType] -> Con) -> f [VarBangType] -> f Con
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (VarBangType -> f VarBangType) -> [VarBangType] -> f [VarBangType]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse ((BangType -> f BangType) -> VarBangType -> f VarBangType
    Traversal' VarBangType BangType
    sansVar BangType -> f BangType
    f) [VarBangType]
    fs
    conFields f :: BangType -> f BangType
    f (InfixC l :: BangType
    l n :: Name
    n r :: BangType
    r)      = BangType -> Name -> BangType -> Con
    InfixC (BangType -> Name -> BangType -> Con)
    -> f BangType -> f (Name -> BangType -> Con)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> BangType -> f BangType
    f BangType
    l f (Name -> BangType -> Con) -> f Name -> f (BangType -> Con)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Name -> f Name
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Name
    n f (BangType -> Con) -> f BangType -> f Con
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> BangType -> f BangType
    f BangType
    r
    conFields f :: BangType -> f BangType
    f (ForallC bds :: [TyVarBndr]
    bds ctx :: Cxt
    ctx c :: Con
    c) = [TyVarBndr] -> Cxt -> Con -> Con
    ForallC [TyVarBndr]
    bds Cxt
    ctx (Con -> Con) -> f Con -> f Con
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (BangType -> f BangType) -> Con -> f Con
    Traversal' Con BangType
    conFields BangType -> f BangType
    f Con
    c
    #if MIN_VERSION_template_haskell(2,11,0)
    conFields f :: BangType -> f BangType
    f (GadtC ns :: [Name]
    ns argTys :: [BangType]
    argTys retTy :: Kind
    retTy) =
      [Name] -> [BangType] -> Kind -> Con
    GadtC [Name]
    ns ([BangType] -> Kind -> Con) -> f [BangType] -> f (Kind -> Con)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (BangType -> f BangType) -> [BangType] -> f [BangType]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse BangType -> f BangType
    f [BangType]
    argTys f (Kind -> Con) -> f Kind -> f Con
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Kind -> f Kind
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Kind
    retTy
    conFields f :: BangType -> f BangType
    f (RecGadtC ns :: [Name]
    ns argTys :: [VarBangType]
    argTys retTy :: Kind
    retTy) =
      [Name] -> [VarBangType] -> Kind -> Con
    RecGadtC [Name]
    ns ([VarBangType] -> Kind -> Con)
    -> f [VarBangType] -> f (Kind -> Con)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (VarBangType -> f VarBangType) -> [VarBangType] -> f [VarBangType]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse ((BangType -> f BangType) -> VarBangType -> f VarBangType
    Traversal' VarBangType BangType
    sansVar BangType -> f BangType
    f) [VarBangType]
    argTys f (Kind -> Con) -> f Kind -> f Con
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Kind -> f Kind
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Kind
    retTy
    #endif

    -- |
    -- @
    -- sansVar :: 'Traversal'' 'VarBangType'   'BangType'   -- template-haskell-2.11+
    -- sansVar :: 'Traversal'' 'VarStrictType' 'StrictType' -- Earlier versions
    -- @
    #if MIN_VERSION_template_haskell(2,11,0)
    sansVar :: Traversal' VarBangType   BangType
    #else
    sansVar :: Traversal' VarStrictType StrictType
    #endif
    sansVar :: (BangType -> f BangType) -> VarBangType -> f VarBangType
    sansVar f :: BangType -> f BangType
    f (fn :: Name
    fn,s :: Bang
    s,t :: Kind
    t) = (\(s' :: Bang
    s', t' :: Kind
    t') -> (Name
    fn,Bang
    s',Kind
    t')) (BangType -> VarBangType) -> f BangType -> f VarBangType
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> BangType -> f BangType
    f (Bang
    s, Kind
    t)

    -- | 'Traversal' of the types of the /named/ fields of a constructor.
    --
    -- @
    -- conNamedFields :: 'Traversal'' 'Con' 'VarBangType'   -- template-haskell-2.11+
    -- conNamedFields :: 'Traversal'' 'Con' 'VarStrictType' -- Earlier versions
    -- @
    conNamedFields :: Traversal' Con
    #if MIN_VERSION_template_haskell(2,11,0)
                                     VarBangType
    #else
                                     VarStrictType
    #endif
    conNamedFields :: (VarBangType -> f VarBangType) -> Con -> f Con
    conNamedFields f :: VarBangType -> f VarBangType
    f (RecC n :: Name
    n fs :: [VarBangType]
    fs) = Name -> [VarBangType] -> Con
    RecC Name
    n ([VarBangType] -> Con) -> f [VarBangType] -> f Con
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (VarBangType -> f VarBangType) -> [VarBangType] -> f [VarBangType]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse VarBangType -> f VarBangType
    f [VarBangType]
    fs
    conNamedFields f :: VarBangType -> f VarBangType
    f (ForallC a :: [TyVarBndr]
    a b :: Cxt
    b fs :: Con
    fs) = [TyVarBndr] -> Cxt -> Con -> Con
    ForallC [TyVarBndr]
    a Cxt
    b (Con -> Con) -> f Con -> f Con
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (VarBangType -> f VarBangType) -> Con -> f Con
    Traversal' Con VarBangType
    conNamedFields VarBangType -> f VarBangType
    f Con
    fs
    #if MIN_VERSION_template_haskell(2,11,0)
    conNamedFields f :: VarBangType -> f VarBangType
    f (RecGadtC ns :: [Name]
    ns argTys :: [VarBangType]
    argTys retTy :: Kind
    retTy) =
      [Name] -> [VarBangType] -> Kind -> Con
    RecGadtC [Name]
    ns ([VarBangType] -> Kind -> Con)
    -> f [VarBangType] -> f (Kind -> Con)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (VarBangType -> f VarBangType) -> [VarBangType] -> f [VarBangType]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse VarBangType -> f VarBangType
    f [VarBangType]
    argTys f (Kind -> Con) -> f Kind -> f Con
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Kind -> f Kind
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Kind
    retTy
    #endif
    conNamedFields _ c :: Con
    c = Con -> f Con
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Con
    c

    -- Lenses and Prisms
    locFileName :: Lens' Loc String
    locFileName :: (String -> f String) -> Loc -> f Loc
    locFileName = (Loc -> String)
    -> (Loc -> String -> Loc) -> Lens Loc Loc String String
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens Loc -> String
    loc_filename
                ((Loc -> String -> Loc) -> (String -> f String) -> Loc -> f Loc)
    -> (Loc -> String -> Loc) -> (String -> f String) -> Loc -> f Loc
    forall a b. (a -> b) -> a -> b
    $ \loc :: Loc
    loc fn :: String
    fn -> Loc
    loc { loc_filename :: String
    loc_filename = String
    fn }

    locPackage :: Lens' Loc String
    locPackage :: (String -> f String) -> Loc -> f Loc
    locPackage = (Loc -> String)
    -> (Loc -> String -> Loc) -> Lens Loc Loc String String
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens Loc -> String
    loc_package
               ((Loc -> String -> Loc) -> (String -> f String) -> Loc -> f Loc)
    -> (Loc -> String -> Loc) -> (String -> f String) -> Loc -> f Loc
    forall a b. (a -> b) -> a -> b
    $ \loc :: Loc
    loc fn :: String
    fn -> Loc
    loc { loc_package :: String
    loc_package = String
    fn }

    locModule :: Lens' Loc String
    locModule :: (String -> f String) -> Loc -> f Loc
    locModule = (Loc -> String)
    -> (Loc -> String -> Loc) -> Lens Loc Loc String String
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens Loc -> String
    loc_module
              ((Loc -> String -> Loc) -> (String -> f String) -> Loc -> f Loc)
    -> (Loc -> String -> Loc) -> (String -> f String) -> Loc -> f Loc
    forall a b. (a -> b) -> a -> b
    $ \loc :: Loc
    loc fn :: String
    fn -> Loc
    loc { loc_module :: String
    loc_module = String
    fn }

    locStart :: Lens' Loc CharPos
    locStart :: (CharPos -> f CharPos) -> Loc -> f Loc
    locStart = (Loc -> CharPos)
    -> (Loc -> CharPos -> Loc) -> Lens Loc Loc CharPos CharPos
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens Loc -> CharPos
    loc_start
             ((Loc -> CharPos -> Loc) -> (CharPos -> f CharPos) -> Loc -> f Loc)
    -> (Loc -> CharPos -> Loc)
    -> (CharPos -> f CharPos)
    -> Loc
    -> f Loc
    forall a b. (a -> b) -> a -> b
    $ \loc :: Loc
    loc fn :: CharPos
    fn -> Loc
    loc { loc_start :: CharPos
    loc_start = CharPos
    fn }

    locEnd :: Lens' Loc CharPos
    locEnd :: (CharPos -> f CharPos) -> Loc -> f Loc
    locEnd = (Loc -> CharPos)
    -> (Loc -> CharPos -> Loc) -> Lens Loc Loc CharPos CharPos
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens Loc -> CharPos
    loc_end
           ((Loc -> CharPos -> Loc) -> (CharPos -> f CharPos) -> Loc -> f Loc)
    -> (Loc -> CharPos -> Loc)
    -> (CharPos -> f CharPos)
    -> Loc
    -> f Loc
    forall a b. (a -> b) -> a -> b
    $ \loc :: Loc
    loc fn :: CharPos
    fn -> Loc
    loc { loc_end :: CharPos
    loc_end = CharPos
    fn }

    funDepInputs :: Lens' FunDep [Name]
    funDepInputs :: ([Name] -> f [Name]) -> FunDep -> f FunDep
    funDepInputs = (FunDep -> [Name])
    -> (FunDep -> [Name] -> FunDep) -> Lens FunDep FunDep [Name] [Name]
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens FunDep -> [Name]
    g FunDep -> [Name] -> FunDep
    s where
       g :: FunDep -> [Name]
    g (FunDep xs :: [Name]
    xs _)    = [Name]
    xs
       s :: FunDep -> [Name] -> FunDep
    s (FunDep _ ys :: [Name]
    ys) xs :: [Name]
    xs = [Name] -> [Name] -> FunDep
    FunDep [Name]
    xs [Name]
    ys

    funDepOutputs :: Lens' FunDep [Name]
    funDepOutputs :: ([Name] -> f [Name]) -> FunDep -> f FunDep
    funDepOutputs = (FunDep -> [Name])
    -> (FunDep -> [Name] -> FunDep) -> Lens FunDep FunDep [Name] [Name]
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens FunDep -> [Name]
    g FunDep -> [Name] -> FunDep
    s where
       g :: FunDep -> [Name]
    g (FunDep _ xs :: [Name]
    xs) = [Name]
    xs
       s :: FunDep -> [Name] -> FunDep
    s (FunDep ys :: [Name]
    ys _) = [Name] -> [Name] -> FunDep
    FunDep [Name]
    ys

    fieldExpName :: Lens' FieldExp Name
    fieldExpName :: (Name -> f Name) -> FieldExp -> f FieldExp
    fieldExpName = (Name -> f Name) -> FieldExp -> f FieldExp
    forall s t a b. Field1 s t a b => Lens s t a b
    _1

    fieldExpExpression :: Lens' FieldExp Exp
    fieldExpExpression :: (Exp -> f Exp) -> FieldExp -> f FieldExp
    fieldExpExpression = (Exp -> f Exp) -> FieldExp -> f FieldExp
    forall s t a b. Field2 s t a b => Lens s t a b
    _2

    fieldPatName :: Lens' FieldPat Name
    fieldPatName :: (Name -> f Name) -> FieldPat -> f FieldPat
    fieldPatName = (Name -> f Name) -> FieldPat -> f FieldPat
    forall s t a b. Field1 s t a b => Lens s t a b
    _1

    fieldPatPattern :: Lens' FieldPat Pat
    fieldPatPattern :: (Pat -> f Pat) -> FieldPat -> f FieldPat
    fieldPatPattern = (Pat -> f Pat) -> FieldPat -> f FieldPat
    forall s t a b. Field2 s t a b => Lens s t a b
    _2

    matchPattern :: Lens' Match Pat
    matchPattern :: (Pat -> f Pat) -> Match -> f Match
    matchPattern = (Match -> Pat)
    -> (Match -> Pat -> Match) -> Lens Match Match Pat Pat
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens Match -> Pat
    g Match -> Pat -> Match
    s where
       g :: Match -> Pat
    g (Match p :: Pat
    p _ _)   = Pat
    p
       s :: Match -> Pat -> Match
    s (Match _ x :: Body
    x y :: [Dec]
    y) p :: Pat
    p = Pat -> Body -> [Dec] -> Match
    Match Pat
    p Body
    x [Dec]
    y

    matchBody :: Lens' Match Body
    matchBody :: (Body -> f Body) -> Match -> f Match
    matchBody = (Match -> Body)
    -> (Match -> Body -> Match) -> Lens Match Match Body Body
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens Match -> Body
    g Match -> Body -> Match
    s where
       g :: Match -> Body
    g (Match _ b :: Body
    b _)   = Body
    b
       s :: Match -> Body -> Match
    s (Match x :: Pat
    x _ y :: [Dec]
    y) b :: Body
    b = Pat -> Body -> [Dec] -> Match
    Match Pat
    x Body
    b [Dec]
    y

    matchDeclarations :: Lens' Match [Dec]
    matchDeclarations :: ([Dec] -> f [Dec]) -> Match -> f Match
    matchDeclarations = (Match -> [Dec])
    -> (Match -> [Dec] -> Match) -> Lens Match Match [Dec] [Dec]
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens Match -> [Dec]
    g Match -> [Dec] -> Match
    s where
       g :: Match -> [Dec]
    g (Match _ _ ds :: [Dec]
    ds) = [Dec]
    ds
       s :: Match -> [Dec] -> Match
    s (Match x :: Pat
    x y :: Body
    y _ ) = Pat -> Body -> [Dec] -> Match
    Match Pat
    x Body
    y

    fixityPrecedence :: Lens' Fixity Int
    fixityPrecedence :: (Int -> f Int) -> Fixity -> f Fixity
    fixityPrecedence = (Fixity -> Int)
    -> (Fixity -> Int -> Fixity) -> Lens Fixity Fixity Int Int
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens Fixity -> Int
    g Fixity -> Int -> Fixity
    s where
       g :: Fixity -> Int
    g (Fixity i :: Int
    i _)   = Int
    i
       s :: Fixity -> Int -> Fixity
    s (Fixity _ x :: FixityDirection
    x) i :: Int
    i = Int -> FixityDirection -> Fixity
    Fixity Int
    i FixityDirection
    x

    fixityDirection :: Lens' Fixity FixityDirection
    fixityDirection :: (FixityDirection -> f FixityDirection) -> Fixity -> f Fixity
    fixityDirection = (Fixity -> FixityDirection)
    -> (Fixity -> FixityDirection -> Fixity)
    -> Lens Fixity Fixity FixityDirection FixityDirection
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens Fixity -> FixityDirection
    g Fixity -> FixityDirection -> Fixity
    s where
       g :: Fixity -> FixityDirection
    g (Fixity _ d :: FixityDirection
    d) = FixityDirection
    d
       s :: Fixity -> FixityDirection -> Fixity
    s (Fixity i :: Int
    i _) = Int -> FixityDirection -> Fixity
    Fixity Int
    i

    clausePattern :: Lens' Clause [Pat]
    clausePattern :: ([Pat] -> f [Pat]) -> Clause -> f Clause
    clausePattern = (Clause -> [Pat])
    -> (Clause -> [Pat] -> Clause) -> Lens Clause Clause [Pat] [Pat]
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens Clause -> [Pat]
    g Clause -> [Pat] -> Clause
    s where
       g :: Clause -> [Pat]
    g (Clause ps :: [Pat]
    ps _ _)    = [Pat]
    ps
       s :: Clause -> [Pat] -> Clause
    s (Clause _  x :: Body
    x y :: [Dec]
    y) ps :: [Pat]
    ps = [Pat] -> Body -> [Dec] -> Clause
    Clause [Pat]
    ps Body
    x [Dec]
    y

    clauseBody :: Lens' Clause Body
    clauseBody :: (Body -> f Body) -> Clause -> f Clause
    clauseBody = (Clause -> Body)
    -> (Clause -> Body -> Clause) -> Lens Clause Clause Body Body
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens Clause -> Body
    g Clause -> Body -> Clause
    s where
       g :: Clause -> Body
    g (Clause _ b :: Body
    b _)   = Body
    b
       s :: Clause -> Body -> Clause
    s (Clause x :: [Pat]
    x _ y :: [Dec]
    y) b :: Body
    b = [Pat] -> Body -> [Dec] -> Clause
    Clause [Pat]
    x Body
    b [Dec]
    y

    clauseDecs :: Lens' Clause [Dec]
    clauseDecs :: ([Dec] -> f [Dec]) -> Clause -> f Clause
    clauseDecs = (Clause -> [Dec])
    -> (Clause -> [Dec] -> Clause) -> Lens Clause Clause [Dec] [Dec]
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens Clause -> [Dec]
    g Clause -> [Dec] -> Clause
    s where
       g :: Clause -> [Dec]
    g (Clause _ _ ds :: [Dec]
    ds) = [Dec]
    ds
       s :: Clause -> [Dec] -> Clause
    s (Clause x :: [Pat]
    x y :: Body
    y _ ) = [Pat] -> Body -> [Dec] -> Clause
    Clause [Pat]
    x Body
    y

    #if MIN_VERSION_template_haskell(2,11,0)
    injectivityAnnOutput :: Lens' InjectivityAnn Name
    injectivityAnnOutput :: (Name -> f Name) -> InjectivityAnn -> f InjectivityAnn
    injectivityAnnOutput = (InjectivityAnn -> Name)
    -> (InjectivityAnn -> Name -> InjectivityAnn)
    -> Lens' InjectivityAnn Name
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens InjectivityAnn -> Name
    g InjectivityAnn -> Name -> InjectivityAnn
    s where
       g :: InjectivityAnn -> Name
    g (InjectivityAnn o :: Name
    o _)   = Name
    o
       s :: InjectivityAnn -> Name -> InjectivityAnn
    s (InjectivityAnn _ i :: [Name]
    i) o :: Name
    o = Name -> [Name] -> InjectivityAnn
    InjectivityAnn Name
    o [Name]
    i

    injectivityAnnInputs :: Lens' InjectivityAnn [Name]
    injectivityAnnInputs :: ([Name] -> f [Name]) -> InjectivityAnn -> f InjectivityAnn
    injectivityAnnInputs = (InjectivityAnn -> [Name])
    -> (InjectivityAnn -> [Name] -> InjectivityAnn)
    -> Lens InjectivityAnn InjectivityAnn [Name] [Name]
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens InjectivityAnn -> [Name]
    g InjectivityAnn -> [Name] -> InjectivityAnn
    s where
       g :: InjectivityAnn -> [Name]
    g (InjectivityAnn _ i :: [Name]
    i) = [Name]
    i
       s :: InjectivityAnn -> [Name] -> InjectivityAnn
    s (InjectivityAnn o :: Name
    o _) = Name -> [Name] -> InjectivityAnn
    InjectivityAnn Name
    o

    typeFamilyHeadName :: Lens' TypeFamilyHead Name
    typeFamilyHeadName :: (Name -> f Name) -> TypeFamilyHead -> f TypeFamilyHead
    typeFamilyHeadName = (TypeFamilyHead -> Name)
    -> (TypeFamilyHead -> Name -> TypeFamilyHead)
    -> Lens' TypeFamilyHead Name
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens TypeFamilyHead -> Name
    g TypeFamilyHead -> Name -> TypeFamilyHead
    s where
      g :: TypeFamilyHead -> Name
    g (TypeFamilyHead n :: Name
    n _    _  _ )   = Name
    n
      s :: TypeFamilyHead -> Name -> TypeFamilyHead
    s (TypeFamilyHead _ tvbs :: [TyVarBndr]
    tvbs rs :: FamilyResultSig
    rs ia :: Maybe InjectivityAnn
    ia) n :: Name
    n = Name
    -> [TyVarBndr]
    -> FamilyResultSig
    -> Maybe InjectivityAnn
    -> TypeFamilyHead
    TypeFamilyHead Name
    n [TyVarBndr]
    tvbs FamilyResultSig
    rs Maybe InjectivityAnn
    ia

    typeFamilyHeadTyVarBndrs :: Lens' TypeFamilyHead [TyVarBndr]
    typeFamilyHeadTyVarBndrs :: ([TyVarBndr] -> f [TyVarBndr])
    -> TypeFamilyHead -> f TypeFamilyHead
    typeFamilyHeadTyVarBndrs = (TypeFamilyHead -> [TyVarBndr])
    -> (TypeFamilyHead -> [TyVarBndr] -> TypeFamilyHead)
    -> Lens TypeFamilyHead TypeFamilyHead [TyVarBndr] [TyVarBndr]
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens TypeFamilyHead -> [TyVarBndr]
    g TypeFamilyHead -> [TyVarBndr] -> TypeFamilyHead
    s where
      g :: TypeFamilyHead -> [TyVarBndr]
    g (TypeFamilyHead _ tvbs :: [TyVarBndr]
    tvbs _  _ )      = [TyVarBndr]
    tvbs
      s :: TypeFamilyHead -> [TyVarBndr] -> TypeFamilyHead
    s (TypeFamilyHead n :: Name
    n _    rs :: FamilyResultSig
    rs ia :: Maybe InjectivityAnn
    ia) tvbs :: [TyVarBndr]
    tvbs = Name
    -> [TyVarBndr]
    -> FamilyResultSig
    -> Maybe InjectivityAnn
    -> TypeFamilyHead
    TypeFamilyHead Name
    n [TyVarBndr]
    tvbs FamilyResultSig
    rs Maybe InjectivityAnn
    ia

    typeFamilyHeadResultSig :: Lens' TypeFamilyHead FamilyResultSig
    typeFamilyHeadResultSig :: (FamilyResultSig -> f FamilyResultSig)
    -> TypeFamilyHead -> f TypeFamilyHead
    typeFamilyHeadResultSig = (TypeFamilyHead -> FamilyResultSig)
    -> (TypeFamilyHead -> FamilyResultSig -> TypeFamilyHead)
    -> Lens
         TypeFamilyHead TypeFamilyHead FamilyResultSig FamilyResultSig
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens TypeFamilyHead -> FamilyResultSig
    g TypeFamilyHead -> FamilyResultSig -> TypeFamilyHead
    s where
      g :: TypeFamilyHead -> FamilyResultSig
    g (TypeFamilyHead _ _    rs :: FamilyResultSig
    rs _ )    = FamilyResultSig
    rs
      s :: TypeFamilyHead -> FamilyResultSig -> TypeFamilyHead
    s (TypeFamilyHead n :: Name
    n tvbs :: [TyVarBndr]
    tvbs _  ia :: Maybe InjectivityAnn
    ia) rs :: FamilyResultSig
    rs = Name
    -> [TyVarBndr]
    -> FamilyResultSig
    -> Maybe InjectivityAnn
    -> TypeFamilyHead
    TypeFamilyHead Name
    n [TyVarBndr]
    tvbs FamilyResultSig
    rs Maybe InjectivityAnn
    ia

    typeFamilyHeadInjectivityAnn :: Lens' TypeFamilyHead (Maybe InjectivityAnn)
    typeFamilyHeadInjectivityAnn :: (Maybe InjectivityAnn -> f (Maybe InjectivityAnn))
    -> TypeFamilyHead -> f TypeFamilyHead
    typeFamilyHeadInjectivityAnn = (TypeFamilyHead -> Maybe InjectivityAnn)
    -> (TypeFamilyHead -> Maybe InjectivityAnn -> TypeFamilyHead)
    -> Lens
         TypeFamilyHead
         TypeFamilyHead
         (Maybe InjectivityAnn)
         (Maybe InjectivityAnn)
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens TypeFamilyHead -> Maybe InjectivityAnn
    g TypeFamilyHead -> Maybe InjectivityAnn -> TypeFamilyHead
    s where
      g :: TypeFamilyHead -> Maybe InjectivityAnn
    g (TypeFamilyHead _ _    _  ia :: Maybe InjectivityAnn
    ia) = Maybe InjectivityAnn
    ia
      s :: TypeFamilyHead -> Maybe InjectivityAnn -> TypeFamilyHead
    s (TypeFamilyHead n :: Name
    n tvbs :: [TyVarBndr]
    tvbs rs :: FamilyResultSig
    rs _ ) = Name
    -> [TyVarBndr]
    -> FamilyResultSig
    -> Maybe InjectivityAnn
    -> TypeFamilyHead
    TypeFamilyHead Name
    n [TyVarBndr]
    tvbs FamilyResultSig
    rs

    bangSourceUnpackedness :: Lens' Bang SourceUnpackedness
    bangSourceUnpackedness :: (SourceUnpackedness -> f SourceUnpackedness) -> Bang -> f Bang
    bangSourceUnpackedness = (Bang -> SourceUnpackedness)
    -> (Bang -> SourceUnpackedness -> Bang)
    -> Lens Bang Bang SourceUnpackedness SourceUnpackedness
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens Bang -> SourceUnpackedness
    g Bang -> SourceUnpackedness -> Bang
    s where
      g :: Bang -> SourceUnpackedness
    g (Bang su :: SourceUnpackedness
    su _ )    = SourceUnpackedness
    su
      s :: Bang -> SourceUnpackedness -> Bang
    s (Bang _  ss :: SourceStrictness
    ss) su :: SourceUnpackedness
    su = SourceUnpackedness -> SourceStrictness -> Bang
    Bang SourceUnpackedness
    su SourceStrictness
    ss

    bangSourceStrictness :: Lens' Bang SourceStrictness
    bangSourceStrictness :: (SourceStrictness -> f SourceStrictness) -> Bang -> f Bang
    bangSourceStrictness = (Bang -> SourceStrictness)
    -> (Bang -> SourceStrictness -> Bang)
    -> Lens Bang Bang SourceStrictness SourceStrictness
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens Bang -> SourceStrictness
    g Bang -> SourceStrictness -> Bang
    s where
      g :: Bang -> SourceStrictness
    g (Bang _  su :: SourceStrictness
    su) = SourceStrictness
    su
      s :: Bang -> SourceStrictness -> Bang
    s (Bang ss :: SourceUnpackedness
    ss _ ) = SourceUnpackedness -> SourceStrictness -> Bang
    Bang SourceUnpackedness
    ss
    #endif

    #if MIN_VERSION_template_haskell(2,12,0)
    derivClauseStrategy :: Lens' DerivClause (Maybe DerivStrategy)
    derivClauseStrategy :: (Maybe DerivStrategy -> f (Maybe DerivStrategy))
    -> DerivClause -> f DerivClause
    derivClauseStrategy = (DerivClause -> Maybe DerivStrategy)
    -> (DerivClause -> Maybe DerivStrategy -> DerivClause)
    -> Lens
         DerivClause DerivClause (Maybe DerivStrategy) (Maybe DerivStrategy)
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens DerivClause -> Maybe DerivStrategy
    g DerivClause -> Maybe DerivStrategy -> DerivClause
    s where
      g :: DerivClause -> Maybe DerivStrategy
    g (DerivClause mds :: Maybe DerivStrategy
    mds _)     = Maybe DerivStrategy
    mds
      s :: DerivClause -> Maybe DerivStrategy -> DerivClause
    s (DerivClause _   c :: Cxt
    c) mds :: Maybe DerivStrategy
    mds = Maybe DerivStrategy -> Cxt -> DerivClause
    DerivClause Maybe DerivStrategy
    mds Cxt
    c

    derivClauseCxt :: Lens' DerivClause Cxt
    derivClauseCxt :: (Cxt -> f Cxt) -> DerivClause -> f DerivClause
    derivClauseCxt = (DerivClause -> Cxt)
    -> (DerivClause -> Cxt -> DerivClause)
    -> Lens DerivClause DerivClause Cxt Cxt
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens DerivClause -> Cxt
    g DerivClause -> Cxt -> DerivClause
    s where
      g :: DerivClause -> Cxt
    g (DerivClause _   c :: Cxt
    c) = Cxt
    c
      s :: DerivClause -> Cxt -> DerivClause
    s (DerivClause mds :: Maybe DerivStrategy
    mds _) = Maybe DerivStrategy -> Cxt -> DerivClause
    DerivClause Maybe DerivStrategy
    mds
    #endif

    #if MIN_VERSION_template_haskell(2,8,0)
    _ClassI :: Prism' Info (Dec, [InstanceDec])
    #else
    _ClassI :: Prism' Info (Dec, [Dec])
    #endif
    _ClassI :: p (Dec, [Dec]) (f (Dec, [Dec])) -> p Info (f Info)
    _ClassI
      = ((Dec, [Dec]) -> Info)
    -> (Info -> Maybe (Dec, [Dec]))
    -> Prism Info Info (Dec, [Dec]) (Dec, [Dec])
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Dec, [Dec]) -> Info
    reviewer Info -> Maybe (Dec, [Dec])
    remitter
      where
          reviewer :: (Dec, [Dec]) -> Info
    reviewer (x :: Dec
    x, y :: [Dec]
    y) = Dec -> [Dec] -> Info
    ClassI Dec
    x [Dec]
    y
          remitter :: Info -> Maybe (Dec, [Dec])
    remitter (ClassI x :: Dec
    x y :: [Dec]
    y) = (Dec, [Dec]) -> Maybe (Dec, [Dec])
    forall a. a -> Maybe a
    Just (Dec
    x, [Dec]
    y)
          remitter _ = Maybe (Dec, [Dec])
    forall a. Maybe a
    Nothing

    -- |
    -- @
    -- _ClassOpI :: 'Prism'' 'Info' ('Name', 'Type', 'ParentName')         -- template-haskell-2.11+
    -- _ClassOpI :: 'Prism'' 'Info' ('Name', 'Type', 'ParentName', 'Fixity') -- template-haskell-2.8 through 2.10
    -- _ClassOpI :: 'Prism'' 'Info' ('Name', 'Type', 'Name',       'Fixity') -- Earlier versions
    -- @
    #if MIN_VERSION_template_haskell(2,11,0)
    _ClassOpI :: Prism' Info (Name, Type, ParentName)
    _ClassOpI :: p (Name, Kind, Name) (f (Name, Kind, Name)) -> p Info (f Info)
    _ClassOpI
      = ((Name, Kind, Name) -> Info)
    -> (Info -> Maybe (Name, Kind, Name))
    -> Prism Info Info (Name, Kind, Name) (Name, Kind, Name)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, Kind, Name) -> Info
    reviewer Info -> Maybe (Name, Kind, Name)
    remitter
      where
          reviewer :: (Name, Kind, Name) -> Info
    reviewer (x :: Name
    x, y :: Kind
    y, z :: Name
    z) = Name -> Kind -> Name -> Info
    ClassOpI Name
    x Kind
    y Name
    z
          remitter :: Info -> Maybe (Name, Kind, Name)
    remitter (ClassOpI x :: Name
    x y :: Kind
    y z :: Name
    z) = (Name, Kind, Name) -> Maybe (Name, Kind, Name)
    forall a. a -> Maybe a
    Just (Name
    x, Kind
    y, Name
    z)
          remitter _ = Maybe (Name, Kind, Name)
    forall a. Maybe a
    Nothing
    #else
    # if MIN_VERSION_template_haskell(2,8,0)
    _ClassOpI :: Prism' Info (Name, Type, ParentName, Fixity)
    # else
    _ClassOpI :: Prism' Info (Name, Type, Name, Fixity)
    # endif
    _ClassOpI
      = prism' reviewer remitter
      where
          reviewer (x, y, z, w) = ClassOpI x y z w
          remitter (ClassOpI x y z w) = Just (x, y, z, w)
          remitter _ = Nothing
    #endif

    _TyConI :: Prism' Info Dec
    _TyConI :: p Dec (f Dec) -> p Info (f Info)
    _TyConI
      = (Dec -> Info) -> (Info -> Maybe Dec) -> Prism Info Info Dec Dec
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Dec -> Info
    reviewer Info -> Maybe Dec
    remitter
      where
          reviewer :: Dec -> Info
    reviewer = Dec -> Info
    TyConI
          remitter :: Info -> Maybe Dec
    remitter (TyConI x :: Dec
    x) = Dec -> Maybe Dec
    forall a. a -> Maybe a
    Just Dec
    x
          remitter _ = Maybe Dec
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,11,0)
    _FamilyI :: Prism' Info (Dec, [InstanceDec])
    #else
    _FamilyI :: Prism' Info (Dec, [Dec])
    #endif
    _FamilyI :: p (Dec, [Dec]) (f (Dec, [Dec])) -> p Info (f Info)
    _FamilyI
      = ((Dec, [Dec]) -> Info)
    -> (Info -> Maybe (Dec, [Dec]))
    -> Prism Info Info (Dec, [Dec]) (Dec, [Dec])
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Dec, [Dec]) -> Info
    reviewer Info -> Maybe (Dec, [Dec])
    remitter
      where
          reviewer :: (Dec, [Dec]) -> Info
    reviewer (x :: Dec
    x, y :: [Dec]
    y) = Dec -> [Dec] -> Info
    FamilyI Dec
    x [Dec]
    y
          remitter :: Info -> Maybe (Dec, [Dec])
    remitter (FamilyI x :: Dec
    x y :: [Dec]
    y) = (Dec, [Dec]) -> Maybe (Dec, [Dec])
    forall a. a -> Maybe a
    Just (Dec
    x, [Dec]
    y)
          remitter _ = Maybe (Dec, [Dec])
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,8,0)
    _PrimTyConI :: Prism' Info (Name, Arity, Unlifted)
    #else
    _PrimTyConI :: Prism' Info (Name, Int, Bool)
    #endif
    _PrimTyConI :: p (Name, Int, Bool) (f (Name, Int, Bool)) -> p Info (f Info)
    _PrimTyConI
      = ((Name, Int, Bool) -> Info)
    -> (Info -> Maybe (Name, Int, Bool))
    -> Prism Info Info (Name, Int, Bool) (Name, Int, Bool)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, Int, Bool) -> Info
    reviewer Info -> Maybe (Name, Int, Bool)
    remitter
      where
          reviewer :: (Name, Int, Bool) -> Info
    reviewer (x :: Name
    x, y :: Int
    y, z :: Bool
    z) = Name -> Int -> Bool -> Info
    PrimTyConI Name
    x Int
    y Bool
    z
          remitter :: Info -> Maybe (Name, Int, Bool)
    remitter (PrimTyConI x :: Name
    x y :: Int
    y z :: Bool
    z) = (Name, Int, Bool) -> Maybe (Name, Int, Bool)
    forall a. a -> Maybe a
    Just (Name
    x, Int
    y, Bool
    z)
          remitter _ = Maybe (Name, Int, Bool)
    forall a. Maybe a
    Nothing

    -- |
    -- @
    -- _DataConI :: 'Prism'' 'Info' ('Name', 'Type', 'ParentName')         -- template-haskell-2.11+
    -- _DataConI :: 'Prism'' 'Info' ('Name', 'Type', 'ParentName', 'Fixity') -- template-haskell-2.8 through 2.10
    -- _DataConI :: 'Prism'' 'Info' ('Name', 'Type', 'Name',       'Fixity') -- Earlier versions
    -- @
    #if MIN_VERSION_template_haskell(2,11,0)
    _DataConI :: Prism' Info (Name, Type, ParentName)
    _DataConI :: p (Name, Kind, Name) (f (Name, Kind, Name)) -> p Info (f Info)
    _DataConI
      = ((Name, Kind, Name) -> Info)
    -> (Info -> Maybe (Name, Kind, Name))
    -> Prism Info Info (Name, Kind, Name) (Name, Kind, Name)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, Kind, Name) -> Info
    reviewer Info -> Maybe (Name, Kind, Name)
    remitter
      where
          reviewer :: (Name, Kind, Name) -> Info
    reviewer (x :: Name
    x, y :: Kind
    y, z :: Name
    z) = Name -> Kind -> Name -> Info
    DataConI Name
    x Kind
    y Name
    z
          remitter :: Info -> Maybe (Name, Kind, Name)
    remitter (DataConI x :: Name
    x y :: Kind
    y z :: Name
    z) = (Name, Kind, Name) -> Maybe (Name, Kind, Name)
    forall a. a -> Maybe a
    Just (Name
    x, Kind
    y, Name
    z)
          remitter _ = Maybe (Name, Kind, Name)
    forall a. Maybe a
    Nothing
    #else
    # if MIN_VERSION_template_haskell(2,8,0)
    _DataConI :: Prism' Info (Name, Type, ParentName, Fixity)
    # else
    _DataConI :: Prism' Info (Name, Type, Name, Fixity)
    # endif
    _DataConI
      = prism' reviewer remitter
      where
          reviewer (x, y, z, w) = DataConI x y z w
          remitter (DataConI x y z w) = Just (x, y, z, w)
          remitter _ = Nothing
    #endif

    -- |
    -- @
    -- _VarI :: 'Prism'' 'Info' ('Name', 'Type', 'Maybe' 'Dec')         -- template-haskell-2.11+
    -- _VarI :: 'Prism'' 'Info' ('Name', 'Type', 'Maybe' 'Dec', 'Fixity') -- Earlier versions
    -- @
    #if MIN_VERSION_template_haskell(2,11,0)
    _VarI :: Prism' Info (Name, Type, Maybe Dec)
    _VarI :: p (Name, Kind, Maybe Dec) (f (Name, Kind, Maybe Dec))
    -> p Info (f Info)
    _VarI
      = ((Name, Kind, Maybe Dec) -> Info)
    -> (Info -> Maybe (Name, Kind, Maybe Dec))
    -> Prism Info Info (Name, Kind, Maybe Dec) (Name, Kind, Maybe Dec)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, Kind, Maybe Dec) -> Info
    reviewer Info -> Maybe (Name, Kind, Maybe Dec)
    remitter
      where
          reviewer :: (Name, Kind, Maybe Dec) -> Info
    reviewer (x :: Name
    x, y :: Kind
    y, z :: Maybe Dec
    z) = Name -> Kind -> Maybe Dec -> Info
    VarI Name
    x Kind
    y Maybe Dec
    z
          remitter :: Info -> Maybe (Name, Kind, Maybe Dec)
    remitter (VarI x :: Name
    x y :: Kind
    y z :: Maybe Dec
    z) = (Name, Kind, Maybe Dec) -> Maybe (Name, Kind, Maybe Dec)
    forall a. a -> Maybe a
    Just (Name
    x, Kind
    y, Maybe Dec
    z)
          remitter _ = Maybe (Name, Kind, Maybe Dec)
    forall a. Maybe a
    Nothing
    #else
    _VarI :: Prism' Info (Name, Type, Maybe Dec, Fixity)
    _VarI
      = prism' reviewer remitter
      where
          reviewer (x, y, z, w) = VarI x y z w
          remitter (VarI x y z w) = Just (x, y, z, w)
          remitter _ = Nothing
    #endif

    _TyVarI :: Prism' Info (Name, Type)
    _TyVarI :: p (Name, Kind) (f (Name, Kind)) -> p Info (f Info)
    _TyVarI
      = ((Name, Kind) -> Info)
    -> (Info -> Maybe (Name, Kind))
    -> Prism Info Info (Name, Kind) (Name, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, Kind) -> Info
    reviewer Info -> Maybe (Name, Kind)
    remitter
      where
          reviewer :: (Name, Kind) -> Info
    reviewer (x :: Name
    x, y :: Kind
    y) = Name -> Kind -> Info
    TyVarI Name
    x Kind
    y
          remitter :: Info -> Maybe (Name, Kind)
    remitter (TyVarI x :: Name
    x y :: Kind
    y) = (Name, Kind) -> Maybe (Name, Kind)
    forall a. a -> Maybe a
    Just (Name
    x, Kind
    y)
          remitter _ = Maybe (Name, Kind)
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,12,0)
    _PatSynI :: Prism' Info (Name, PatSynType)
    _PatSynI :: p (Name, Kind) (f (Name, Kind)) -> p Info (f Info)
    _PatSynI
      = ((Name, Kind) -> Info)
    -> (Info -> Maybe (Name, Kind))
    -> Prism Info Info (Name, Kind) (Name, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, Kind) -> Info
    reviewer Info -> Maybe (Name, Kind)
    remitter
      where
          reviewer :: (Name, Kind) -> Info
    reviewer (x :: Name
    x, y :: Kind
    y) = Name -> Kind -> Info
    PatSynI Name
    x Kind
    y
          remitter :: Info -> Maybe (Name, Kind)
    remitter (PatSynI x :: Name
    x y :: Kind
    y) = (Name, Kind) -> Maybe (Name, Kind)
    forall a. a -> Maybe a
    Just (Name
    x, Kind
    y)
          remitter _ = Maybe (Name, Kind)
    forall a. Maybe a
    Nothing
    #endif

    _FunD :: Prism' Dec (Name, [Clause])
    _FunD :: p (Name, [Clause]) (f (Name, [Clause])) -> p Dec (f Dec)
    _FunD
      = ((Name, [Clause]) -> Dec)
    -> (Dec -> Maybe (Name, [Clause]))
    -> Prism Dec Dec (Name, [Clause]) (Name, [Clause])
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, [Clause]) -> Dec
    reviewer Dec -> Maybe (Name, [Clause])
    remitter
      where
          reviewer :: (Name, [Clause]) -> Dec
    reviewer (x :: Name
    x, y :: [Clause]
    y) = Name -> [Clause] -> Dec
    FunD Name
    x [Clause]
    y
          remitter :: Dec -> Maybe (Name, [Clause])
    remitter (FunD x :: Name
    x y :: [Clause]
    y) = (Name, [Clause]) -> Maybe (Name, [Clause])
    forall a. a -> Maybe a
    Just (Name
    x,[Clause]
    y)
          remitter _ = Maybe (Name, [Clause])
    forall a. Maybe a
    Nothing

    _ValD :: Prism' Dec (Pat, Body, [Dec])
    _ValD :: p (Pat, Body, [Dec]) (f (Pat, Body, [Dec])) -> p Dec (f Dec)
    _ValD
      = ((Pat, Body, [Dec]) -> Dec)
    -> (Dec -> Maybe (Pat, Body, [Dec]))
    -> Prism Dec Dec (Pat, Body, [Dec]) (Pat, Body, [Dec])
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Pat, Body, [Dec]) -> Dec
    reviewer Dec -> Maybe (Pat, Body, [Dec])
    remitter
      where
          reviewer :: (Pat, Body, [Dec]) -> Dec
    reviewer (x :: Pat
    x, y :: Body
    y, z :: [Dec]
    z) = Pat -> Body -> [Dec] -> Dec
    ValD Pat
    x Body
    y [Dec]
    z
          remitter :: Dec -> Maybe (Pat, Body, [Dec])
    remitter (ValD x :: Pat
    x y :: Body
    y z :: [Dec]
    z) = (Pat, Body, [Dec]) -> Maybe (Pat, Body, [Dec])
    forall a. a -> Maybe a
    Just (Pat
    x, Body
    y, [Dec]
    z)
          remitter _ = Maybe (Pat, Body, [Dec])
    forall a. Maybe a
    Nothing

    _TySynD :: Prism' Dec (Name, [TyVarBndr], Type)
    _TySynD :: p (Name, [TyVarBndr], Kind) (f (Name, [TyVarBndr], Kind))
    -> p Dec (f Dec)
    _TySynD
      = ((Name, [TyVarBndr], Kind) -> Dec)
    -> (Dec -> Maybe (Name, [TyVarBndr], Kind))
    -> Prism
         Dec Dec (Name, [TyVarBndr], Kind) (Name, [TyVarBndr], Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, [TyVarBndr], Kind) -> Dec
    reviewer Dec -> Maybe (Name, [TyVarBndr], Kind)
    remitter
      where
          reviewer :: (Name, [TyVarBndr], Kind) -> Dec
    reviewer (x :: Name
    x, y :: [TyVarBndr]
    y, z :: Kind
    z) = Name -> [TyVarBndr] -> Kind -> Dec
    TySynD Name
    x [TyVarBndr]
    y Kind
    z
          remitter :: Dec -> Maybe (Name, [TyVarBndr], Kind)
    remitter (TySynD x :: Name
    x y :: [TyVarBndr]
    y z :: Kind
    z) = (Name, [TyVarBndr], Kind) -> Maybe (Name, [TyVarBndr], Kind)
    forall a. a -> Maybe a
    Just (Name
    x, [TyVarBndr]
    y, Kind
    z)
          remitter _ = Maybe (Name, [TyVarBndr], Kind)
    forall a. Maybe a
    Nothing

    _ClassD :: Prism' Dec (Cxt, Name, [TyVarBndr], [FunDep], [Dec])
    _ClassD :: p (Cxt, Name, [TyVarBndr], [FunDep], [Dec])
      (f (Cxt, Name, [TyVarBndr], [FunDep], [Dec]))
    -> p Dec (f Dec)
    _ClassD
      = ((Cxt, Name, [TyVarBndr], [FunDep], [Dec]) -> Dec)
    -> (Dec -> Maybe (Cxt, Name, [TyVarBndr], [FunDep], [Dec]))
    -> Prism
         Dec
         Dec
         (Cxt, Name, [TyVarBndr], [FunDep], [Dec])
         (Cxt, Name, [TyVarBndr], [FunDep], [Dec])
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Cxt, Name, [TyVarBndr], [FunDep], [Dec]) -> Dec
    reviewer Dec -> Maybe (Cxt, Name, [TyVarBndr], [FunDep], [Dec])
    remitter
      where
          reviewer :: (Cxt, Name, [TyVarBndr], [FunDep], [Dec]) -> Dec
    reviewer (x :: Cxt
    x, y :: Name
    y, z :: [TyVarBndr]
    z, w :: [FunDep]
    w, u :: [Dec]
    u) = Cxt -> Name -> [TyVarBndr] -> [FunDep] -> [Dec] -> Dec
    ClassD Cxt
    x Name
    y [TyVarBndr]
    z [FunDep]
    w [Dec]
    u
          remitter :: Dec -> Maybe (Cxt, Name, [TyVarBndr], [FunDep], [Dec])
    remitter (ClassD x :: Cxt
    x y :: Name
    y z :: [TyVarBndr]
    z w :: [FunDep]
    w u :: [Dec]
    u) = (Cxt, Name, [TyVarBndr], [FunDep], [Dec])
    -> Maybe (Cxt, Name, [TyVarBndr], [FunDep], [Dec])
    forall a. a -> Maybe a
    Just (Cxt
    x, Name
    y, [TyVarBndr]
    z, [FunDep]
    w, [Dec]
    u)
          remitter _ = Maybe (Cxt, Name, [TyVarBndr], [FunDep], [Dec])
    forall a. Maybe a
    Nothing

    -- |
    -- @
    -- _InstanceD :: 'Prism'' 'Dec' ('Maybe' 'Overlap', 'Cxt', 'Type', ['Dec']) -- template-haskell-2.11+
    -- _InstanceD :: 'Prism'' 'Dec'                ('Cxt', 'Type', ['Dec']) -- Earlier versions
    -- @
    #if MIN_VERSION_template_haskell(2,11,0)
    _InstanceD :: Prism' Dec (Maybe Overlap, Cxt, Type, [Dec])
    #else
    _InstanceD :: Prism' Dec (Cxt, Type, [Dec])
    #endif
    _InstanceD :: p (Maybe Overlap, Cxt, Kind, [Dec])
      (f (Maybe Overlap, Cxt, Kind, [Dec]))
    -> p Dec (f Dec)
    _InstanceD
      = ((Maybe Overlap, Cxt, Kind, [Dec]) -> Dec)
    -> (Dec -> Maybe (Maybe Overlap, Cxt, Kind, [Dec]))
    -> Prism
         Dec
         Dec
         (Maybe Overlap, Cxt, Kind, [Dec])
         (Maybe Overlap, Cxt, Kind, [Dec])
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Maybe Overlap, Cxt, Kind, [Dec]) -> Dec
    reviewer Dec -> Maybe (Maybe Overlap, Cxt, Kind, [Dec])
    remitter
      where
    #if MIN_VERSION_template_haskell(2,11,0)
          reviewer :: (Maybe Overlap, Cxt, Kind, [Dec]) -> Dec
    reviewer (x :: Maybe Overlap
    x, y :: Cxt
    y, z :: Kind
    z, w :: [Dec]
    w) = Maybe Overlap -> Cxt -> Kind -> [Dec] -> Dec
    InstanceD Maybe Overlap
    x Cxt
    y Kind
    z [Dec]
    w
          remitter :: Dec -> Maybe (Maybe Overlap, Cxt, Kind, [Dec])
    remitter (InstanceD x :: Maybe Overlap
    x y :: Cxt
    y z :: Kind
    z w :: [Dec]
    w) = (Maybe Overlap, Cxt, Kind, [Dec])
    -> Maybe (Maybe Overlap, Cxt, Kind, [Dec])
    forall a. a -> Maybe a
    Just (Maybe Overlap
    x, Cxt
    y, Kind
    z, [Dec]
    w)
    #else
          reviewer (x, y, z) = InstanceD x y z
          remitter (InstanceD x y z) = Just ( x, y, z)
    #endif
          remitter _ = Maybe (Maybe Overlap, Cxt, Kind, [Dec])
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,11,0)
    _Overlappable  :: Prism' Overlap  ()
    _Overlappable :: p () (f ()) -> p Overlap (f Overlap)
    _Overlappable  = (() -> Overlap)
    -> (Overlap -> Maybe ()) -> Prism Overlap Overlap () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Overlap
    reviewer Overlap -> Maybe ()
    remitter
      where
          reviewer :: () -> Overlap
    reviewer () = Overlap
    Overlappable
          remitter :: Overlap -> Maybe ()
    remitter Overlappable = () -> Maybe ()
    forall a. a -> Maybe a
    Just  ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _Overlapping :: Prism' Overlap ()
    _Overlapping :: p () (f ()) -> p Overlap (f Overlap)
    _Overlapping = (() -> Overlap)
    -> (Overlap -> Maybe ()) -> Prism Overlap Overlap () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Overlap
    reviewer Overlap -> Maybe ()
    remitter
      where
          reviewer :: () -> Overlap
    reviewer () = Overlap
    Overlapping
          remitter :: Overlap -> Maybe ()
    remitter Overlapping = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _Overlaps ::  Prism' Overlap  ()
    _Overlaps :: p () (f ()) -> p Overlap (f Overlap)
    _Overlaps =  (() -> Overlap)
    -> (Overlap -> Maybe ()) -> Prism Overlap Overlap () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Overlap
    reviewer Overlap -> Maybe ()
    remitter
      where
          reviewer :: () -> Overlap
    reviewer () =  Overlap
    Overlaps
          remitter :: Overlap -> Maybe ()
    remitter Overlaps = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _Incoherent  :: Prism' Overlap ()
    _Incoherent :: p () (f ()) -> p Overlap (f Overlap)
    _Incoherent  = (() -> Overlap)
    -> (Overlap -> Maybe ()) -> Prism Overlap Overlap () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Overlap
    reviewer Overlap -> Maybe ()
    remitter
      where
          reviewer :: () -> Overlap
    reviewer () = Overlap
    Incoherent
          remitter :: Overlap -> Maybe ()
    remitter Incoherent = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing
    #endif

    _SigD :: Prism' Dec (Name, Type)
    _SigD :: p (Name, Kind) (f (Name, Kind)) -> p Dec (f Dec)
    _SigD
      = ((Name, Kind) -> Dec)
    -> (Dec -> Maybe (Name, Kind))
    -> Prism Dec Dec (Name, Kind) (Name, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, Kind) -> Dec
    reviewer Dec -> Maybe (Name, Kind)
    remitter
      where
          reviewer :: (Name, Kind) -> Dec
    reviewer (x :: Name
    x, y :: Kind
    y) = Name -> Kind -> Dec
    SigD Name
    x Kind
    y
          remitter :: Dec -> Maybe (Name, Kind)
    remitter (SigD x :: Name
    x y :: Kind
    y) = (Name, Kind) -> Maybe (Name, Kind)
    forall a. a -> Maybe a
    Just (Name
    x, Kind
    y)
          remitter _ = Maybe (Name, Kind)
    forall a. Maybe a
    Nothing

    _ForeignD :: Prism' Dec Foreign
    _ForeignD :: p Foreign (f Foreign) -> p Dec (f Dec)
    _ForeignD
      = (Foreign -> Dec)
    -> (Dec -> Maybe Foreign) -> Prism Dec Dec Foreign Foreign
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Foreign -> Dec
    reviewer Dec -> Maybe Foreign
    remitter
      where
          reviewer :: Foreign -> Dec
    reviewer = Foreign -> Dec
    ForeignD
          remitter :: Dec -> Maybe Foreign
    remitter (ForeignD x :: Foreign
    x) = Foreign -> Maybe Foreign
    forall a. a -> Maybe a
    Just Foreign
    x
          remitter _ = Maybe Foreign
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,8,0)
    _InfixD :: Prism' Dec (Fixity, Name)
    _InfixD :: p (Fixity, Name) (f (Fixity, Name)) -> p Dec (f Dec)
    _InfixD
      = ((Fixity, Name) -> Dec)
    -> (Dec -> Maybe (Fixity, Name))
    -> Prism Dec Dec (Fixity, Name) (Fixity, Name)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Fixity, Name) -> Dec
    reviewer Dec -> Maybe (Fixity, Name)
    remitter
      where
          reviewer :: (Fixity, Name) -> Dec
    reviewer (x :: Fixity
    x, y :: Name
    y) = Fixity -> Name -> Dec
    InfixD Fixity
    x Name
    y
          remitter :: Dec -> Maybe (Fixity, Name)
    remitter (InfixD x :: Fixity
    x y :: Name
    y) = (Fixity, Name) -> Maybe (Fixity, Name)
    forall a. a -> Maybe a
    Just (Fixity
    x, Name
    y)
          remitter _ = Maybe (Fixity, Name)
    forall a. Maybe a
    Nothing
    #endif

    _PragmaD :: Prism' Dec Pragma
    _PragmaD :: p Pragma (f Pragma) -> p Dec (f Dec)
    _PragmaD
      = (Pragma -> Dec)
    -> (Dec -> Maybe Pragma) -> Prism Dec Dec Pragma Pragma
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Pragma -> Dec
    reviewer Dec -> Maybe Pragma
    remitter
      where
          reviewer :: Pragma -> Dec
    reviewer = Pragma -> Dec
    PragmaD
          remitter :: Dec -> Maybe Pragma
    remitter (PragmaD x :: Pragma
    x) = Pragma -> Maybe Pragma
    forall a. a -> Maybe a
    Just Pragma
    x
          remitter _ = Maybe Pragma
    forall a. Maybe a
    Nothing

    -- |
    -- @
    -- _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
    -- @
    #if MIN_VERSION_template_haskell(2,15,0)
    _TySynInstD :: Prism' Dec TySynEqn
    _TySynInstD :: p TySynEqn (f TySynEqn) -> p Dec (f Dec)
    _TySynInstD
      = (TySynEqn -> Dec)
    -> (Dec -> Maybe TySynEqn) -> Prism Dec Dec TySynEqn TySynEqn
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' TySynEqn -> Dec
    reviewer Dec -> Maybe TySynEqn
    remitter
      where
          reviewer :: TySynEqn -> Dec
    reviewer = TySynEqn -> Dec
    TySynInstD
          remitter :: Dec -> Maybe TySynEqn
    remitter (TySynInstD x :: TySynEqn
    x) = TySynEqn -> Maybe TySynEqn
    forall a. a -> Maybe a
    Just TySynEqn
    x
          remitter _ = Maybe TySynEqn
    forall a. Maybe a
    Nothing
    #elif MIN_VERSION_template_haskell(2,9,0)
    _TySynInstD :: Prism' Dec (Name, TySynEqn)
    _TySynInstD
      = prism' reviewer remitter
      where
          reviewer (x, y) = TySynInstD x y
          remitter (TySynInstD x y) = Just (x, y)
          remitter _ = Nothing
    #else
    _TySynInstD :: Prism' Dec (Name, [Type], Type)
    _TySynInstD
      = prism' reviewer remitter
      where
          reviewer (x, y, z) = TySynInstD x y z
          remitter (TySynInstD x y z) = Just (x, y, z)
          remitter _ = Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,9,0)
    _RoleAnnotD :: Prism' Dec (Name, [Role])
    _RoleAnnotD :: p (Name, [Role]) (f (Name, [Role])) -> p Dec (f Dec)
    _RoleAnnotD
      = ((Name, [Role]) -> Dec)
    -> (Dec -> Maybe (Name, [Role]))
    -> Prism Dec Dec (Name, [Role]) (Name, [Role])
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, [Role]) -> Dec
    reviewer Dec -> Maybe (Name, [Role])
    remitter
      where
          reviewer :: (Name, [Role]) -> Dec
    reviewer (x :: Name
    x, y :: [Role]
    y) = Name -> [Role] -> Dec
    RoleAnnotD Name
    x [Role]
    y
          remitter :: Dec -> Maybe (Name, [Role])
    remitter (RoleAnnotD x :: Name
    x y :: [Role]
    y) = (Name, [Role]) -> Maybe (Name, [Role])
    forall a. a -> Maybe a
    Just (Name
    x, [Role]
    y)
          remitter _ = Maybe (Name, [Role])
    forall a. Maybe a
    Nothing
    #endif

    -- |
    -- @
    -- _StandaloneDerivD :: 'Prism'' 'Dec' ('Maybe' 'DerivStrategy', 'Cxt', 'Type') -- template-haskell-2.12+
    -- _StandaloneDerivD :: 'Prism'' 'Dec'                      ('Cxt', 'Type') -- Earlier versions
    -- @
    #if MIN_VERSION_template_haskell(2,12,0)
    _StandaloneDerivD :: Prism' Dec (Maybe DerivStrategy, Cxt, Type)
    _StandaloneDerivD :: p (Maybe DerivStrategy, Cxt, Kind)
      (f (Maybe DerivStrategy, Cxt, Kind))
    -> p Dec (f Dec)
    _StandaloneDerivD
      = ((Maybe DerivStrategy, Cxt, Kind) -> Dec)
    -> (Dec -> Maybe (Maybe DerivStrategy, Cxt, Kind))
    -> Prism
         Dec
         Dec
         (Maybe DerivStrategy, Cxt, Kind)
         (Maybe DerivStrategy, Cxt, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Maybe DerivStrategy, Cxt, Kind) -> Dec
    reviewer Dec -> Maybe (Maybe DerivStrategy, Cxt, Kind)
    remitter
      where
          reviewer :: (Maybe DerivStrategy, Cxt, Kind) -> Dec
    reviewer (x :: Maybe DerivStrategy
    x, y :: Cxt
    y, z :: Kind
    z) = Maybe DerivStrategy -> Cxt -> Kind -> Dec
    StandaloneDerivD Maybe DerivStrategy
    x Cxt
    y Kind
    z
          remitter :: Dec -> Maybe (Maybe DerivStrategy, Cxt, Kind)
    remitter (StandaloneDerivD x :: Maybe DerivStrategy
    x y :: Cxt
    y z :: Kind
    z) = (Maybe DerivStrategy, Cxt, Kind)
    -> Maybe (Maybe DerivStrategy, Cxt, Kind)
    forall a. a -> Maybe a
    Just (Maybe DerivStrategy
    x, Cxt
    y, Kind
    z)
          remitter _ = Maybe (Maybe DerivStrategy, Cxt, Kind)
    forall a. Maybe a
    Nothing
    #elif MIN_VERSION_template_haskell(2,10,0)
    _StandaloneDerivD :: Prism' Dec (Cxt, Type)
    _StandaloneDerivD
      = prism' reviewer remitter
      where
          reviewer (x, y) = StandaloneDerivD x y
          remitter (StandaloneDerivD x y) = Just (x, y)
          remitter _ = Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,10,0)
    _DefaultSigD :: Prism' Dec (Name, Type)
    _DefaultSigD :: p (Name, Kind) (f (Name, Kind)) -> p Dec (f Dec)
    _DefaultSigD
      = ((Name, Kind) -> Dec)
    -> (Dec -> Maybe (Name, Kind))
    -> Prism Dec Dec (Name, Kind) (Name, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, Kind) -> Dec
    reviewer Dec -> Maybe (Name, Kind)
    remitter
      where
          reviewer :: (Name, Kind) -> Dec
    reviewer (x :: Name
    x, y :: Kind
    y) = Name -> Kind -> Dec
    DefaultSigD Name
    x Kind
    y
          remitter :: Dec -> Maybe (Name, Kind)
    remitter (DefaultSigD x :: Name
    x y :: Kind
    y) = (Name, Kind) -> Maybe (Name, Kind)
    forall a. a -> Maybe a
    Just (Name
    x, Kind
    y)
          remitter _ = Maybe (Name, Kind)
    forall a. Maybe a
    Nothing
    #endif

    # if MIN_VERSION_template_haskell(2,12,0)
    type DataPrism' tys cons = Prism' Dec (Cxt, Name, tys, Maybe Kind, cons, [DerivClause])
    # elif MIN_VERSION_template_haskell(2,11,0)
    type DataPrism' tys cons = Prism' Dec (Cxt, Name, tys, Maybe Kind, cons, Cxt)
    # endif

    -- |
    -- @
    -- _DataInstD :: 'Prism'' 'Dec' ('Cxt', 'Maybe' ['TyVarBndr'], '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')           -- template-haskell-2.11
    -- _DataInstD :: 'Prism'' 'Dec' ('Cxt', 'Name', ['Type'],                        ['Con'], ['Name'])        -- Earlier versions
    -- @
    #if MIN_VERSION_template_haskell(2,15,0)
    _DataInstD :: Prism' Dec (Cxt, Maybe [TyVarBndr], Type, Maybe Kind, [Con], [DerivClause])
    _DataInstD :: p (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, [Con], [DerivClause])
      (f (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, [Con],
          [DerivClause]))
    -> p Dec (f Dec)
    _DataInstD
      = ((Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, [Con], [DerivClause])
     -> Dec)
    -> (Dec
        -> Maybe
             (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, [Con], [DerivClause]))
    -> Prism
         Dec
         Dec
         (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, [Con], [DerivClause])
         (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, [Con], [DerivClause])
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, [Con], [DerivClause])
    -> Dec
    reviewer Dec
    -> Maybe
         (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, [Con], [DerivClause])
    remitter
      where
          reviewer :: (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, [Con], [DerivClause])
    -> Dec
    reviewer (x :: Cxt
    x, y :: Maybe [TyVarBndr]
    y, z :: Kind
    z, w :: Maybe Kind
    w, u :: [Con]
    u, v :: [DerivClause]
    v) = Cxt
    -> Maybe [TyVarBndr]
    -> Kind
    -> Maybe Kind
    -> [Con]
    -> [DerivClause]
    -> Dec
    DataInstD Cxt
    x Maybe [TyVarBndr]
    y Kind
    z Maybe Kind
    w [Con]
    u [DerivClause]
    v
          remitter :: Dec
    -> Maybe
         (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, [Con], [DerivClause])
    remitter (DataInstD x :: Cxt
    x y :: Maybe [TyVarBndr]
    y z :: Kind
    z w :: Maybe Kind
    w u :: [Con]
    u v :: [DerivClause]
    v) = (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, [Con], [DerivClause])
    -> Maybe
         (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, [Con], [DerivClause])
    forall a. a -> Maybe a
    Just (Cxt
    x, Maybe [TyVarBndr]
    y, Kind
    z, Maybe Kind
    w, [Con]
    u, [DerivClause]
    v)
          remitter _ = Maybe
      (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, [Con], [DerivClause])
    forall a. Maybe a
    Nothing
    #elif MIN_VERSION_template_haskell(2,11,0)
    _DataInstD :: DataPrism' [Type] [Con]
    _DataInstD
      = prism' reviewer remitter
      where
          reviewer (x, y, z, w, u, v) = DataInstD x y z w u v
          remitter (DataInstD x y z w u v) = Just (x, y, z, w, u, v)
          remitter _ = Nothing
    #else
    _DataInstD :: Prism' Dec (Cxt, Name, [Type], [Con], [Name])
    _DataInstD
      = prism' reviewer remitter
      where
          reviewer (x, y, z, w, u) = DataInstD x y z w u
          remitter (DataInstD x y z w u) = Just (x, y, z, w, u)
          remitter _ = Nothing
    #endif

    -- |
    -- @
    -- _NewtypeInstD :: 'Prism'' 'Dec' ('Cxt', 'Maybe' ['TyVarBndr'], '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')           -- template-haskell-2.11
    -- _NewtypeInstD :: 'Prism'' 'Dec' ('Cxt', 'Name', ['Type'],                        'Con', ['Name'])        -- Earlier versions
    -- @
    #if MIN_VERSION_template_haskell(2,15,0)
    _NewtypeInstD :: Prism' Dec (Cxt, Maybe [TyVarBndr], Type, Maybe Kind, Con, [DerivClause])
    _NewtypeInstD :: p (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, Con, [DerivClause])
      (f (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, Con, [DerivClause]))
    -> p Dec (f Dec)
    _NewtypeInstD
      = ((Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, Con, [DerivClause])
     -> Dec)
    -> (Dec
        -> Maybe
             (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, Con, [DerivClause]))
    -> Prism
         Dec
         Dec
         (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, Con, [DerivClause])
         (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, Con, [DerivClause])
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, Con, [DerivClause])
    -> Dec
    reviewer Dec
    -> Maybe
         (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, Con, [DerivClause])
    remitter
      where
          reviewer :: (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, Con, [DerivClause])
    -> Dec
    reviewer (x :: Cxt
    x, y :: Maybe [TyVarBndr]
    y, z :: Kind
    z, w :: Maybe Kind
    w, u :: Con
    u, v :: [DerivClause]
    v) = Cxt
    -> Maybe [TyVarBndr]
    -> Kind
    -> Maybe Kind
    -> Con
    -> [DerivClause]
    -> Dec
    NewtypeInstD Cxt
    x Maybe [TyVarBndr]
    y Kind
    z Maybe Kind
    w Con
    u [DerivClause]
    v
          remitter :: Dec
    -> Maybe
         (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, Con, [DerivClause])
    remitter (NewtypeInstD x :: Cxt
    x y :: Maybe [TyVarBndr]
    y z :: Kind
    z w :: Maybe Kind
    w u :: Con
    u v :: [DerivClause]
    v) = (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, Con, [DerivClause])
    -> Maybe
         (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, Con, [DerivClause])
    forall a. a -> Maybe a
    Just (Cxt
    x, Maybe [TyVarBndr]
    y, Kind
    z, Maybe Kind
    w, Con
    u, [DerivClause]
    v)
          remitter _ = Maybe
      (Cxt, Maybe [TyVarBndr], Kind, Maybe Kind, Con, [DerivClause])
    forall a. Maybe a
    Nothing
    #elif MIN_VERSION_template_haskell(2,11,0)
    _NewtypeInstD :: DataPrism' [Type] Con
    _NewtypeInstD
      = prism' reviewer remitter
      where
          reviewer (x, y, z, w, u, v) = NewtypeInstD x y z w u v
          remitter (NewtypeInstD x y z w u v) = Just (x, y, z, w, u, v)
          remitter _ = Nothing
    #else
    _NewtypeInstD :: Prism' Dec (Cxt, Name, [Type], Con, [Name])
    _NewtypeInstD
      = prism' reviewer remitter
      where
          reviewer (x, y, z, w, u) = NewtypeInstD x y z w u
          remitter (NewtypeInstD x y z w u) = Just (x, y, z, w, u)
          remitter _ = Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,11,0)
    _ClosedTypeFamilyD :: Prism' Dec (TypeFamilyHead, [TySynEqn])
    _ClosedTypeFamilyD :: p (TypeFamilyHead, [TySynEqn]) (f (TypeFamilyHead, [TySynEqn]))
    -> p Dec (f Dec)
    _ClosedTypeFamilyD
      = ((TypeFamilyHead, [TySynEqn]) -> Dec)
    -> (Dec -> Maybe (TypeFamilyHead, [TySynEqn]))
    -> Prism
         Dec Dec (TypeFamilyHead, [TySynEqn]) (TypeFamilyHead, [TySynEqn])
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (TypeFamilyHead, [TySynEqn]) -> Dec
    reviewer Dec -> Maybe (TypeFamilyHead, [TySynEqn])
    remitter
      where
          reviewer :: (TypeFamilyHead, [TySynEqn]) -> Dec
    reviewer (x :: TypeFamilyHead
    x, y :: [TySynEqn]
    y) = TypeFamilyHead -> [TySynEqn] -> Dec
    ClosedTypeFamilyD TypeFamilyHead
    x [TySynEqn]
    y
          remitter :: Dec -> Maybe (TypeFamilyHead, [TySynEqn])
    remitter (ClosedTypeFamilyD x :: TypeFamilyHead
    x y :: [TySynEqn]
    y) = (TypeFamilyHead, [TySynEqn]) -> Maybe (TypeFamilyHead, [TySynEqn])
    forall a. a -> Maybe a
    Just (TypeFamilyHead
    x, [TySynEqn]
    y)
          remitter _ = Maybe (TypeFamilyHead, [TySynEqn])
    forall a. Maybe a
    Nothing
    #elif MIN_VERSION_template_haskell(2,9,0)
    _ClosedTypeFamilyD :: Prism' Dec (Name, [TyVarBndr], Maybe Kind, [TySynEqn])
    _ClosedTypeFamilyD
      = prism' reviewer remitter
      where
          reviewer (x, y, z, w) = ClosedTypeFamilyD x y z w
          remitter (ClosedTypeFamilyD x y z w) = Just (x, y, z, w)
          remitter _ = Nothing
    #endif

    -- |
    -- @
    -- _DataD :: 'Prism'' 'Dec' ('Cxt', 'Name', ['TyVarBndr'], 'Maybe' 'Kind', ['Con'], ['DerivClause']) -- template-haskell-2.12+
    -- _DataD :: 'Prism'' 'Dec' ('Cxt', 'Name', ['Type'],      'Maybe' 'Kind', ['Con'], 'Cxt')           -- template-haskell-2.11
    -- _DataD :: 'Prism'' 'Dec' ('Cxt', 'Name', ['Type'],                  ['Con'], ['Name'])        -- Earlier versions
    -- @
    #if MIN_VERSION_template_haskell(2,11,0)
    _DataD :: DataPrism' [TyVarBndr] [Con]
    _DataD :: p (Cxt, Name, [TyVarBndr], Maybe Kind, [Con], [DerivClause])
      (f (Cxt, Name, [TyVarBndr], Maybe Kind, [Con], [DerivClause]))
    -> p Dec (f Dec)
    _DataD
      = ((Cxt, Name, [TyVarBndr], Maybe Kind, [Con], [DerivClause]) -> Dec)
    -> (Dec
        -> Maybe
             (Cxt, Name, [TyVarBndr], Maybe Kind, [Con], [DerivClause]))
    -> Prism
         Dec
         Dec
         (Cxt, Name, [TyVarBndr], Maybe Kind, [Con], [DerivClause])
         (Cxt, Name, [TyVarBndr], Maybe Kind, [Con], [DerivClause])
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Cxt, Name, [TyVarBndr], Maybe Kind, [Con], [DerivClause]) -> Dec
    reviewer Dec
    -> Maybe (Cxt, Name, [TyVarBndr], Maybe Kind, [Con], [DerivClause])
    remitter
      where
          reviewer :: (Cxt, Name, [TyVarBndr], Maybe Kind, [Con], [DerivClause]) -> Dec
    reviewer (x :: Cxt
    x, y :: Name
    y, z :: [TyVarBndr]
    z, w :: Maybe Kind
    w, u :: [Con]
    u, v :: [DerivClause]
    v) = Cxt
    -> Name
    -> [TyVarBndr]
    -> Maybe Kind
    -> [Con]
    -> [DerivClause]
    -> Dec
    DataD Cxt
    x Name
    y [TyVarBndr]
    z Maybe Kind
    w [Con]
    u [DerivClause]
    v
          remitter :: Dec
    -> Maybe (Cxt, Name, [TyVarBndr], Maybe Kind, [Con], [DerivClause])
    remitter (DataD x :: Cxt
    x y :: Name
    y z :: [TyVarBndr]
    z w :: Maybe Kind
    w u :: [Con]
    u v :: [DerivClause]
    v) = (Cxt, Name, [TyVarBndr], Maybe Kind, [Con], [DerivClause])
    -> Maybe (Cxt, Name, [TyVarBndr], Maybe Kind, [Con], [DerivClause])
    forall a. a -> Maybe a
    Just (Cxt
    x, Name
    y, [TyVarBndr]
    z, Maybe Kind
    w, [Con]
    u, [DerivClause]
    v)
          remitter _ = Maybe (Cxt, Name, [TyVarBndr], Maybe Kind, [Con], [DerivClause])
    forall a. Maybe a
    Nothing
    #else
    _DataD :: Prism' Dec (Cxt, Name, [TyVarBndr], [Con], [Name])
    _DataD
      = prism' reviewer remitter
      where
          reviewer (x, y, z, w, u) = DataD x y z w u
          remitter (DataD x y z w u) = Just (x, y, z, w, u)
          remitter _ = Nothing
    #endif

    -- |
    -- @
    -- _NewtypeD :: 'Prism'' 'Dec' ('Cxt', 'Name', ['TyVarBndr'], 'Maybe' 'Kind', 'Con', ['DerivClause']) -- template-haskell-2.12+
    -- _NewtypeD :: 'Prism'' 'Dec' ('Cxt', 'Name', ['Type'],      'Maybe' 'Kind', 'Con', 'Cxt')           -- template-haskell-2.11
    -- _NewtypeD :: 'Prism'' 'Dec' ('Cxt', 'Name', ['Type'],                  'Con', ['Name'])        -- Earlier versions
    -- @
    #if MIN_VERSION_template_haskell(2,11,0)
    _NewtypeD :: DataPrism' [TyVarBndr] Con
    _NewtypeD :: p (Cxt, Name, [TyVarBndr], Maybe Kind, Con, [DerivClause])
      (f (Cxt, Name, [TyVarBndr], Maybe Kind, Con, [DerivClause]))
    -> p Dec (f Dec)
    _NewtypeD
      = ((Cxt, Name, [TyVarBndr], Maybe Kind, Con, [DerivClause]) -> Dec)
    -> (Dec
        -> Maybe (Cxt, Name, [TyVarBndr], Maybe Kind, Con, [DerivClause]))
    -> Prism
         Dec
         Dec
         (Cxt, Name, [TyVarBndr], Maybe Kind, Con, [DerivClause])
         (Cxt, Name, [TyVarBndr], Maybe Kind, Con, [DerivClause])
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Cxt, Name, [TyVarBndr], Maybe Kind, Con, [DerivClause]) -> Dec
    reviewer Dec
    -> Maybe (Cxt, Name, [TyVarBndr], Maybe Kind, Con, [DerivClause])
    remitter
      where
          reviewer :: (Cxt, Name, [TyVarBndr], Maybe Kind, Con, [DerivClause]) -> Dec
    reviewer (x :: Cxt
    x, y :: Name
    y, z :: [TyVarBndr]
    z, w :: Maybe Kind
    w, u :: Con
    u, v :: [DerivClause]
    v) = Cxt
    -> Name -> [TyVarBndr] -> Maybe Kind -> Con -> [DerivClause] -> Dec
    NewtypeD Cxt
    x Name
    y [TyVarBndr]
    z Maybe Kind
    w Con
    u [DerivClause]
    v
          remitter :: Dec
    -> Maybe (Cxt, Name, [TyVarBndr], Maybe Kind, Con, [DerivClause])
    remitter (NewtypeD x :: Cxt
    x y :: Name
    y z :: [TyVarBndr]
    z w :: Maybe Kind
    w u :: Con
    u v :: [DerivClause]
    v) = (Cxt, Name, [TyVarBndr], Maybe Kind, Con, [DerivClause])
    -> Maybe (Cxt, Name, [TyVarBndr], Maybe Kind, Con, [DerivClause])
    forall a. a -> Maybe a
    Just (Cxt
    x, Name
    y, [TyVarBndr]
    z, Maybe Kind
    w, Con
    u, [DerivClause]
    v)
          remitter _ = Maybe (Cxt, Name, [TyVarBndr], Maybe Kind, Con, [DerivClause])
    forall a. Maybe a
    Nothing
    #else
    _NewtypeD :: Prism' Dec (Cxt, Name, [TyVarBndr], Con, [Name])
    _NewtypeD
      = prism' reviewer remitter
      where
          reviewer (x, y, z, w, u) = NewtypeD x y z w u
          remitter (NewtypeD x y z w u) = Just (x, y, z, w, u)
          remitter _ = Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,11,0)
    _DataFamilyD :: Prism' Dec (Name, [TyVarBndr], Maybe Kind)
    _DataFamilyD :: p (Name, [TyVarBndr], Maybe Kind)
      (f (Name, [TyVarBndr], Maybe Kind))
    -> p Dec (f Dec)
    _DataFamilyD
      = ((Name, [TyVarBndr], Maybe Kind) -> Dec)
    -> (Dec -> Maybe (Name, [TyVarBndr], Maybe Kind))
    -> Prism
         Dec
         Dec
         (Name, [TyVarBndr], Maybe Kind)
         (Name, [TyVarBndr], Maybe Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, [TyVarBndr], Maybe Kind) -> Dec
    reviewer Dec -> Maybe (Name, [TyVarBndr], Maybe Kind)
    remitter
      where
          reviewer :: (Name, [TyVarBndr], Maybe Kind) -> Dec
    reviewer (x :: Name
    x, y :: [TyVarBndr]
    y, z :: Maybe Kind
    z) = Name -> [TyVarBndr] -> Maybe Kind -> Dec
    DataFamilyD Name
    x [TyVarBndr]
    y Maybe Kind
    z
          remitter :: Dec -> Maybe (Name, [TyVarBndr], Maybe Kind)
    remitter (DataFamilyD x :: Name
    x y :: [TyVarBndr]
    y z :: Maybe Kind
    z) = (Name, [TyVarBndr], Maybe Kind)
    -> Maybe (Name, [TyVarBndr], Maybe Kind)
    forall a. a -> Maybe a
    Just (Name
    x, [TyVarBndr]
    y, Maybe Kind
    z)
          remitter _ = Maybe (Name, [TyVarBndr], Maybe Kind)
    forall a. Maybe a
    Nothing

    _OpenTypeFamilyD :: Prism' Dec TypeFamilyHead
    _OpenTypeFamilyD :: p TypeFamilyHead (f TypeFamilyHead) -> p Dec (f Dec)
    _OpenTypeFamilyD
      = (TypeFamilyHead -> Dec)
    -> (Dec -> Maybe TypeFamilyHead)
    -> Prism Dec Dec TypeFamilyHead TypeFamilyHead
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' TypeFamilyHead -> Dec
    reviewer Dec -> Maybe TypeFamilyHead
    remitter
      where
          reviewer :: TypeFamilyHead -> Dec
    reviewer = TypeFamilyHead -> Dec
    OpenTypeFamilyD
          remitter :: Dec -> Maybe TypeFamilyHead
    remitter (OpenTypeFamilyD x :: TypeFamilyHead
    x) = TypeFamilyHead -> Maybe TypeFamilyHead
    forall a. a -> Maybe a
    Just TypeFamilyHead
    x
          remitter _ = Maybe TypeFamilyHead
    forall a. Maybe a
    Nothing
    #else
    _FamilyD :: Prism' Dec (FamFlavour, Name, [TyVarBndr], Maybe Kind)
    _FamilyD
      = prism' reviewer remitter
      where
          reviewer (x, y, z, w) = FamilyD x y z w
          remitter (FamilyD x y z w) = Just (x, y, z, w)
          remitter _ = Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,12,0)
    _PatSynD :: Prism' Dec (Name, PatSynArgs, PatSynDir, Pat)
    _PatSynD :: p (Name, PatSynArgs, PatSynDir, Pat)
      (f (Name, PatSynArgs, PatSynDir, Pat))
    -> p Dec (f Dec)
    _PatSynD
      = ((Name, PatSynArgs, PatSynDir, Pat) -> Dec)
    -> (Dec -> Maybe (Name, PatSynArgs, PatSynDir, Pat))
    -> Prism
         Dec
         Dec
         (Name, PatSynArgs, PatSynDir, Pat)
         (Name, PatSynArgs, PatSynDir, Pat)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, PatSynArgs, PatSynDir, Pat) -> Dec
    reviewer Dec -> Maybe (Name, PatSynArgs, PatSynDir, Pat)
    remitter
      where
          reviewer :: (Name, PatSynArgs, PatSynDir, Pat) -> Dec
    reviewer (x :: Name
    x, y :: PatSynArgs
    y, z :: PatSynDir
    z, w :: Pat
    w) = Name -> PatSynArgs -> PatSynDir -> Pat -> Dec
    PatSynD Name
    x PatSynArgs
    y PatSynDir
    z Pat
    w
          remitter :: Dec -> Maybe (Name, PatSynArgs, PatSynDir, Pat)
    remitter (PatSynD x :: Name
    x y :: PatSynArgs
    y z :: PatSynDir
    z w :: Pat
    w) = (Name, PatSynArgs, PatSynDir, Pat)
    -> Maybe (Name, PatSynArgs, PatSynDir, Pat)
    forall a. a -> Maybe a
    Just (Name
    x, PatSynArgs
    y, PatSynDir
    z, Pat
    w)
          remitter _ = Maybe (Name, PatSynArgs, PatSynDir, Pat)
    forall a. Maybe a
    Nothing

    _PatSynSigD :: Prism' Dec (Name, PatSynType)
    _PatSynSigD :: p (Name, Kind) (f (Name, Kind)) -> p Dec (f Dec)
    _PatSynSigD
      = ((Name, Kind) -> Dec)
    -> (Dec -> Maybe (Name, Kind))
    -> Prism Dec Dec (Name, Kind) (Name, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, Kind) -> Dec
    reviewer Dec -> Maybe (Name, Kind)
    remitter
      where
          reviewer :: (Name, Kind) -> Dec
    reviewer (x :: Name
    x, y :: Kind
    y) = Name -> Kind -> Dec
    PatSynSigD Name
    x Kind
    y
          remitter :: Dec -> Maybe (Name, Kind)
    remitter (PatSynSigD x :: Name
    x y :: Kind
    y) = (Name, Kind) -> Maybe (Name, Kind)
    forall a. a -> Maybe a
    Just (Name
    x, Kind
    y)
          remitter _ = Maybe (Name, Kind)
    forall a. Maybe a
    Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,15,0)
    _ImplicitParamBindD :: Prism' Dec (String, Exp)
    _ImplicitParamBindD :: p (String, Exp) (f (String, Exp)) -> p Dec (f Dec)
    _ImplicitParamBindD
      = ((String, Exp) -> Dec)
    -> (Dec -> Maybe (String, Exp))
    -> Prism Dec Dec (String, Exp) (String, Exp)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (String, Exp) -> Dec
    reviewer Dec -> Maybe (String, Exp)
    remitter
      where
          reviewer :: (String, Exp) -> Dec
    reviewer (x :: String
    x, y :: Exp
    y) = String -> Exp -> Dec
    ImplicitParamBindD String
    x Exp
    y
          remitter :: Dec -> Maybe (String, Exp)
    remitter (ImplicitParamBindD x :: String
    x y :: Exp
    y) = (String, Exp) -> Maybe (String, Exp)
    forall a. a -> Maybe a
    Just (String
    x, Exp
    y)
          remitter _ = Maybe (String, Exp)
    forall a. Maybe a
    Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,12,0)
    _Unidir :: Prism' PatSynDir ()
    _Unidir :: p () (f ()) -> p PatSynDir (f PatSynDir)
    _Unidir
      = (() -> PatSynDir)
    -> (PatSynDir -> Maybe ()) -> Prism PatSynDir PatSynDir () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> PatSynDir
    reviewer PatSynDir -> Maybe ()
    remitter
      where
          reviewer :: () -> PatSynDir
    reviewer () = PatSynDir
    Unidir
          remitter :: PatSynDir -> Maybe ()
    remitter Unidir = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _ImplBidir :: Prism' PatSynDir ()
    _ImplBidir :: p () (f ()) -> p PatSynDir (f PatSynDir)
    _ImplBidir
      = (() -> PatSynDir)
    -> (PatSynDir -> Maybe ()) -> Prism PatSynDir PatSynDir () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> PatSynDir
    reviewer PatSynDir -> Maybe ()
    remitter
      where
          reviewer :: () -> PatSynDir
    reviewer () = PatSynDir
    ImplBidir
          remitter :: PatSynDir -> Maybe ()
    remitter ImplBidir = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _ExplBidir :: Prism' PatSynDir [Clause]
    _ExplBidir :: p [Clause] (f [Clause]) -> p PatSynDir (f PatSynDir)
    _ExplBidir
      = ([Clause] -> PatSynDir)
    -> (PatSynDir -> Maybe [Clause])
    -> Prism PatSynDir PatSynDir [Clause] [Clause]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [Clause] -> PatSynDir
    reviewer PatSynDir -> Maybe [Clause]
    remitter
      where
          reviewer :: [Clause] -> PatSynDir
    reviewer = [Clause] -> PatSynDir
    ExplBidir
          remitter :: PatSynDir -> Maybe [Clause]
    remitter (ExplBidir x :: [Clause]
    x) = [Clause] -> Maybe [Clause]
    forall a. a -> Maybe a
    Just [Clause]
    x
          remitter _ = Maybe [Clause]
    forall a. Maybe a
    Nothing

    _PrefixPatSyn :: Prism' PatSynArgs [Name]
    _PrefixPatSyn :: p [Name] (f [Name]) -> p PatSynArgs (f PatSynArgs)
    _PrefixPatSyn
      = ([Name] -> PatSynArgs)
    -> (PatSynArgs -> Maybe [Name])
    -> Prism PatSynArgs PatSynArgs [Name] [Name]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [Name] -> PatSynArgs
    reviewer PatSynArgs -> Maybe [Name]
    remitter
      where
          reviewer :: [Name] -> PatSynArgs
    reviewer = [Name] -> PatSynArgs
    PrefixPatSyn
          remitter :: PatSynArgs -> Maybe [Name]
    remitter (PrefixPatSyn x :: [Name]
    x) = [Name] -> Maybe [Name]
    forall a. a -> Maybe a
    Just [Name]
    x
          remitter _ = Maybe [Name]
    forall a. Maybe a
    Nothing

    _InfixPatSyn :: Prism' PatSynArgs (Name, Name)
    _InfixPatSyn :: p (Name, Name) (f (Name, Name)) -> p PatSynArgs (f PatSynArgs)
    _InfixPatSyn
      = ((Name, Name) -> PatSynArgs)
    -> (PatSynArgs -> Maybe (Name, Name))
    -> Prism PatSynArgs PatSynArgs (Name, Name) (Name, Name)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, Name) -> PatSynArgs
    reviewer PatSynArgs -> Maybe (Name, Name)
    remitter
      where
          reviewer :: (Name, Name) -> PatSynArgs
    reviewer (x :: Name
    x, y :: Name
    y) = Name -> Name -> PatSynArgs
    InfixPatSyn Name
    x Name
    y
          remitter :: PatSynArgs -> Maybe (Name, Name)
    remitter (InfixPatSyn x :: Name
    x y :: Name
    y) = (Name, Name) -> Maybe (Name, Name)
    forall a. a -> Maybe a
    Just (Name
    x, Name
    y)
          remitter _ = Maybe (Name, Name)
    forall a. Maybe a
    Nothing

    _RecordPatSyn :: Prism' PatSynArgs [Name]
    _RecordPatSyn :: p [Name] (f [Name]) -> p PatSynArgs (f PatSynArgs)
    _RecordPatSyn
      = ([Name] -> PatSynArgs)
    -> (PatSynArgs -> Maybe [Name])
    -> Prism PatSynArgs PatSynArgs [Name] [Name]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [Name] -> PatSynArgs
    reviewer PatSynArgs -> Maybe [Name]
    remitter
      where
          reviewer :: [Name] -> PatSynArgs
    reviewer = [Name] -> PatSynArgs
    RecordPatSyn
          remitter :: PatSynArgs -> Maybe [Name]
    remitter (RecordPatSyn x :: [Name]
    x) = [Name] -> Maybe [Name]
    forall a. a -> Maybe a
    Just [Name]
    x
          remitter _ = Maybe [Name]
    forall a. Maybe a
    Nothing
    #endif

    -- |
    -- @
    -- _NormalC :: 'Prism'' 'Con' ('Name', ['BangType'])   -- template-haskell-2.11+
    -- _NormalC :: 'Prism'' 'Con' ('Name', ['StrictType']) -- Earlier versions
    -- @
    _NormalC ::
      Prism' Con ( Name
    #if MIN_VERSION_template_haskell(2,11,0)
                 , [BangType]
    #else
                 , [StrictType]
    #endif
                 )
    _NormalC :: p (Name, [BangType]) (f (Name, [BangType])) -> p Con (f Con)
    _NormalC
      = ((Name, [BangType]) -> Con)
    -> (Con -> Maybe (Name, [BangType]))
    -> Prism Con Con (Name, [BangType]) (Name, [BangType])
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, [BangType]) -> Con
    reviewer Con -> Maybe (Name, [BangType])
    remitter
      where
          reviewer :: (Name, [BangType]) -> Con
    reviewer (x :: Name
    x, y :: [BangType]
    y) = Name -> [BangType] -> Con
    NormalC Name
    x [BangType]
    y
          remitter :: Con -> Maybe (Name, [BangType])
    remitter (NormalC x :: Name
    x y :: [BangType]
    y) = (Name, [BangType]) -> Maybe (Name, [BangType])
    forall a. a -> Maybe a
    Just (Name
    x, [BangType]
    y)
          remitter _ = Maybe (Name, [BangType])
    forall a. Maybe a
    Nothing

    -- |
    -- @
    -- _RecC :: 'Prism'' 'Con' ('Name', ['VarBangType'])   -- template-haskell-2.11+
    -- _RecC :: 'Prism'' 'Con' ('Name', ['VarStrictType']) -- Earlier versions
    -- @
    _RecC ::
      Prism' Con ( Name
    #if MIN_VERSION_template_haskell(2,11,0)
                 , [VarBangType]
    #else
                 , [VarStrictType]
    #endif
                 )
    _RecC :: p (Name, [VarBangType]) (f (Name, [VarBangType])) -> p Con (f Con)
    _RecC
      = ((Name, [VarBangType]) -> Con)
    -> (Con -> Maybe (Name, [VarBangType]))
    -> Prism Con Con (Name, [VarBangType]) (Name, [VarBangType])
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, [VarBangType]) -> Con
    reviewer Con -> Maybe (Name, [VarBangType])
    remitter
      where
          reviewer :: (Name, [VarBangType]) -> Con
    reviewer (x :: Name
    x, y :: [VarBangType]
    y) = Name -> [VarBangType] -> Con
    RecC Name
    x [VarBangType]
    y
          remitter :: Con -> Maybe (Name, [VarBangType])
    remitter (RecC x :: Name
    x y :: [VarBangType]
    y) = (Name, [VarBangType]) -> Maybe (Name, [VarBangType])
    forall a. a -> Maybe a
    Just (Name
    x, [VarBangType]
    y)
          remitter _ = Maybe (Name, [VarBangType])
    forall a. Maybe a
    Nothing

    -- |
    -- @
    -- _InfixC :: 'Prism'' 'Con' ('BangType',   'Name', 'BangType')   -- template-haskell-2.11+
    -- _InfixC :: 'Prism'' 'Con' ('StrictType', 'Name', 'StrictType') -- Earlier versions
    -- @
    _InfixC ::
      Prism' Con
    #if MIN_VERSION_template_haskell(2,11,0)
                 (BangType,   Name, BangType  )
    #else
                 (StrictType, Name, StrictType)
    #endif
    _InfixC :: p (BangType, Name, BangType) (f (BangType, Name, BangType))
    -> p Con (f Con)
    _InfixC
      = ((BangType, Name, BangType) -> Con)
    -> (Con -> Maybe (BangType, Name, BangType))
    -> Prism
         Con Con (BangType, Name, BangType) (BangType, Name, BangType)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (BangType, Name, BangType) -> Con
    reviewer Con -> Maybe (BangType, Name, BangType)
    remitter
      where
          reviewer :: (BangType, Name, BangType) -> Con
    reviewer (x :: BangType
    x, y :: Name
    y, z :: BangType
    z) = BangType -> Name -> BangType -> Con
    InfixC BangType
    x Name
    y BangType
    z
          remitter :: Con -> Maybe (BangType, Name, BangType)
    remitter (InfixC x :: BangType
    x y :: Name
    y z :: BangType
    z) = (BangType, Name, BangType) -> Maybe (BangType, Name, BangType)
    forall a. a -> Maybe a
    Just (BangType
    x, Name
    y, BangType
    z)
          remitter _ = Maybe (BangType, Name, BangType)
    forall a. Maybe a
    Nothing

    _ForallC :: Prism' Con ([TyVarBndr], Cxt, Con)
    _ForallC :: p ([TyVarBndr], Cxt, Con) (f ([TyVarBndr], Cxt, Con))
    -> p Con (f Con)
    _ForallC
      = (([TyVarBndr], Cxt, Con) -> Con)
    -> (Con -> Maybe ([TyVarBndr], Cxt, Con))
    -> Prism Con Con ([TyVarBndr], Cxt, Con) ([TyVarBndr], Cxt, Con)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' ([TyVarBndr], Cxt, Con) -> Con
    reviewer Con -> Maybe ([TyVarBndr], Cxt, Con)
    remitter
      where
          reviewer :: ([TyVarBndr], Cxt, Con) -> Con
    reviewer (x :: [TyVarBndr]
    x, y :: Cxt
    y, z :: Con
    z) = [TyVarBndr] -> Cxt -> Con -> Con
    ForallC [TyVarBndr]
    x Cxt
    y Con
    z
          remitter :: Con -> Maybe ([TyVarBndr], Cxt, Con)
    remitter (ForallC x :: [TyVarBndr]
    x y :: Cxt
    y z :: Con
    z) = ([TyVarBndr], Cxt, Con) -> Maybe ([TyVarBndr], Cxt, Con)
    forall a. a -> Maybe a
    Just ([TyVarBndr]
    x, Cxt
    y, Con
    z)
          remitter _ = Maybe ([TyVarBndr], Cxt, Con)
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,11,0)
    _GadtC :: Prism' Con ([Name], [BangType], Type)
    _GadtC :: p ([Name], [BangType], Kind) (f ([Name], [BangType], Kind))
    -> p Con (f Con)
    _GadtC
      = (([Name], [BangType], Kind) -> Con)
    -> (Con -> Maybe ([Name], [BangType], Kind))
    -> Prism
         Con Con ([Name], [BangType], Kind) ([Name], [BangType], Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' ([Name], [BangType], Kind) -> Con
    reviewer Con -> Maybe ([Name], [BangType], Kind)
    remitter
      where
          reviewer :: ([Name], [BangType], Kind) -> Con
    reviewer (x :: [Name]
    x, y :: [BangType]
    y, z :: Kind
    z) = [Name] -> [BangType] -> Kind -> Con
    GadtC [Name]
    x [BangType]
    y Kind
    z
          remitter :: Con -> Maybe ([Name], [BangType], Kind)
    remitter (GadtC x :: [Name]
    x y :: [BangType]
    y z :: Kind
    z) = ([Name], [BangType], Kind) -> Maybe ([Name], [BangType], Kind)
    forall a. a -> Maybe a
    Just ([Name]
    x, [BangType]
    y, Kind
    z)
          remitter _ = Maybe ([Name], [BangType], Kind)
    forall a. Maybe a
    Nothing

    _RecGadtC :: Prism' Con ([Name], [VarBangType], Type)
    _RecGadtC :: p ([Name], [VarBangType], Kind) (f ([Name], [VarBangType], Kind))
    -> p Con (f Con)
    _RecGadtC
      = (([Name], [VarBangType], Kind) -> Con)
    -> (Con -> Maybe ([Name], [VarBangType], Kind))
    -> Prism
         Con Con ([Name], [VarBangType], Kind) ([Name], [VarBangType], Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' ([Name], [VarBangType], Kind) -> Con
    reviewer Con -> Maybe ([Name], [VarBangType], Kind)
    remitter
      where
          reviewer :: ([Name], [VarBangType], Kind) -> Con
    reviewer (x :: [Name]
    x, y :: [VarBangType]
    y, z :: Kind
    z) = [Name] -> [VarBangType] -> Kind -> Con
    RecGadtC [Name]
    x [VarBangType]
    y Kind
    z
          remitter :: Con -> Maybe ([Name], [VarBangType], Kind)
    remitter (RecGadtC x :: [Name]
    x y :: [VarBangType]
    y z :: Kind
    z) = ([Name], [VarBangType], Kind)
    -> Maybe ([Name], [VarBangType], Kind)
    forall a. a -> Maybe a
    Just ([Name]
    x, [VarBangType]
    y, Kind
    z)
          remitter _ = Maybe ([Name], [VarBangType], Kind)
    forall a. Maybe a
    Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,11,0)
    _NoSourceUnpackedness :: Prism' SourceUnpackedness ()
    _NoSourceUnpackedness :: p () (f ()) -> p SourceUnpackedness (f SourceUnpackedness)
    _NoSourceUnpackedness
      = (() -> SourceUnpackedness)
    -> (SourceUnpackedness -> Maybe ())
    -> Prism SourceUnpackedness SourceUnpackedness () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> SourceUnpackedness
    reviewer SourceUnpackedness -> Maybe ()
    remitter
      where
          reviewer :: () -> SourceUnpackedness
    reviewer () = SourceUnpackedness
    NoSourceUnpackedness
          remitter :: SourceUnpackedness -> Maybe ()
    remitter NoSourceUnpackedness = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _SourceNoUnpack :: Prism' SourceUnpackedness ()
    _SourceNoUnpack :: p () (f ()) -> p SourceUnpackedness (f SourceUnpackedness)
    _SourceNoUnpack
      = (() -> SourceUnpackedness)
    -> (SourceUnpackedness -> Maybe ())
    -> Prism SourceUnpackedness SourceUnpackedness () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> SourceUnpackedness
    reviewer SourceUnpackedness -> Maybe ()
    remitter
      where
          reviewer :: () -> SourceUnpackedness
    reviewer () = SourceUnpackedness
    SourceNoUnpack
          remitter :: SourceUnpackedness -> Maybe ()
    remitter SourceNoUnpack = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _SourceUnpack :: Prism' SourceUnpackedness ()
    _SourceUnpack :: p () (f ()) -> p SourceUnpackedness (f SourceUnpackedness)
    _SourceUnpack
      = (() -> SourceUnpackedness)
    -> (SourceUnpackedness -> Maybe ())
    -> Prism SourceUnpackedness SourceUnpackedness () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> SourceUnpackedness
    reviewer SourceUnpackedness -> Maybe ()
    remitter
      where
          reviewer :: () -> SourceUnpackedness
    reviewer () = SourceUnpackedness
    SourceUnpack
          remitter :: SourceUnpackedness -> Maybe ()
    remitter SourceUnpack = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _NoSourceStrictness :: Prism' SourceStrictness ()
    _NoSourceStrictness :: p () (f ()) -> p SourceStrictness (f SourceStrictness)
    _NoSourceStrictness
      = (() -> SourceStrictness)
    -> (SourceStrictness -> Maybe ())
    -> Prism SourceStrictness SourceStrictness () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> SourceStrictness
    reviewer SourceStrictness -> Maybe ()
    remitter
      where
          reviewer :: () -> SourceStrictness
    reviewer () = SourceStrictness
    NoSourceStrictness
          remitter :: SourceStrictness -> Maybe ()
    remitter NoSourceStrictness = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _SourceLazy :: Prism' SourceStrictness ()
    _SourceLazy :: p () (f ()) -> p SourceStrictness (f SourceStrictness)
    _SourceLazy
      = (() -> SourceStrictness)
    -> (SourceStrictness -> Maybe ())
    -> Prism SourceStrictness SourceStrictness () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> SourceStrictness
    reviewer SourceStrictness -> Maybe ()
    remitter
      where
          reviewer :: () -> SourceStrictness
    reviewer () = SourceStrictness
    SourceLazy
          remitter :: SourceStrictness -> Maybe ()
    remitter SourceLazy = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _SourceStrict :: Prism' SourceStrictness ()
    _SourceStrict :: p () (f ()) -> p SourceStrictness (f SourceStrictness)
    _SourceStrict
      = (() -> SourceStrictness)
    -> (SourceStrictness -> Maybe ())
    -> Prism SourceStrictness SourceStrictness () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> SourceStrictness
    reviewer SourceStrictness -> Maybe ()
    remitter
      where
          reviewer :: () -> SourceStrictness
    reviewer () = SourceStrictness
    SourceStrict
          remitter :: SourceStrictness -> Maybe ()
    remitter SourceStrict = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _DecidedLazy :: Prism' DecidedStrictness ()
    _DecidedLazy :: p () (f ()) -> p DecidedStrictness (f DecidedStrictness)
    _DecidedLazy
      = (() -> DecidedStrictness)
    -> (DecidedStrictness -> Maybe ())
    -> Prism DecidedStrictness DecidedStrictness () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> DecidedStrictness
    reviewer DecidedStrictness -> Maybe ()
    remitter
      where
          reviewer :: () -> DecidedStrictness
    reviewer () = DecidedStrictness
    DecidedLazy
          remitter :: DecidedStrictness -> Maybe ()
    remitter DecidedLazy = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _DecidedStrict :: Prism' DecidedStrictness ()
    _DecidedStrict :: p () (f ()) -> p DecidedStrictness (f DecidedStrictness)
    _DecidedStrict
      = (() -> DecidedStrictness)
    -> (DecidedStrictness -> Maybe ())
    -> Prism DecidedStrictness DecidedStrictness () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> DecidedStrictness
    reviewer DecidedStrictness -> Maybe ()
    remitter
      where
          reviewer :: () -> DecidedStrictness
    reviewer () = DecidedStrictness
    DecidedStrict
          remitter :: DecidedStrictness -> Maybe ()
    remitter DecidedStrict = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _DecidedUnpack :: Prism' DecidedStrictness ()
    _DecidedUnpack :: p () (f ()) -> p DecidedStrictness (f DecidedStrictness)
    _DecidedUnpack
      = (() -> DecidedStrictness)
    -> (DecidedStrictness -> Maybe ())
    -> Prism DecidedStrictness DecidedStrictness () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> DecidedStrictness
    reviewer DecidedStrictness -> Maybe ()
    remitter
      where
          reviewer :: () -> DecidedStrictness
    reviewer () = DecidedStrictness
    DecidedUnpack
          remitter :: DecidedStrictness -> Maybe ()
    remitter DecidedUnpack = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing
    #else
    _IsStrict :: Prism' Strict ()
    _IsStrict
      = prism' reviewer remitter
      where
          reviewer () = IsStrict
          remitter IsStrict = Just ()
          remitter _ = Nothing

    _NotStrict :: Prism' Strict ()
    _NotStrict
      = prism' reviewer remitter
      where
          reviewer () = NotStrict
          remitter NotStrict = Just ()
          remitter _ = Nothing

    _Unpacked :: Prism' Strict ()
    _Unpacked
      = prism' reviewer remitter
      where
          reviewer () = Unpacked
          remitter Unpacked = Just ()
          remitter _ = Nothing
    #endif

    _ImportF :: Prism' Foreign (Callconv, Safety, String, Name, Type)
    _ImportF :: p (Callconv, Safety, String, Name, Kind)
      (f (Callconv, Safety, String, Name, Kind))
    -> p Foreign (f Foreign)
    _ImportF
      = ((Callconv, Safety, String, Name, Kind) -> Foreign)
    -> (Foreign -> Maybe (Callconv, Safety, String, Name, Kind))
    -> Prism
         Foreign
         Foreign
         (Callconv, Safety, String, Name, Kind)
         (Callconv, Safety, String, Name, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Callconv, Safety, String, Name, Kind) -> Foreign
    reviewer Foreign -> Maybe (Callconv, Safety, String, Name, Kind)
    remitter
      where
          reviewer :: (Callconv, Safety, String, Name, Kind) -> Foreign
    reviewer (x :: Callconv
    x, y :: Safety
    y, z :: String
    z, w :: Name
    w, u :: Kind
    u) = Callconv -> Safety -> String -> Name -> Kind -> Foreign
    ImportF Callconv
    x Safety
    y String
    z Name
    w Kind
    u
          remitter :: Foreign -> Maybe (Callconv, Safety, String, Name, Kind)
    remitter (ImportF x :: Callconv
    x y :: Safety
    y z :: String
    z w :: Name
    w u :: Kind
    u) = (Callconv, Safety, String, Name, Kind)
    -> Maybe (Callconv, Safety, String, Name, Kind)
    forall a. a -> Maybe a
    Just (Callconv
    x,Safety
    y,String
    z,Name
    w,Kind
    u)
          remitter _ = Maybe (Callconv, Safety, String, Name, Kind)
    forall a. Maybe a
    Nothing

    _ExportF :: Prism' Foreign (Callconv, String, Name, Type)
    _ExportF :: p (Callconv, String, Name, Kind) (f (Callconv, String, Name, Kind))
    -> p Foreign (f Foreign)
    _ExportF
      = ((Callconv, String, Name, Kind) -> Foreign)
    -> (Foreign -> Maybe (Callconv, String, Name, Kind))
    -> Prism
         Foreign
         Foreign
         (Callconv, String, Name, Kind)
         (Callconv, String, Name, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Callconv, String, Name, Kind) -> Foreign
    reviewer Foreign -> Maybe (Callconv, String, Name, Kind)
    remitter
      where
          reviewer :: (Callconv, String, Name, Kind) -> Foreign
    reviewer (x :: Callconv
    x, y :: String
    y, z :: Name
    z, w :: Kind
    w) = Callconv -> String -> Name -> Kind -> Foreign
    ExportF Callconv
    x String
    y Name
    z Kind
    w
          remitter :: Foreign -> Maybe (Callconv, String, Name, Kind)
    remitter (ExportF x :: Callconv
    x y :: String
    y z :: Name
    z w :: Kind
    w) = (Callconv, String, Name, Kind)
    -> Maybe (Callconv, String, Name, Kind)
    forall a. a -> Maybe a
    Just (Callconv
    x, String
    y, Name
    z, Kind
    w)
          remitter _ = Maybe (Callconv, String, Name, Kind)
    forall a. Maybe a
    Nothing

    _CCall :: Prism' Callconv ()
    _CCall :: p () (f ()) -> p Callconv (f Callconv)
    _CCall
      = (() -> Callconv)
    -> (Callconv -> Maybe ()) -> Prism Callconv Callconv () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Callconv
    reviewer Callconv -> Maybe ()
    remitter
      where
          reviewer :: () -> Callconv
    reviewer () = Callconv
    CCall
          remitter :: Callconv -> Maybe ()
    remitter CCall = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _StdCall :: Prism' Callconv ()
    _StdCall :: p () (f ()) -> p Callconv (f Callconv)
    _StdCall
      = (() -> Callconv)
    -> (Callconv -> Maybe ()) -> Prism Callconv Callconv () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Callconv
    reviewer Callconv -> Maybe ()
    remitter
      where
          reviewer :: () -> Callconv
    reviewer () = Callconv
    StdCall
          remitter :: Callconv -> Maybe ()
    remitter StdCall = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,10,0)
    _CApi :: Prism' Callconv ()
    _CApi :: p () (f ()) -> p Callconv (f Callconv)
    _CApi
      = (() -> Callconv)
    -> (Callconv -> Maybe ()) -> Prism Callconv Callconv () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Callconv
    reviewer Callconv -> Maybe ()
    remitter
      where
          reviewer :: () -> Callconv
    reviewer () = Callconv
    CApi
          remitter :: Callconv -> Maybe ()
    remitter CApi = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _Prim :: Prism' Callconv ()
    _Prim :: p () (f ()) -> p Callconv (f Callconv)
    _Prim
      = (() -> Callconv)
    -> (Callconv -> Maybe ()) -> Prism Callconv Callconv () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Callconv
    reviewer Callconv -> Maybe ()
    remitter
      where
          reviewer :: () -> Callconv
    reviewer () = Callconv
    Prim
          remitter :: Callconv -> Maybe ()
    remitter Prim = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _JavaScript :: Prism' Callconv ()
    _JavaScript :: p () (f ()) -> p Callconv (f Callconv)
    _JavaScript
      = (() -> Callconv)
    -> (Callconv -> Maybe ()) -> Prism Callconv Callconv () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Callconv
    reviewer Callconv -> Maybe ()
    remitter
      where
          reviewer :: () -> Callconv
    reviewer () = Callconv
    JavaScript
          remitter :: Callconv -> Maybe ()
    remitter JavaScript = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing
    #endif

    _Unsafe :: Prism' Safety ()
    _Unsafe :: p () (f ()) -> p Safety (f Safety)
    _Unsafe
      = (() -> Safety) -> (Safety -> Maybe ()) -> Prism Safety Safety () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Safety
    reviewer Safety -> Maybe ()
    remitter
      where
          reviewer :: () -> Safety
    reviewer () = Safety
    Unsafe
          remitter :: Safety -> Maybe ()
    remitter Unsafe = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _Safe :: Prism' Safety ()
    _Safe :: p () (f ()) -> p Safety (f Safety)
    _Safe
      = (() -> Safety) -> (Safety -> Maybe ()) -> Prism Safety Safety () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Safety
    reviewer Safety -> Maybe ()
    remitter
      where
          reviewer :: () -> Safety
    reviewer () = Safety
    Safe
          remitter :: Safety -> Maybe ()
    remitter Safe = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _Interruptible :: Prism' Safety ()
    _Interruptible :: p () (f ()) -> p Safety (f Safety)
    _Interruptible
      = (() -> Safety) -> (Safety -> Maybe ()) -> Prism Safety Safety () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Safety
    reviewer Safety -> Maybe ()
    remitter
      where
          reviewer :: () -> Safety
    reviewer () = Safety
    Interruptible
          remitter :: Safety -> Maybe ()
    remitter Interruptible = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    -- |
    -- @
    -- _InlineP :: 'Prism'' 'Pragma' ('Name', 'Inline', 'RuleMatch', 'Phases') -- template-haskell-2.8+
    -- _InlineP :: 'Prism'' 'Pragma' ('Name', 'Inline')                    -- Earlier versions
    -- @
    #if MIN_VERSION_template_haskell(2,8,0)
    _InlineP :: Prism' Pragma (Name, Inline, RuleMatch, Phases)
    _InlineP :: p (Name, Inline, RuleMatch, Phases)
      (f (Name, Inline, RuleMatch, Phases))
    -> p Pragma (f Pragma)
    _InlineP
      = ((Name, Inline, RuleMatch, Phases) -> Pragma)
    -> (Pragma -> Maybe (Name, Inline, RuleMatch, Phases))
    -> Prism
         Pragma
         Pragma
         (Name, Inline, RuleMatch, Phases)
         (Name, Inline, RuleMatch, Phases)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, Inline, RuleMatch, Phases) -> Pragma
    reviewer Pragma -> Maybe (Name, Inline, RuleMatch, Phases)
    remitter
      where
          reviewer :: (Name, Inline, RuleMatch, Phases) -> Pragma
    reviewer (x :: Name
    x, y :: Inline
    y, z :: RuleMatch
    z, w :: Phases
    w) = Name -> Inline -> RuleMatch -> Phases -> Pragma
    InlineP Name
    x Inline
    y RuleMatch
    z Phases
    w
          remitter :: Pragma -> Maybe (Name, Inline, RuleMatch, Phases)
    remitter (InlineP x :: Name
    x y :: Inline
    y z :: RuleMatch
    z w :: Phases
    w) = (Name, Inline, RuleMatch, Phases)
    -> Maybe (Name, Inline, RuleMatch, Phases)
    forall a. a -> Maybe a
    Just (Name
    x, Inline
    y, RuleMatch
    z, Phases
    w)
          remitter _ = Maybe (Name, Inline, RuleMatch, Phases)
    forall a. Maybe a
    Nothing
    #else
    _InlineP :: Prism' Pragma (Name, InlineSpec)
    _InlineP
      = prism' reviewer remitter
      where
          reviewer (x, y) = InlineP x y
          remitter (InlineP x y) = Just (x, y)
          remitter _ = Nothing
    #endif

    -- |
    -- @
    -- _SpecialiseP :: 'Prism'' 'Pragma' ('Name', 'Type', 'Maybe' 'Inline', 'Phases') -- template-haskell-2.8+
    -- _SpecialiseP :: 'Prism'' 'Pragma' ('Name', 'Type', 'Maybe' 'InlineSpec')     -- Earlier versions
    -- @
    #if MIN_VERSION_template_haskell(2,8,0)
    _SpecialiseP :: Prism' Pragma (Name, Type, Maybe Inline, Phases)
    _SpecialiseP :: p (Name, Kind, Maybe Inline, Phases)
      (f (Name, Kind, Maybe Inline, Phases))
    -> p Pragma (f Pragma)
    _SpecialiseP
      = ((Name, Kind, Maybe Inline, Phases) -> Pragma)
    -> (Pragma -> Maybe (Name, Kind, Maybe Inline, Phases))
    -> Prism
         Pragma
         Pragma
         (Name, Kind, Maybe Inline, Phases)
         (Name, Kind, Maybe Inline, Phases)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, Kind, Maybe Inline, Phases) -> Pragma
    reviewer Pragma -> Maybe (Name, Kind, Maybe Inline, Phases)
    remitter
      where
          reviewer :: (Name, Kind, Maybe Inline, Phases) -> Pragma
    reviewer (x :: Name
    x, y :: Kind
    y, z :: Maybe Inline
    z, w :: Phases
    w) = Name -> Kind -> Maybe Inline -> Phases -> Pragma
    SpecialiseP Name
    x Kind
    y Maybe Inline
    z Phases
    w
          remitter :: Pragma -> Maybe (Name, Kind, Maybe Inline, Phases)
    remitter (SpecialiseP x :: Name
    x y :: Kind
    y z :: Maybe Inline
    z w :: Phases
    w) = (Name, Kind, Maybe Inline, Phases)
    -> Maybe (Name, Kind, Maybe Inline, Phases)
    forall a. a -> Maybe a
    Just (Name
    x, Kind
    y, Maybe Inline
    z, Phases
    w)
          remitter _ = Maybe (Name, Kind, Maybe Inline, Phases)
    forall a. Maybe a
    Nothing
    #else
    _SpecialiseP :: Prism' Pragma (Name, Type, Maybe InlineSpec)
    _SpecialiseP
      = prism' reviewer remitter
      where
          reviewer (x, y, z) = SpecialiseP x y z
          remitter (SpecialiseP x y z) = Just (x, y, z)
          remitter _ = Nothing
    #endif

    -- TODO add lenses for InlineSpec

    #if MIN_VERSION_template_haskell(2,8,0)
    _SpecialiseInstP :: Prism' Pragma Type
    _SpecialiseInstP :: p Kind (f Kind) -> p Pragma (f Pragma)
    _SpecialiseInstP
      = (Kind -> Pragma)
    -> (Pragma -> Maybe Kind) -> Prism Pragma Pragma Kind Kind
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Kind -> Pragma
    reviewer Pragma -> Maybe Kind
    remitter
      where
          reviewer :: Kind -> Pragma
    reviewer = Kind -> Pragma
    SpecialiseInstP
          remitter :: Pragma -> Maybe Kind
    remitter (SpecialiseInstP x :: Kind
    x) = Kind -> Maybe Kind
    forall a. a -> Maybe a
    Just Kind
    x
          remitter _ = Maybe Kind
    forall a. Maybe a
    Nothing

    -- |
    -- @
    -- _RuleP :: 'Prism'' 'Pragma' ('String', 'Maybe' ['TyVarBndr'], ['RuleBndr'], 'Exp', 'Exp', 'Phases') -- template-haskell-2.15+
    -- _RuleP :: 'Prism'' 'Pragma' ('String',                    ['RuleBndr'], 'Exp', 'Exp', 'Phases') -- Earlier versions
    -- @
    #if MIN_VERSION_template_haskell(2,15,0)
    _RuleP :: Prism' Pragma (String, Maybe [TyVarBndr], [RuleBndr], Exp, Exp, Phases)
    _RuleP :: p (String, Maybe [TyVarBndr], [RuleBndr], Exp, Exp, Phases)
      (f (String, Maybe [TyVarBndr], [RuleBndr], Exp, Exp, Phases))
    -> p Pragma (f Pragma)
    _RuleP
      = ((String, Maybe [TyVarBndr], [RuleBndr], Exp, Exp, Phases)
     -> Pragma)
    -> (Pragma
        -> Maybe (String, Maybe [TyVarBndr], [RuleBndr], Exp, Exp, Phases))
    -> Prism
         Pragma
         Pragma
         (String, Maybe [TyVarBndr], [RuleBndr], Exp, Exp, Phases)
         (String, Maybe [TyVarBndr], [RuleBndr], Exp, Exp, Phases)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (String, Maybe [TyVarBndr], [RuleBndr], Exp, Exp, Phases) -> Pragma
    reviewer Pragma
    -> Maybe (String, Maybe [TyVarBndr], [RuleBndr], Exp, Exp, Phases)
    remitter
      where
          reviewer :: (String, Maybe [TyVarBndr], [RuleBndr], Exp, Exp, Phases) -> Pragma
    reviewer (x :: String
    x, y :: Maybe [TyVarBndr]
    y, z :: [RuleBndr]
    z, w :: Exp
    w, u :: Exp
    u, v :: Phases
    v) = String
    -> Maybe [TyVarBndr]
    -> [RuleBndr]
    -> Exp
    -> Exp
    -> Phases
    -> Pragma
    RuleP String
    x Maybe [TyVarBndr]
    y [RuleBndr]
    z Exp
    w Exp
    u Phases
    v
          remitter :: Pragma
    -> Maybe (String, Maybe [TyVarBndr], [RuleBndr], Exp, Exp, Phases)
    remitter (RuleP x :: String
    x y :: Maybe [TyVarBndr]
    y z :: [RuleBndr]
    z w :: Exp
    w u :: Exp
    u v :: Phases
    v) = (String, Maybe [TyVarBndr], [RuleBndr], Exp, Exp, Phases)
    -> Maybe (String, Maybe [TyVarBndr], [RuleBndr], Exp, Exp, Phases)
    forall a. a -> Maybe a
    Just (String
    x, Maybe [TyVarBndr]
    y, [RuleBndr]
    z, Exp
    w, Exp
    u, Phases
    v)
          remitter _ = Maybe (String, Maybe [TyVarBndr], [RuleBndr], Exp, Exp, Phases)
    forall a. Maybe a
    Nothing
    #else
    _RuleP :: Prism' Pragma (String, [RuleBndr], Exp, Exp, Phases)
    _RuleP
      = prism' reviewer remitter
      where
          reviewer (x, y, z, w, u) = RuleP x y z w u
          remitter (RuleP x y z w u) = Just (x, y, z, w, u)
          remitter _ = Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,9,0)
    _AnnP :: Prism' Pragma (AnnTarget, Exp)
    _AnnP :: p (AnnTarget, Exp) (f (AnnTarget, Exp)) -> p Pragma (f Pragma)
    _AnnP
      = ((AnnTarget, Exp) -> Pragma)
    -> (Pragma -> Maybe (AnnTarget, Exp))
    -> Prism Pragma Pragma (AnnTarget, Exp) (AnnTarget, Exp)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (AnnTarget, Exp) -> Pragma
    reviewer Pragma -> Maybe (AnnTarget, Exp)
    remitter
      where
          reviewer :: (AnnTarget, Exp) -> Pragma
    reviewer (x :: AnnTarget
    x, y :: Exp
    y) = AnnTarget -> Exp -> Pragma
    AnnP AnnTarget
    x Exp
    y
          remitter :: Pragma -> Maybe (AnnTarget, Exp)
    remitter (AnnP x :: AnnTarget
    x y :: Exp
    y) = (AnnTarget, Exp) -> Maybe (AnnTarget, Exp)
    forall a. a -> Maybe a
    Just (AnnTarget
    x, Exp
    y)
          remitter _ = Maybe (AnnTarget, Exp)
    forall a. Maybe a
    Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,10,0)
    _LineP :: Prism' Pragma (Int, String)
    _LineP :: p (Int, String) (f (Int, String)) -> p Pragma (f Pragma)
    _LineP
      = ((Int, String) -> Pragma)
    -> (Pragma -> Maybe (Int, String))
    -> Prism Pragma Pragma (Int, String) (Int, String)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Int, String) -> Pragma
    reviewer Pragma -> Maybe (Int, String)
    remitter
      where
          reviewer :: (Int, String) -> Pragma
    reviewer (x :: Int
    x, y :: String
    y) = Int -> String -> Pragma
    LineP Int
    x String
    y
          remitter :: Pragma -> Maybe (Int, String)
    remitter (LineP x :: Int
    x y :: String
    y) = (Int, String) -> Maybe (Int, String)
    forall a. a -> Maybe a
    Just (Int
    x, String
    y)
          remitter _ = Maybe (Int, String)
    forall a. Maybe a
    Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,12,0)
    _CompleteP :: Prism' Pragma ([Name], Maybe Name)
    _CompleteP :: p ([Name], Maybe Name) (f ([Name], Maybe Name))
    -> p Pragma (f Pragma)
    _CompleteP
      = (([Name], Maybe Name) -> Pragma)
    -> (Pragma -> Maybe ([Name], Maybe Name))
    -> Prism Pragma Pragma ([Name], Maybe Name) ([Name], Maybe Name)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' ([Name], Maybe Name) -> Pragma
    reviewer Pragma -> Maybe ([Name], Maybe Name)
    remitter
      where
          reviewer :: ([Name], Maybe Name) -> Pragma
    reviewer (x :: [Name]
    x, y :: Maybe Name
    y) = [Name] -> Maybe Name -> Pragma
    CompleteP [Name]
    x Maybe Name
    y
          remitter :: Pragma -> Maybe ([Name], Maybe Name)
    remitter (CompleteP x :: [Name]
    x y :: Maybe Name
    y) = ([Name], Maybe Name) -> Maybe ([Name], Maybe Name)
    forall a. a -> Maybe a
    Just ([Name]
    x, Maybe Name
    y)
          remitter _ = Maybe ([Name], Maybe Name)
    forall a. Maybe a
    Nothing
    #endif

    _NoInline :: Prism' Inline ()
    _NoInline :: p () (f ()) -> p Inline (f Inline)
    _NoInline
      = (() -> Inline) -> (Inline -> Maybe ()) -> Prism Inline Inline () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Inline
    reviewer Inline -> Maybe ()
    remitter
      where
          reviewer :: () -> Inline
    reviewer () = Inline
    NoInline
          remitter :: Inline -> Maybe ()
    remitter NoInline = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _Inline :: Prism' Inline ()
    _Inline :: p () (f ()) -> p Inline (f Inline)
    _Inline
      = (() -> Inline) -> (Inline -> Maybe ()) -> Prism Inline Inline () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Inline
    reviewer Inline -> Maybe ()
    remitter
      where
          reviewer :: () -> Inline
    reviewer () = Inline
    Inline
          remitter :: Inline -> Maybe ()
    remitter Inline = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _Inlinable :: Prism' Inline ()
    _Inlinable :: p () (f ()) -> p Inline (f Inline)
    _Inlinable
      = (() -> Inline) -> (Inline -> Maybe ()) -> Prism Inline Inline () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Inline
    reviewer Inline -> Maybe ()
    remitter
      where
          reviewer :: () -> Inline
    reviewer () = Inline
    Inlinable
          remitter :: Inline -> Maybe ()
    remitter Inlinable = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _ConLike :: Prism' RuleMatch ()
    _ConLike :: p () (f ()) -> p RuleMatch (f RuleMatch)
    _ConLike
      = (() -> RuleMatch)
    -> (RuleMatch -> Maybe ()) -> Prism RuleMatch RuleMatch () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> RuleMatch
    reviewer RuleMatch -> Maybe ()
    remitter
      where
          reviewer :: () -> RuleMatch
    reviewer () = RuleMatch
    ConLike
          remitter :: RuleMatch -> Maybe ()
    remitter ConLike = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _FunLike :: Prism' RuleMatch ()
    _FunLike :: p () (f ()) -> p RuleMatch (f RuleMatch)
    _FunLike
      = (() -> RuleMatch)
    -> (RuleMatch -> Maybe ()) -> Prism RuleMatch RuleMatch () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> RuleMatch
    reviewer RuleMatch -> Maybe ()
    remitter
      where
          reviewer :: () -> RuleMatch
    reviewer () = RuleMatch
    FunLike
          remitter :: RuleMatch -> Maybe ()
    remitter FunLike = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _AllPhases :: Prism' Phases ()
    _AllPhases :: p () (f ()) -> p Phases (f Phases)
    _AllPhases
      = (() -> Phases) -> (Phases -> Maybe ()) -> Prism Phases Phases () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Phases
    reviewer Phases -> Maybe ()
    remitter
      where
          reviewer :: () -> Phases
    reviewer () = Phases
    AllPhases
          remitter :: Phases -> Maybe ()
    remitter AllPhases = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _FromPhase :: Prism' Phases Int
    _FromPhase :: p Int (f Int) -> p Phases (f Phases)
    _FromPhase
      = (Int -> Phases)
    -> (Phases -> Maybe Int) -> Prism Phases Phases Int Int
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Int -> Phases
    reviewer Phases -> Maybe Int
    remitter
      where
          reviewer :: Int -> Phases
    reviewer = Int -> Phases
    FromPhase
          remitter :: Phases -> Maybe Int
    remitter (FromPhase x :: Int
    x) = Int -> Maybe Int
    forall a. a -> Maybe a
    Just Int
    x
          remitter _ = Maybe Int
    forall a. Maybe a
    Nothing

    _BeforePhase :: Prism' Phases Int
    _BeforePhase :: p Int (f Int) -> p Phases (f Phases)
    _BeforePhase
      = (Int -> Phases)
    -> (Phases -> Maybe Int) -> Prism Phases Phases Int Int
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Int -> Phases
    reviewer Phases -> Maybe Int
    remitter
      where
          reviewer :: Int -> Phases
    reviewer = Int -> Phases
    BeforePhase
          remitter :: Phases -> Maybe Int
    remitter (BeforePhase x :: Int
    x) = Int -> Maybe Int
    forall a. a -> Maybe a
    Just Int
    x
          remitter _ = Maybe Int
    forall a. Maybe a
    Nothing

    _RuleVar :: Prism' RuleBndr Name
    _RuleVar :: p Name (f Name) -> p RuleBndr (f RuleBndr)
    _RuleVar
      = (Name -> RuleBndr)
    -> (RuleBndr -> Maybe Name) -> Prism RuleBndr RuleBndr Name Name
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Name -> RuleBndr
    reviewer RuleBndr -> Maybe Name
    remitter
      where
          reviewer :: Name -> RuleBndr
    reviewer = Name -> RuleBndr
    RuleVar
          remitter :: RuleBndr -> Maybe Name
    remitter (RuleVar x :: Name
    x) = Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    x
          remitter _ = Maybe Name
    forall a. Maybe a
    Nothing

    _TypedRuleVar :: Prism' RuleBndr (Name, Type)
    _TypedRuleVar :: p (Name, Kind) (f (Name, Kind)) -> p RuleBndr (f RuleBndr)
    _TypedRuleVar
      = ((Name, Kind) -> RuleBndr)
    -> (RuleBndr -> Maybe (Name, Kind))
    -> Prism RuleBndr RuleBndr (Name, Kind) (Name, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, Kind) -> RuleBndr
    reviewer RuleBndr -> Maybe (Name, Kind)
    remitter
      where
          reviewer :: (Name, Kind) -> RuleBndr
    reviewer (x :: Name
    x, y :: Kind
    y) = Name -> Kind -> RuleBndr
    TypedRuleVar Name
    x Kind
    y
          remitter :: RuleBndr -> Maybe (Name, Kind)
    remitter (TypedRuleVar x :: Name
    x y :: Kind
    y) = (Name, Kind) -> Maybe (Name, Kind)
    forall a. a -> Maybe a
    Just (Name
    x, Kind
    y)
          remitter _ = Maybe (Name, Kind)
    forall a. Maybe a
    Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,9,0)
    _ModuleAnnotation :: Prism' AnnTarget ()
    _ModuleAnnotation :: p () (f ()) -> p AnnTarget (f AnnTarget)
    _ModuleAnnotation
      = (() -> AnnTarget)
    -> (AnnTarget -> Maybe ()) -> Prism AnnTarget AnnTarget () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> AnnTarget
    reviewer AnnTarget -> Maybe ()
    remitter
      where
          reviewer :: () -> AnnTarget
    reviewer () = AnnTarget
    ModuleAnnotation
          remitter :: AnnTarget -> Maybe ()
    remitter ModuleAnnotation = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _TypeAnnotation :: Prism' AnnTarget Name
    _TypeAnnotation :: p Name (f Name) -> p AnnTarget (f AnnTarget)
    _TypeAnnotation
      = (Name -> AnnTarget)
    -> (AnnTarget -> Maybe Name) -> Prism AnnTarget AnnTarget Name Name
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Name -> AnnTarget
    reviewer AnnTarget -> Maybe Name
    remitter
      where
          reviewer :: Name -> AnnTarget
    reviewer = Name -> AnnTarget
    TypeAnnotation
          remitter :: AnnTarget -> Maybe Name
    remitter (TypeAnnotation x :: Name
    x) = Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    x
          remitter _ = Maybe Name
    forall a. Maybe a
    Nothing

    _ValueAnnotation :: Prism' AnnTarget Name
    _ValueAnnotation :: p Name (f Name) -> p AnnTarget (f AnnTarget)
    _ValueAnnotation
      = (Name -> AnnTarget)
    -> (AnnTarget -> Maybe Name) -> Prism AnnTarget AnnTarget Name Name
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Name -> AnnTarget
    reviewer AnnTarget -> Maybe Name
    remitter
      where
          reviewer :: Name -> AnnTarget
    reviewer = Name -> AnnTarget
    ValueAnnotation
          remitter :: AnnTarget -> Maybe Name
    remitter (ValueAnnotation x :: Name
    x) = Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    x
          remitter _ = Maybe Name
    forall a. Maybe a
    Nothing
    #endif

    _FunDep :: Iso' FunDep ([Name], [Name])
    _FunDep :: p ([Name], [Name]) (f ([Name], [Name])) -> p FunDep (f FunDep)
    _FunDep
      = (FunDep -> ([Name], [Name]))
    -> (([Name], [Name]) -> FunDep)
    -> Iso FunDep FunDep ([Name], [Name]) ([Name], [Name])
    forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
    iso FunDep -> ([Name], [Name])
    remitter ([Name], [Name]) -> FunDep
    reviewer
      where
          reviewer :: ([Name], [Name]) -> FunDep
    reviewer (x :: [Name]
    x, y :: [Name]
    y) = [Name] -> [Name] -> FunDep
    FunDep [Name]
    x [Name]
    y
          remitter :: FunDep -> ([Name], [Name])
    remitter (FunDep x :: [Name]
    x y :: [Name]
    y) = ([Name]
    x, [Name]
    y)

    #if !(MIN_VERSION_template_haskell(2,13,0))
    _TypeFam :: Prism' FamFlavour ()
    _TypeFam
      = prism' reviewer remitter
      where
          reviewer () = TypeFam
          remitter TypeFam = Just ()
          remitter _ = Nothing

    _DataFam :: Prism' FamFlavour ()
    _DataFam
      = prism' reviewer remitter
      where
          reviewer () = DataFam
          remitter DataFam = Just ()
          remitter _ = Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,15,0)
    tySynEqnLHS :: Lens' TySynEqn Type
    tySynEqnLHS :: (Kind -> f Kind) -> TySynEqn -> f TySynEqn
    tySynEqnLHS = (TySynEqn -> Kind)
    -> (TySynEqn -> Kind -> TySynEqn)
    -> Lens TySynEqn TySynEqn Kind Kind
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens TySynEqn -> Kind
    g TySynEqn -> Kind -> TySynEqn
    s where
       g :: TySynEqn -> Kind
    g (TySynEqn _     lhs :: Kind
    lhs _)       = Kind
    lhs
       s :: TySynEqn -> Kind -> TySynEqn
    s (TySynEqn mtvbs :: Maybe [TyVarBndr]
    mtvbs _   rhs :: Kind
    rhs) lhs :: Kind
    lhs = Maybe [TyVarBndr] -> Kind -> Kind -> TySynEqn
    TySynEqn Maybe [TyVarBndr]
    mtvbs Kind
    lhs Kind
    rhs

    tySynEqnPatterns :: Lens' TySynEqn [Type]
    tySynEqnPatterns :: (Cxt -> f Cxt) -> TySynEqn -> f TySynEqn
    tySynEqnPatterns = (TySynEqn -> Cxt)
    -> (TySynEqn -> Cxt -> TySynEqn) -> Lens TySynEqn TySynEqn Cxt Cxt
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens TySynEqn -> Cxt
    g TySynEqn -> Cxt -> TySynEqn
    forall (t :: * -> *). Foldable t => TySynEqn -> t Kind -> TySynEqn
    s where
       g :: TySynEqn -> Cxt
    g (TySynEqn _     lhs :: Kind
    lhs _) = Cxt
    pats
         where (_n :: Kind
    _n, pats :: Cxt
    pats) = Kind -> (Kind, Cxt)
    unfoldType Kind
    lhs
       s :: TySynEqn -> t Kind -> TySynEqn
    s (TySynEqn mtvbs :: Maybe [TyVarBndr]
    mtvbs lhs :: Kind
    lhs rhs :: Kind
    rhs) pats :: t Kind
    pats = Maybe [TyVarBndr] -> Kind -> Kind -> TySynEqn
    TySynEqn Maybe [TyVarBndr]
    mtvbs ((Kind -> Kind -> Kind) -> Kind -> t Kind -> Kind
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    F.foldl' Kind -> Kind -> Kind
    AppT Kind
    n t Kind
    pats) Kind
    rhs
         where (n :: Kind
    n, _pats :: Cxt
    _pats) = Kind -> (Kind, Cxt)
    unfoldType Kind
    lhs

    tySynEqnResult :: Lens' TySynEqn Type
    tySynEqnResult :: (Kind -> f Kind) -> TySynEqn -> f TySynEqn
    tySynEqnResult = (TySynEqn -> Kind)
    -> (TySynEqn -> Kind -> TySynEqn)
    -> Lens TySynEqn TySynEqn Kind Kind
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
    lens TySynEqn -> Kind
    g TySynEqn -> Kind -> TySynEqn
    s where
       g :: TySynEqn -> Kind
    g (TySynEqn _     _   rhs :: Kind
    rhs) = Kind
    rhs
       s :: TySynEqn -> Kind -> TySynEqn
    s (TySynEqn mtvbs :: Maybe [TyVarBndr]
    mtvbs lhs :: Kind
    lhs _)   = Maybe [TyVarBndr] -> Kind -> Kind -> TySynEqn
    TySynEqn Maybe [TyVarBndr]
    mtvbs Kind
    lhs
    #elif MIN_VERSION_template_haskell(2,9,0)
    tySynEqnPatterns :: Lens' TySynEqn [Type]
    tySynEqnPatterns = lens g s where
       g (TySynEqn xs _)    = xs
       s (TySynEqn _  y) xs = TySynEqn xs y

    tySynEqnResult :: Lens' TySynEqn Type
    tySynEqnResult = lens g s where
       g (TySynEqn _  x) = x
       s (TySynEqn xs _) = TySynEqn xs
    #endif

    _InfixL :: Prism' FixityDirection ()
    _InfixL :: p () (f ()) -> p FixityDirection (f FixityDirection)
    _InfixL
      = (() -> FixityDirection)
    -> (FixityDirection -> Maybe ())
    -> Prism FixityDirection FixityDirection () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> FixityDirection
    reviewer FixityDirection -> Maybe ()
    remitter
      where
          reviewer :: () -> FixityDirection
    reviewer () = FixityDirection
    InfixL
          remitter :: FixityDirection -> Maybe ()
    remitter InfixL = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _InfixR :: Prism' FixityDirection ()
    _InfixR :: p () (f ()) -> p FixityDirection (f FixityDirection)
    _InfixR
      = (() -> FixityDirection)
    -> (FixityDirection -> Maybe ())
    -> Prism FixityDirection FixityDirection () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> FixityDirection
    reviewer FixityDirection -> Maybe ()
    remitter
      where
          reviewer :: () -> FixityDirection
    reviewer () = FixityDirection
    InfixR
          remitter :: FixityDirection -> Maybe ()
    remitter InfixR = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _InfixN :: Prism' FixityDirection ()
    _InfixN :: p () (f ()) -> p FixityDirection (f FixityDirection)
    _InfixN
      = (() -> FixityDirection)
    -> (FixityDirection -> Maybe ())
    -> Prism FixityDirection FixityDirection () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> FixityDirection
    reviewer FixityDirection -> Maybe ()
    remitter
      where
          reviewer :: () -> FixityDirection
    reviewer () = FixityDirection
    InfixN
          remitter :: FixityDirection -> Maybe ()
    remitter InfixN = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _VarE :: Prism' Exp Name
    _VarE :: p Name (f Name) -> p Exp (f Exp)
    _VarE
      = (Name -> Exp) -> (Exp -> Maybe Name) -> Prism Exp Exp Name Name
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Name -> Exp
    reviewer Exp -> Maybe Name
    remitter
      where
          reviewer :: Name -> Exp
    reviewer = Name -> Exp
    VarE
          remitter :: Exp -> Maybe Name
    remitter (VarE x :: Name
    x) = Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    x
          remitter _ = Maybe Name
    forall a. Maybe a
    Nothing

    _ConE :: Prism' Exp Name
    _ConE :: p Name (f Name) -> p Exp (f Exp)
    _ConE
      = (Name -> Exp) -> (Exp -> Maybe Name) -> Prism Exp Exp Name Name
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Name -> Exp
    reviewer Exp -> Maybe Name
    remitter
      where
          reviewer :: Name -> Exp
    reviewer = Name -> Exp
    ConE
          remitter :: Exp -> Maybe Name
    remitter (ConE x :: Name
    x) = Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    x
          remitter _ = Maybe Name
    forall a. Maybe a
    Nothing

    _LitE :: Prism' Exp Lit
    _LitE :: p Lit (f Lit) -> p Exp (f Exp)
    _LitE
      = (Lit -> Exp) -> (Exp -> Maybe Lit) -> Prism Exp Exp Lit Lit
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Lit -> Exp
    reviewer Exp -> Maybe Lit
    remitter
      where
          reviewer :: Lit -> Exp
    reviewer = Lit -> Exp
    LitE
          remitter :: Exp -> Maybe Lit
    remitter (LitE x :: Lit
    x) = Lit -> Maybe Lit
    forall a. a -> Maybe a
    Just Lit
    x
          remitter _ = Maybe Lit
    forall a. Maybe a
    Nothing

    _AppE :: Prism' Exp (Exp, Exp)
    _AppE :: p (Exp, Exp) (f (Exp, Exp)) -> p Exp (f Exp)
    _AppE
      = ((Exp, Exp) -> Exp)
    -> (Exp -> Maybe (Exp, Exp)) -> Prism Exp Exp (Exp, Exp) (Exp, Exp)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Exp, Exp) -> Exp
    reviewer Exp -> Maybe (Exp, Exp)
    remitter
      where
          reviewer :: (Exp, Exp) -> Exp
    reviewer (x :: Exp
    x, y :: Exp
    y) = Exp -> Exp -> Exp
    AppE Exp
    x Exp
    y
          remitter :: Exp -> Maybe (Exp, Exp)
    remitter (AppE x :: Exp
    x y :: Exp
    y) = (Exp, Exp) -> Maybe (Exp, Exp)
    forall a. a -> Maybe a
    Just (Exp
    x, Exp
    y)
          remitter _ = Maybe (Exp, Exp)
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,12,0)
    _AppTypeE :: Prism' Exp (Exp, Type)
    _AppTypeE :: p (Exp, Kind) (f (Exp, Kind)) -> p Exp (f Exp)
    _AppTypeE
      = ((Exp, Kind) -> Exp)
    -> (Exp -> Maybe (Exp, Kind))
    -> Prism Exp Exp (Exp, Kind) (Exp, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Exp, Kind) -> Exp
    reviewer Exp -> Maybe (Exp, Kind)
    remitter
      where
          reviewer :: (Exp, Kind) -> Exp
    reviewer (x :: Exp
    x, y :: Kind
    y) = Exp -> Kind -> Exp
    AppTypeE Exp
    x Kind
    y
          remitter :: Exp -> Maybe (Exp, Kind)
    remitter (AppTypeE x :: Exp
    x y :: Kind
    y) = (Exp, Kind) -> Maybe (Exp, Kind)
    forall a. a -> Maybe a
    Just (Exp
    x, Kind
    y)
          remitter _ = Maybe (Exp, Kind)
    forall a. Maybe a
    Nothing
    #endif

    _InfixE :: Prism' Exp (Maybe Exp, Exp, Maybe Exp)
    _InfixE :: p (Maybe Exp, Exp, Maybe Exp) (f (Maybe Exp, Exp, Maybe Exp))
    -> p Exp (f Exp)
    _InfixE
      = ((Maybe Exp, Exp, Maybe Exp) -> Exp)
    -> (Exp -> Maybe (Maybe Exp, Exp, Maybe Exp))
    -> Prism
         Exp Exp (Maybe Exp, Exp, Maybe Exp) (Maybe Exp, Exp, Maybe Exp)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Maybe Exp, Exp, Maybe Exp) -> Exp
    reviewer Exp -> Maybe (Maybe Exp, Exp, Maybe Exp)
    remitter
      where
          reviewer :: (Maybe Exp, Exp, Maybe Exp) -> Exp
    reviewer (x :: Maybe Exp
    x, y :: Exp
    y, z :: Maybe Exp
    z) = Maybe Exp -> Exp -> Maybe Exp -> Exp
    InfixE Maybe Exp
    x Exp
    y Maybe Exp
    z
          remitter :: Exp -> Maybe (Maybe Exp, Exp, Maybe Exp)
    remitter (InfixE x :: Maybe Exp
    x y :: Exp
    y z :: Maybe Exp
    z) = (Maybe Exp, Exp, Maybe Exp) -> Maybe (Maybe Exp, Exp, Maybe Exp)
    forall a. a -> Maybe a
    Just (Maybe Exp
    x, Exp
    y, Maybe Exp
    z)
          remitter _ = Maybe (Maybe Exp, Exp, Maybe Exp)
    forall a. Maybe a
    Nothing

    _UInfixE :: Prism' Exp (Exp, Exp, Exp)
    _UInfixE :: p (Exp, Exp, Exp) (f (Exp, Exp, Exp)) -> p Exp (f Exp)
    _UInfixE
      = ((Exp, Exp, Exp) -> Exp)
    -> (Exp -> Maybe (Exp, Exp, Exp))
    -> Prism Exp Exp (Exp, Exp, Exp) (Exp, Exp, Exp)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Exp, Exp, Exp) -> Exp
    reviewer Exp -> Maybe (Exp, Exp, Exp)
    remitter
      where
          reviewer :: (Exp, Exp, Exp) -> Exp
    reviewer (x :: Exp
    x, y :: Exp
    y, z :: Exp
    z) = Exp -> Exp -> Exp -> Exp
    UInfixE Exp
    x Exp
    y Exp
    z
          remitter :: Exp -> Maybe (Exp, Exp, Exp)
    remitter (UInfixE x :: Exp
    x y :: Exp
    y z :: Exp
    z) = (Exp, Exp, Exp) -> Maybe (Exp, Exp, Exp)
    forall a. a -> Maybe a
    Just (Exp
    x, Exp
    y, Exp
    z)
          remitter _ = Maybe (Exp, Exp, Exp)
    forall a. Maybe a
    Nothing

    _ParensE :: Prism' Exp Exp
    _ParensE :: p Exp (f Exp) -> p Exp (f Exp)
    _ParensE
      = (Exp -> Exp) -> (Exp -> Maybe Exp) -> Prism Exp Exp Exp Exp
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Exp -> Exp
    reviewer Exp -> Maybe Exp
    remitter
      where
          reviewer :: Exp -> Exp
    reviewer = Exp -> Exp
    ParensE
          remitter :: Exp -> Maybe Exp
    remitter (ParensE x :: Exp
    x) = Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just Exp
    x
          remitter _ = Maybe Exp
    forall a. Maybe a
    Nothing

    _LamE :: Prism' Exp ([Pat], Exp)
    _LamE :: p ([Pat], Exp) (f ([Pat], Exp)) -> p Exp (f Exp)
    _LamE
      = (([Pat], Exp) -> Exp)
    -> (Exp -> Maybe ([Pat], Exp))
    -> Prism Exp Exp ([Pat], Exp) ([Pat], Exp)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' ([Pat], Exp) -> Exp
    reviewer Exp -> Maybe ([Pat], Exp)
    remitter
      where
          reviewer :: ([Pat], Exp) -> Exp
    reviewer (x :: [Pat]
    x, y :: Exp
    y) = [Pat] -> Exp -> Exp
    LamE [Pat]
    x Exp
    y
          remitter :: Exp -> Maybe ([Pat], Exp)
    remitter (LamE x :: [Pat]
    x y :: Exp
    y) = ([Pat], Exp) -> Maybe ([Pat], Exp)
    forall a. a -> Maybe a
    Just ([Pat]
    x, Exp
    y)
          remitter _ = Maybe ([Pat], Exp)
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,8,0)
    _LamCaseE :: Prism' Exp [Match]
    _LamCaseE :: p [Match] (f [Match]) -> p Exp (f Exp)
    _LamCaseE
      = ([Match] -> Exp)
    -> (Exp -> Maybe [Match]) -> Prism Exp Exp [Match] [Match]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [Match] -> Exp
    reviewer Exp -> Maybe [Match]
    remitter
      where
          reviewer :: [Match] -> Exp
    reviewer = [Match] -> Exp
    LamCaseE
          remitter :: Exp -> Maybe [Match]
    remitter (LamCaseE x :: [Match]
    x) = [Match] -> Maybe [Match]
    forall a. a -> Maybe a
    Just [Match]
    x
          remitter _ = Maybe [Match]
    forall a. Maybe a
    Nothing
    #endif

    _TupE :: Prism' Exp [Exp]
    _TupE :: p [Exp] (f [Exp]) -> p Exp (f Exp)
    _TupE
      = ([Exp] -> Exp) -> (Exp -> Maybe [Exp]) -> Prism Exp Exp [Exp] [Exp]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [Exp] -> Exp
    reviewer Exp -> Maybe [Exp]
    remitter
      where
          reviewer :: [Exp] -> Exp
    reviewer = [Exp] -> Exp
    TupE
          remitter :: Exp -> Maybe [Exp]
    remitter (TupE x :: [Exp]
    x) = [Exp] -> Maybe [Exp]
    forall a. a -> Maybe a
    Just [Exp]
    x
          remitter _ = Maybe [Exp]
    forall a. Maybe a
    Nothing

    _UnboxedTupE :: Prism' Exp [Exp]
    _UnboxedTupE :: p [Exp] (f [Exp]) -> p Exp (f Exp)
    _UnboxedTupE
      = ([Exp] -> Exp) -> (Exp -> Maybe [Exp]) -> Prism Exp Exp [Exp] [Exp]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [Exp] -> Exp
    reviewer Exp -> Maybe [Exp]
    remitter
      where
          reviewer :: [Exp] -> Exp
    reviewer = [Exp] -> Exp
    UnboxedTupE
          remitter :: Exp -> Maybe [Exp]
    remitter (UnboxedTupE x :: [Exp]
    x) = [Exp] -> Maybe [Exp]
    forall a. a -> Maybe a
    Just [Exp]
    x
          remitter _ = Maybe [Exp]
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,12,0)
    _UnboxedSumE :: Prism' Exp (Exp, SumAlt, SumArity)
    _UnboxedSumE :: p (Exp, Int, Int) (f (Exp, Int, Int)) -> p Exp (f Exp)
    _UnboxedSumE
      = ((Exp, Int, Int) -> Exp)
    -> (Exp -> Maybe (Exp, Int, Int))
    -> Prism Exp Exp (Exp, Int, Int) (Exp, Int, Int)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Exp, Int, Int) -> Exp
    reviewer Exp -> Maybe (Exp, Int, Int)
    remitter
      where
          reviewer :: (Exp, Int, Int) -> Exp
    reviewer (x :: Exp
    x, y :: Int
    y, z :: Int
    z) = Exp -> Int -> Int -> Exp
    UnboxedSumE Exp
    x Int
    y Int
    z
          remitter :: Exp -> Maybe (Exp, Int, Int)
    remitter (UnboxedSumE x :: Exp
    x y :: Int
    y z :: Int
    z) = (Exp, Int, Int) -> Maybe (Exp, Int, Int)
    forall a. a -> Maybe a
    Just (Exp
    x, Int
    y, Int
    z)
          remitter _ = Maybe (Exp, Int, Int)
    forall a. Maybe a
    Nothing
    #endif

    _CondE :: Prism' Exp (Exp, Exp, Exp)
    _CondE :: p (Exp, Exp, Exp) (f (Exp, Exp, Exp)) -> p Exp (f Exp)
    _CondE
      = ((Exp, Exp, Exp) -> Exp)
    -> (Exp -> Maybe (Exp, Exp, Exp))
    -> Prism Exp Exp (Exp, Exp, Exp) (Exp, Exp, Exp)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Exp, Exp, Exp) -> Exp
    reviewer Exp -> Maybe (Exp, Exp, Exp)
    remitter
      where
          reviewer :: (Exp, Exp, Exp) -> Exp
    reviewer (x :: Exp
    x, y :: Exp
    y, z :: Exp
    z) = Exp -> Exp -> Exp -> Exp
    CondE Exp
    x Exp
    y Exp
    z
          remitter :: Exp -> Maybe (Exp, Exp, Exp)
    remitter (CondE x :: Exp
    x y :: Exp
    y z :: Exp
    z) = (Exp, Exp, Exp) -> Maybe (Exp, Exp, Exp)
    forall a. a -> Maybe a
    Just (Exp
    x, Exp
    y, Exp
    z)
          remitter _ = Maybe (Exp, Exp, Exp)
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,8,0)
    _MultiIfE :: Prism' Exp [(Guard, Exp)]
    _MultiIfE :: p [(Guard, Exp)] (f [(Guard, Exp)]) -> p Exp (f Exp)
    _MultiIfE
      = ([(Guard, Exp)] -> Exp)
    -> (Exp -> Maybe [(Guard, Exp)])
    -> Prism Exp Exp [(Guard, Exp)] [(Guard, Exp)]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [(Guard, Exp)] -> Exp
    reviewer Exp -> Maybe [(Guard, Exp)]
    remitter
      where
          reviewer :: [(Guard, Exp)] -> Exp
    reviewer = [(Guard, Exp)] -> Exp
    MultiIfE
          remitter :: Exp -> Maybe [(Guard, Exp)]
    remitter (MultiIfE x :: [(Guard, Exp)]
    x) = [(Guard, Exp)] -> Maybe [(Guard, Exp)]
    forall a. a -> Maybe a
    Just [(Guard, Exp)]
    x
          remitter _ = Maybe [(Guard, Exp)]
    forall a. Maybe a
    Nothing
    #endif

    _LetE :: Prism' Exp ([Dec], Exp)
    _LetE :: p ([Dec], Exp) (f ([Dec], Exp)) -> p Exp (f Exp)
    _LetE
      = (([Dec], Exp) -> Exp)
    -> (Exp -> Maybe ([Dec], Exp))
    -> Prism Exp Exp ([Dec], Exp) ([Dec], Exp)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' ([Dec], Exp) -> Exp
    reviewer Exp -> Maybe ([Dec], Exp)
    remitter
      where
          reviewer :: ([Dec], Exp) -> Exp
    reviewer (x :: [Dec]
    x, y :: Exp
    y) = [Dec] -> Exp -> Exp
    LetE [Dec]
    x Exp
    y
          remitter :: Exp -> Maybe ([Dec], Exp)
    remitter (LetE x :: [Dec]
    x y :: Exp
    y) = ([Dec], Exp) -> Maybe ([Dec], Exp)
    forall a. a -> Maybe a
    Just ([Dec]
    x, Exp
    y)
          remitter _ = Maybe ([Dec], Exp)
    forall a. Maybe a
    Nothing

    _CaseE :: Prism' Exp (Exp, [Match])
    _CaseE :: p (Exp, [Match]) (f (Exp, [Match])) -> p Exp (f Exp)
    _CaseE
      = ((Exp, [Match]) -> Exp)
    -> (Exp -> Maybe (Exp, [Match]))
    -> Prism Exp Exp (Exp, [Match]) (Exp, [Match])
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Exp, [Match]) -> Exp
    reviewer Exp -> Maybe (Exp, [Match])
    remitter
      where
          reviewer :: (Exp, [Match]) -> Exp
    reviewer (x :: Exp
    x, y :: [Match]
    y) = Exp -> [Match] -> Exp
    CaseE Exp
    x [Match]
    y
          remitter :: Exp -> Maybe (Exp, [Match])
    remitter (CaseE x :: Exp
    x y :: [Match]
    y) = (Exp, [Match]) -> Maybe (Exp, [Match])
    forall a. a -> Maybe a
    Just (Exp
    x, [Match]
    y)
          remitter _ = Maybe (Exp, [Match])
    forall a. Maybe a
    Nothing

    _DoE :: Prism' Exp [Stmt]
    _DoE :: p [Stmt] (f [Stmt]) -> p Exp (f Exp)
    _DoE
      = ([Stmt] -> Exp)
    -> (Exp -> Maybe [Stmt]) -> Prism Exp Exp [Stmt] [Stmt]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [Stmt] -> Exp
    reviewer Exp -> Maybe [Stmt]
    remitter
      where
          reviewer :: [Stmt] -> Exp
    reviewer = [Stmt] -> Exp
    DoE
          remitter :: Exp -> Maybe [Stmt]
    remitter (DoE x :: [Stmt]
    x) = [Stmt] -> Maybe [Stmt]
    forall a. a -> Maybe a
    Just [Stmt]
    x
          remitter _ = Maybe [Stmt]
    forall a. Maybe a
    Nothing

    _CompE :: Prism' Exp [Stmt]
    _CompE :: p [Stmt] (f [Stmt]) -> p Exp (f Exp)
    _CompE
      = ([Stmt] -> Exp)
    -> (Exp -> Maybe [Stmt]) -> Prism Exp Exp [Stmt] [Stmt]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [Stmt] -> Exp
    reviewer Exp -> Maybe [Stmt]
    remitter
      where
          reviewer :: [Stmt] -> Exp
    reviewer = [Stmt] -> Exp
    CompE
          remitter :: Exp -> Maybe [Stmt]
    remitter (CompE x :: [Stmt]
    x) = [Stmt] -> Maybe [Stmt]
    forall a. a -> Maybe a
    Just [Stmt]
    x
          remitter _ = Maybe [Stmt]
    forall a. Maybe a
    Nothing

    _ArithSeqE :: Prism' Exp Range
    _ArithSeqE :: p Range (f Range) -> p Exp (f Exp)
    _ArithSeqE
      = (Range -> Exp) -> (Exp -> Maybe Range) -> Prism Exp Exp Range Range
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Range -> Exp
    reviewer Exp -> Maybe Range
    remitter
      where
          reviewer :: Range -> Exp
    reviewer = Range -> Exp
    ArithSeqE
          remitter :: Exp -> Maybe Range
    remitter (ArithSeqE x :: Range
    x) = Range -> Maybe Range
    forall a. a -> Maybe a
    Just Range
    x
          remitter _ = Maybe Range
    forall a. Maybe a
    Nothing

    _ListE :: Prism' Exp [Exp]
    _ListE :: p [Exp] (f [Exp]) -> p Exp (f Exp)
    _ListE
      = ([Exp] -> Exp) -> (Exp -> Maybe [Exp]) -> Prism Exp Exp [Exp] [Exp]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [Exp] -> Exp
    reviewer Exp -> Maybe [Exp]
    remitter
      where
          reviewer :: [Exp] -> Exp
    reviewer = [Exp] -> Exp
    ListE
          remitter :: Exp -> Maybe [Exp]
    remitter (ListE x :: [Exp]
    x) = [Exp] -> Maybe [Exp]
    forall a. a -> Maybe a
    Just [Exp]
    x
          remitter _ = Maybe [Exp]
    forall a. Maybe a
    Nothing

    _SigE :: Prism' Exp (Exp, Type)
    _SigE :: p (Exp, Kind) (f (Exp, Kind)) -> p Exp (f Exp)
    _SigE
      = ((Exp, Kind) -> Exp)
    -> (Exp -> Maybe (Exp, Kind))
    -> Prism Exp Exp (Exp, Kind) (Exp, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Exp, Kind) -> Exp
    reviewer Exp -> Maybe (Exp, Kind)
    remitter
      where
          reviewer :: (Exp, Kind) -> Exp
    reviewer (x :: Exp
    x, y :: Kind
    y) = Exp -> Kind -> Exp
    SigE Exp
    x Kind
    y
          remitter :: Exp -> Maybe (Exp, Kind)
    remitter (SigE x :: Exp
    x y :: Kind
    y) = (Exp, Kind) -> Maybe (Exp, Kind)
    forall a. a -> Maybe a
    Just (Exp
    x, Kind
    y)
          remitter _ = Maybe (Exp, Kind)
    forall a. Maybe a
    Nothing

    _RecConE :: Prism' Exp (Name, [FieldExp])
    _RecConE :: p (Name, [FieldExp]) (f (Name, [FieldExp])) -> p Exp (f Exp)
    _RecConE
      = ((Name, [FieldExp]) -> Exp)
    -> (Exp -> Maybe (Name, [FieldExp]))
    -> Prism Exp Exp (Name, [FieldExp]) (Name, [FieldExp])
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, [FieldExp]) -> Exp
    reviewer Exp -> Maybe (Name, [FieldExp])
    remitter
      where
          reviewer :: (Name, [FieldExp]) -> Exp
    reviewer (x :: Name
    x, y :: [FieldExp]
    y) = Name -> [FieldExp] -> Exp
    RecConE Name
    x [FieldExp]
    y
          remitter :: Exp -> Maybe (Name, [FieldExp])
    remitter (RecConE x :: Name
    x y :: [FieldExp]
    y) = (Name, [FieldExp]) -> Maybe (Name, [FieldExp])
    forall a. a -> Maybe a
    Just (Name
    x, [FieldExp]
    y)
          remitter _ = Maybe (Name, [FieldExp])
    forall a. Maybe a
    Nothing

    _RecUpdE :: Prism' Exp (Exp, [FieldExp])
    _RecUpdE :: p (Exp, [FieldExp]) (f (Exp, [FieldExp])) -> p Exp (f Exp)
    _RecUpdE
      = ((Exp, [FieldExp]) -> Exp)
    -> (Exp -> Maybe (Exp, [FieldExp]))
    -> Prism Exp Exp (Exp, [FieldExp]) (Exp, [FieldExp])
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Exp, [FieldExp]) -> Exp
    reviewer Exp -> Maybe (Exp, [FieldExp])
    remitter
      where
          reviewer :: (Exp, [FieldExp]) -> Exp
    reviewer (x :: Exp
    x, y :: [FieldExp]
    y) = Exp -> [FieldExp] -> Exp
    RecUpdE Exp
    x [FieldExp]
    y
          remitter :: Exp -> Maybe (Exp, [FieldExp])
    remitter (RecUpdE x :: Exp
    x y :: [FieldExp]
    y) = (Exp, [FieldExp]) -> Maybe (Exp, [FieldExp])
    forall a. a -> Maybe a
    Just (Exp
    x, [FieldExp]
    y)
          remitter _ = Maybe (Exp, [FieldExp])
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,10,0)
    _StaticE :: Prism' Exp Exp
    _StaticE :: p Exp (f Exp) -> p Exp (f Exp)
    _StaticE
      = (Exp -> Exp) -> (Exp -> Maybe Exp) -> Prism Exp Exp Exp Exp
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Exp -> Exp
    reviewer Exp -> Maybe Exp
    remitter
      where
          reviewer :: Exp -> Exp
    reviewer = Exp -> Exp
    StaticE
          remitter :: Exp -> Maybe Exp
    remitter (StaticE x :: Exp
    x) = Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just Exp
    x
          remitter _ = Maybe Exp
    forall a. Maybe a
    Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,11,0)
    _UnboundVarE :: Prism' Exp Name
    _UnboundVarE :: p Name (f Name) -> p Exp (f Exp)
    _UnboundVarE
      = (Name -> Exp) -> (Exp -> Maybe Name) -> Prism Exp Exp Name Name
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Name -> Exp
    reviewer Exp -> Maybe Name
    remitter
      where
          reviewer :: Name -> Exp
    reviewer = Name -> Exp
    UnboundVarE
          remitter :: Exp -> Maybe Name
    remitter (UnboundVarE x :: Name
    x) = Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    x
          remitter _ = Maybe Name
    forall a. Maybe a
    Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,13,0)
    _LabelE :: Prism' Exp String
    _LabelE :: p String (f String) -> p Exp (f Exp)
    _LabelE
      = (String -> Exp)
    -> (Exp -> Maybe String) -> Prism Exp Exp String String
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' String -> Exp
    reviewer Exp -> Maybe String
    remitter
      where
          reviewer :: String -> Exp
    reviewer = String -> Exp
    LabelE
          remitter :: Exp -> Maybe String
    remitter (LabelE x :: String
    x) = String -> Maybe String
    forall a. a -> Maybe a
    Just String
    x
          remitter _ = Maybe String
    forall a. Maybe a
    Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,15,0)
    _MDoE :: Prism' Exp [Stmt]
    _MDoE :: p [Stmt] (f [Stmt]) -> p Exp (f Exp)
    _MDoE
      = ([Stmt] -> Exp)
    -> (Exp -> Maybe [Stmt]) -> Prism Exp Exp [Stmt] [Stmt]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [Stmt] -> Exp
    reviewer Exp -> Maybe [Stmt]
    remitter
      where
          reviewer :: [Stmt] -> Exp
    reviewer = [Stmt] -> Exp
    MDoE
          remitter :: Exp -> Maybe [Stmt]
    remitter (MDoE x :: [Stmt]
    x) = [Stmt] -> Maybe [Stmt]
    forall a. a -> Maybe a
    Just [Stmt]
    x
          remitter _ = Maybe [Stmt]
    forall a. Maybe a
    Nothing

    _ImplicitParamVarE :: Prism' Exp String
    _ImplicitParamVarE :: p String (f String) -> p Exp (f Exp)
    _ImplicitParamVarE
      = (String -> Exp)
    -> (Exp -> Maybe String) -> Prism Exp Exp String String
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' String -> Exp
    reviewer Exp -> Maybe String
    remitter
      where
          reviewer :: String -> Exp
    reviewer = String -> Exp
    ImplicitParamVarE
          remitter :: Exp -> Maybe String
    remitter (ImplicitParamVarE x :: String
    x) = String -> Maybe String
    forall a. a -> Maybe a
    Just String
    x
          remitter _ = Maybe String
    forall a. Maybe a
    Nothing
    #endif

    _GuardedB :: Prism' Body [(Guard, Exp)]
    _GuardedB :: p [(Guard, Exp)] (f [(Guard, Exp)]) -> p Body (f Body)
    _GuardedB
      = ([(Guard, Exp)] -> Body)
    -> (Body -> Maybe [(Guard, Exp)])
    -> Prism Body Body [(Guard, Exp)] [(Guard, Exp)]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [(Guard, Exp)] -> Body
    reviewer Body -> Maybe [(Guard, Exp)]
    remitter
      where
          reviewer :: [(Guard, Exp)] -> Body
    reviewer = [(Guard, Exp)] -> Body
    GuardedB
          remitter :: Body -> Maybe [(Guard, Exp)]
    remitter (GuardedB x :: [(Guard, Exp)]
    x) = [(Guard, Exp)] -> Maybe [(Guard, Exp)]
    forall a. a -> Maybe a
    Just [(Guard, Exp)]
    x
          remitter _ = Maybe [(Guard, Exp)]
    forall a. Maybe a
    Nothing

    _NormalB :: Prism' Body Exp
    _NormalB :: p Exp (f Exp) -> p Body (f Body)
    _NormalB
      = (Exp -> Body) -> (Body -> Maybe Exp) -> Prism Body Body Exp Exp
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Exp -> Body
    reviewer Body -> Maybe Exp
    remitter
      where
          reviewer :: Exp -> Body
    reviewer = Exp -> Body
    NormalB
          remitter :: Body -> Maybe Exp
    remitter (NormalB x :: Exp
    x) = Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just Exp
    x
          remitter _ = Maybe Exp
    forall a. Maybe a
    Nothing

    _NormalG :: Prism' Guard Exp
    _NormalG :: p Exp (f Exp) -> p Guard (f Guard)
    _NormalG
      = (Exp -> Guard) -> (Guard -> Maybe Exp) -> Prism Guard Guard Exp Exp
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Exp -> Guard
    reviewer Guard -> Maybe Exp
    remitter
      where
          reviewer :: Exp -> Guard
    reviewer = Exp -> Guard
    NormalG
          remitter :: Guard -> Maybe Exp
    remitter (NormalG x :: Exp
    x) = Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just Exp
    x
          remitter _ = Maybe Exp
    forall a. Maybe a
    Nothing

    _PatG :: Prism' Guard [Stmt]
    _PatG :: p [Stmt] (f [Stmt]) -> p Guard (f Guard)
    _PatG
      = ([Stmt] -> Guard)
    -> (Guard -> Maybe [Stmt]) -> Prism Guard Guard [Stmt] [Stmt]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [Stmt] -> Guard
    reviewer Guard -> Maybe [Stmt]
    remitter
      where
          reviewer :: [Stmt] -> Guard
    reviewer = [Stmt] -> Guard
    PatG
          remitter :: Guard -> Maybe [Stmt]
    remitter (PatG x :: [Stmt]
    x) = [Stmt] -> Maybe [Stmt]
    forall a. a -> Maybe a
    Just [Stmt]
    x
          remitter _ = Maybe [Stmt]
    forall a. Maybe a
    Nothing

    _BindS :: Prism' Stmt (Pat, Exp)
    _BindS :: p (Pat, Exp) (f (Pat, Exp)) -> p Stmt (f Stmt)
    _BindS
      = ((Pat, Exp) -> Stmt)
    -> (Stmt -> Maybe (Pat, Exp))
    -> Prism Stmt Stmt (Pat, Exp) (Pat, Exp)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Pat, Exp) -> Stmt
    reviewer Stmt -> Maybe (Pat, Exp)
    remitter
      where
          reviewer :: (Pat, Exp) -> Stmt
    reviewer (x :: Pat
    x, y :: Exp
    y) = Pat -> Exp -> Stmt
    BindS Pat
    x Exp
    y
          remitter :: Stmt -> Maybe (Pat, Exp)
    remitter (BindS x :: Pat
    x y :: Exp
    y) = (Pat, Exp) -> Maybe (Pat, Exp)
    forall a. a -> Maybe a
    Just (Pat
    x, Exp
    y)
          remitter _ = Maybe (Pat, Exp)
    forall a. Maybe a
    Nothing

    _LetS :: Prism' Stmt [Dec]
    _LetS :: p [Dec] (f [Dec]) -> p Stmt (f Stmt)
    _LetS
      = ([Dec] -> Stmt)
    -> (Stmt -> Maybe [Dec]) -> Prism Stmt Stmt [Dec] [Dec]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [Dec] -> Stmt
    reviewer Stmt -> Maybe [Dec]
    remitter
      where
          reviewer :: [Dec] -> Stmt
    reviewer = [Dec] -> Stmt
    LetS
          remitter :: Stmt -> Maybe [Dec]
    remitter (LetS x :: [Dec]
    x) = [Dec] -> Maybe [Dec]
    forall a. a -> Maybe a
    Just [Dec]
    x
          remitter _ = Maybe [Dec]
    forall a. Maybe a
    Nothing

    _NoBindS :: Prism' Stmt Exp
    _NoBindS :: p Exp (f Exp) -> p Stmt (f Stmt)
    _NoBindS
      = (Exp -> Stmt) -> (Stmt -> Maybe Exp) -> Prism Stmt Stmt Exp Exp
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Exp -> Stmt
    reviewer Stmt -> Maybe Exp
    remitter
      where
          reviewer :: Exp -> Stmt
    reviewer = Exp -> Stmt
    NoBindS
          remitter :: Stmt -> Maybe Exp
    remitter (NoBindS x :: Exp
    x) = Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just Exp
    x
          remitter _ = Maybe Exp
    forall a. Maybe a
    Nothing

    _ParS :: Prism' Stmt [[Stmt]]
    _ParS :: p [[Stmt]] (f [[Stmt]]) -> p Stmt (f Stmt)
    _ParS
      = ([[Stmt]] -> Stmt)
    -> (Stmt -> Maybe [[Stmt]]) -> Prism Stmt Stmt [[Stmt]] [[Stmt]]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [[Stmt]] -> Stmt
    reviewer Stmt -> Maybe [[Stmt]]
    remitter
      where
          reviewer :: [[Stmt]] -> Stmt
    reviewer = [[Stmt]] -> Stmt
    ParS
          remitter :: Stmt -> Maybe [[Stmt]]
    remitter (ParS x :: [[Stmt]]
    x) = [[Stmt]] -> Maybe [[Stmt]]
    forall a. a -> Maybe a
    Just [[Stmt]]
    x
          remitter _ = Maybe [[Stmt]]
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,15,0)
    _RecS :: Prism' Stmt [Stmt]
    _RecS :: p [Stmt] (f [Stmt]) -> p Stmt (f Stmt)
    _RecS
      = ([Stmt] -> Stmt)
    -> (Stmt -> Maybe [Stmt]) -> Prism Stmt Stmt [Stmt] [Stmt]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [Stmt] -> Stmt
    reviewer Stmt -> Maybe [Stmt]
    remitter
      where
          reviewer :: [Stmt] -> Stmt
    reviewer = [Stmt] -> Stmt
    RecS
          remitter :: Stmt -> Maybe [Stmt]
    remitter (RecS x :: [Stmt]
    x) = [Stmt] -> Maybe [Stmt]
    forall a. a -> Maybe a
    Just [Stmt]
    x
          remitter _ = Maybe [Stmt]
    forall a. Maybe a
    Nothing
    #endif

    _FromR :: Prism' Range Exp
    _FromR :: p Exp (f Exp) -> p Range (f Range)
    _FromR
      = (Exp -> Range) -> (Range -> Maybe Exp) -> Prism Range Range Exp Exp
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Exp -> Range
    reviewer Range -> Maybe Exp
    remitter
      where
          reviewer :: Exp -> Range
    reviewer = Exp -> Range
    FromR
          remitter :: Range -> Maybe Exp
    remitter (FromR x :: Exp
    x) = Exp -> Maybe Exp
    forall a. a -> Maybe a
    Just Exp
    x
          remitter _ = Maybe Exp
    forall a. Maybe a
    Nothing

    _FromThenR :: Prism' Range (Exp, Exp)
    _FromThenR :: p (Exp, Exp) (f (Exp, Exp)) -> p Range (f Range)
    _FromThenR
      = ((Exp, Exp) -> Range)
    -> (Range -> Maybe (Exp, Exp))
    -> Prism Range Range (Exp, Exp) (Exp, Exp)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Exp, Exp) -> Range
    reviewer Range -> Maybe (Exp, Exp)
    remitter
      where
          reviewer :: (Exp, Exp) -> Range
    reviewer (x :: Exp
    x, y :: Exp
    y) = Exp -> Exp -> Range
    FromThenR Exp
    x Exp
    y
          remitter :: Range -> Maybe (Exp, Exp)
    remitter (FromThenR x :: Exp
    x y :: Exp
    y) = (Exp, Exp) -> Maybe (Exp, Exp)
    forall a. a -> Maybe a
    Just (Exp
    x, Exp
    y)
          remitter _ = Maybe (Exp, Exp)
    forall a. Maybe a
    Nothing

    _FromToR :: Prism' Range (Exp, Exp)
    _FromToR :: p (Exp, Exp) (f (Exp, Exp)) -> p Range (f Range)
    _FromToR
      = ((Exp, Exp) -> Range)
    -> (Range -> Maybe (Exp, Exp))
    -> Prism Range Range (Exp, Exp) (Exp, Exp)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Exp, Exp) -> Range
    reviewer Range -> Maybe (Exp, Exp)
    remitter
      where
          reviewer :: (Exp, Exp) -> Range
    reviewer (x :: Exp
    x, y :: Exp
    y) = Exp -> Exp -> Range
    FromToR Exp
    x Exp
    y
          remitter :: Range -> Maybe (Exp, Exp)
    remitter (FromToR x :: Exp
    x y :: Exp
    y) = (Exp, Exp) -> Maybe (Exp, Exp)
    forall a. a -> Maybe a
    Just (Exp
    x, Exp
    y)
          remitter _ = Maybe (Exp, Exp)
    forall a. Maybe a
    Nothing

    _FromThenToR :: Prism' Range (Exp, Exp, Exp)
    _FromThenToR :: p (Exp, Exp, Exp) (f (Exp, Exp, Exp)) -> p Range (f Range)
    _FromThenToR
      = ((Exp, Exp, Exp) -> Range)
    -> (Range -> Maybe (Exp, Exp, Exp))
    -> Prism Range Range (Exp, Exp, Exp) (Exp, Exp, Exp)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Exp, Exp, Exp) -> Range
    reviewer Range -> Maybe (Exp, Exp, Exp)
    remitter
      where
          reviewer :: (Exp, Exp, Exp) -> Range
    reviewer (x :: Exp
    x, y :: Exp
    y, z :: Exp
    z) = Exp -> Exp -> Exp -> Range
    FromThenToR Exp
    x Exp
    y Exp
    z
          remitter :: Range -> Maybe (Exp, Exp, Exp)
    remitter (FromThenToR x :: Exp
    x y :: Exp
    y z :: Exp
    z) = (Exp, Exp, Exp) -> Maybe (Exp, Exp, Exp)
    forall a. a -> Maybe a
    Just (Exp
    x, Exp
    y, Exp
    z)
          remitter _ = Maybe (Exp, Exp, Exp)
    forall a. Maybe a
    Nothing

    _CharL :: Prism' Lit Char
    _CharL :: p Char (f Char) -> p Lit (f Lit)
    _CharL
      = (Char -> Lit) -> (Lit -> Maybe Char) -> Prism Lit Lit Char Char
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Char -> Lit
    reviewer Lit -> Maybe Char
    remitter
      where
          reviewer :: Char -> Lit
    reviewer = Char -> Lit
    CharL
          remitter :: Lit -> Maybe Char
    remitter (CharL x :: Char
    x) = Char -> Maybe Char
    forall a. a -> Maybe a
    Just Char
    x
          remitter _ = Maybe Char
    forall a. Maybe a
    Nothing

    _StringL :: Prism' Lit String
    _StringL :: p String (f String) -> p Lit (f Lit)
    _StringL
      = (String -> Lit)
    -> (Lit -> Maybe String) -> Prism Lit Lit String String
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' String -> Lit
    reviewer Lit -> Maybe String
    remitter
      where
          reviewer :: String -> Lit
    reviewer = String -> Lit
    StringL
          remitter :: Lit -> Maybe String
    remitter (StringL x :: String
    x) = String -> Maybe String
    forall a. a -> Maybe a
    Just String
    x
          remitter _ = Maybe String
    forall a. Maybe a
    Nothing

    _IntegerL :: Prism' Lit Integer
    _IntegerL :: p Integer (f Integer) -> p Lit (f Lit)
    _IntegerL
      = (Integer -> Lit)
    -> (Lit -> Maybe Integer) -> Prism Lit Lit Integer Integer
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Integer -> Lit
    reviewer Lit -> Maybe Integer
    remitter
      where
          reviewer :: Integer -> Lit
    reviewer = Integer -> Lit
    IntegerL
          remitter :: Lit -> Maybe Integer
    remitter (IntegerL x :: Integer
    x) = Integer -> Maybe Integer
    forall a. a -> Maybe a
    Just Integer
    x
          remitter _ = Maybe Integer
    forall a. Maybe a
    Nothing

    _RationalL :: Prism' Lit Rational
    _RationalL :: p Rational (f Rational) -> p Lit (f Lit)
    _RationalL
      = (Rational -> Lit)
    -> (Lit -> Maybe Rational) -> Prism Lit Lit Rational Rational
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Rational -> Lit
    reviewer Lit -> Maybe Rational
    remitter
      where
          reviewer :: Rational -> Lit
    reviewer = Rational -> Lit
    RationalL
          remitter :: Lit -> Maybe Rational
    remitter (RationalL x :: Rational
    x) = Rational -> Maybe Rational
    forall a. a -> Maybe a
    Just Rational
    x
          remitter _ = Maybe Rational
    forall a. Maybe a
    Nothing

    _IntPrimL :: Prism' Lit Integer
    _IntPrimL :: p Integer (f Integer) -> p Lit (f Lit)
    _IntPrimL
      = (Integer -> Lit)
    -> (Lit -> Maybe Integer) -> Prism Lit Lit Integer Integer
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Integer -> Lit
    reviewer Lit -> Maybe Integer
    remitter
      where
          reviewer :: Integer -> Lit
    reviewer = Integer -> Lit
    IntPrimL
          remitter :: Lit -> Maybe Integer
    remitter (IntPrimL x :: Integer
    x) = Integer -> Maybe Integer
    forall a. a -> Maybe a
    Just Integer
    x
          remitter _ = Maybe Integer
    forall a. Maybe a
    Nothing

    _WordPrimL :: Prism' Lit Integer
    _WordPrimL :: p Integer (f Integer) -> p Lit (f Lit)
    _WordPrimL
      = (Integer -> Lit)
    -> (Lit -> Maybe Integer) -> Prism Lit Lit Integer Integer
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Integer -> Lit
    reviewer Lit -> Maybe Integer
    remitter
      where
          reviewer :: Integer -> Lit
    reviewer = Integer -> Lit
    WordPrimL
          remitter :: Lit -> Maybe Integer
    remitter (WordPrimL x :: Integer
    x) = Integer -> Maybe Integer
    forall a. a -> Maybe a
    Just Integer
    x
          remitter _ = Maybe Integer
    forall a. Maybe a
    Nothing

    _FloatPrimL :: Prism' Lit Rational
    _FloatPrimL :: p Rational (f Rational) -> p Lit (f Lit)
    _FloatPrimL
      = (Rational -> Lit)
    -> (Lit -> Maybe Rational) -> Prism Lit Lit Rational Rational
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Rational -> Lit
    reviewer Lit -> Maybe Rational
    remitter
      where
          reviewer :: Rational -> Lit
    reviewer = Rational -> Lit
    FloatPrimL
          remitter :: Lit -> Maybe Rational
    remitter (FloatPrimL x :: Rational
    x) = Rational -> Maybe Rational
    forall a. a -> Maybe a
    Just Rational
    x
          remitter _ = Maybe Rational
    forall a. Maybe a
    Nothing

    _DoublePrimL :: Prism' Lit Rational
    _DoublePrimL :: p Rational (f Rational) -> p Lit (f Lit)
    _DoublePrimL
      = (Rational -> Lit)
    -> (Lit -> Maybe Rational) -> Prism Lit Lit Rational Rational
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Rational -> Lit
    reviewer Lit -> Maybe Rational
    remitter
      where
          reviewer :: Rational -> Lit
    reviewer = Rational -> Lit
    DoublePrimL
          remitter :: Lit -> Maybe Rational
    remitter (DoublePrimL x :: Rational
    x) = Rational -> Maybe Rational
    forall a. a -> Maybe a
    Just Rational
    x
          remitter _ = Maybe Rational
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,8,0)
    _StringPrimL :: Prism' Lit [Word8]
    _StringPrimL :: p [Word8] (f [Word8]) -> p Lit (f Lit)
    _StringPrimL
      = ([Word8] -> Lit)
    -> (Lit -> Maybe [Word8]) -> Prism Lit Lit [Word8] [Word8]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [Word8] -> Lit
    reviewer Lit -> Maybe [Word8]
    remitter
      where
          reviewer :: [Word8] -> Lit
    reviewer = [Word8] -> Lit
    StringPrimL
          remitter :: Lit -> Maybe [Word8]
    remitter (StringPrimL x :: [Word8]
    x) = [Word8] -> Maybe [Word8]
    forall a. a -> Maybe a
    Just [Word8]
    x
          remitter _ = Maybe [Word8]
    forall a. Maybe a
    Nothing
    #else
    _StringPrimL :: Prism' Lit String
    _StringPrimL
      = prism' reviewer remitter
      where
          reviewer = StringPrimL
          remitter (StringPrimL x) = Just x
          remitter _ = Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,11,0)
    _CharPrimL :: Prism' Lit Char
    _CharPrimL :: p Char (f Char) -> p Lit (f Lit)
    _CharPrimL
      = (Char -> Lit) -> (Lit -> Maybe Char) -> Prism Lit Lit Char Char
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Char -> Lit
    reviewer Lit -> Maybe Char
    remitter
      where
          reviewer :: Char -> Lit
    reviewer = Char -> Lit
    CharPrimL
          remitter :: Lit -> Maybe Char
    remitter (CharPrimL x :: Char
    x) = Char -> Maybe Char
    forall a. a -> Maybe a
    Just Char
    x
          remitter _ = Maybe Char
    forall a. Maybe a
    Nothing
    #endif

    _LitP :: Prism' Pat Lit
    _LitP :: p Lit (f Lit) -> p Pat (f Pat)
    _LitP
      = (Lit -> Pat) -> (Pat -> Maybe Lit) -> Prism Pat Pat Lit Lit
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Lit -> Pat
    reviewer Pat -> Maybe Lit
    remitter
      where
          reviewer :: Lit -> Pat
    reviewer = Lit -> Pat
    LitP
          remitter :: Pat -> Maybe Lit
    remitter (LitP x :: Lit
    x) = Lit -> Maybe Lit
    forall a. a -> Maybe a
    Just Lit
    x
          remitter _ = Maybe Lit
    forall a. Maybe a
    Nothing

    _VarP :: Prism' Pat Name
    _VarP :: p Name (f Name) -> p Pat (f Pat)
    _VarP
      = (Name -> Pat) -> (Pat -> Maybe Name) -> Prism Pat Pat Name Name
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Name -> Pat
    reviewer Pat -> Maybe Name
    remitter
      where
          reviewer :: Name -> Pat
    reviewer = Name -> Pat
    VarP
          remitter :: Pat -> Maybe Name
    remitter (VarP x :: Name
    x) = Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    x
          remitter _ = Maybe Name
    forall a. Maybe a
    Nothing

    _TupP :: Prism' Pat [Pat]
    _TupP :: p [Pat] (f [Pat]) -> p Pat (f Pat)
    _TupP
      = ([Pat] -> Pat) -> (Pat -> Maybe [Pat]) -> Prism Pat Pat [Pat] [Pat]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [Pat] -> Pat
    reviewer Pat -> Maybe [Pat]
    remitter
      where
          reviewer :: [Pat] -> Pat
    reviewer = [Pat] -> Pat
    TupP
          remitter :: Pat -> Maybe [Pat]
    remitter (TupP x :: [Pat]
    x) = [Pat] -> Maybe [Pat]
    forall a. a -> Maybe a
    Just [Pat]
    x
          remitter _ = Maybe [Pat]
    forall a. Maybe a
    Nothing

    _UnboxedTupP :: Prism' Pat [Pat]
    _UnboxedTupP :: p [Pat] (f [Pat]) -> p Pat (f Pat)
    _UnboxedTupP
      = ([Pat] -> Pat) -> (Pat -> Maybe [Pat]) -> Prism Pat Pat [Pat] [Pat]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [Pat] -> Pat
    reviewer Pat -> Maybe [Pat]
    remitter
      where
          reviewer :: [Pat] -> Pat
    reviewer = [Pat] -> Pat
    UnboxedTupP
          remitter :: Pat -> Maybe [Pat]
    remitter (UnboxedTupP x :: [Pat]
    x) = [Pat] -> Maybe [Pat]
    forall a. a -> Maybe a
    Just [Pat]
    x
          remitter _ = Maybe [Pat]
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,12,0)
    _UnboxedSumP :: Prism' Pat (Pat, SumAlt, SumArity)
    _UnboxedSumP :: p (Pat, Int, Int) (f (Pat, Int, Int)) -> p Pat (f Pat)
    _UnboxedSumP
      = ((Pat, Int, Int) -> Pat)
    -> (Pat -> Maybe (Pat, Int, Int))
    -> Prism Pat Pat (Pat, Int, Int) (Pat, Int, Int)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Pat, Int, Int) -> Pat
    reviewer Pat -> Maybe (Pat, Int, Int)
    remitter
      where
          reviewer :: (Pat, Int, Int) -> Pat
    reviewer (x :: Pat
    x, y :: Int
    y, z :: Int
    z) = Pat -> Int -> Int -> Pat
    UnboxedSumP Pat
    x Int
    y Int
    z
          remitter :: Pat -> Maybe (Pat, Int, Int)
    remitter (UnboxedSumP x :: Pat
    x y :: Int
    y z :: Int
    z) = (Pat, Int, Int) -> Maybe (Pat, Int, Int)
    forall a. a -> Maybe a
    Just (Pat
    x, Int
    y, Int
    z)
          remitter _ = Maybe (Pat, Int, Int)
    forall a. Maybe a
    Nothing
    #endif

    _ConP :: Prism' Pat (Name, [Pat])
    _ConP :: p (Name, [Pat]) (f (Name, [Pat])) -> p Pat (f Pat)
    _ConP
      = ((Name, [Pat]) -> Pat)
    -> (Pat -> Maybe (Name, [Pat]))
    -> Prism Pat Pat (Name, [Pat]) (Name, [Pat])
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, [Pat]) -> Pat
    reviewer Pat -> Maybe (Name, [Pat])
    remitter
      where
          reviewer :: (Name, [Pat]) -> Pat
    reviewer (x :: Name
    x, y :: [Pat]
    y) = Name -> [Pat] -> Pat
    ConP Name
    x [Pat]
    y
          remitter :: Pat -> Maybe (Name, [Pat])
    remitter (ConP x :: Name
    x y :: [Pat]
    y) = (Name, [Pat]) -> Maybe (Name, [Pat])
    forall a. a -> Maybe a
    Just (Name
    x, [Pat]
    y)
          remitter _ = Maybe (Name, [Pat])
    forall a. Maybe a
    Nothing

    _InfixP :: Prism' Pat (Pat, Name, Pat)
    _InfixP :: p (Pat, Name, Pat) (f (Pat, Name, Pat)) -> p Pat (f Pat)
    _InfixP
      = ((Pat, Name, Pat) -> Pat)
    -> (Pat -> Maybe (Pat, Name, Pat))
    -> Prism Pat Pat (Pat, Name, Pat) (Pat, Name, Pat)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Pat, Name, Pat) -> Pat
    reviewer Pat -> Maybe (Pat, Name, Pat)
    remitter
      where
          reviewer :: (Pat, Name, Pat) -> Pat
    reviewer (x :: Pat
    x, y :: Name
    y, z :: Pat
    z) = Pat -> Name -> Pat -> Pat
    InfixP Pat
    x Name
    y Pat
    z
          remitter :: Pat -> Maybe (Pat, Name, Pat)
    remitter (InfixP x :: Pat
    x y :: Name
    y z :: Pat
    z) = (Pat, Name, Pat) -> Maybe (Pat, Name, Pat)
    forall a. a -> Maybe a
    Just (Pat
    x, Name
    y, Pat
    z)
          remitter _ = Maybe (Pat, Name, Pat)
    forall a. Maybe a
    Nothing

    _UInfixP :: Prism' Pat (Pat, Name, Pat)
    _UInfixP :: p (Pat, Name, Pat) (f (Pat, Name, Pat)) -> p Pat (f Pat)
    _UInfixP
      = ((Pat, Name, Pat) -> Pat)
    -> (Pat -> Maybe (Pat, Name, Pat))
    -> Prism Pat Pat (Pat, Name, Pat) (Pat, Name, Pat)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Pat, Name, Pat) -> Pat
    reviewer Pat -> Maybe (Pat, Name, Pat)
    remitter
      where
          reviewer :: (Pat, Name, Pat) -> Pat
    reviewer (x :: Pat
    x, y :: Name
    y, z :: Pat
    z) = Pat -> Name -> Pat -> Pat
    UInfixP Pat
    x Name
    y Pat
    z
          remitter :: Pat -> Maybe (Pat, Name, Pat)
    remitter (UInfixP x :: Pat
    x y :: Name
    y z :: Pat
    z) = (Pat, Name, Pat) -> Maybe (Pat, Name, Pat)
    forall a. a -> Maybe a
    Just (Pat
    x, Name
    y, Pat
    z)
          remitter _ = Maybe (Pat, Name, Pat)
    forall a. Maybe a
    Nothing

    _ParensP :: Prism' Pat Pat
    _ParensP :: p Pat (f Pat) -> p Pat (f Pat)
    _ParensP
      = (Pat -> Pat) -> (Pat -> Maybe Pat) -> Prism Pat Pat Pat Pat
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Pat -> Pat
    reviewer Pat -> Maybe Pat
    remitter
      where
          reviewer :: Pat -> Pat
    reviewer = Pat -> Pat
    ParensP
          remitter :: Pat -> Maybe Pat
    remitter (ParensP x :: Pat
    x) = Pat -> Maybe Pat
    forall a. a -> Maybe a
    Just Pat
    x
          remitter _ = Maybe Pat
    forall a. Maybe a
    Nothing

    _TildeP :: Prism' Pat Pat
    _TildeP :: p Pat (f Pat) -> p Pat (f Pat)
    _TildeP
      = (Pat -> Pat) -> (Pat -> Maybe Pat) -> Prism Pat Pat Pat Pat
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Pat -> Pat
    reviewer Pat -> Maybe Pat
    remitter
      where
          reviewer :: Pat -> Pat
    reviewer = Pat -> Pat
    TildeP
          remitter :: Pat -> Maybe Pat
    remitter (TildeP x :: Pat
    x) = Pat -> Maybe Pat
    forall a. a -> Maybe a
    Just Pat
    x
          remitter _ = Maybe Pat
    forall a. Maybe a
    Nothing

    _BangP :: Prism' Pat Pat
    _BangP :: p Pat (f Pat) -> p Pat (f Pat)
    _BangP
      = (Pat -> Pat) -> (Pat -> Maybe Pat) -> Prism Pat Pat Pat Pat
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Pat -> Pat
    reviewer Pat -> Maybe Pat
    remitter
      where
          reviewer :: Pat -> Pat
    reviewer = Pat -> Pat
    BangP
          remitter :: Pat -> Maybe Pat
    remitter (BangP x :: Pat
    x) = Pat -> Maybe Pat
    forall a. a -> Maybe a
    Just Pat
    x
          remitter _ = Maybe Pat
    forall a. Maybe a
    Nothing

    _AsP :: Prism' Pat (Name, Pat)
    _AsP :: p FieldPat (f FieldPat) -> p Pat (f Pat)
    _AsP
      = (FieldPat -> Pat)
    -> (Pat -> Maybe FieldPat) -> Prism Pat Pat FieldPat FieldPat
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' FieldPat -> Pat
    reviewer Pat -> Maybe FieldPat
    remitter
      where
          reviewer :: FieldPat -> Pat
    reviewer (x :: Name
    x, y :: Pat
    y) = Name -> Pat -> Pat
    AsP Name
    x Pat
    y
          remitter :: Pat -> Maybe FieldPat
    remitter (AsP x :: Name
    x y :: Pat
    y) = FieldPat -> Maybe FieldPat
    forall a. a -> Maybe a
    Just (Name
    x, Pat
    y)
          remitter _ = Maybe FieldPat
    forall a. Maybe a
    Nothing

    _WildP :: Prism' Pat ()
    _WildP :: p () (f ()) -> p Pat (f Pat)
    _WildP
      = (() -> Pat) -> (Pat -> Maybe ()) -> Prism Pat Pat () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Pat
    reviewer Pat -> Maybe ()
    remitter
      where
          reviewer :: () -> Pat
    reviewer () = Pat
    WildP
          remitter :: Pat -> Maybe ()
    remitter WildP = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _RecP :: Prism' Pat (Name, [FieldPat])
    _RecP :: p (Name, [FieldPat]) (f (Name, [FieldPat])) -> p Pat (f Pat)
    _RecP
      = ((Name, [FieldPat]) -> Pat)
    -> (Pat -> Maybe (Name, [FieldPat]))
    -> Prism Pat Pat (Name, [FieldPat]) (Name, [FieldPat])
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, [FieldPat]) -> Pat
    reviewer Pat -> Maybe (Name, [FieldPat])
    remitter
      where
          reviewer :: (Name, [FieldPat]) -> Pat
    reviewer (x :: Name
    x, y :: [FieldPat]
    y) = Name -> [FieldPat] -> Pat
    RecP Name
    x [FieldPat]
    y
          remitter :: Pat -> Maybe (Name, [FieldPat])
    remitter (RecP x :: Name
    x y :: [FieldPat]
    y) = (Name, [FieldPat]) -> Maybe (Name, [FieldPat])
    forall a. a -> Maybe a
    Just (Name
    x, [FieldPat]
    y)
          remitter _ = Maybe (Name, [FieldPat])
    forall a. Maybe a
    Nothing

    _ListP :: Prism' Pat [Pat]
    _ListP :: p [Pat] (f [Pat]) -> p Pat (f Pat)
    _ListP
      = ([Pat] -> Pat) -> (Pat -> Maybe [Pat]) -> Prism Pat Pat [Pat] [Pat]
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' [Pat] -> Pat
    reviewer Pat -> Maybe [Pat]
    remitter
      where
          reviewer :: [Pat] -> Pat
    reviewer = [Pat] -> Pat
    ListP
          remitter :: Pat -> Maybe [Pat]
    remitter (ListP x :: [Pat]
    x) = [Pat] -> Maybe [Pat]
    forall a. a -> Maybe a
    Just [Pat]
    x
          remitter _ = Maybe [Pat]
    forall a. Maybe a
    Nothing

    _SigP :: Prism' Pat (Pat, Type)
    _SigP :: p (Pat, Kind) (f (Pat, Kind)) -> p Pat (f Pat)
    _SigP
      = ((Pat, Kind) -> Pat)
    -> (Pat -> Maybe (Pat, Kind))
    -> Prism Pat Pat (Pat, Kind) (Pat, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Pat, Kind) -> Pat
    reviewer Pat -> Maybe (Pat, Kind)
    remitter
      where
          reviewer :: (Pat, Kind) -> Pat
    reviewer (x :: Pat
    x, y :: Kind
    y) = Pat -> Kind -> Pat
    SigP Pat
    x Kind
    y
          remitter :: Pat -> Maybe (Pat, Kind)
    remitter (SigP x :: Pat
    x y :: Kind
    y) = (Pat, Kind) -> Maybe (Pat, Kind)
    forall a. a -> Maybe a
    Just (Pat
    x, Kind
    y)
          remitter _ = Maybe (Pat, Kind)
    forall a. Maybe a
    Nothing

    _ViewP :: Prism' Pat (Exp, Pat)
    _ViewP :: p (Exp, Pat) (f (Exp, Pat)) -> p Pat (f Pat)
    _ViewP
      = ((Exp, Pat) -> Pat)
    -> (Pat -> Maybe (Exp, Pat)) -> Prism Pat Pat (Exp, Pat) (Exp, Pat)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Exp, Pat) -> Pat
    reviewer Pat -> Maybe (Exp, Pat)
    remitter
      where
          reviewer :: (Exp, Pat) -> Pat
    reviewer (x :: Exp
    x, y :: Pat
    y) = Exp -> Pat -> Pat
    ViewP Exp
    x Pat
    y
          remitter :: Pat -> Maybe (Exp, Pat)
    remitter (ViewP x :: Exp
    x y :: Pat
    y) = (Exp, Pat) -> Maybe (Exp, Pat)
    forall a. a -> Maybe a
    Just (Exp
    x, Pat
    y)
          remitter _ = Maybe (Exp, Pat)
    forall a. Maybe a
    Nothing

    _ForallT :: Prism' Type ([TyVarBndr], Cxt, Type)
    _ForallT :: p ([TyVarBndr], Cxt, Kind) (f ([TyVarBndr], Cxt, Kind))
    -> p Kind (f Kind)
    _ForallT
      = (([TyVarBndr], Cxt, Kind) -> Kind)
    -> (Kind -> Maybe ([TyVarBndr], Cxt, Kind))
    -> Prism
         Kind Kind ([TyVarBndr], Cxt, Kind) ([TyVarBndr], Cxt, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' ([TyVarBndr], Cxt, Kind) -> Kind
    reviewer Kind -> Maybe ([TyVarBndr], Cxt, Kind)
    remitter
      where
          reviewer :: ([TyVarBndr], Cxt, Kind) -> Kind
    reviewer (x :: [TyVarBndr]
    x, y :: Cxt
    y, z :: Kind
    z) = [TyVarBndr] -> Cxt -> Kind -> Kind
    ForallT [TyVarBndr]
    x Cxt
    y Kind
    z
          remitter :: Kind -> Maybe ([TyVarBndr], Cxt, Kind)
    remitter (ForallT x :: [TyVarBndr]
    x y :: Cxt
    y z :: Kind
    z) = ([TyVarBndr], Cxt, Kind) -> Maybe ([TyVarBndr], Cxt, Kind)
    forall a. a -> Maybe a
    Just ([TyVarBndr]
    x, Cxt
    y, Kind
    z)
          remitter _ = Maybe ([TyVarBndr], Cxt, Kind)
    forall a. Maybe a
    Nothing

    _AppT :: Prism' Type (Type, Type)
    _AppT :: p (Kind, Kind) (f (Kind, Kind)) -> p Kind (f Kind)
    _AppT
      = ((Kind, Kind) -> Kind)
    -> (Kind -> Maybe (Kind, Kind))
    -> Prism Kind Kind (Kind, Kind) (Kind, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Kind, Kind) -> Kind
    reviewer Kind -> Maybe (Kind, Kind)
    remitter
      where
          reviewer :: (Kind, Kind) -> Kind
    reviewer (x :: Kind
    x, y :: Kind
    y) = Kind -> Kind -> Kind
    AppT Kind
    x Kind
    y
          remitter :: Kind -> Maybe (Kind, Kind)
    remitter (AppT x :: Kind
    x y :: Kind
    y) = (Kind, Kind) -> Maybe (Kind, Kind)
    forall a. a -> Maybe a
    Just (Kind
    x, Kind
    y)
          remitter _ = Maybe (Kind, Kind)
    forall a. Maybe a
    Nothing

    _SigT :: Prism' Type (Type, Kind)
    _SigT :: p (Kind, Kind) (f (Kind, Kind)) -> p Kind (f Kind)
    _SigT
      = ((Kind, Kind) -> Kind)
    -> (Kind -> Maybe (Kind, Kind))
    -> Prism Kind Kind (Kind, Kind) (Kind, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Kind, Kind) -> Kind
    reviewer Kind -> Maybe (Kind, Kind)
    remitter
      where
          reviewer :: (Kind, Kind) -> Kind
    reviewer (x :: Kind
    x, y :: Kind
    y) = Kind -> Kind -> Kind
    SigT Kind
    x Kind
    y
          remitter :: Kind -> Maybe (Kind, Kind)
    remitter (SigT x :: Kind
    x y :: Kind
    y) = (Kind, Kind) -> Maybe (Kind, Kind)
    forall a. a -> Maybe a
    Just (Kind
    x, Kind
    y)
          remitter _ = Maybe (Kind, Kind)
    forall a. Maybe a
    Nothing

    _VarT :: Prism' Type Name
    _VarT :: p Name (f Name) -> p Kind (f Kind)
    _VarT
      = (Name -> Kind) -> (Kind -> Maybe Name) -> Prism Kind Kind Name Name
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Name -> Kind
    reviewer Kind -> Maybe Name
    remitter
      where
          reviewer :: Name -> Kind
    reviewer = Name -> Kind
    VarT
          remitter :: Kind -> Maybe Name
    remitter (VarT x :: Name
    x) = Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    x
          remitter _ = Maybe Name
    forall a. Maybe a
    Nothing

    _ConT :: Prism' Type Name
    _ConT :: p Name (f Name) -> p Kind (f Kind)
    _ConT
      = (Name -> Kind) -> (Kind -> Maybe Name) -> Prism Kind Kind Name Name
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Name -> Kind
    reviewer Kind -> Maybe Name
    remitter
      where
          reviewer :: Name -> Kind
    reviewer = Name -> Kind
    ConT
          remitter :: Kind -> Maybe Name
    remitter (ConT x :: Name
    x) = Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    x
          remitter _ = Maybe Name
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,8,0)
    _PromotedT :: Prism' Type Name
    _PromotedT :: p Name (f Name) -> p Kind (f Kind)
    _PromotedT
      = (Name -> Kind) -> (Kind -> Maybe Name) -> Prism Kind Kind Name Name
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Name -> Kind
    reviewer Kind -> Maybe Name
    remitter
      where
          reviewer :: Name -> Kind
    reviewer = Name -> Kind
    PromotedT
          remitter :: Kind -> Maybe Name
    remitter (PromotedT x :: Name
    x) = Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    x
          remitter _ = Maybe Name
    forall a. Maybe a
    Nothing
    #endif

    _TupleT :: Prism' Type Int
    _TupleT :: p Int (f Int) -> p Kind (f Kind)
    _TupleT
      = (Int -> Kind) -> (Kind -> Maybe Int) -> Prism Kind Kind Int Int
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Int -> Kind
    reviewer Kind -> Maybe Int
    remitter
      where
          reviewer :: Int -> Kind
    reviewer = Int -> Kind
    TupleT
          remitter :: Kind -> Maybe Int
    remitter (TupleT x :: Int
    x) = Int -> Maybe Int
    forall a. a -> Maybe a
    Just Int
    x
          remitter _ = Maybe Int
    forall a. Maybe a
    Nothing

    _UnboxedTupleT :: Prism' Type Int
    _UnboxedTupleT :: p Int (f Int) -> p Kind (f Kind)
    _UnboxedTupleT
      = (Int -> Kind) -> (Kind -> Maybe Int) -> Prism Kind Kind Int Int
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Int -> Kind
    reviewer Kind -> Maybe Int
    remitter
      where
          reviewer :: Int -> Kind
    reviewer = Int -> Kind
    UnboxedTupleT
          remitter :: Kind -> Maybe Int
    remitter (UnboxedTupleT x :: Int
    x) = Int -> Maybe Int
    forall a. a -> Maybe a
    Just Int
    x
          remitter _ = Maybe Int
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,12,0)
    _UnboxedSumT :: Prism' Type SumArity
    _UnboxedSumT :: p Int (f Int) -> p Kind (f Kind)
    _UnboxedSumT
      = (Int -> Kind) -> (Kind -> Maybe Int) -> Prism Kind Kind Int Int
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Int -> Kind
    reviewer Kind -> Maybe Int
    remitter
      where
          reviewer :: Int -> Kind
    reviewer = Int -> Kind
    UnboxedSumT
          remitter :: Kind -> Maybe Int
    remitter (UnboxedSumT x :: Int
    x) = Int -> Maybe Int
    forall a. a -> Maybe a
    Just Int
    x
          remitter _ = Maybe Int
    forall a. Maybe a
    Nothing
    #endif

    _ArrowT :: Prism' Type ()
    _ArrowT :: p () (f ()) -> p Kind (f Kind)
    _ArrowT
      = (() -> Kind) -> (Kind -> Maybe ()) -> Prism Kind Kind () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Kind
    reviewer Kind -> Maybe ()
    remitter
      where
          reviewer :: () -> Kind
    reviewer () = Kind
    ArrowT
          remitter :: Kind -> Maybe ()
    remitter ArrowT = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,10,0)
    _EqualityT :: Prism' Type ()
    _EqualityT :: p () (f ()) -> p Kind (f Kind)
    _EqualityT
      = (() -> Kind) -> (Kind -> Maybe ()) -> Prism Kind Kind () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Kind
    reviewer Kind -> Maybe ()
    remitter
      where
          reviewer :: () -> Kind
    reviewer () = Kind
    EqualityT
          remitter :: Kind -> Maybe ()
    remitter EqualityT = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing
    #endif

    _ListT :: Prism' Type ()
    _ListT :: p () (f ()) -> p Kind (f Kind)
    _ListT
      = (() -> Kind) -> (Kind -> Maybe ()) -> Prism Kind Kind () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Kind
    reviewer Kind -> Maybe ()
    remitter
      where
          reviewer :: () -> Kind
    reviewer () = Kind
    ListT
          remitter :: Kind -> Maybe ()
    remitter ListT = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,8,0)
    _PromotedTupleT :: Prism' Type Int
    _PromotedTupleT :: p Int (f Int) -> p Kind (f Kind)
    _PromotedTupleT
      = (Int -> Kind) -> (Kind -> Maybe Int) -> Prism Kind Kind Int Int
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Int -> Kind
    reviewer Kind -> Maybe Int
    remitter
      where
          reviewer :: Int -> Kind
    reviewer = Int -> Kind
    PromotedTupleT
          remitter :: Kind -> Maybe Int
    remitter (PromotedTupleT x :: Int
    x) = Int -> Maybe Int
    forall a. a -> Maybe a
    Just Int
    x
          remitter _ = Maybe Int
    forall a. Maybe a
    Nothing

    _PromotedNilT :: Prism' Type ()
    _PromotedNilT :: p () (f ()) -> p Kind (f Kind)
    _PromotedNilT
      = (() -> Kind) -> (Kind -> Maybe ()) -> Prism Kind Kind () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Kind
    reviewer Kind -> Maybe ()
    remitter
      where
          reviewer :: () -> Kind
    reviewer () = Kind
    PromotedNilT
          remitter :: Kind -> Maybe ()
    remitter PromotedNilT = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _PromotedConsT :: Prism' Type ()
    _PromotedConsT :: p () (f ()) -> p Kind (f Kind)
    _PromotedConsT
      = (() -> Kind) -> (Kind -> Maybe ()) -> Prism Kind Kind () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Kind
    reviewer Kind -> Maybe ()
    remitter
      where
          reviewer :: () -> Kind
    reviewer () = Kind
    PromotedConsT
          remitter :: Kind -> Maybe ()
    remitter PromotedConsT = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _StarT :: Prism' Type ()
    _StarT :: p () (f ()) -> p Kind (f Kind)
    _StarT
      = (() -> Kind) -> (Kind -> Maybe ()) -> Prism Kind Kind () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Kind
    reviewer Kind -> Maybe ()
    remitter
      where
          reviewer :: () -> Kind
    reviewer () = Kind
    StarT
          remitter :: Kind -> Maybe ()
    remitter StarT = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _ConstraintT :: Prism' Type ()
    _ConstraintT :: p () (f ()) -> p Kind (f Kind)
    _ConstraintT
      = (() -> Kind) -> (Kind -> Maybe ()) -> Prism Kind Kind () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Kind
    reviewer Kind -> Maybe ()
    remitter
      where
          reviewer :: () -> Kind
    reviewer () = Kind
    ConstraintT
          remitter :: Kind -> Maybe ()
    remitter ConstraintT = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _LitT :: Prism' Type TyLit
    _LitT :: p TyLit (f TyLit) -> p Kind (f Kind)
    _LitT
      = (TyLit -> Kind)
    -> (Kind -> Maybe TyLit) -> Prism Kind Kind TyLit TyLit
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' TyLit -> Kind
    reviewer Kind -> Maybe TyLit
    remitter
      where
          reviewer :: TyLit -> Kind
    reviewer = TyLit -> Kind
    LitT
          remitter :: Kind -> Maybe TyLit
    remitter (LitT x :: TyLit
    x) = TyLit -> Maybe TyLit
    forall a. a -> Maybe a
    Just TyLit
    x
          remitter _ = Maybe TyLit
    forall a. Maybe a
    Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,11,0)
    _InfixT :: Prism' Type (Type, Name, Type)
    _InfixT :: p (Kind, Name, Kind) (f (Kind, Name, Kind)) -> p Kind (f Kind)
    _InfixT
      = ((Kind, Name, Kind) -> Kind)
    -> (Kind -> Maybe (Kind, Name, Kind))
    -> Prism Kind Kind (Kind, Name, Kind) (Kind, Name, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Kind, Name, Kind) -> Kind
    reviewer Kind -> Maybe (Kind, Name, Kind)
    remitter
      where
          reviewer :: (Kind, Name, Kind) -> Kind
    reviewer (x :: Kind
    x, y :: Name
    y, z :: Kind
    z) = Kind -> Name -> Kind -> Kind
    InfixT Kind
    x Name
    y Kind
    z
          remitter :: Kind -> Maybe (Kind, Name, Kind)
    remitter (InfixT x :: Kind
    x y :: Name
    y z :: Kind
    z) = (Kind, Name, Kind) -> Maybe (Kind, Name, Kind)
    forall a. a -> Maybe a
    Just (Kind
    x, Name
    y, Kind
    z)
          remitter _ = Maybe (Kind, Name, Kind)
    forall a. Maybe a
    Nothing

    _UInfixT :: Prism' Type (Type, Name, Type)
    _UInfixT :: p (Kind, Name, Kind) (f (Kind, Name, Kind)) -> p Kind (f Kind)
    _UInfixT
      = ((Kind, Name, Kind) -> Kind)
    -> (Kind -> Maybe (Kind, Name, Kind))
    -> Prism Kind Kind (Kind, Name, Kind) (Kind, Name, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Kind, Name, Kind) -> Kind
    reviewer Kind -> Maybe (Kind, Name, Kind)
    remitter
      where
          reviewer :: (Kind, Name, Kind) -> Kind
    reviewer (x :: Kind
    x, y :: Name
    y, z :: Kind
    z) = Kind -> Name -> Kind -> Kind
    UInfixT Kind
    x Name
    y Kind
    z
          remitter :: Kind -> Maybe (Kind, Name, Kind)
    remitter (UInfixT x :: Kind
    x y :: Name
    y z :: Kind
    z) = (Kind, Name, Kind) -> Maybe (Kind, Name, Kind)
    forall a. a -> Maybe a
    Just (Kind
    x, Name
    y, Kind
    z)
          remitter _ = Maybe (Kind, Name, Kind)
    forall a. Maybe a
    Nothing

    _ParensT :: Prism' Type Type
    _ParensT :: p Kind (f Kind) -> p Kind (f Kind)
    _ParensT
      = (Kind -> Kind) -> (Kind -> Maybe Kind) -> Prism Kind Kind Kind Kind
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Kind -> Kind
    reviewer Kind -> Maybe Kind
    remitter
      where
          reviewer :: Kind -> Kind
    reviewer = Kind -> Kind
    ParensT
          remitter :: Kind -> Maybe Kind
    remitter (ParensT x :: Kind
    x) = Kind -> Maybe Kind
    forall a. a -> Maybe a
    Just Kind
    x
          remitter _ = Maybe Kind
    forall a. Maybe a
    Nothing

    _WildCardT :: Prism' Type ()
    _WildCardT :: p () (f ()) -> p Kind (f Kind)
    _WildCardT
      = (() -> Kind) -> (Kind -> Maybe ()) -> Prism Kind Kind () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Kind
    reviewer Kind -> Maybe ()
    remitter
      where
          reviewer :: () -> Kind
    reviewer () = Kind
    WildCardT
          remitter :: Kind -> Maybe ()
    remitter WildCardT = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,15,0)
    _AppKindT :: Prism' Type (Type, Kind)
    _AppKindT :: p (Kind, Kind) (f (Kind, Kind)) -> p Kind (f Kind)
    _AppKindT
      = ((Kind, Kind) -> Kind)
    -> (Kind -> Maybe (Kind, Kind))
    -> Prism Kind Kind (Kind, Kind) (Kind, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Kind, Kind) -> Kind
    reviewer Kind -> Maybe (Kind, Kind)
    remitter
      where
          reviewer :: (Kind, Kind) -> Kind
    reviewer (x :: Kind
    x, y :: Kind
    y) = Kind -> Kind -> Kind
    AppKindT Kind
    x Kind
    y
          remitter :: Kind -> Maybe (Kind, Kind)
    remitter (AppKindT x :: Kind
    x y :: Kind
    y) = (Kind, Kind) -> Maybe (Kind, Kind)
    forall a. a -> Maybe a
    Just (Kind
    x, Kind
    y)
          remitter _ = Maybe (Kind, Kind)
    forall a. Maybe a
    Nothing

    _ImplicitParamT :: Prism' Type (String, Type)
    _ImplicitParamT :: p (String, Kind) (f (String, Kind)) -> p Kind (f Kind)
    _ImplicitParamT
      = ((String, Kind) -> Kind)
    -> (Kind -> Maybe (String, Kind))
    -> Prism Kind Kind (String, Kind) (String, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (String, Kind) -> Kind
    reviewer Kind -> Maybe (String, Kind)
    remitter
      where
          reviewer :: (String, Kind) -> Kind
    reviewer (x :: String
    x, y :: Kind
    y) = String -> Kind -> Kind
    ImplicitParamT String
    x Kind
    y
          remitter :: Kind -> Maybe (String, Kind)
    remitter (ImplicitParamT x :: String
    x y :: Kind
    y) = (String, Kind) -> Maybe (String, Kind)
    forall a. a -> Maybe a
    Just (String
    x, Kind
    y)
          remitter _ = Maybe (String, Kind)
    forall a. Maybe a
    Nothing
    #endif

    _PlainTV :: Prism' TyVarBndr Name
    _PlainTV :: p Name (f Name) -> p TyVarBndr (f TyVarBndr)
    _PlainTV
      = (Name -> TyVarBndr)
    -> (TyVarBndr -> Maybe Name) -> Prism TyVarBndr TyVarBndr Name Name
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Name -> TyVarBndr
    reviewer TyVarBndr -> Maybe Name
    remitter
      where
          reviewer :: Name -> TyVarBndr
    reviewer = Name -> TyVarBndr
    PlainTV
          remitter :: TyVarBndr -> Maybe Name
    remitter (PlainTV x :: Name
    x) = Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    x
          remitter _ = Maybe Name
    forall a. Maybe a
    Nothing

    _KindedTV :: Prism' TyVarBndr (Name, Kind)
    _KindedTV :: p (Name, Kind) (f (Name, Kind)) -> p TyVarBndr (f TyVarBndr)
    _KindedTV
      = ((Name, Kind) -> TyVarBndr)
    -> (TyVarBndr -> Maybe (Name, Kind))
    -> Prism TyVarBndr TyVarBndr (Name, Kind) (Name, Kind)
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' (Name, Kind) -> TyVarBndr
    reviewer TyVarBndr -> Maybe (Name, Kind)
    remitter
      where
          reviewer :: (Name, Kind) -> TyVarBndr
    reviewer (x :: Name
    x, y :: Kind
    y) = Name -> Kind -> TyVarBndr
    KindedTV Name
    x Kind
    y
          remitter :: TyVarBndr -> Maybe (Name, Kind)
    remitter (KindedTV x :: Name
    x y :: Kind
    y) = (Name, Kind) -> Maybe (Name, Kind)
    forall a. a -> Maybe a
    Just (Name
    x, Kind
    y)
          remitter _ = Maybe (Name, Kind)
    forall a. Maybe a
    Nothing

    #if MIN_VERSION_template_haskell(2,11,0)
    _NoSig :: Prism' FamilyResultSig ()
    _NoSig :: p () (f ()) -> p FamilyResultSig (f FamilyResultSig)
    _NoSig
      = (() -> FamilyResultSig)
    -> (FamilyResultSig -> Maybe ())
    -> Prism FamilyResultSig FamilyResultSig () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> FamilyResultSig
    reviewer FamilyResultSig -> Maybe ()
    remitter
      where
          reviewer :: () -> FamilyResultSig
    reviewer () = FamilyResultSig
    NoSig
          remitter :: FamilyResultSig -> Maybe ()
    remitter NoSig = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _KindSig :: Prism' FamilyResultSig Kind
    _KindSig :: p Kind (f Kind) -> p FamilyResultSig (f FamilyResultSig)
    _KindSig
      = (Kind -> FamilyResultSig)
    -> (FamilyResultSig -> Maybe Kind)
    -> Prism FamilyResultSig FamilyResultSig Kind Kind
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Kind -> FamilyResultSig
    reviewer FamilyResultSig -> Maybe Kind
    remitter
      where
          reviewer :: Kind -> FamilyResultSig
    reviewer = Kind -> FamilyResultSig
    KindSig
          remitter :: FamilyResultSig -> Maybe Kind
    remitter (KindSig x :: Kind
    x) = Kind -> Maybe Kind
    forall a. a -> Maybe a
    Just Kind
    x
          remitter _ = Maybe Kind
    forall a. Maybe a
    Nothing

    _TyVarSig :: Prism' FamilyResultSig TyVarBndr
    _TyVarSig :: p TyVarBndr (f TyVarBndr) -> p FamilyResultSig (f FamilyResultSig)
    _TyVarSig
      = (TyVarBndr -> FamilyResultSig)
    -> (FamilyResultSig -> Maybe TyVarBndr)
    -> Prism FamilyResultSig FamilyResultSig TyVarBndr TyVarBndr
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' TyVarBndr -> FamilyResultSig
    reviewer FamilyResultSig -> Maybe TyVarBndr
    remitter
      where
          reviewer :: TyVarBndr -> FamilyResultSig
    reviewer = TyVarBndr -> FamilyResultSig
    TyVarSig
          remitter :: FamilyResultSig -> Maybe TyVarBndr
    remitter (TyVarSig x :: TyVarBndr
    x) = TyVarBndr -> Maybe TyVarBndr
    forall a. a -> Maybe a
    Just TyVarBndr
    x
          remitter _ = Maybe TyVarBndr
    forall a. Maybe a
    Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,8,0)
    _NumTyLit :: Prism' TyLit Integer
    _NumTyLit :: p Integer (f Integer) -> p TyLit (f TyLit)
    _NumTyLit
      = (Integer -> TyLit)
    -> (TyLit -> Maybe Integer) -> Prism TyLit TyLit Integer Integer
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' Integer -> TyLit
    reviewer TyLit -> Maybe Integer
    remitter
      where
          reviewer :: Integer -> TyLit
    reviewer = Integer -> TyLit
    NumTyLit
          remitter :: TyLit -> Maybe Integer
    remitter (NumTyLit x :: Integer
    x) = Integer -> Maybe Integer
    forall a. a -> Maybe a
    Just Integer
    x
          remitter _ = Maybe Integer
    forall a. Maybe a
    Nothing

    _StrTyLit :: Prism' TyLit String
    _StrTyLit :: p String (f String) -> p TyLit (f TyLit)
    _StrTyLit
      = (String -> TyLit)
    -> (TyLit -> Maybe String) -> Prism TyLit TyLit String String
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' String -> TyLit
    reviewer TyLit -> Maybe String
    remitter
      where
          reviewer :: String -> TyLit
    reviewer = String -> TyLit
    StrTyLit
          remitter :: TyLit -> Maybe String
    remitter (StrTyLit x :: String
    x) = String -> Maybe String
    forall a. a -> Maybe a
    Just String
    x
          remitter _ = Maybe String
    forall a. Maybe a
    Nothing
    #endif

    #if !MIN_VERSION_template_haskell(2,10,0)
    _ClassP :: Prism' Pred (Name, [Type])
    _ClassP
      = prism' reviewer remitter
      where
          reviewer (x, y) = ClassP x y
          remitter (ClassP x y) = Just (x, y)
          remitter _ = Nothing

    _EqualP :: Prism' Pred (Type, Type)
    _EqualP
      = prism' reviewer remitter
      where
          reviewer (x, y) = EqualP x y
          remitter (EqualP x y) = Just (x, y)
          remitter _ = Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,9,0)
    _NominalR :: Prism' Role ()
    _NominalR :: p () (f ()) -> p Role (f Role)
    _NominalR
      = (() -> Role) -> (Role -> Maybe ()) -> Prism Role Role () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Role
    reviewer Role -> Maybe ()
    remitter
      where
          reviewer :: () -> Role
    reviewer () = Role
    NominalR
          remitter :: Role -> Maybe ()
    remitter NominalR = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _RepresentationalR :: Prism' Role ()
    _RepresentationalR :: p () (f ()) -> p Role (f Role)
    _RepresentationalR
      = (() -> Role) -> (Role -> Maybe ()) -> Prism Role Role () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Role
    reviewer Role -> Maybe ()
    remitter
      where
          reviewer :: () -> Role
    reviewer () = Role
    RepresentationalR
          remitter :: Role -> Maybe ()
    remitter RepresentationalR = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _PhantomR :: Prism' Role ()
    _PhantomR :: p () (f ()) -> p Role (f Role)
    _PhantomR
      = (() -> Role) -> (Role -> Maybe ()) -> Prism Role Role () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Role
    reviewer Role -> Maybe ()
    remitter
      where
          reviewer :: () -> Role
    reviewer () = Role
    PhantomR
          remitter :: Role -> Maybe ()
    remitter PhantomR = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _InferR :: Prism' Role ()
    _InferR :: p () (f ()) -> p Role (f Role)
    _InferR
      = (() -> Role) -> (Role -> Maybe ()) -> Prism Role Role () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> Role
    reviewer Role -> Maybe ()
    remitter
      where
          reviewer :: () -> Role
    reviewer () = Role
    InferR
          remitter :: Role -> Maybe ()
    remitter InferR = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing
    #endif

    #if MIN_VERSION_template_haskell(2,12,0)
    _StockStrategy :: Prism' DerivStrategy ()
    _StockStrategy :: p () (f ()) -> p DerivStrategy (f DerivStrategy)
    _StockStrategy
      = (() -> DerivStrategy)
    -> (DerivStrategy -> Maybe ())
    -> Prism DerivStrategy DerivStrategy () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> DerivStrategy
    reviewer DerivStrategy -> Maybe ()
    remitter
      where
          reviewer :: () -> DerivStrategy
    reviewer () = DerivStrategy
    StockStrategy
          remitter :: DerivStrategy -> Maybe ()
    remitter StockStrategy = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _AnyclassStrategy :: Prism' DerivStrategy ()
    _AnyclassStrategy :: p () (f ()) -> p DerivStrategy (f DerivStrategy)
    _AnyclassStrategy
      = (() -> DerivStrategy)
    -> (DerivStrategy -> Maybe ())
    -> Prism DerivStrategy DerivStrategy () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> DerivStrategy
    reviewer DerivStrategy -> Maybe ()
    remitter
      where
          reviewer :: () -> DerivStrategy
    reviewer () = DerivStrategy
    AnyclassStrategy
          remitter :: DerivStrategy -> Maybe ()
    remitter AnyclassStrategy = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing

    _NewtypeStrategy :: Prism' DerivStrategy ()
    _NewtypeStrategy :: p () (f ()) -> p DerivStrategy (f DerivStrategy)
    _NewtypeStrategy
      = (() -> DerivStrategy)
    -> (DerivStrategy -> Maybe ())
    -> Prism DerivStrategy DerivStrategy () ()
    forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
    prism' () -> DerivStrategy
    reviewer DerivStrategy -> Maybe ()
    remitter
      where
          reviewer :: () -> DerivStrategy
    reviewer () = DerivStrategy
    NewtypeStrategy
          remitter :: DerivStrategy -> Maybe ()
    remitter NewtypeStrategy = () -> Maybe ()
    forall a. a -> Maybe a
    Just ()
          remitter _ = Maybe ()
    forall a. Maybe a
    Nothing
    #endif