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