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

#include "lens-common.h"

-----------------------------------------------------------------------------
-- |
-- 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
  -- ** TySynEqn Lenses
# if MIN_VERSION_template_haskell(2,15,0)
  , tySynEqnLHS
# endif
  , tySynEqnPatterns
  , tySynEqnResult
  -- ** InjectivityAnn Lenses
  , injectivityAnnOutput
  , injectivityAnnInputs
  -- ** TypeFamilyHead Lenses
  , typeFamilyHeadName
  , typeFamilyHeadTyVarBndrs
  , typeFamilyHeadResultSig
  , typeFamilyHeadInjectivityAnn
  -- ** Bang Lenses
  , bangSourceUnpackedness
  , bangSourceStrictness
#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
  , _InfixD
  , _PragmaD
  , _DataInstD
  , _NewtypeInstD
  , _TySynInstD
  , _ClosedTypeFamilyD
  , _RoleAnnotD
  , _StandaloneDerivD
  , _DefaultSigD
  , _DataFamilyD
  , _OpenTypeFamilyD
#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,19,0)
  , _DefaultD
#endif
#if MIN_VERSION_template_haskell(2,20,0)
  , _TypeDataD
#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
  , _GadtC
  , _RecGadtC
#if MIN_VERSION_template_haskell(2,22,0)
  -- ** NamespaceSpecifier Prisms
  , _NoNamespaceSpecifier
  , _TypeNamespaceSpecifier
  , _DataNamespaceSpecifier
#endif
  -- ** Overlap Prisms
  ,_Overlappable
  ,_Overlapping
  ,_Overlaps
  ,_Incoherent
  -- ** SourceUnpackedness Prisms
  , _NoSourceUnpackedness
  , _SourceNoUnpack
  , _SourceUnpack
  -- ** SourceStrictness Prisms
  , _NoSourceStrictness
  , _SourceLazy
  , _SourceStrict
  -- ** DecidedStrictness Prisms
  , _DecidedLazy
  , _DecidedStrict
  , _DecidedUnpack
  -- ** Foreign Prisms
  , _ImportF
  , _ExportF
  -- ** Callconv Prisms
  , _CCall
  , _StdCall
  , _CApi
  , _Prim
  , _JavaScript
  -- ** Safety Prisms
  , _Unsafe
  , _Safe
  , _Interruptible
  -- ** Pragma Prisms
  , _InlineP
  , _SpecialiseP
  , _SpecialiseInstP
  , _RuleP
  , _AnnP
  , _LineP
#if MIN_VERSION_template_haskell(2,12,0)
  , _CompleteP
#endif
#if MIN_VERSION_template_haskell(2,19,0)
  , _OpaqueP
#endif
#if MIN_VERSION_template_haskell(2,22,0)
  , _SCCP
#endif
  -- ** Inline Prisms
  , _NoInline
  , _Inline
  , _Inlinable
  -- ** RuleMatch Prisms
  , _ConLike
  , _FunLike
  -- ** Phases Prisms
  , _AllPhases
  , _FromPhase
  , _BeforePhase
  -- ** RuleBndr Prisms
  , _RuleVar
  , _TypedRuleVar
  -- ** AnnTarget Prisms
  , _ModuleAnnotation
  , _TypeAnnotation
  , _ValueAnnotation
  -- ** 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
  , _LamCaseE
  , _TupE
  , _UnboxedTupE
#if MIN_VERSION_template_haskell(2,12,0)
  , _UnboxedSumE
#endif
  , _CondE
  , _MultiIfE
  , _LetE
  , _CaseE
  , _DoE
  , _CompE
  , _ArithSeqE
  , _ListE
  , _SigE
  , _RecConE
  , _RecUpdE
  , _StaticE
  , _UnboundVarE
#if MIN_VERSION_template_haskell(2,13,0)
  , _LabelE
#endif
#if MIN_VERSION_template_haskell(2,15,0)
  , _MDoE
  , _ImplicitParamVarE
#endif
#if MIN_VERSION_template_haskell(2,18,0)
  , _GetFieldE
  , _ProjectionE
#endif
#if MIN_VERSION_template_haskell(2,19,0)
  , _LamCasesE
#endif
#if MIN_VERSION_template_haskell(2,21,0)
  , _TypedBracketE
  , _TypedSpliceE
#endif
#if MIN_VERSION_template_haskell(2,22,0)
  , _TypeE
#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
  , _CharPrimL
#if MIN_VERSION_template_haskell(2,16,0)
  , _BytesPrimL
#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
#if MIN_VERSION_template_haskell(2,22,0)
  , _TypeP
  , _InvisP
#endif
  -- ** Type Prisms
  , _ForallT
  , _AppT
  , _SigT
  , _VarT
  , _ConT
  , _PromotedT
  , _TupleT
  , _UnboxedTupleT
#if MIN_VERSION_template_haskell(2,12,0)
  , _UnboxedSumT
#endif
  , _ArrowT
  , _EqualityT
  , _ListT
  , _PromotedTupleT
  , _PromotedNilT
  , _PromotedConsT
  , _StarT
  , _ConstraintT
  , _LitT
  , _InfixT
  , _UInfixT
  , _ParensT
  , _WildCardT
#if MIN_VERSION_template_haskell(2,15,0)
  , _AppKindT
  , _ImplicitParamT
#endif
#if MIN_VERSION_template_haskell(2,16,0)
  , _ForallVisT
#endif
#if MIN_VERSION_template_haskell(2,17,0)
  , _MulArrowT
#endif
#if MIN_VERSION_template_haskell(2,19,0)
  , _PromotedInfixT
  , _PromotedUInfixT
#endif
#if MIN_VERSION_template_haskell(2,17,0)
  -- ** Specificity Prisms
  , _SpecifiedSpec
  , _InferredSpec
#endif
#if MIN_VERSION_template_haskell(2,21,0)
  -- ** BndrVis Prisms
  , _BndrReq
  , _BndrInvis
#endif
  -- ** TyVarBndr Prisms
  , _PlainTV
  , _KindedTV
  -- ** FamilyResultSig Prisms
  , _NoSig
  , _KindSig
  , _TyVarSig
  -- ** TyLit Prisms
  , _NumTyLit
  , _StrTyLit
#if MIN_VERSION_template_haskell(2,18,0)
  , _CharTyLit
#endif
  -- ** Role Prisms
  , _NominalR
  , _RepresentationalR
  , _PhantomR
  , _InferR
#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.Internal.TH
import Control.Lens.Iso (Iso', iso)
import Control.Lens.Lens
import Control.Lens.Prism
import Control.Lens.Tuple
import Control.Lens.Traversal
import qualified Data.Map as Map
import Data.Map (Map)
import Data.Maybe (fromMaybe)
import Data.Monoid
import qualified Data.Set as Set
import Data.Set (Set)
import Data.Set.Lens
import Language.Haskell.TH
import Language.Haskell.TH.Datatype.TyVarBndr
import Language.Haskell.TH.Syntax
import Data.Word
#if MIN_VERSION_template_haskell(2,15,0)
import Data.Foldable as F (foldl')
#endif
#if MIN_VERSION_template_haskell(2,18,0)
import Data.List.NonEmpty (NonEmpty)
#endif
import Prelude

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

instance HasName (TyVarBndr_ flag) where
  name :: Lens' (TyVarBndr_ flag) Name
name = (Name -> f Name) -> TyVarBndr_ flag -> f (TyVarBndr_ flag)
forall (f :: * -> *) flag.
Functor f =>
(Name -> f Name) -> TyVarBndr_ flag -> f (TyVarBndr_ flag)
traverseTVName

instance HasName Name where
  name :: Lens' Name 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 :: Lens' Con Name
name Name -> f Name
f (NormalC Name
n [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 Name -> f Name
f (RecC Name
n [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 Name -> f Name
f (InfixC BangType
l Name
n BangType
r)        = (\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 Name -> f Name
f (ForallC [TyVarBndr Specificity]
bds Cxt
ctx Con
con) = [TyVarBndr Specificity] -> Cxt -> Con -> Con
ForallC [TyVarBndr Specificity]
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
Lens' Con Name
name Name -> f Name
f Con
con
  name Name -> f Name
f (GadtC [Name]
ns [BangType]
argTys Type
retTy) =
    (\Name
n -> [Name] -> [BangType] -> Type -> Con
GadtC [Name
n] [BangType]
argTys Type
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
headGadtConName [Name]
ns)
  name Name -> f Name
f (RecGadtC [Name]
ns [VarBangType]
argTys Type
retTy) =
    (\Name
n -> [Name] -> [VarBangType] -> Type -> Con
RecGadtC [Name
n] [VarBangType]
argTys Type
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
headGadtConName [Name]
ns)

-- @template-haskell@ maintains the invariant that the list of constructor
-- @Name@s in a 'GadtC' or 'RecGadtC' will always be non-empty.
headGadtConName :: [Name] -> Name
headGadtConName :: [Name] -> Name
headGadtConName [Name]
conNames =
  case [Name]
conNames of
    Name
conName:[Name]
_ -> Name
conName
    [] -> [Char] -> Name
forall a. HasCallStack => [Char] -> a
error [Char]
"headGadtConName: Unexpected empty list of GADT constructor names"

instance HasName Foreign where
  name :: Lens' Foreign Name
name Name -> f Name
f (ImportF Callconv
cc Safety
saf [Char]
str Name
n Type
ty) =
    (\Name
n' -> Callconv -> Safety -> [Char] -> Name -> Type -> Foreign
ImportF Callconv
cc Safety
saf [Char]
str Name
n' Type
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 Name -> f Name
f (ExportF Callconv
cc [Char]
str Name
n Type
ty) =
    (\Name
n' -> Callconv -> [Char] -> Name -> Type -> Foreign
ExportF Callconv
cc [Char]
str Name
n' Type
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

instance HasName RuleBndr where
  name :: Lens' RuleBndr Name
name Name -> f Name
f (RuleVar 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 Name -> f Name
f (TypedRuleVar Name
n Type
ty) = (Name -> Type -> RuleBndr
`TypedRuleVar` Type
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

instance HasName TypeFamilyHead where
  name :: Lens' TypeFamilyHead Name
name Name -> f Name
f (TypeFamilyHead Name
n [TyVarBndr ()]
tvbs FamilyResultSig
frs Maybe InjectivityAnn
mia) =
    (\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 :: Lens' InjectivityAnn Name
name Name -> f Name
f (InjectivityAnn Name
n [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

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

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

instance HasTypes Con where
  types :: Traversal' Con Type
types Type -> f Type
f (NormalC Name
n [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)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((Type -> f Type) -> BangType -> f BangType
forall s t a b. Field2 s t a b => Lens s t a b
Lens BangType BangType Type Type
_2 ((Type -> f Type) -> Type -> f Type
forall t. HasTypes t => Traversal' t Type
Traversal' Type Type
types Type -> f Type
f)) [BangType]
t
  types Type -> f Type
f (RecC Name
n [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)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((Type -> f Type) -> VarBangType -> f VarBangType
forall s t a b. Field3 s t a b => Lens s t a b
Lens VarBangType VarBangType Type Type
_3 ((Type -> f Type) -> Type -> f Type
forall t. HasTypes t => Traversal' t Type
Traversal' Type Type
types Type -> f Type
f)) [VarBangType]
t
  types Type -> f Type
f (InfixC BangType
t1 Name
n 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
<$> (Type -> f Type) -> BangType -> f BangType
forall s t a b. Field2 s t a b => Lens s t a b
Lens BangType BangType Type Type
_2 ((Type -> f Type) -> Type -> f Type
forall t. HasTypes t => Traversal' t Type
Traversal' Type Type
types Type -> f Type
f) BangType
t1
                                       f (Name -> BangType -> Con) -> f Name -> f (BangType -> Con)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Name -> f Name
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Name
n f (BangType -> Con) -> f BangType -> f Con
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Type -> f Type) -> BangType -> f BangType
forall s t a b. Field2 s t a b => Lens s t a b
Lens BangType BangType Type Type
_2 ((Type -> f Type) -> Type -> f Type
forall t. HasTypes t => Traversal' t Type
Traversal' Type Type
types Type -> f Type
f) BangType
t2
  types Type -> f Type
f (ForallC [TyVarBndr Specificity]
vb Cxt
ctx Con
con)    = [TyVarBndr Specificity] -> Cxt -> Con -> Con
ForallC [TyVarBndr Specificity]
vb Cxt
ctx (Con -> Con) -> f Con -> f Con
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Type -> f Type) -> Con -> f Con
forall t. HasTypes t => Traversal' t Type
Traversal' Con Type
types Type -> f Type
f Con
con
  types Type -> f Type
f (GadtC [Name]
ns [BangType]
argTys Type
retTy) =
    [Name] -> [BangType] -> Type -> Con
GadtC    [Name]
ns ([BangType] -> Type -> Con) -> f [BangType] -> f (Type -> 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)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((Type -> f Type) -> BangType -> f BangType
forall s t a b. Field2 s t a b => Lens s t a b
Lens BangType BangType Type Type
_2 ((Type -> f Type) -> Type -> f Type
forall t. HasTypes t => Traversal' t Type
Traversal' Type Type
types Type -> f Type
f)) [BangType]
argTys f (Type -> Con) -> f Type -> f Con
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Type -> f Type) -> Type -> f Type
forall t. HasTypes t => Traversal' t Type
Traversal' Type Type
types Type -> f Type
f Type
retTy
  types Type -> f Type
f (RecGadtC [Name]
ns [VarBangType]
argTys Type
retTy) =
    [Name] -> [VarBangType] -> Type -> Con
RecGadtC [Name]
ns ([VarBangType] -> Type -> Con)
-> f [VarBangType] -> f (Type -> 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)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((Type -> f Type) -> VarBangType -> f VarBangType
forall s t a b. Field3 s t a b => Lens s t a b
Lens VarBangType VarBangType Type Type
_3 ((Type -> f Type) -> Type -> f Type
forall t. HasTypes t => Traversal' t Type
Traversal' Type Type
types Type -> f Type
f)) [VarBangType]
argTys f (Type -> Con) -> f Type -> f Con
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Type -> f Type) -> Type -> f Type
forall t. HasTypes t => Traversal' t Type
Traversal' Type Type
types Type -> f Type
f Type
retTy

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

instance HasTypes TySynEqn where
#if MIN_VERSION_template_haskell(2,15,0)
  types :: Traversal' TySynEqn Type
types Type -> f Type
f (TySynEqn Maybe [TyVarBndr ()]
mtvbs Type
lhs Type
rhs) = Maybe [TyVarBndr ()] -> Type -> Type -> TySynEqn
TySynEqn (Maybe [TyVarBndr ()] -> Type -> Type -> TySynEqn)
-> f (Maybe [TyVarBndr ()]) -> f (Type -> Type -> 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)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe 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)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse TyVarBndr () -> f (TyVarBndr ())
forall {flag}. TyVarBndr_ flag -> f (TyVarBndr_ flag)
go) Maybe [TyVarBndr ()]
mtvbs
                                              f (Type -> Type -> TySynEqn) -> f Type -> f (Type -> TySynEqn)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Type -> f Type) -> Type -> f Type
forall t. HasTypes t => Traversal' t Type
Traversal' Type Type
types Type -> f Type
f Type
lhs
                                              f (Type -> TySynEqn) -> f Type -> f TySynEqn
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Type -> f Type) -> Type -> f Type
forall t. HasTypes t => Traversal' t Type
Traversal' Type Type
types Type -> f Type
f Type
rhs
    where
      go :: TyVarBndr_ flag -> f (TyVarBndr_ flag)
go = (Type -> f Type) -> TyVarBndr_ flag -> f (TyVarBndr_ flag)
forall (f :: * -> *) flag.
Applicative f =>
(Type -> f Type) -> TyVarBndr_ flag -> f (TyVarBndr_ flag)
traverseTVKind Type -> f Type
f
#else
  types f (TySynEqn lhss rhs) = TySynEqn <$> traverse (types f) lhss
                                         <*> types f rhs
#endif

instance HasTypes t => HasTypes [t] where
  types :: Traversal' [t] Type
types = (t -> f t) -> [t] -> f [t]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((t -> f t) -> [t] -> f [t])
-> ((Type -> f Type) -> t -> f t)
-> (Type -> f Type)
-> [t]
-> f [t]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Type -> f Type) -> t -> f t
forall t. HasTypes t => Traversal' t Type
Traversal' t Type
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_ flag) where
  typeVarsEx :: Set Name -> Traversal' (TyVarBndr_ flag) Name
typeVarsEx Set Name
s Name -> f Name
f TyVarBndr_ flag
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_ flag
bTyVarBndr_ flag -> Getting Name (TyVarBndr_ flag) Name -> Name
forall s a. s -> Getting a s a -> a
^.Getting Name (TyVarBndr_ flag) Name
forall t. HasName t => Lens' t Name
Lens' (TyVarBndr_ flag) Name
name) = TyVarBndr_ flag -> f (TyVarBndr_ flag)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TyVarBndr_ flag
b
    | Bool
otherwise             = (Name -> f Name) -> TyVarBndr_ flag -> f (TyVarBndr_ flag)
forall t. HasName t => Lens' t Name
Lens' (TyVarBndr_ flag) Name
name Name -> f Name
f TyVarBndr_ flag
b

instance HasTypeVars Name where
  typeVarsEx :: Set Name -> Traversal' Name Name
typeVarsEx Set Name
s Name -> f Name
f 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 a. a -> f a
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' Type Name
typeVarsEx Set Name
s Name -> f Name
f (VarT Name
n)             = Name -> Type
VarT (Name -> Type) -> f Name -> f Type
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Name -> Traversal' Name Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f Name
n
  typeVarsEx Set Name
s Name -> f Name
f (AppT Type
l Type
r)           = Type -> Type -> Type
AppT (Type -> Type -> Type) -> f Type -> f (Type -> Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f Type
l f (Type -> Type) -> f Type -> f Type
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f Type
r
  typeVarsEx Set Name
s Name -> f Name
f (ForallT [TyVarBndr Specificity]
bs Cxt
ctx Type
ty)  = [TyVarBndr Specificity] -> Cxt -> Type -> Type
ForallT [TyVarBndr Specificity]
bs (Cxt -> Type -> Type) -> f Cxt -> f (Type -> Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Name -> Traversal' Cxt Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s' Name -> f Name
f Cxt
ctx f (Type -> Type) -> f Type -> f Type
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s' Name -> f Name
f Type
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 Specificity] Name
-> [TyVarBndr Specificity] -> Set Name
forall a s. Getting (Set a) s a -> s -> Set a
setOf Getting (Set Name) [TyVarBndr Specificity] Name
forall t. HasTypeVars t => Traversal' t Name
Traversal' [TyVarBndr Specificity] Name
typeVars [TyVarBndr Specificity]
bs
  typeVarsEx Set Name
_ Name -> f Name
_ t :: Type
t@ConT{}             = Type -> f Type
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
t
  typeVarsEx Set Name
_ Name -> f Name
_ t :: Type
t@TupleT{}           = Type -> f Type
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
t
  typeVarsEx Set Name
_ Name -> f Name
_ t :: Type
t@ListT{}            = Type -> f Type
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
t
  typeVarsEx Set Name
_ Name -> f Name
_ t :: Type
t@ArrowT{}           = Type -> f Type
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
t
  typeVarsEx Set Name
_ Name -> f Name
_ t :: Type
t@UnboxedTupleT{}    = Type -> f Type
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
t
  typeVarsEx Set Name
s Name -> f Name
f (SigT Type
t Type
k)           = Type -> Type -> Type
SigT (Type -> Type -> Type) -> f Type -> f (Type -> Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f Type
t
                                             f (Type -> Type) -> f Type -> f Type
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f Type
k
  typeVarsEx Set Name
_ Name -> f Name
_ t :: Type
t@PromotedT{}        = Type -> f Type
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
t
  typeVarsEx Set Name
_ Name -> f Name
_ t :: Type
t@PromotedTupleT{}   = Type -> f Type
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
t
  typeVarsEx Set Name
_ Name -> f Name
_ t :: Type
t@PromotedNilT{}     = Type -> f Type
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
t
  typeVarsEx Set Name
_ Name -> f Name
_ t :: Type
t@PromotedConsT{}    = Type -> f Type
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
t
  typeVarsEx Set Name
_ Name -> f Name
_ t :: Type
t@StarT{}            = Type -> f Type
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
t
  typeVarsEx Set Name
_ Name -> f Name
_ t :: Type
t@ConstraintT{}      = Type -> f Type
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
t
  typeVarsEx Set Name
_ Name -> f Name
_ t :: Type
t@LitT{}             = Type -> f Type
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
t
  typeVarsEx Set Name
_ Name -> f Name
_ t :: Type
t@EqualityT{}        = Type -> f Type
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
t
  typeVarsEx Set Name
s Name -> f Name
f (InfixT  Type
t1 Name
n Type
t2)    = Type -> Name -> Type -> Type
InfixT  (Type -> Name -> Type -> Type)
-> f Type -> f (Name -> Type -> Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f Type
t1
                                                f (Name -> Type -> Type) -> f Name -> f (Type -> Type)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Name -> f Name
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Name
n
                                                f (Type -> Type) -> f Type -> f Type
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f Type
t2
  typeVarsEx Set Name
s Name -> f Name
f (UInfixT Type
t1 Name
n Type
t2)    = Type -> Name -> Type -> Type
UInfixT (Type -> Name -> Type -> Type)
-> f Type -> f (Name -> Type -> Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f Type
t1
                                                f (Name -> Type -> Type) -> f Name -> f (Type -> Type)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Name -> f Name
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Name
n
                                                f (Type -> Type) -> f Type -> f Type
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f Type
t2
  typeVarsEx Set Name
s Name -> f Name
f (ParensT Type
t)          = Type -> Type
ParensT (Type -> Type) -> f Type -> f Type
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f Type
t
  typeVarsEx Set Name
_ Name -> f Name
_ t :: Type
t@WildCardT{}        = Type -> f Type
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
t
#if MIN_VERSION_template_haskell(2,12,0)
  typeVarsEx Set Name
_ Name -> f Name
_ t :: Type
t@UnboxedSumT{}      = Type -> f Type
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
t
#endif
#if MIN_VERSION_template_haskell(2,15,0)
  typeVarsEx Set Name
s Name -> f Name
f (AppKindT Type
t Type
k)       = Type -> Type -> Type
AppKindT (Type -> Type -> Type) -> f Type -> f (Type -> Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f Type
t
                                                 f (Type -> Type) -> f Type -> f Type
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f Type
k
  typeVarsEx Set Name
s Name -> f Name
f (ImplicitParamT [Char]
n Type
t) = [Char] -> Type -> Type
ImplicitParamT [Char]
n (Type -> Type) -> f Type -> f Type
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f Type
t
#endif
#if MIN_VERSION_template_haskell(2,16,0)
  typeVarsEx Set Name
s Name -> f Name
f (ForallVisT [TyVarBndr ()]
bs Type
ty)   = [TyVarBndr ()] -> Type -> Type
ForallVisT [TyVarBndr ()]
bs (Type -> Type) -> f Type -> f Type
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s' Name -> f Name
f Type
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
Traversal' [TyVarBndr ()] Name
typeVars [TyVarBndr ()]
bs
#endif
#if MIN_VERSION_template_haskell(2,17,0)
  typeVarsEx Set Name
_ Name -> f Name
_ t :: Type
t@MulArrowT{}        = Type -> f Type
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
t
#endif
#if MIN_VERSION_template_haskell(2,19,0)
  typeVarsEx Set Name
s Name -> f Name
f (PromotedInfixT  Type
t1 Name
n Type
t2) = Type -> Name -> Type -> Type
PromotedInfixT  (Type -> Name -> Type -> Type)
-> f Type -> f (Name -> Type -> Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f Type
t1
                                                             f (Name -> Type -> Type) -> f Name -> f (Type -> Type)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Name -> f Name
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Name
n
                                                             f (Type -> Type) -> f Type -> f Type
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f Type
t2
  typeVarsEx Set Name
s Name -> f Name
f (PromotedUInfixT Type
t1 Name
n Type
t2) = Type -> Name -> Type -> Type
PromotedUInfixT (Type -> Name -> Type -> Type)
-> f Type -> f (Name -> Type -> Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f Type
t1
                                                             f (Name -> Type -> Type) -> f Name -> f (Type -> Type)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Name -> f Name
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Name
n
                                                             f (Type -> Type) -> f Type -> f Type
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f Type
t2
#endif

instance HasTypeVars Con where
  typeVarsEx :: Set Name -> Traversal' Con Name
typeVarsEx Set Name
s Name -> f Name
f (NormalC Name
n [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] Type Type
-> LensLike f [BangType] [BangType] Type Type
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)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((BangType -> f BangType) -> [BangType] -> f [BangType])
-> ((Type -> f Type) -> BangType -> f BangType)
-> LensLike f [BangType] [BangType] Type Type
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Type -> f Type) -> BangType -> f BangType
forall s t a b. Field2 s t a b => Lens s t a b
Lens BangType BangType Type Type
_2) (Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f) [BangType]
ts
  typeVarsEx Set Name
s Name -> f Name
f (RecC Name
n [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] Type Type
-> LensLike f [VarBangType] [VarBangType] Type Type
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)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((VarBangType -> f VarBangType)
 -> [VarBangType] -> f [VarBangType])
-> ((Type -> f Type) -> VarBangType -> f VarBangType)
-> LensLike f [VarBangType] [VarBangType] Type Type
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Type -> f Type) -> VarBangType -> f VarBangType
forall s t a b. Field3 s t a b => Lens s t a b
Lens VarBangType VarBangType Type Type
_3) (Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f) [VarBangType]
ts
  typeVarsEx Set Name
s Name -> f Name
f (InfixC BangType
l Name
n 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 {a} {a}. HasTypeVars a => (a, a) -> f (a, a)
g BangType
l f (Name -> BangType -> Con) -> f Name -> f (BangType -> Con)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Name -> f Name
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Name
n f (BangType -> Con) -> f BangType -> f Con
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> BangType -> f BangType
forall {a} {a}. HasTypeVars a => (a, a) -> f (a, a)
g BangType
r
       where g :: (a, a) -> f (a, a)
g (a
i, a
t) = (,) a
i (a -> (a, a)) -> f a -> f (a, a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Name -> Traversal' a Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f a
t
  typeVarsEx Set Name
s Name -> f Name
f (ForallC [TyVarBndr Specificity]
bs Cxt
ctx Con
c) = [TyVarBndr Specificity] -> Cxt -> Con -> Con
ForallC [TyVarBndr Specificity]
bs (Cxt -> Con -> Con) -> f Cxt -> f (Con -> Con)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set Name -> Traversal' Cxt Name
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 a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set Name -> Traversal' Con Name
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 Specificity] Name
-> [TyVarBndr Specificity] -> Set Name
forall a s. Getting (Set a) s a -> s -> Set a
setOf Getting (Set Name) [TyVarBndr Specificity] Name
forall t. HasTypeVars t => Traversal' t Name
Traversal' [TyVarBndr Specificity] Name
typeVars [TyVarBndr Specificity]
bs
  typeVarsEx Set Name
s Name -> f Name
f (GadtC [Name]
ns [BangType]
argTys Type
retTy) =
    [Name] -> [BangType] -> Type -> Con
GadtC [Name]
ns ([BangType] -> Type -> Con) -> f [BangType] -> f (Type -> Con)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LensLike f [BangType] [BangType] Type Type
-> LensLike f [BangType] [BangType] Type Type
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)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((BangType -> f BangType) -> [BangType] -> f [BangType])
-> ((Type -> f Type) -> BangType -> f BangType)
-> LensLike f [BangType] [BangType] Type Type
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Type -> f Type) -> BangType -> f BangType
forall s t a b. Field2 s t a b => Lens s t a b
Lens BangType BangType Type Type
_2) (Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f) [BangType]
argTys
             f (Type -> Con) -> f Type -> f Con
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f Type
retTy
  typeVarsEx Set Name
s Name -> f Name
f (RecGadtC [Name]
ns [VarBangType]
argTys Type
retTy) =
    [Name] -> [VarBangType] -> Type -> Con
RecGadtC [Name]
ns ([VarBangType] -> Type -> Con)
-> f [VarBangType] -> f (Type -> Con)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LensLike f [VarBangType] [VarBangType] Type Type
-> LensLike f [VarBangType] [VarBangType] Type Type
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)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((VarBangType -> f VarBangType)
 -> [VarBangType] -> f [VarBangType])
-> ((Type -> f Type) -> VarBangType -> f VarBangType)
-> LensLike f [VarBangType] [VarBangType] Type Type
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Type -> f Type) -> VarBangType -> f VarBangType
forall s t a b. Field3 s t a b => Lens s t a b
Lens VarBangType VarBangType Type Type
_3) (Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f) [VarBangType]
argTys
                f (Type -> Con) -> f Type -> f Con
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set Name -> Traversal' Type Name
forall t. HasTypeVars t => Set Name -> Traversal' t Name
typeVarsEx Set Name
s Name -> f Name
f Type
retTy

instance HasTypeVars t => HasTypeVars [t] where
  typeVarsEx :: Set Name -> Traversal' [t] Name
typeVarsEx 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)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [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 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)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe 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 :: forall t. HasTypeVars t => 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 :: forall t. HasTypeVars t => Map Name Name -> t -> t
substTypeVars 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
Traversal' t Name
typeVars ((Name -> Name) -> t -> t) -> (Name -> Name) -> t -> t
forall a b. (a -> b) -> a -> b
$ \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 Type -> Type -> Type
substType Map Name Type
m t :: Type
t@(VarT Name
n)           = Type -> Maybe Type -> Type
forall a. a -> Maybe a -> a
fromMaybe Type
t (Map Name Type
mMap Name Type
-> Getting (Maybe Type) (Map Name Type) (Maybe Type) -> Maybe Type
forall s a. s -> Getting a s a -> a
^.Index (Map Name Type)
-> Lens' (Map Name Type) (Maybe (IxValue (Map Name Type)))
forall m. At m => Index m -> Lens' m (Maybe (IxValue m))
at Name
Index (Map Name Type)
n)
  substType Map Name Type
m (ForallT [TyVarBndr Specificity]
bs Cxt
ctx Type
ty)  = [TyVarBndr Specificity] -> Cxt -> Type -> Type
ForallT [TyVarBndr Specificity]
bs (Map Name Type -> Cxt -> Cxt
forall t. SubstType t => Map Name Type -> t -> t
substType Map Name Type
m' Cxt
ctx) (Map Name Type -> Type -> Type
forall t. SubstType t => Map Name Type -> t -> t
substType Map Name Type
m' Type
ty)
    where m' :: Map Name Type
m' = Getting (Endo (Map Name Type)) [TyVarBndr Specificity] Name
-> (Name -> Map Name Type -> Map Name Type)
-> Map Name Type
-> [TyVarBndr Specificity]
-> Map Name Type
forall r s a. Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
foldrOf Getting (Endo (Map Name Type)) [TyVarBndr Specificity] Name
forall t. HasTypeVars t => Traversal' t Name
Traversal' [TyVarBndr Specificity] Name
typeVars Name -> Map Name Type -> Map Name Type
forall k a. Ord k => k -> Map k a -> Map k a
Map.delete Map Name Type
m [TyVarBndr Specificity]
bs
  substType Map Name Type
_ t :: Type
t@ConT{}             = Type
t
  substType Map Name Type
_ t :: Type
t@TupleT{}           = Type
t
  substType Map Name Type
_ t :: Type
t@ListT{}            = Type
t
  substType Map Name Type
_ t :: Type
t@ArrowT{}           = Type
t
  substType Map Name Type
_ t :: Type
t@UnboxedTupleT{}    = Type
t
  substType Map Name Type
m (AppT Type
l Type
r)           = Type -> Type -> Type
AppT (Map Name Type -> Type -> Type
forall t. SubstType t => Map Name Type -> t -> t
substType Map Name Type
m Type
l) (Map Name Type -> Type -> Type
forall t. SubstType t => Map Name Type -> t -> t
substType Map Name Type
m Type
r)
  substType Map Name Type
m (SigT Type
t Type
k)           = Type -> Type -> Type
SigT (Map Name Type -> Type -> Type
forall t. SubstType t => Map Name Type -> t -> t
substType Map Name Type
m Type
t)
                                          (Map Name Type -> Type -> Type
forall t. SubstType t => Map Name Type -> t -> t
substType Map Name Type
m Type
k)
  substType Map Name Type
_ t :: Type
t@PromotedT{}        = Type
t
  substType Map Name Type
_ t :: Type
t@PromotedTupleT{}   = Type
t
  substType Map Name Type
_ t :: Type
t@PromotedNilT{}     = Type
t
  substType Map Name Type
_ t :: Type
t@PromotedConsT{}    = Type
t
  substType Map Name Type
_ t :: Type
t@StarT{}            = Type
t
  substType Map Name Type
_ t :: Type
t@ConstraintT{}      = Type
t
  substType Map Name Type
_ t :: Type
t@LitT{}             = Type
t
  substType Map Name Type
_ t :: Type
t@EqualityT{}        = Type
t
  substType Map Name Type
m (InfixT  Type
t1 Name
n Type
t2)    = Type -> Name -> Type -> Type
InfixT  (Map Name Type -> Type -> Type
forall t. SubstType t => Map Name Type -> t -> t
substType Map Name Type
m Type
t1) Name
n (Map Name Type -> Type -> Type
forall t. SubstType t => Map Name Type -> t -> t
substType Map Name Type
m Type
t2)
  substType Map Name Type
m (UInfixT Type
t1 Name
n Type
t2)    = Type -> Name -> Type -> Type
UInfixT (Map Name Type -> Type -> Type
forall t. SubstType t => Map Name Type -> t -> t
substType Map Name Type
m Type
t1) Name
n (Map Name Type -> Type -> Type
forall t. SubstType t => Map Name Type -> t -> t
substType Map Name Type
m Type
t2)
  substType Map Name Type
m (ParensT Type
t)          = Type -> Type
ParensT (Map Name Type -> Type -> Type
forall t. SubstType t => Map Name Type -> t -> t
substType Map Name Type
m Type
t)
  substType Map Name Type
_ t :: Type
t@WildCardT{}        = Type
t
#if MIN_VERSION_template_haskell(2,12,0)
  substType Map Name Type
_ t :: Type
t@UnboxedSumT{}      = Type
t
#endif
#if MIN_VERSION_template_haskell(2,15,0)
  substType Map Name Type
m (AppKindT Type
t Type
k)       = Type -> Type -> Type
AppKindT (Map Name Type -> Type -> Type
forall t. SubstType t => Map Name Type -> t -> t
substType Map Name Type
m Type
t) (Map Name Type -> Type -> Type
forall t. SubstType t => Map Name Type -> t -> t
substType Map Name Type
m Type
k)
  substType Map Name Type
m (ImplicitParamT [Char]
n Type
t) = [Char] -> Type -> Type
ImplicitParamT [Char]
n (Map Name Type -> Type -> Type
forall t. SubstType t => Map Name Type -> t -> t
substType Map Name Type
m Type
t)
#endif
#if MIN_VERSION_template_haskell(2,16,0)
  substType Map Name Type
m (ForallVisT [TyVarBndr ()]
bs Type
ty)   = [TyVarBndr ()] -> Type -> Type
ForallVisT [TyVarBndr ()]
bs (Map Name Type -> Type -> Type
forall t. SubstType t => Map Name Type -> t -> t
substType Map Name Type
m' Type
ty)
    where m' :: Map Name Type
m' = Getting (Endo (Map Name Type)) [TyVarBndr ()] Name
-> (Name -> Map Name Type -> Map Name Type)
-> Map Name Type
-> [TyVarBndr ()]
-> Map Name Type
forall r s a. Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
foldrOf Getting (Endo (Map Name Type)) [TyVarBndr ()] Name
forall t. HasTypeVars t => Traversal' t Name
Traversal' [TyVarBndr ()] Name
typeVars Name -> Map Name Type -> Map Name Type
forall k a. Ord k => k -> Map k a -> Map k a
Map.delete Map Name Type
m [TyVarBndr ()]
bs
#endif
#if MIN_VERSION_template_haskell(2,17,0)
  substType Map Name Type
_ t :: Type
t@MulArrowT{}        = Type
t
#endif
#if MIN_VERSION_template_haskell(2,19,0)
  substType Map Name Type
m (PromotedInfixT  Type
t1 Name
n Type
t2) = Type -> Name -> Type -> Type
PromotedInfixT  (Map Name Type -> Type -> Type
forall t. SubstType t => Map Name Type -> t -> t
substType Map Name Type
m Type
t1) Name
n (Map Name Type -> Type -> Type
forall t. SubstType t => Map Name Type -> t -> t
substType Map Name Type
m Type
t2)
  substType Map Name Type
m (PromotedUInfixT Type
t1 Name
n Type
t2) = Type -> Name -> Type -> Type
PromotedUInfixT (Map Name Type -> Type -> Type
forall t. SubstType t => Map Name Type -> t -> t
substType Map Name Type
m Type
t1) Name
n (Map Name Type -> Type -> Type
forall t. SubstType t => Map Name Type -> t -> t
substType Map Name Type
m Type
t2)
#endif

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

-- | Provides a 'Traversal' of the types of each field of a constructor.
conFields :: Traversal' Con BangType
conFields :: Traversal' Con BangType
conFields BangType -> f BangType
f (NormalC Name
n [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)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse BangType -> f BangType
f [BangType]
fs
conFields BangType -> f BangType
f (RecC Name
n [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)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((BangType -> f BangType) -> VarBangType -> f VarBangType
Traversal' VarBangType BangType
sansVar BangType -> f BangType
f) [VarBangType]
fs
conFields BangType -> f BangType
f (InfixC BangType
l Name
n 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 a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Name -> f Name
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Name
n f (BangType -> Con) -> f BangType -> f Con
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> BangType -> f BangType
f BangType
r
conFields BangType -> f BangType
f (ForallC [TyVarBndr Specificity]
bds Cxt
ctx Con
c) = [TyVarBndr Specificity] -> Cxt -> Con -> Con
ForallC [TyVarBndr Specificity]
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
conFields BangType -> f BangType
f (GadtC [Name]
ns [BangType]
argTys Type
retTy) =
  [Name] -> [BangType] -> Type -> Con
GadtC [Name]
ns ([BangType] -> Type -> Con) -> f [BangType] -> f (Type -> 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)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse BangType -> f BangType
f [BangType]
argTys f (Type -> Con) -> f Type -> f Con
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Type -> f Type
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
retTy
conFields BangType -> f BangType
f (RecGadtC [Name]
ns [VarBangType]
argTys Type
retTy) =
  [Name] -> [VarBangType] -> Type -> Con
RecGadtC [Name]
ns ([VarBangType] -> Type -> Con)
-> f [VarBangType] -> f (Type -> 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)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((BangType -> f BangType) -> VarBangType -> f VarBangType
Traversal' VarBangType BangType
sansVar BangType -> f BangType
f) [VarBangType]
argTys f (Type -> Con) -> f Type -> f Con
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Type -> f Type
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
retTy

sansVar :: Traversal' VarBangType BangType
sansVar :: Traversal' VarBangType BangType
sansVar BangType -> f BangType
f (Name
fn,Bang
s,Type
t) = (\(Bang
s', Type
t') -> (Name
fn,Bang
s',Type
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, Type
t)

-- | 'Traversal' of the types of the /named/ fields of a constructor.
conNamedFields :: Traversal' Con VarBangType
conNamedFields :: Traversal' Con VarBangType
conNamedFields VarBangType -> f VarBangType
_ c :: Con
c@NormalC{}      = Con -> f Con
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Con
c
conNamedFields VarBangType -> f VarBangType
_ c :: Con
c@InfixC{}       = Con -> f Con
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Con
c
conNamedFields VarBangType -> f VarBangType
f (RecC Name
n [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)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse VarBangType -> f VarBangType
f [VarBangType]
fs
conNamedFields VarBangType -> f VarBangType
f (ForallC [TyVarBndr Specificity]
a Cxt
b Con
fs) = [TyVarBndr Specificity] -> Cxt -> Con -> Con
ForallC [TyVarBndr Specificity]
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
conNamedFields VarBangType -> f VarBangType
_ c :: Con
c@GadtC{}        = Con -> f Con
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Con
c
conNamedFields VarBangType -> f VarBangType
f (RecGadtC [Name]
ns [VarBangType]
argTys Type
retTy) =
  [Name] -> [VarBangType] -> Type -> Con
RecGadtC [Name]
ns ([VarBangType] -> Type -> Con)
-> f [VarBangType] -> f (Type -> 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)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse VarBangType -> f VarBangType
f [VarBangType]
argTys f (Type -> Con) -> f Type -> f Con
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Type -> f Type
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Type
retTy

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

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

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

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

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

funDepInputs :: Lens' FunDep [Name]
funDepInputs :: Lens' FunDep [Name]
funDepInputs = (FunDep -> [Name])
-> (FunDep -> [Name] -> FunDep) -> Lens' FunDep [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 [Name]
xs [Name]
_)    = [Name]
xs
   s :: FunDep -> [Name] -> FunDep
s (FunDep [Name]
_ [Name]
ys) [Name]
xs = [Name] -> [Name] -> FunDep
FunDep [Name]
xs [Name]
ys

funDepOutputs :: Lens' FunDep [Name]
funDepOutputs :: Lens' FunDep [Name]
funDepOutputs = (FunDep -> [Name])
-> (FunDep -> [Name] -> FunDep) -> Lens' FunDep [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 [Name]
_ [Name]
xs) = [Name]
xs
   s :: FunDep -> [Name] -> FunDep
s (FunDep [Name]
ys [Name]
_) = [Name] -> [Name] -> FunDep
FunDep [Name]
ys

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

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

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

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

matchPattern :: Lens' Match Pat
matchPattern :: Lens' Match Pat
matchPattern = (Match -> Pat) -> (Match -> Pat -> Match) -> Lens' Match 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 Pat
p Body
_ [Dec]
_)   = Pat
p
   s :: Match -> Pat -> Match
s (Match Pat
_ Body
x [Dec]
y) Pat
p = Pat -> Body -> [Dec] -> Match
Match Pat
p Body
x [Dec]
y

matchBody :: Lens' Match Body
matchBody :: Lens' Match Body
matchBody = (Match -> Body) -> (Match -> Body -> Match) -> Lens' Match 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 Pat
_ Body
b [Dec]
_)   = Body
b
   s :: Match -> Body -> Match
s (Match Pat
x Body
_ [Dec]
y) Body
b = Pat -> Body -> [Dec] -> Match
Match Pat
x Body
b [Dec]
y

matchDeclarations :: Lens' Match [Dec]
matchDeclarations :: Lens' Match [Dec]
matchDeclarations = (Match -> [Dec]) -> (Match -> [Dec] -> Match) -> Lens' Match [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 Pat
_ Body
_ [Dec]
ds) = [Dec]
ds
   s :: Match -> [Dec] -> Match
s (Match Pat
x Body
y [Dec]
_ ) = Pat -> Body -> [Dec] -> Match
Match Pat
x Body
y

fixityPrecedence :: Lens' Fixity Int
fixityPrecedence :: Lens' Fixity Int
fixityPrecedence = (Fixity -> Int) -> (Fixity -> Int -> Fixity) -> Lens' Fixity 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 Int
i FixityDirection
_)   = Int
i
   s :: Fixity -> Int -> Fixity
s (Fixity Int
_ FixityDirection
x) Int
i = Int -> FixityDirection -> Fixity
Fixity Int
i FixityDirection
x

fixityDirection :: Lens' Fixity FixityDirection
fixityDirection :: Lens' Fixity FixityDirection
fixityDirection = (Fixity -> FixityDirection)
-> (Fixity -> FixityDirection -> Fixity)
-> Lens' Fixity 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 Int
_ FixityDirection
d) = FixityDirection
d
   s :: Fixity -> FixityDirection -> Fixity
s (Fixity Int
i FixityDirection
_) = Int -> FixityDirection -> Fixity
Fixity Int
i

clausePattern :: Lens' Clause [Pat]
clausePattern :: Lens' Clause [Pat]
clausePattern = (Clause -> [Pat])
-> (Clause -> [Pat] -> Clause) -> Lens' Clause [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 [Pat]
ps Body
_ [Dec]
_)    = [Pat]
ps
   s :: Clause -> [Pat] -> Clause
s (Clause [Pat]
_  Body
x [Dec]
y) [Pat]
ps = [Pat] -> Body -> [Dec] -> Clause
Clause [Pat]
ps Body
x [Dec]
y

clauseBody :: Lens' Clause Body
clauseBody :: Lens' Clause Body
clauseBody = (Clause -> Body) -> (Clause -> Body -> Clause) -> Lens' Clause 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 [Pat]
_ Body
b [Dec]
_)   = Body
b
   s :: Clause -> Body -> Clause
s (Clause [Pat]
x Body
_ [Dec]
y) Body
b = [Pat] -> Body -> [Dec] -> Clause
Clause [Pat]
x Body
b [Dec]
y

clauseDecs :: Lens' Clause [Dec]
clauseDecs :: Lens' Clause [Dec]
clauseDecs = (Clause -> [Dec])
-> (Clause -> [Dec] -> Clause) -> Lens' Clause [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 [Pat]
_ Body
_ [Dec]
ds) = [Dec]
ds
   s :: Clause -> [Dec] -> Clause
s (Clause [Pat]
x Body
y [Dec]
_ ) = [Pat] -> Body -> [Dec] -> Clause
Clause [Pat]
x Body
y

injectivityAnnOutput :: Lens' InjectivityAnn Name
injectivityAnnOutput :: Lens' InjectivityAnn Name
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 Name
o [Name]
_)   = Name
o
   s :: InjectivityAnn -> Name -> InjectivityAnn
s (InjectivityAnn Name
_ [Name]
i) Name
o = Name -> [Name] -> InjectivityAnn
InjectivityAnn Name
o [Name]
i

injectivityAnnInputs :: Lens' InjectivityAnn [Name]
injectivityAnnInputs :: Lens' InjectivityAnn [Name]
injectivityAnnInputs = (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 Name
_ [Name]
i) = [Name]
i
   s :: InjectivityAnn -> [Name] -> InjectivityAnn
s (InjectivityAnn Name
o [Name]
_) = Name -> [Name] -> InjectivityAnn
InjectivityAnn Name
o

typeFamilyHeadName :: Lens' TypeFamilyHead Name
typeFamilyHeadName :: Lens' TypeFamilyHead Name
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 Name
n [TyVarBndr ()]
_    FamilyResultSig
_  Maybe InjectivityAnn
_ )   = Name
n
  s :: TypeFamilyHead -> Name -> TypeFamilyHead
s (TypeFamilyHead Name
_ [TyVarBndr ()]
tvbs FamilyResultSig
rs Maybe InjectivityAnn
ia) Name
n = Name
-> [TyVarBndr ()]
-> FamilyResultSig
-> Maybe InjectivityAnn
-> TypeFamilyHead
TypeFamilyHead Name
n [TyVarBndr ()]
tvbs FamilyResultSig
rs Maybe InjectivityAnn
ia

typeFamilyHeadTyVarBndrs :: Lens' TypeFamilyHead [TyVarBndrVis]
typeFamilyHeadTyVarBndrs :: Lens' TypeFamilyHead [TyVarBndr ()]
typeFamilyHeadTyVarBndrs = (TypeFamilyHead -> [TyVarBndr ()])
-> (TypeFamilyHead -> [TyVarBndr ()] -> TypeFamilyHead)
-> Lens' TypeFamilyHead [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 Name
_ [TyVarBndr ()]
tvbs FamilyResultSig
_  Maybe InjectivityAnn
_ )      = [TyVarBndr ()]
tvbs
  s :: TypeFamilyHead -> [TyVarBndr ()] -> TypeFamilyHead
s (TypeFamilyHead Name
n [TyVarBndr ()]
_    FamilyResultSig
rs Maybe InjectivityAnn
ia) [TyVarBndr ()]
tvbs = Name
-> [TyVarBndr ()]
-> FamilyResultSig
-> Maybe InjectivityAnn
-> TypeFamilyHead
TypeFamilyHead Name
n [TyVarBndr ()]
tvbs FamilyResultSig
rs Maybe InjectivityAnn
ia

typeFamilyHeadResultSig :: Lens' TypeFamilyHead FamilyResultSig
typeFamilyHeadResultSig :: Lens' TypeFamilyHead FamilyResultSig
typeFamilyHeadResultSig = (TypeFamilyHead -> FamilyResultSig)
-> (TypeFamilyHead -> FamilyResultSig -> TypeFamilyHead)
-> Lens' TypeFamilyHead 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 Name
_ [TyVarBndr ()]
_    FamilyResultSig
rs Maybe InjectivityAnn
_ )    = FamilyResultSig
rs
  s :: TypeFamilyHead -> FamilyResultSig -> TypeFamilyHead
s (TypeFamilyHead Name
n [TyVarBndr ()]
tvbs FamilyResultSig
_  Maybe InjectivityAnn
ia) FamilyResultSig
rs = Name
-> [TyVarBndr ()]
-> FamilyResultSig
-> Maybe InjectivityAnn
-> TypeFamilyHead
TypeFamilyHead Name
n [TyVarBndr ()]
tvbs FamilyResultSig
rs Maybe InjectivityAnn
ia

typeFamilyHeadInjectivityAnn :: Lens' TypeFamilyHead (Maybe InjectivityAnn)
typeFamilyHeadInjectivityAnn :: Lens' TypeFamilyHead (Maybe InjectivityAnn)
typeFamilyHeadInjectivityAnn = (TypeFamilyHead -> Maybe InjectivityAnn)
-> (TypeFamilyHead -> Maybe InjectivityAnn -> TypeFamilyHead)
-> Lens' TypeFamilyHead (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 Name
_ [TyVarBndr ()]
_    FamilyResultSig
_  Maybe InjectivityAnn
ia) = Maybe InjectivityAnn
ia
  s :: TypeFamilyHead -> Maybe InjectivityAnn -> TypeFamilyHead
s (TypeFamilyHead Name
n [TyVarBndr ()]
tvbs FamilyResultSig
rs Maybe InjectivityAnn
_ ) = Name
-> [TyVarBndr ()]
-> FamilyResultSig
-> Maybe InjectivityAnn
-> TypeFamilyHead
TypeFamilyHead Name
n [TyVarBndr ()]
tvbs FamilyResultSig
rs

bangSourceUnpackedness :: Lens' Bang SourceUnpackedness
bangSourceUnpackedness :: Lens' Bang SourceUnpackedness
bangSourceUnpackedness = (Bang -> SourceUnpackedness)
-> (Bang -> SourceUnpackedness -> Bang)
-> Lens' Bang 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 SourceUnpackedness
su SourceStrictness
_ )    = SourceUnpackedness
su
  s :: Bang -> SourceUnpackedness -> Bang
s (Bang SourceUnpackedness
_  SourceStrictness
ss) SourceUnpackedness
su = SourceUnpackedness -> SourceStrictness -> Bang
Bang SourceUnpackedness
su SourceStrictness
ss

bangSourceStrictness :: Lens' Bang SourceStrictness
bangSourceStrictness :: Lens' Bang SourceStrictness
bangSourceStrictness = (Bang -> SourceStrictness)
-> (Bang -> SourceStrictness -> Bang)
-> Lens' Bang 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 SourceUnpackedness
_  SourceStrictness
su) = SourceStrictness
su
  s :: Bang -> SourceStrictness -> Bang
s (Bang SourceUnpackedness
ss SourceStrictness
_ ) = SourceUnpackedness -> SourceStrictness -> Bang
Bang SourceUnpackedness
ss

#if MIN_VERSION_template_haskell(2,12,0)
derivClauseStrategy :: Lens' DerivClause (Maybe DerivStrategy)
derivClauseStrategy :: Lens' DerivClause (Maybe DerivStrategy)
derivClauseStrategy = (DerivClause -> Maybe DerivStrategy)
-> (DerivClause -> Maybe DerivStrategy -> DerivClause)
-> Lens' DerivClause (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 Maybe DerivStrategy
mds Cxt
_)     = Maybe DerivStrategy
mds
  s :: DerivClause -> Maybe DerivStrategy -> DerivClause
s (DerivClause Maybe DerivStrategy
_   Cxt
c) Maybe DerivStrategy
mds = Maybe DerivStrategy -> Cxt -> DerivClause
DerivClause Maybe DerivStrategy
mds Cxt
c

derivClauseCxt :: Lens' DerivClause Cxt
derivClauseCxt :: Lens' DerivClause Cxt
derivClauseCxt = (DerivClause -> Cxt)
-> (DerivClause -> Cxt -> DerivClause) -> Lens' DerivClause 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 Maybe DerivStrategy
_   Cxt
c) = Cxt
c
  s :: DerivClause -> Cxt -> DerivClause
s (DerivClause Maybe DerivStrategy
mds Cxt
_) = Maybe DerivStrategy -> Cxt -> DerivClause
DerivClause Maybe DerivStrategy
mds
#endif

_ClassI :: Prism' Info (Dec, [InstanceDec])
_ClassI :: Prism' Info (Dec, [Dec])
_ClassI
  = ((Dec, [Dec]) -> Info)
-> (Info -> Maybe (Dec, [Dec])) -> Prism' Info (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 (Dec
x, [Dec]
y) = Dec -> [Dec] -> Info
ClassI Dec
x [Dec]
y
      remitter :: Info -> Maybe (Dec, [Dec])
remitter (ClassI Dec
x [Dec]
y) = (Dec, [Dec]) -> Maybe (Dec, [Dec])
forall a. a -> Maybe a
Just (Dec
x, [Dec]
y)
      remitter Info
_ = Maybe (Dec, [Dec])
forall a. Maybe a
Nothing

_ClassOpI :: Prism' Info (Name, Type, ParentName)
_ClassOpI :: Prism' Info (Name, Type, Name)
_ClassOpI
  = ((Name, Type, Name) -> Info)
-> (Info -> Maybe (Name, Type, Name))
-> Prism' Info (Name, Type, Name)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Name, Type, Name) -> Info
reviewer Info -> Maybe (Name, Type, Name)
remitter
  where
      reviewer :: (Name, Type, Name) -> Info
reviewer (Name
x, Type
y, Name
z) = Name -> Type -> Name -> Info
ClassOpI Name
x Type
y Name
z
      remitter :: Info -> Maybe (Name, Type, Name)
remitter (ClassOpI Name
x Type
y Name
z) = (Name, Type, Name) -> Maybe (Name, Type, Name)
forall a. a -> Maybe a
Just (Name
x, Type
y, Name
z)
      remitter Info
_ = Maybe (Name, Type, Name)
forall a. Maybe a
Nothing

_TyConI :: Prism' Info Dec
_TyConI :: Prism' Info Dec
_TyConI
  = (Dec -> Info) -> (Info -> Maybe Dec) -> Prism' Info 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 Dec
x) = Dec -> Maybe Dec
forall a. a -> Maybe a
Just Dec
x
      remitter Info
_ = Maybe Dec
forall a. Maybe a
Nothing

_FamilyI :: Prism' Info (Dec, [InstanceDec])
_FamilyI :: Prism' Info (Dec, [Dec])
_FamilyI
  = ((Dec, [Dec]) -> Info)
-> (Info -> Maybe (Dec, [Dec])) -> Prism' Info (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 (Dec
x, [Dec]
y) = Dec -> [Dec] -> Info
FamilyI Dec
x [Dec]
y
      remitter :: Info -> Maybe (Dec, [Dec])
remitter (FamilyI Dec
x [Dec]
y) = (Dec, [Dec]) -> Maybe (Dec, [Dec])
forall a. a -> Maybe a
Just (Dec
x, [Dec]
y)
      remitter Info
_ = Maybe (Dec, [Dec])
forall a. Maybe a
Nothing

_PrimTyConI :: Prism' Info (Name, Arity, Unlifted)
_PrimTyConI :: Prism' Info (Name, Int, Bool)
_PrimTyConI
  = ((Name, Int, Bool) -> Info)
-> (Info -> Maybe (Name, Int, Bool))
-> Prism' Info (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 (Name
x, Int
y, Bool
z) = Name -> Int -> Bool -> Info
PrimTyConI Name
x Int
y Bool
z
      remitter :: Info -> Maybe (Name, Int, Bool)
remitter (PrimTyConI Name
x Int
y Bool
z) = (Name, Int, Bool) -> Maybe (Name, Int, Bool)
forall a. a -> Maybe a
Just (Name
x, Int
y, Bool
z)
      remitter Info
_ = Maybe (Name, Int, Bool)
forall a. Maybe a
Nothing

_DataConI :: Prism' Info (Name, Type, ParentName)
_DataConI :: Prism' Info (Name, Type, Name)
_DataConI
  = ((Name, Type, Name) -> Info)
-> (Info -> Maybe (Name, Type, Name))
-> Prism' Info (Name, Type, Name)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Name, Type, Name) -> Info
reviewer Info -> Maybe (Name, Type, Name)
remitter
  where
      reviewer :: (Name, Type, Name) -> Info
reviewer (Name
x, Type
y, Name
z) = Name -> Type -> Name -> Info
DataConI Name
x Type
y Name
z
      remitter :: Info -> Maybe (Name, Type, Name)
remitter (DataConI Name
x Type
y Name
z) = (Name, Type, Name) -> Maybe (Name, Type, Name)
forall a. a -> Maybe a
Just (Name
x, Type
y, Name
z)
      remitter Info
_ = Maybe (Name, Type, Name)
forall a. Maybe a
Nothing

_VarI :: Prism' Info (Name, Type, Maybe Dec)
_VarI :: Prism' Info (Name, Type, Maybe Dec)
_VarI
  = ((Name, Type, Maybe Dec) -> Info)
-> (Info -> Maybe (Name, Type, Maybe Dec))
-> Prism' Info (Name, Type, Maybe Dec)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Name, Type, Maybe Dec) -> Info
reviewer Info -> Maybe (Name, Type, Maybe Dec)
remitter
  where
      reviewer :: (Name, Type, Maybe Dec) -> Info
reviewer (Name
x, Type
y, Maybe Dec
z) = Name -> Type -> Maybe Dec -> Info
VarI Name
x Type
y Maybe Dec
z
      remitter :: Info -> Maybe (Name, Type, Maybe Dec)
remitter (VarI Name
x Type
y Maybe Dec
z) = (Name, Type, Maybe Dec) -> Maybe (Name, Type, Maybe Dec)
forall a. a -> Maybe a
Just (Name
x, Type
y, Maybe Dec
z)
      remitter Info
_ = Maybe (Name, Type, Maybe Dec)
forall a. Maybe a
Nothing

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

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

_FunD :: Prism' Dec (Name, [Clause])
_FunD :: Prism' Dec (Name, [Clause])
_FunD
  = ((Name, [Clause]) -> Dec)
-> (Dec -> Maybe (Name, [Clause])) -> Prism' Dec (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 (Name
x, [Clause]
y) = Name -> [Clause] -> Dec
FunD Name
x [Clause]
y
      remitter :: Dec -> Maybe (Name, [Clause])
remitter (FunD Name
x [Clause]
y) = (Name, [Clause]) -> Maybe (Name, [Clause])
forall a. a -> Maybe a
Just (Name
x,[Clause]
y)
      remitter Dec
_ = Maybe (Name, [Clause])
forall a. Maybe a
Nothing

_ValD :: Prism' Dec (Pat, Body, [Dec])
_ValD :: Prism' Dec (Pat, Body, [Dec])
_ValD
  = ((Pat, Body, [Dec]) -> Dec)
-> (Dec -> Maybe (Pat, Body, [Dec]))
-> Prism' 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 (Pat
x, Body
y, [Dec]
z) = Pat -> Body -> [Dec] -> Dec
ValD Pat
x Body
y [Dec]
z
      remitter :: Dec -> Maybe (Pat, Body, [Dec])
remitter (ValD Pat
x Body
y [Dec]
z) = (Pat, Body, [Dec]) -> Maybe (Pat, Body, [Dec])
forall a. a -> Maybe a
Just (Pat
x, Body
y, [Dec]
z)
      remitter Dec
_ = Maybe (Pat, Body, [Dec])
forall a. Maybe a
Nothing

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

_ClassD :: Prism' Dec (Cxt, Name, [TyVarBndrVis], [FunDep], [Dec])
_ClassD :: Prism' Dec (Cxt, Name, [TyVarBndr ()], [FunDep], [Dec])
_ClassD
  = ((Cxt, Name, [TyVarBndr ()], [FunDep], [Dec]) -> Dec)
-> (Dec -> Maybe (Cxt, Name, [TyVarBndr ()], [FunDep], [Dec]))
-> Prism' 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 (Cxt
x, Name
y, [TyVarBndr ()]
z, [FunDep]
w, [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 Cxt
x Name
y [TyVarBndr ()]
z [FunDep]
w [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 Dec
_ = Maybe (Cxt, Name, [TyVarBndr ()], [FunDep], [Dec])
forall a. Maybe a
Nothing

_InstanceD :: Prism' Dec (Maybe Overlap, Cxt, Type, [Dec])
_InstanceD :: Prism' Dec (Maybe Overlap, Cxt, Type, [Dec])
_InstanceD
  = ((Maybe Overlap, Cxt, Type, [Dec]) -> Dec)
-> (Dec -> Maybe (Maybe Overlap, Cxt, Type, [Dec]))
-> Prism' Dec (Maybe Overlap, Cxt, Type, [Dec])
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Maybe Overlap, Cxt, Type, [Dec]) -> Dec
reviewer Dec -> Maybe (Maybe Overlap, Cxt, Type, [Dec])
remitter
  where
      reviewer :: (Maybe Overlap, Cxt, Type, [Dec]) -> Dec
reviewer (Maybe Overlap
x, Cxt
y, Type
z, [Dec]
w) = Maybe Overlap -> Cxt -> Type -> [Dec] -> Dec
InstanceD Maybe Overlap
x Cxt
y Type
z [Dec]
w
      remitter :: Dec -> Maybe (Maybe Overlap, Cxt, Type, [Dec])
remitter (InstanceD Maybe Overlap
x Cxt
y Type
z [Dec]
w) = (Maybe Overlap, Cxt, Type, [Dec])
-> Maybe (Maybe Overlap, Cxt, Type, [Dec])
forall a. a -> Maybe a
Just (Maybe Overlap
x, Cxt
y, Type
z, [Dec]
w)
      remitter Dec
_ = Maybe (Maybe Overlap, Cxt, Type, [Dec])
forall a. Maybe a
Nothing

#if MIN_VERSION_template_haskell(2,22,0)
_NoNamespaceSpecifier :: Prism' NamespaceSpecifier ()
_NoNamespaceSpecifier
  = prism' reviewer remitter
  where
      reviewer () = NoNamespaceSpecifier
      remitter NoNamespaceSpecifier = Just ()
      remitter _ = Nothing

_TypeNamespaceSpecifier :: Prism' NamespaceSpecifier ()
_TypeNamespaceSpecifier
  = prism' reviewer remitter
  where
      reviewer () = TypeNamespaceSpecifier
      remitter TypeNamespaceSpecifier = Just ()
      remitter _ = Nothing

_DataNamespaceSpecifier :: Prism' NamespaceSpecifier ()
_DataNamespaceSpecifier
  = prism' reviewer remitter
  where
      reviewer () = DataNamespaceSpecifier
      remitter DataNamespaceSpecifier = Just ()
      remitter _ = Nothing
#endif

_Overlappable  :: Prism' Overlap  ()
_Overlappable :: Prism' Overlap ()
_Overlappable  = (() -> Overlap) -> (Overlap -> Maybe ()) -> Prism' 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 Overlap
Overlappable = () -> Maybe ()
forall a. a -> Maybe a
Just  ()
      remitter Overlap
_ = Maybe ()
forall a. Maybe a
Nothing

_Overlapping :: Prism' Overlap ()
_Overlapping :: Prism' Overlap ()
_Overlapping = (() -> Overlap) -> (Overlap -> Maybe ()) -> Prism' 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 Overlap
Overlapping = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Overlap
_ = Maybe ()
forall a. Maybe a
Nothing

_Overlaps ::  Prism' Overlap  ()
_Overlaps :: Prism' Overlap ()
_Overlaps =  (() -> Overlap) -> (Overlap -> Maybe ()) -> Prism' 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 Overlap
Overlaps = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Overlap
_ = Maybe ()
forall a. Maybe a
Nothing

_Incoherent  :: Prism' Overlap ()
_Incoherent :: Prism' Overlap ()
_Incoherent  = (() -> Overlap) -> (Overlap -> Maybe ()) -> Prism' 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 Overlap
Incoherent = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Overlap
_ = Maybe ()
forall a. Maybe a
Nothing

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

_ForeignD :: Prism' Dec Foreign
_ForeignD :: Prism' Dec Foreign
_ForeignD
  = (Foreign -> Dec) -> (Dec -> Maybe Foreign) -> Prism' Dec 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 Foreign
x) = Foreign -> Maybe Foreign
forall a. a -> Maybe a
Just Foreign
x
      remitter Dec
_ = Maybe Foreign
forall a. Maybe a
Nothing

-- |
-- @
-- _InfixD :: 'Prism'' 'Dec' ('Fixity', 'NamespaceSpecifier', 'Name') -- template-haskell-2.22+
-- _InfixD :: 'Prism'' 'Dec' ('Fixity', 'Name')                     -- Earlier versions
-- @
#if MIN_VERSION_template_haskell(2,22,0)
_InfixD :: Prism' Dec (Fixity, NamespaceSpecifier, Name)
_InfixD
  = prism' reviewer remitter
  where
      reviewer (x, y, z) = InfixD x y z
      remitter (InfixD x y z) = Just (x, y, z)
      remitter _ = Nothing
#else
_InfixD :: Prism' Dec (Fixity, Name)
_InfixD :: Prism' Dec (Fixity, Name)
_InfixD
  = ((Fixity, Name) -> Dec)
-> (Dec -> Maybe (Fixity, Name)) -> Prism' Dec (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 (Fixity
x, Name
y) = Fixity -> Name -> Dec
InfixD Fixity
x Name
y
      remitter :: Dec -> Maybe (Fixity, Name)
remitter (InfixD Fixity
x Name
y) = (Fixity, Name) -> Maybe (Fixity, Name)
forall a. a -> Maybe a
Just (Fixity
x, Name
y)
      remitter Dec
_ = Maybe (Fixity, Name)
forall a. Maybe a
Nothing
#endif

_PragmaD :: Prism' Dec Pragma
_PragmaD :: Prism' Dec Pragma
_PragmaD
  = (Pragma -> Dec) -> (Dec -> Maybe Pragma) -> Prism' Dec 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 Pragma
x) = Pragma -> Maybe Pragma
forall a. a -> Maybe a
Just Pragma
x
      remitter Dec
_ = 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 :: Prism' Dec TySynEqn
_TySynInstD
  = (TySynEqn -> Dec) -> (Dec -> Maybe TySynEqn) -> Prism' Dec 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 TySynEqn
x) = TySynEqn -> Maybe TySynEqn
forall a. a -> Maybe a
Just TySynEqn
x
      remitter Dec
_ = Maybe TySynEqn
forall a. Maybe a
Nothing
#else
_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
#endif

_RoleAnnotD :: Prism' Dec (Name, [Role])
_RoleAnnotD :: Prism' Dec (Name, [Role])
_RoleAnnotD
  = ((Name, [Role]) -> Dec)
-> (Dec -> Maybe (Name, [Role])) -> Prism' Dec (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 (Name
x, [Role]
y) = Name -> [Role] -> Dec
RoleAnnotD Name
x [Role]
y
      remitter :: Dec -> Maybe (Name, [Role])
remitter (RoleAnnotD Name
x [Role]
y) = (Name, [Role]) -> Maybe (Name, [Role])
forall a. a -> Maybe a
Just (Name
x, [Role]
y)
      remitter Dec
_ = Maybe (Name, [Role])
forall a. Maybe a
Nothing

-- |
-- @
-- _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 :: Prism' Dec (Maybe DerivStrategy, Cxt, Type)
_StandaloneDerivD
  = ((Maybe DerivStrategy, Cxt, Type) -> Dec)
-> (Dec -> Maybe (Maybe DerivStrategy, Cxt, Type))
-> Prism' Dec (Maybe DerivStrategy, Cxt, Type)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Maybe DerivStrategy, Cxt, Type) -> Dec
reviewer Dec -> Maybe (Maybe DerivStrategy, Cxt, Type)
remitter
  where
      reviewer :: (Maybe DerivStrategy, Cxt, Type) -> Dec
reviewer (Maybe DerivStrategy
x, Cxt
y, Type
z) = Maybe DerivStrategy -> Cxt -> Type -> Dec
StandaloneDerivD Maybe DerivStrategy
x Cxt
y Type
z
      remitter :: Dec -> Maybe (Maybe DerivStrategy, Cxt, Type)
remitter (StandaloneDerivD Maybe DerivStrategy
x Cxt
y Type
z) = (Maybe DerivStrategy, Cxt, Type)
-> Maybe (Maybe DerivStrategy, Cxt, Type)
forall a. a -> Maybe a
Just (Maybe DerivStrategy
x, Cxt
y, Type
z)
      remitter Dec
_ = Maybe (Maybe DerivStrategy, Cxt, Type)
forall a. Maybe a
Nothing
#else
_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

_DefaultSigD :: Prism' Dec (Name, Type)
_DefaultSigD :: Prism' Dec (Name, Type)
_DefaultSigD
  = ((Name, Type) -> Dec)
-> (Dec -> Maybe (Name, Type)) -> Prism' Dec (Name, Type)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Name, Type) -> Dec
reviewer Dec -> Maybe (Name, Type)
remitter
  where
      reviewer :: (Name, Type) -> Dec
reviewer (Name
x, Type
y) = Name -> Type -> Dec
DefaultSigD Name
x Type
y
      remitter :: Dec -> Maybe (Name, Type)
remitter (DefaultSigD Name
x Type
y) = (Name, Type) -> Maybe (Name, Type)
forall a. a -> Maybe a
Just (Name
x, Type
y)
      remitter Dec
_ = Maybe (Name, Type)
forall a. Maybe a
Nothing

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

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

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

_ClosedTypeFamilyD :: Prism' Dec (TypeFamilyHead, [TySynEqn])
_ClosedTypeFamilyD :: Prism' Dec (TypeFamilyHead, [TySynEqn])
_ClosedTypeFamilyD
  = ((TypeFamilyHead, [TySynEqn]) -> Dec)
-> (Dec -> Maybe (TypeFamilyHead, [TySynEqn]))
-> Prism' Dec (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 (TypeFamilyHead
x, [TySynEqn]
y) = TypeFamilyHead -> [TySynEqn] -> Dec
ClosedTypeFamilyD TypeFamilyHead
x [TySynEqn]
y
      remitter :: Dec -> Maybe (TypeFamilyHead, [TySynEqn])
remitter (ClosedTypeFamilyD TypeFamilyHead
x [TySynEqn]
y) = (TypeFamilyHead, [TySynEqn]) -> Maybe (TypeFamilyHead, [TySynEqn])
forall a. a -> Maybe a
Just (TypeFamilyHead
x, [TySynEqn]
y)
      remitter Dec
_ = Maybe (TypeFamilyHead, [TySynEqn])
forall a. Maybe a
Nothing

-- |
-- @
-- _DataD :: 'Prism'' 'Dec' ('Cxt', 'Name', ['TyVarBndrUnit'], 'Maybe' 'Kind', ['Con'], ['DerivClause']) -- template-haskell-2.12+
-- _DataD :: 'Prism'' 'Dec' ('Cxt', 'Name', ['Type'],          'Maybe' 'Kind', ['Con'], 'Cxt')           -- Earlier versions
-- @
_DataD :: DataPrism' [TyVarBndrVis] [Con]
_DataD :: DataPrism' [TyVarBndr ()] [Con]
_DataD
  = ((Cxt, Name, [TyVarBndr ()], Maybe Type, [Con], [DerivClause])
 -> Dec)
-> (Dec
    -> Maybe
         (Cxt, Name, [TyVarBndr ()], Maybe Type, [Con], [DerivClause]))
-> DataPrism' [TyVarBndr ()] [Con]
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Cxt, Name, [TyVarBndr ()], Maybe Type, [Con], [DerivClause])
-> Dec
reviewer Dec
-> Maybe
     (Cxt, Name, [TyVarBndr ()], Maybe Type, [Con], [DerivClause])
remitter
  where
      reviewer :: (Cxt, Name, [TyVarBndr ()], Maybe Type, [Con], [DerivClause])
-> Dec
reviewer (Cxt
x, Name
y, [TyVarBndr ()]
z, Maybe Type
w, [Con]
u, [DerivClause]
v) = Cxt
-> Name
-> [TyVarBndr ()]
-> Maybe Type
-> [Con]
-> [DerivClause]
-> Dec
DataD Cxt
x Name
y [TyVarBndr ()]
z Maybe Type
w [Con]
u [DerivClause]
v
      remitter :: Dec
-> Maybe
     (Cxt, Name, [TyVarBndr ()], Maybe Type, [Con], [DerivClause])
remitter (DataD Cxt
x Name
y [TyVarBndr ()]
z Maybe Type
w [Con]
u [DerivClause]
v) = (Cxt, Name, [TyVarBndr ()], Maybe Type, [Con], [DerivClause])
-> Maybe
     (Cxt, Name, [TyVarBndr ()], Maybe Type, [Con], [DerivClause])
forall a. a -> Maybe a
Just (Cxt
x, Name
y, [TyVarBndr ()]
z, Maybe Type
w, [Con]
u, [DerivClause]
v)
      remitter Dec
_ = Maybe (Cxt, Name, [TyVarBndr ()], Maybe Type, [Con], [DerivClause])
forall a. Maybe a
Nothing

-- |
-- @
-- _NewtypeD :: 'Prism'' 'Dec' ('Cxt', 'Name', ['TyVarBndrUnit'], 'Maybe' 'Kind', 'Con', ['DerivClause']) -- template-haskell-2.12+
-- _NewtypeD :: 'Prism'' 'Dec' ('Cxt', 'Name', ['Type'],          'Maybe' 'Kind', 'Con', 'Cxt')           -- Earlier versions
-- @
_NewtypeD :: DataPrism' [TyVarBndrVis] Con
_NewtypeD :: DataPrism' [TyVarBndr ()] Con
_NewtypeD
  = ((Cxt, Name, [TyVarBndr ()], Maybe Type, Con, [DerivClause])
 -> Dec)
-> (Dec
    -> Maybe
         (Cxt, Name, [TyVarBndr ()], Maybe Type, Con, [DerivClause]))
-> DataPrism' [TyVarBndr ()] Con
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Cxt, Name, [TyVarBndr ()], Maybe Type, Con, [DerivClause]) -> Dec
reviewer Dec
-> Maybe
     (Cxt, Name, [TyVarBndr ()], Maybe Type, Con, [DerivClause])
remitter
  where
      reviewer :: (Cxt, Name, [TyVarBndr ()], Maybe Type, Con, [DerivClause]) -> Dec
reviewer (Cxt
x, Name
y, [TyVarBndr ()]
z, Maybe Type
w, Con
u, [DerivClause]
v) = Cxt
-> Name
-> [TyVarBndr ()]
-> Maybe Type
-> Con
-> [DerivClause]
-> Dec
NewtypeD Cxt
x Name
y [TyVarBndr ()]
z Maybe Type
w Con
u [DerivClause]
v
      remitter :: Dec
-> Maybe
     (Cxt, Name, [TyVarBndr ()], Maybe Type, Con, [DerivClause])
remitter (NewtypeD Cxt
x Name
y [TyVarBndr ()]
z Maybe Type
w Con
u [DerivClause]
v) = (Cxt, Name, [TyVarBndr ()], Maybe Type, Con, [DerivClause])
-> Maybe
     (Cxt, Name, [TyVarBndr ()], Maybe Type, Con, [DerivClause])
forall a. a -> Maybe a
Just (Cxt
x, Name
y, [TyVarBndr ()]
z, Maybe Type
w, Con
u, [DerivClause]
v)
      remitter Dec
_ = Maybe (Cxt, Name, [TyVarBndr ()], Maybe Type, Con, [DerivClause])
forall a. Maybe a
Nothing

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

_OpenTypeFamilyD :: Prism' Dec TypeFamilyHead
_OpenTypeFamilyD :: Prism' Dec TypeFamilyHead
_OpenTypeFamilyD
  = (TypeFamilyHead -> Dec)
-> (Dec -> Maybe TypeFamilyHead) -> Prism' Dec 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 TypeFamilyHead
x) = TypeFamilyHead -> Maybe TypeFamilyHead
forall a. a -> Maybe a
Just TypeFamilyHead
x
      remitter Dec
_ = Maybe TypeFamilyHead
forall a. Maybe a
Nothing

#if MIN_VERSION_template_haskell(2,12,0)
_PatSynD :: Prism' Dec (Name, PatSynArgs, PatSynDir, Pat)
_PatSynD :: Prism' Dec (Name, PatSynArgs, PatSynDir, Pat)
_PatSynD
  = ((Name, PatSynArgs, PatSynDir, Pat) -> Dec)
-> (Dec -> Maybe (Name, PatSynArgs, PatSynDir, Pat))
-> Prism' Dec (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 (Name
x, PatSynArgs
y, PatSynDir
z, 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 Name
x PatSynArgs
y PatSynDir
z 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 Dec
_ = Maybe (Name, PatSynArgs, PatSynDir, Pat)
forall a. Maybe a
Nothing

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

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

#if MIN_VERSION_template_haskell(2,19,0)
_DefaultD :: Prism' Dec [Type]
_DefaultD :: Prism' Dec Cxt
_DefaultD
  = (Cxt -> Dec) -> (Dec -> Maybe Cxt) -> Prism' Dec Cxt
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' Cxt -> Dec
reviewer Dec -> Maybe Cxt
remitter
  where
      reviewer :: Cxt -> Dec
reviewer = Cxt -> Dec
DefaultD
      remitter :: Dec -> Maybe Cxt
remitter (DefaultD Cxt
x) = Cxt -> Maybe Cxt
forall a. a -> Maybe a
Just Cxt
x
      remitter Dec
_ = Maybe Cxt
forall a. Maybe a
Nothing
#endif

#if MIN_VERSION_template_haskell(2,20,0)
_TypeDataD :: Prism' Dec (Name, [TyVarBndrVis], Maybe Kind, [Con])
_TypeDataD :: Prism' Dec (Name, [TyVarBndr ()], Maybe Type, [Con])
_TypeDataD
  = ((Name, [TyVarBndr ()], Maybe Type, [Con]) -> Dec)
-> (Dec -> Maybe (Name, [TyVarBndr ()], Maybe Type, [Con]))
-> Prism' Dec (Name, [TyVarBndr ()], Maybe Type, [Con])
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Name, [TyVarBndr ()], Maybe Type, [Con]) -> Dec
reviewer Dec -> Maybe (Name, [TyVarBndr ()], Maybe Type, [Con])
remitter
  where
      reviewer :: (Name, [TyVarBndr ()], Maybe Type, [Con]) -> Dec
reviewer (Name
x, [TyVarBndr ()]
y, Maybe Type
z, [Con]
u) = Name -> [TyVarBndr ()] -> Maybe Type -> [Con] -> Dec
TypeDataD Name
x [TyVarBndr ()]
y Maybe Type
z [Con]
u
      remitter :: Dec -> Maybe (Name, [TyVarBndr ()], Maybe Type, [Con])
remitter (TypeDataD Name
x [TyVarBndr ()]
y Maybe Type
z [Con]
u) = (Name, [TyVarBndr ()], Maybe Type, [Con])
-> Maybe (Name, [TyVarBndr ()], Maybe Type, [Con])
forall a. a -> Maybe a
Just (Name
x, [TyVarBndr ()]
y, Maybe Type
z, [Con]
u)
      remitter Dec
_ = Maybe (Name, [TyVarBndr ()], Maybe Type, [Con])
forall a. Maybe a
Nothing
#endif

#if MIN_VERSION_template_haskell(2,12,0)
_Unidir :: Prism' PatSynDir ()
_Unidir :: Prism' PatSynDir ()
_Unidir
  = (() -> PatSynDir) -> (PatSynDir -> Maybe ()) -> Prism' 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 PatSynDir
Unidir = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter PatSynDir
_ = Maybe ()
forall a. Maybe a
Nothing

_ImplBidir :: Prism' PatSynDir ()
_ImplBidir :: Prism' PatSynDir ()
_ImplBidir
  = (() -> PatSynDir) -> (PatSynDir -> Maybe ()) -> Prism' 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 PatSynDir
ImplBidir = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter PatSynDir
_ = Maybe ()
forall a. Maybe a
Nothing

_ExplBidir :: Prism' PatSynDir [Clause]
_ExplBidir :: Prism' PatSynDir [Clause]
_ExplBidir
  = ([Clause] -> PatSynDir)
-> (PatSynDir -> Maybe [Clause]) -> Prism' PatSynDir [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 [Clause]
x) = [Clause] -> Maybe [Clause]
forall a. a -> Maybe a
Just [Clause]
x
      remitter PatSynDir
_ = Maybe [Clause]
forall a. Maybe a
Nothing

_PrefixPatSyn :: Prism' PatSynArgs [Name]
_PrefixPatSyn :: Prism' PatSynArgs [Name]
_PrefixPatSyn
  = ([Name] -> PatSynArgs)
-> (PatSynArgs -> Maybe [Name]) -> Prism' PatSynArgs [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 [Name]
x) = [Name] -> Maybe [Name]
forall a. a -> Maybe a
Just [Name]
x
      remitter PatSynArgs
_ = Maybe [Name]
forall a. Maybe a
Nothing

_InfixPatSyn :: Prism' PatSynArgs (Name, Name)
_InfixPatSyn :: Prism' PatSynArgs (Name, Name)
_InfixPatSyn
  = ((Name, Name) -> PatSynArgs)
-> (PatSynArgs -> Maybe (Name, Name))
-> Prism' PatSynArgs (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 (Name
x, Name
y) = Name -> Name -> PatSynArgs
InfixPatSyn Name
x Name
y
      remitter :: PatSynArgs -> Maybe (Name, Name)
remitter (InfixPatSyn Name
x Name
y) = (Name, Name) -> Maybe (Name, Name)
forall a. a -> Maybe a
Just (Name
x, Name
y)
      remitter PatSynArgs
_ = Maybe (Name, Name)
forall a. Maybe a
Nothing

_RecordPatSyn :: Prism' PatSynArgs [Name]
_RecordPatSyn :: Prism' PatSynArgs [Name]
_RecordPatSyn
  = ([Name] -> PatSynArgs)
-> (PatSynArgs -> Maybe [Name]) -> Prism' PatSynArgs [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 [Name]
x) = [Name] -> Maybe [Name]
forall a. a -> Maybe a
Just [Name]
x
      remitter PatSynArgs
_ = Maybe [Name]
forall a. Maybe a
Nothing
#endif

_NormalC :: Prism' Con (Name, [BangType])
_NormalC :: Prism' Con (Name, [BangType])
_NormalC
  = ((Name, [BangType]) -> Con)
-> (Con -> Maybe (Name, [BangType]))
-> Prism' Con (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 (Name
x, [BangType]
y) = Name -> [BangType] -> Con
NormalC Name
x [BangType]
y
      remitter :: Con -> Maybe (Name, [BangType])
remitter (NormalC Name
x [BangType]
y) = (Name, [BangType]) -> Maybe (Name, [BangType])
forall a. a -> Maybe a
Just (Name
x, [BangType]
y)
      remitter Con
_ = Maybe (Name, [BangType])
forall a. Maybe a
Nothing

_RecC :: Prism' Con (Name, [VarBangType])
_RecC :: Prism' Con (Name, [VarBangType])
_RecC
  = ((Name, [VarBangType]) -> Con)
-> (Con -> Maybe (Name, [VarBangType]))
-> Prism' Con (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 (Name
x, [VarBangType]
y) = Name -> [VarBangType] -> Con
RecC Name
x [VarBangType]
y
      remitter :: Con -> Maybe (Name, [VarBangType])
remitter (RecC Name
x [VarBangType]
y) = (Name, [VarBangType]) -> Maybe (Name, [VarBangType])
forall a. a -> Maybe a
Just (Name
x, [VarBangType]
y)
      remitter Con
_ = Maybe (Name, [VarBangType])
forall a. Maybe a
Nothing

_InfixC :: Prism' Con (BangType, Name, BangType  )
_InfixC :: Prism' Con (BangType, Name, BangType)
_InfixC
  = ((BangType, Name, BangType) -> Con)
-> (Con -> Maybe (BangType, Name, BangType))
-> Prism' Con (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 (BangType
x, Name
y, BangType
z) = BangType -> Name -> BangType -> Con
InfixC BangType
x Name
y BangType
z
      remitter :: Con -> Maybe (BangType, Name, BangType)
remitter (InfixC BangType
x Name
y BangType
z) = (BangType, Name, BangType) -> Maybe (BangType, Name, BangType)
forall a. a -> Maybe a
Just (BangType
x, Name
y, BangType
z)
      remitter Con
_ = Maybe (BangType, Name, BangType)
forall a. Maybe a
Nothing

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

_GadtC :: Prism' Con ([Name], [BangType], Type)
_GadtC :: Prism' Con ([Name], [BangType], Type)
_GadtC
  = (([Name], [BangType], Type) -> Con)
-> (Con -> Maybe ([Name], [BangType], Type))
-> Prism' Con ([Name], [BangType], Type)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ([Name], [BangType], Type) -> Con
reviewer Con -> Maybe ([Name], [BangType], Type)
remitter
  where
      reviewer :: ([Name], [BangType], Type) -> Con
reviewer ([Name]
x, [BangType]
y, Type
z) = [Name] -> [BangType] -> Type -> Con
GadtC [Name]
x [BangType]
y Type
z
      remitter :: Con -> Maybe ([Name], [BangType], Type)
remitter (GadtC [Name]
x [BangType]
y Type
z) = ([Name], [BangType], Type) -> Maybe ([Name], [BangType], Type)
forall a. a -> Maybe a
Just ([Name]
x, [BangType]
y, Type
z)
      remitter Con
_ = Maybe ([Name], [BangType], Type)
forall a. Maybe a
Nothing

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

_NoSourceUnpackedness :: Prism' SourceUnpackedness ()
_NoSourceUnpackedness :: Prism' SourceUnpackedness ()
_NoSourceUnpackedness
  = (() -> SourceUnpackedness)
-> (SourceUnpackedness -> Maybe ()) -> Prism' 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 SourceUnpackedness
NoSourceUnpackedness = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter SourceUnpackedness
_ = Maybe ()
forall a. Maybe a
Nothing

_SourceNoUnpack :: Prism' SourceUnpackedness ()
_SourceNoUnpack :: Prism' SourceUnpackedness ()
_SourceNoUnpack
  = (() -> SourceUnpackedness)
-> (SourceUnpackedness -> Maybe ()) -> Prism' 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 SourceUnpackedness
SourceNoUnpack = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter SourceUnpackedness
_ = Maybe ()
forall a. Maybe a
Nothing

_SourceUnpack :: Prism' SourceUnpackedness ()
_SourceUnpack :: Prism' SourceUnpackedness ()
_SourceUnpack
  = (() -> SourceUnpackedness)
-> (SourceUnpackedness -> Maybe ()) -> Prism' 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 SourceUnpackedness
SourceUnpack = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter SourceUnpackedness
_ = Maybe ()
forall a. Maybe a
Nothing

_NoSourceStrictness :: Prism' SourceStrictness ()
_NoSourceStrictness :: Prism' SourceStrictness ()
_NoSourceStrictness
  = (() -> SourceStrictness)
-> (SourceStrictness -> Maybe ()) -> Prism' 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 SourceStrictness
NoSourceStrictness = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter SourceStrictness
_ = Maybe ()
forall a. Maybe a
Nothing

_SourceLazy :: Prism' SourceStrictness ()
_SourceLazy :: Prism' SourceStrictness ()
_SourceLazy
  = (() -> SourceStrictness)
-> (SourceStrictness -> Maybe ()) -> Prism' 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 SourceStrictness
SourceLazy = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter SourceStrictness
_ = Maybe ()
forall a. Maybe a
Nothing

_SourceStrict :: Prism' SourceStrictness ()
_SourceStrict :: Prism' SourceStrictness ()
_SourceStrict
  = (() -> SourceStrictness)
-> (SourceStrictness -> Maybe ()) -> Prism' 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 SourceStrictness
SourceStrict = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter SourceStrictness
_ = Maybe ()
forall a. Maybe a
Nothing

_DecidedLazy :: Prism' DecidedStrictness ()
_DecidedLazy :: Prism' DecidedStrictness ()
_DecidedLazy
  = (() -> DecidedStrictness)
-> (DecidedStrictness -> Maybe ()) -> Prism' 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 DecidedStrictness
DecidedLazy = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter DecidedStrictness
_ = Maybe ()
forall a. Maybe a
Nothing

_DecidedStrict :: Prism' DecidedStrictness ()
_DecidedStrict :: Prism' DecidedStrictness ()
_DecidedStrict
  = (() -> DecidedStrictness)
-> (DecidedStrictness -> Maybe ()) -> Prism' 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 DecidedStrictness
DecidedStrict = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter DecidedStrictness
_ = Maybe ()
forall a. Maybe a
Nothing

_DecidedUnpack :: Prism' DecidedStrictness ()
_DecidedUnpack :: Prism' DecidedStrictness ()
_DecidedUnpack
  = (() -> DecidedStrictness)
-> (DecidedStrictness -> Maybe ()) -> Prism' 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 DecidedStrictness
DecidedUnpack = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter DecidedStrictness
_ = Maybe ()
forall a. Maybe a
Nothing

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

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

_CCall :: Prism' Callconv ()
_CCall :: Prism' Callconv ()
_CCall
  = (() -> Callconv) -> (Callconv -> Maybe ()) -> Prism' 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 Callconv
CCall = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Callconv
_ = Maybe ()
forall a. Maybe a
Nothing

_StdCall :: Prism' Callconv ()
_StdCall :: Prism' Callconv ()
_StdCall
  = (() -> Callconv) -> (Callconv -> Maybe ()) -> Prism' 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 Callconv
StdCall = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Callconv
_ = Maybe ()
forall a. Maybe a
Nothing

_CApi :: Prism' Callconv ()
_CApi :: Prism' Callconv ()
_CApi
  = (() -> Callconv) -> (Callconv -> Maybe ()) -> Prism' 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 Callconv
CApi = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Callconv
_ = Maybe ()
forall a. Maybe a
Nothing

_Prim :: Prism' Callconv ()
_Prim :: Prism' Callconv ()
_Prim
  = (() -> Callconv) -> (Callconv -> Maybe ()) -> Prism' 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 Callconv
Prim = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Callconv
_ = Maybe ()
forall a. Maybe a
Nothing

_JavaScript :: Prism' Callconv ()
_JavaScript :: Prism' Callconv ()
_JavaScript
  = (() -> Callconv) -> (Callconv -> Maybe ()) -> Prism' 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 Callconv
JavaScript = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Callconv
_ = Maybe ()
forall a. Maybe a
Nothing

_Unsafe :: Prism' Safety ()
_Unsafe :: Prism' Safety ()
_Unsafe
  = (() -> Safety) -> (Safety -> Maybe ()) -> Prism' 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 Safety
Unsafe = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Safety
_ = Maybe ()
forall a. Maybe a
Nothing

_Safe :: Prism' Safety ()
_Safe :: Prism' Safety ()
_Safe
  = (() -> Safety) -> (Safety -> Maybe ()) -> Prism' 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 Safety
Safe = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Safety
_ = Maybe ()
forall a. Maybe a
Nothing

_Interruptible :: Prism' Safety ()
_Interruptible :: Prism' Safety ()
_Interruptible
  = (() -> Safety) -> (Safety -> Maybe ()) -> Prism' 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 Safety
Interruptible = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Safety
_ = Maybe ()
forall a. Maybe a
Nothing

_InlineP :: Prism' Pragma (Name, Inline, RuleMatch, Phases)
_InlineP :: Prism' Pragma (Name, Inline, RuleMatch, Phases)
_InlineP
  = ((Name, Inline, RuleMatch, Phases) -> Pragma)
-> (Pragma -> Maybe (Name, Inline, RuleMatch, Phases))
-> Prism' Pragma (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 (Name
x, Inline
y, RuleMatch
z, 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 Name
x Inline
y RuleMatch
z 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 Pragma
_ = Maybe (Name, Inline, RuleMatch, Phases)
forall a. Maybe a
Nothing

_SpecialiseP :: Prism' Pragma (Name, Type, Maybe Inline, Phases)
_SpecialiseP :: Prism' Pragma (Name, Type, Maybe Inline, Phases)
_SpecialiseP
  = ((Name, Type, Maybe Inline, Phases) -> Pragma)
-> (Pragma -> Maybe (Name, Type, Maybe Inline, Phases))
-> Prism' Pragma (Name, Type, Maybe Inline, Phases)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Name, Type, Maybe Inline, Phases) -> Pragma
reviewer Pragma -> Maybe (Name, Type, Maybe Inline, Phases)
remitter
  where
      reviewer :: (Name, Type, Maybe Inline, Phases) -> Pragma
reviewer (Name
x, Type
y, Maybe Inline
z, Phases
w) = Name -> Type -> Maybe Inline -> Phases -> Pragma
SpecialiseP Name
x Type
y Maybe Inline
z Phases
w
      remitter :: Pragma -> Maybe (Name, Type, Maybe Inline, Phases)
remitter (SpecialiseP Name
x Type
y Maybe Inline
z Phases
w) = (Name, Type, Maybe Inline, Phases)
-> Maybe (Name, Type, Maybe Inline, Phases)
forall a. a -> Maybe a
Just (Name
x, Type
y, Maybe Inline
z, Phases
w)
      remitter Pragma
_ = Maybe (Name, Type, Maybe Inline, Phases)
forall a. Maybe a
Nothing

-- TODO add lenses for InlineSpec

_SpecialiseInstP :: Prism' Pragma Type
_SpecialiseInstP :: Prism' Pragma Type
_SpecialiseInstP
  = (Type -> Pragma) -> (Pragma -> Maybe Type) -> Prism' Pragma Type
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' Type -> Pragma
reviewer Pragma -> Maybe Type
remitter
  where
      reviewer :: Type -> Pragma
reviewer = Type -> Pragma
SpecialiseInstP
      remitter :: Pragma -> Maybe Type
remitter (SpecialiseInstP Type
x) = Type -> Maybe Type
forall a. a -> Maybe a
Just Type
x
      remitter Pragma
_ = Maybe Type
forall a. Maybe a
Nothing

-- |
-- @
-- _RuleP :: 'Prism'' 'Pragma' ('String', 'Maybe' ['TyVarBndrUnit'], ['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 [TyVarBndrUnit], [RuleBndr], Exp, Exp, Phases)
_RuleP :: Prism'
  Pragma ([Char], Maybe [TyVarBndr ()], [RuleBndr], Exp, Exp, Phases)
_RuleP
  = (([Char], Maybe [TyVarBndr ()], [RuleBndr], Exp, Exp, Phases)
 -> Pragma)
-> (Pragma
    -> Maybe
         ([Char], Maybe [TyVarBndr ()], [RuleBndr], Exp, Exp, Phases))
-> Prism'
     Pragma ([Char], Maybe [TyVarBndr ()], [RuleBndr], Exp, Exp, Phases)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ([Char], Maybe [TyVarBndr ()], [RuleBndr], Exp, Exp, Phases)
-> Pragma
reviewer Pragma
-> Maybe
     ([Char], Maybe [TyVarBndr ()], [RuleBndr], Exp, Exp, Phases)
remitter
  where
      reviewer :: ([Char], Maybe [TyVarBndr ()], [RuleBndr], Exp, Exp, Phases)
-> Pragma
reviewer ([Char]
x, Maybe [TyVarBndr ()]
y, [RuleBndr]
z, Exp
w, Exp
u, Phases
v) = [Char]
-> Maybe [TyVarBndr ()]
-> [RuleBndr]
-> Exp
-> Exp
-> Phases
-> Pragma
RuleP [Char]
x Maybe [TyVarBndr ()]
y [RuleBndr]
z Exp
w Exp
u Phases
v
      remitter :: Pragma
-> Maybe
     ([Char], Maybe [TyVarBndr ()], [RuleBndr], Exp, Exp, Phases)
remitter (RuleP [Char]
x Maybe [TyVarBndr ()]
y [RuleBndr]
z Exp
w Exp
u Phases
v) = ([Char], Maybe [TyVarBndr ()], [RuleBndr], Exp, Exp, Phases)
-> Maybe
     ([Char], Maybe [TyVarBndr ()], [RuleBndr], Exp, Exp, Phases)
forall a. a -> Maybe a
Just ([Char]
x, Maybe [TyVarBndr ()]
y, [RuleBndr]
z, Exp
w, Exp
u, Phases
v)
      remitter Pragma
_ = Maybe ([Char], 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

_AnnP :: Prism' Pragma (AnnTarget, Exp)
_AnnP :: Prism' Pragma (AnnTarget, Exp)
_AnnP
  = ((AnnTarget, Exp) -> Pragma)
-> (Pragma -> Maybe (AnnTarget, Exp))
-> Prism' Pragma (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 (AnnTarget
x, Exp
y) = AnnTarget -> Exp -> Pragma
AnnP AnnTarget
x Exp
y
      remitter :: Pragma -> Maybe (AnnTarget, Exp)
remitter (AnnP AnnTarget
x Exp
y) = (AnnTarget, Exp) -> Maybe (AnnTarget, Exp)
forall a. a -> Maybe a
Just (AnnTarget
x, Exp
y)
      remitter Pragma
_ = Maybe (AnnTarget, Exp)
forall a. Maybe a
Nothing

_LineP :: Prism' Pragma (Int, String)
_LineP :: Prism' Pragma (Int, [Char])
_LineP
  = ((Int, [Char]) -> Pragma)
-> (Pragma -> Maybe (Int, [Char])) -> Prism' Pragma (Int, [Char])
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Int, [Char]) -> Pragma
reviewer Pragma -> Maybe (Int, [Char])
remitter
  where
      reviewer :: (Int, [Char]) -> Pragma
reviewer (Int
x, [Char]
y) = Int -> [Char] -> Pragma
LineP Int
x [Char]
y
      remitter :: Pragma -> Maybe (Int, [Char])
remitter (LineP Int
x [Char]
y) = (Int, [Char]) -> Maybe (Int, [Char])
forall a. a -> Maybe a
Just (Int
x, [Char]
y)
      remitter Pragma
_ = Maybe (Int, [Char])
forall a. Maybe a
Nothing

#if MIN_VERSION_template_haskell(2,12,0)
_CompleteP :: Prism' Pragma ([Name], Maybe Name)
_CompleteP :: Prism' Pragma ([Name], Maybe Name)
_CompleteP
  = (([Name], Maybe Name) -> Pragma)
-> (Pragma -> Maybe ([Name], Maybe Name))
-> Prism' Pragma ([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 ([Name]
x, Maybe Name
y) = [Name] -> Maybe Name -> Pragma
CompleteP [Name]
x Maybe Name
y
      remitter :: Pragma -> Maybe ([Name], Maybe Name)
remitter (CompleteP [Name]
x Maybe Name
y) = ([Name], Maybe Name) -> Maybe ([Name], Maybe Name)
forall a. a -> Maybe a
Just ([Name]
x, Maybe Name
y)
      remitter Pragma
_ = Maybe ([Name], Maybe Name)
forall a. Maybe a
Nothing
#endif

#if MIN_VERSION_template_haskell(2,19,0)
_OpaqueP :: Prism' Pragma Name
_OpaqueP :: Prism' Pragma Name
_OpaqueP
  = (Name -> Pragma) -> (Pragma -> Maybe Name) -> Prism' Pragma Name
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' Name -> Pragma
reviewer Pragma -> Maybe Name
remitter
  where
      reviewer :: Name -> Pragma
reviewer = Name -> Pragma
OpaqueP
      remitter :: Pragma -> Maybe Name
remitter (OpaqueP Name
x) = Name -> Maybe Name
forall a. a -> Maybe a
Just Name
x
      remitter Pragma
_ = Maybe Name
forall a. Maybe a
Nothing
#endif

#if MIN_VERSION_template_haskell(2,22,0)
_SCCP :: Prism' Pragma (Name, Maybe String)
_SCCP
  = prism' reviewer remitter
  where
      reviewer (x, y) = SCCP x y
      remitter (SCCP x y) = Just (x, y)
      remitter _ = Nothing
#endif

_NoInline :: Prism' Inline ()
_NoInline :: Prism' Inline ()
_NoInline
  = (() -> Inline) -> (Inline -> Maybe ()) -> Prism' 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 Inline
NoInline = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Inline
_ = Maybe ()
forall a. Maybe a
Nothing

_Inline :: Prism' Inline ()
_Inline :: Prism' Inline ()
_Inline
  = (() -> Inline) -> (Inline -> Maybe ()) -> Prism' 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
Inline = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Inline
_ = Maybe ()
forall a. Maybe a
Nothing

_Inlinable :: Prism' Inline ()
_Inlinable :: Prism' Inline ()
_Inlinable
  = (() -> Inline) -> (Inline -> Maybe ()) -> Prism' 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 Inline
Inlinable = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Inline
_ = Maybe ()
forall a. Maybe a
Nothing

_ConLike :: Prism' RuleMatch ()
_ConLike :: Prism' RuleMatch ()
_ConLike
  = (() -> RuleMatch) -> (RuleMatch -> Maybe ()) -> Prism' 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 RuleMatch
ConLike = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter RuleMatch
_ = Maybe ()
forall a. Maybe a
Nothing

_FunLike :: Prism' RuleMatch ()
_FunLike :: Prism' RuleMatch ()
_FunLike
  = (() -> RuleMatch) -> (RuleMatch -> Maybe ()) -> Prism' 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 RuleMatch
FunLike = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter RuleMatch
_ = Maybe ()
forall a. Maybe a
Nothing

_AllPhases :: Prism' Phases ()
_AllPhases :: Prism' Phases ()
_AllPhases
  = (() -> Phases) -> (Phases -> Maybe ()) -> Prism' 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 Phases
AllPhases = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Phases
_ = Maybe ()
forall a. Maybe a
Nothing

_FromPhase :: Prism' Phases Int
_FromPhase :: Prism' Phases Int
_FromPhase
  = (Int -> Phases) -> (Phases -> Maybe Int) -> Prism' Phases 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 Int
x) = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
x
      remitter Phases
_ = Maybe Int
forall a. Maybe a
Nothing

_BeforePhase :: Prism' Phases Int
_BeforePhase :: Prism' Phases Int
_BeforePhase
  = (Int -> Phases) -> (Phases -> Maybe Int) -> Prism' Phases 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 Int
x) = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
x
      remitter Phases
_ = Maybe Int
forall a. Maybe a
Nothing

_RuleVar :: Prism' RuleBndr Name
_RuleVar :: Prism' RuleBndr Name
_RuleVar
  = (Name -> RuleBndr)
-> (RuleBndr -> Maybe Name) -> Prism' RuleBndr 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 Name
x) = Name -> Maybe Name
forall a. a -> Maybe a
Just Name
x
      remitter RuleBndr
_ = Maybe Name
forall a. Maybe a
Nothing

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

_ModuleAnnotation :: Prism' AnnTarget ()
_ModuleAnnotation :: Prism' AnnTarget ()
_ModuleAnnotation
  = (() -> AnnTarget) -> (AnnTarget -> Maybe ()) -> Prism' 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 AnnTarget
ModuleAnnotation = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter AnnTarget
_ = Maybe ()
forall a. Maybe a
Nothing

_TypeAnnotation :: Prism' AnnTarget Name
_TypeAnnotation :: Prism' AnnTarget Name
_TypeAnnotation
  = (Name -> AnnTarget)
-> (AnnTarget -> Maybe Name) -> Prism' AnnTarget 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 Name
x) = Name -> Maybe Name
forall a. a -> Maybe a
Just Name
x
      remitter AnnTarget
_ = Maybe Name
forall a. Maybe a
Nothing

_ValueAnnotation :: Prism' AnnTarget Name
_ValueAnnotation :: Prism' AnnTarget Name
_ValueAnnotation
  = (Name -> AnnTarget)
-> (AnnTarget -> Maybe Name) -> Prism' AnnTarget 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 Name
x) = Name -> Maybe Name
forall a. a -> Maybe a
Just Name
x
      remitter AnnTarget
_ = Maybe Name
forall a. Maybe a
Nothing

_FunDep :: Iso' FunDep ([Name], [Name])
_FunDep :: Iso' FunDep ([Name], [Name])
_FunDep
  = (FunDep -> ([Name], [Name]))
-> (([Name], [Name]) -> FunDep) -> Iso' FunDep ([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 ([Name]
x, [Name]
y) = [Name] -> [Name] -> FunDep
FunDep [Name]
x [Name]
y
      remitter :: FunDep -> ([Name], [Name])
remitter (FunDep [Name]
x [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 :: Lens' TySynEqn Type
tySynEqnLHS = (TySynEqn -> Type)
-> (TySynEqn -> Type -> TySynEqn) -> Lens' TySynEqn Type
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TySynEqn -> Type
g TySynEqn -> Type -> TySynEqn
s where
   g :: TySynEqn -> Type
g (TySynEqn Maybe [TyVarBndr ()]
_     Type
lhs Type
_)       = Type
lhs
   s :: TySynEqn -> Type -> TySynEqn
s (TySynEqn Maybe [TyVarBndr ()]
mtvbs Type
_   Type
rhs) Type
lhs = Maybe [TyVarBndr ()] -> Type -> Type -> TySynEqn
TySynEqn Maybe [TyVarBndr ()]
mtvbs Type
lhs Type
rhs

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

tySynEqnResult :: Lens' TySynEqn Type
tySynEqnResult :: Lens' TySynEqn Type
tySynEqnResult = (TySynEqn -> Type)
-> (TySynEqn -> Type -> TySynEqn) -> Lens' TySynEqn Type
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TySynEqn -> Type
g TySynEqn -> Type -> TySynEqn
s where
   g :: TySynEqn -> Type
g (TySynEqn Maybe [TyVarBndr ()]
_     Type
_   Type
rhs) = Type
rhs
   s :: TySynEqn -> Type -> TySynEqn
s (TySynEqn Maybe [TyVarBndr ()]
mtvbs Type
lhs Type
_)   = Maybe [TyVarBndr ()] -> Type -> Type -> TySynEqn
TySynEqn Maybe [TyVarBndr ()]
mtvbs Type
lhs
#else
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 :: Prism' FixityDirection ()
_InfixL
  = (() -> FixityDirection)
-> (FixityDirection -> Maybe ()) -> Prism' 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 FixityDirection
InfixL = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter FixityDirection
_ = Maybe ()
forall a. Maybe a
Nothing

_InfixR :: Prism' FixityDirection ()
_InfixR :: Prism' FixityDirection ()
_InfixR
  = (() -> FixityDirection)
-> (FixityDirection -> Maybe ()) -> Prism' 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 FixityDirection
InfixR = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter FixityDirection
_ = Maybe ()
forall a. Maybe a
Nothing

_InfixN :: Prism' FixityDirection ()
_InfixN :: Prism' FixityDirection ()
_InfixN
  = (() -> FixityDirection)
-> (FixityDirection -> Maybe ()) -> Prism' 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 FixityDirection
InfixN = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter FixityDirection
_ = Maybe ()
forall a. Maybe a
Nothing

_VarE :: Prism' Exp Name
_VarE :: Prism' Exp Name
_VarE
  = (Name -> Exp) -> (Exp -> Maybe Name) -> Prism' Exp 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 Name
x) = Name -> Maybe Name
forall a. a -> Maybe a
Just Name
x
      remitter Exp
_ = Maybe Name
forall a. Maybe a
Nothing

_ConE :: Prism' Exp Name
_ConE :: Prism' Exp Name
_ConE
  = (Name -> Exp) -> (Exp -> Maybe Name) -> Prism' Exp 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 Name
x) = Name -> Maybe Name
forall a. a -> Maybe a
Just Name
x
      remitter Exp
_ = Maybe Name
forall a. Maybe a
Nothing

_LitE :: Prism' Exp Lit
_LitE :: Prism' Exp Lit
_LitE
  = (Lit -> Exp) -> (Exp -> Maybe Lit) -> Prism' Exp 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 Lit
x) = Lit -> Maybe Lit
forall a. a -> Maybe a
Just Lit
x
      remitter Exp
_ = Maybe Lit
forall a. Maybe a
Nothing

_AppE :: Prism' Exp (Exp, Exp)
_AppE :: Prism' Exp (Exp, Exp)
_AppE
  = ((Exp, Exp) -> Exp)
-> (Exp -> Maybe (Exp, Exp)) -> Prism' 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 (Exp
x, Exp
y) = Exp -> Exp -> Exp
AppE Exp
x Exp
y
      remitter :: Exp -> Maybe (Exp, Exp)
remitter (AppE Exp
x Exp
y) = (Exp, Exp) -> Maybe (Exp, Exp)
forall a. a -> Maybe a
Just (Exp
x, Exp
y)
      remitter Exp
_ = Maybe (Exp, Exp)
forall a. Maybe a
Nothing

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

_InfixE :: Prism' Exp (Maybe Exp, Exp, Maybe Exp)
_InfixE :: Prism' Exp (Maybe Exp, Exp, Maybe Exp)
_InfixE
  = ((Maybe Exp, Exp, Maybe Exp) -> Exp)
-> (Exp -> Maybe (Maybe Exp, Exp, Maybe Exp))
-> Prism' 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 (Maybe Exp
x, Exp
y, 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 Maybe Exp
x Exp
y 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 Exp
_ = Maybe (Maybe Exp, Exp, Maybe Exp)
forall a. Maybe a
Nothing

_UInfixE :: Prism' Exp (Exp, Exp, Exp)
_UInfixE :: Prism' Exp (Exp, Exp, Exp)
_UInfixE
  = ((Exp, Exp, Exp) -> Exp)
-> (Exp -> Maybe (Exp, Exp, Exp)) -> Prism' 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 (Exp
x, Exp
y, Exp
z) = Exp -> Exp -> Exp -> Exp
UInfixE Exp
x Exp
y Exp
z
      remitter :: Exp -> Maybe (Exp, Exp, Exp)
remitter (UInfixE Exp
x Exp
y Exp
z) = (Exp, Exp, Exp) -> Maybe (Exp, Exp, Exp)
forall a. a -> Maybe a
Just (Exp
x, Exp
y, Exp
z)
      remitter Exp
_ = Maybe (Exp, Exp, Exp)
forall a. Maybe a
Nothing

_ParensE :: Prism' Exp Exp
_ParensE :: Prism' Exp Exp
_ParensE
  = (Exp -> Exp) -> (Exp -> Maybe Exp) -> Prism' 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 Exp
x) = Exp -> Maybe Exp
forall a. a -> Maybe a
Just Exp
x
      remitter Exp
_ = Maybe Exp
forall a. Maybe a
Nothing

_LamE :: Prism' Exp ([Pat], Exp)
_LamE :: Prism' Exp ([Pat], Exp)
_LamE
  = (([Pat], Exp) -> Exp)
-> (Exp -> Maybe ([Pat], Exp)) -> Prism' 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 ([Pat]
x, Exp
y) = [Pat] -> Exp -> Exp
LamE [Pat]
x Exp
y
      remitter :: Exp -> Maybe ([Pat], Exp)
remitter (LamE [Pat]
x Exp
y) = ([Pat], Exp) -> Maybe ([Pat], Exp)
forall a. a -> Maybe a
Just ([Pat]
x, Exp
y)
      remitter Exp
_ = Maybe ([Pat], Exp)
forall a. Maybe a
Nothing

_LamCaseE :: Prism' Exp [Match]
_LamCaseE :: Prism' Exp [Match]
_LamCaseE
  = ([Match] -> Exp) -> (Exp -> Maybe [Match]) -> Prism' Exp [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 [Match]
x) = [Match] -> Maybe [Match]
forall a. a -> Maybe a
Just [Match]
x
      remitter Exp
_ = Maybe [Match]
forall a. Maybe a
Nothing

-- |
-- @
-- _TupE :: 'Prism'' 'Exp' ['Maybe' 'Exp'] -- template-haskell-2.16+
-- _TupE :: 'Prism'' 'Exp' ['Exp']       -- Earlier versions
-- @
#if MIN_VERSION_template_haskell(2,16,0)
_TupE :: Prism' Exp [Maybe Exp]
#else
_TupE :: Prism' Exp [Exp]
#endif
_TupE :: Prism' Exp [Maybe Exp]
_TupE
  = ([Maybe Exp] -> Exp)
-> (Exp -> Maybe [Maybe Exp]) -> Prism' Exp [Maybe Exp]
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' [Maybe Exp] -> Exp
reviewer Exp -> Maybe [Maybe Exp]
remitter
  where
      reviewer :: [Maybe Exp] -> Exp
reviewer = [Maybe Exp] -> Exp
TupE
      remitter :: Exp -> Maybe [Maybe Exp]
remitter (TupE [Maybe Exp]
x) = [Maybe Exp] -> Maybe [Maybe Exp]
forall a. a -> Maybe a
Just [Maybe Exp]
x
      remitter Exp
_ = Maybe [Maybe Exp]
forall a. Maybe a
Nothing

-- |
-- @
-- _UnboxedTupE :: 'Prism'' 'Exp' ['Maybe' 'Exp'] -- template-haskell-2.16+
-- _UnboxedTupE :: 'Prism'' 'Exp' ['Exp']       -- Earlier versions
-- @
#if MIN_VERSION_template_haskell(2,16,0)
_UnboxedTupE :: Prism' Exp [Maybe Exp]
#else
_UnboxedTupE :: Prism' Exp [Exp]
#endif
_UnboxedTupE :: Prism' Exp [Maybe Exp]
_UnboxedTupE
  = ([Maybe Exp] -> Exp)
-> (Exp -> Maybe [Maybe Exp]) -> Prism' Exp [Maybe Exp]
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' [Maybe Exp] -> Exp
reviewer Exp -> Maybe [Maybe Exp]
remitter
  where
      reviewer :: [Maybe Exp] -> Exp
reviewer = [Maybe Exp] -> Exp
UnboxedTupE
      remitter :: Exp -> Maybe [Maybe Exp]
remitter (UnboxedTupE [Maybe Exp]
x) = [Maybe Exp] -> Maybe [Maybe Exp]
forall a. a -> Maybe a
Just [Maybe Exp]
x
      remitter Exp
_ = Maybe [Maybe Exp]
forall a. Maybe a
Nothing

#if MIN_VERSION_template_haskell(2,12,0)
_UnboxedSumE :: Prism' Exp (Exp, SumAlt, SumArity)
_UnboxedSumE :: Prism' Exp (Exp, Int, Int)
_UnboxedSumE
  = ((Exp, Int, Int) -> Exp)
-> (Exp -> Maybe (Exp, Int, Int)) -> Prism' Exp (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 (Exp
x, Int
y, Int
z) = Exp -> Int -> Int -> Exp
UnboxedSumE Exp
x Int
y Int
z
      remitter :: Exp -> Maybe (Exp, Int, Int)
remitter (UnboxedSumE Exp
x Int
y Int
z) = (Exp, Int, Int) -> Maybe (Exp, Int, Int)
forall a. a -> Maybe a
Just (Exp
x, Int
y, Int
z)
      remitter Exp
_ = Maybe (Exp, Int, Int)
forall a. Maybe a
Nothing
#endif

_CondE :: Prism' Exp (Exp, Exp, Exp)
_CondE :: Prism' Exp (Exp, Exp, Exp)
_CondE
  = ((Exp, Exp, Exp) -> Exp)
-> (Exp -> Maybe (Exp, Exp, Exp)) -> Prism' 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 (Exp
x, Exp
y, Exp
z) = Exp -> Exp -> Exp -> Exp
CondE Exp
x Exp
y Exp
z
      remitter :: Exp -> Maybe (Exp, Exp, Exp)
remitter (CondE Exp
x Exp
y Exp
z) = (Exp, Exp, Exp) -> Maybe (Exp, Exp, Exp)
forall a. a -> Maybe a
Just (Exp
x, Exp
y, Exp
z)
      remitter Exp
_ = Maybe (Exp, Exp, Exp)
forall a. Maybe a
Nothing

_MultiIfE :: Prism' Exp [(Guard, Exp)]
_MultiIfE :: Prism' Exp [(Guard, Exp)]
_MultiIfE
  = ([(Guard, Exp)] -> Exp)
-> (Exp -> Maybe [(Guard, Exp)]) -> Prism' 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 [(Guard, Exp)]
x) = [(Guard, Exp)] -> Maybe [(Guard, Exp)]
forall a. a -> Maybe a
Just [(Guard, Exp)]
x
      remitter Exp
_ = Maybe [(Guard, Exp)]
forall a. Maybe a
Nothing

_LetE :: Prism' Exp ([Dec], Exp)
_LetE :: Prism' Exp ([Dec], Exp)
_LetE
  = (([Dec], Exp) -> Exp)
-> (Exp -> Maybe ([Dec], Exp)) -> Prism' 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 ([Dec]
x, Exp
y) = [Dec] -> Exp -> Exp
LetE [Dec]
x Exp
y
      remitter :: Exp -> Maybe ([Dec], Exp)
remitter (LetE [Dec]
x Exp
y) = ([Dec], Exp) -> Maybe ([Dec], Exp)
forall a. a -> Maybe a
Just ([Dec]
x, Exp
y)
      remitter Exp
_ = Maybe ([Dec], Exp)
forall a. Maybe a
Nothing

_CaseE :: Prism' Exp (Exp, [Match])
_CaseE :: Prism' Exp (Exp, [Match])
_CaseE
  = ((Exp, [Match]) -> Exp)
-> (Exp -> Maybe (Exp, [Match])) -> Prism' Exp (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 (Exp
x, [Match]
y) = Exp -> [Match] -> Exp
CaseE Exp
x [Match]
y
      remitter :: Exp -> Maybe (Exp, [Match])
remitter (CaseE Exp
x [Match]
y) = (Exp, [Match]) -> Maybe (Exp, [Match])
forall a. a -> Maybe a
Just (Exp
x, [Match]
y)
      remitter Exp
_ = Maybe (Exp, [Match])
forall a. Maybe a
Nothing

-- |
-- @
-- _DoE :: 'Prism'' 'Exp' ('Maybe' 'ModName', ['Stmt']) -- template-haskell-2.17+
-- _DoE :: 'Prism'' 'Exp' ['Stmt']                  -- Earlier versions
-- @
# if MIN_VERSION_template_haskell(2,17,0)
_DoE :: Prism' Exp (Maybe ModName, [Stmt])
_DoE :: Prism' Exp (Maybe ModName, [Stmt])
_DoE
  = ((Maybe ModName, [Stmt]) -> Exp)
-> (Exp -> Maybe (Maybe ModName, [Stmt]))
-> Prism' Exp (Maybe ModName, [Stmt])
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Maybe ModName, [Stmt]) -> Exp
reviewer Exp -> Maybe (Maybe ModName, [Stmt])
remitter
  where
      reviewer :: (Maybe ModName, [Stmt]) -> Exp
reviewer (Maybe ModName
x, [Stmt]
y) = Maybe ModName -> [Stmt] -> Exp
DoE Maybe ModName
x [Stmt]
y
      remitter :: Exp -> Maybe (Maybe ModName, [Stmt])
remitter (DoE Maybe ModName
x [Stmt]
y) = (Maybe ModName, [Stmt]) -> Maybe (Maybe ModName, [Stmt])
forall a. a -> Maybe a
Just (Maybe ModName
x, [Stmt]
y)
      remitter Exp
_ = Maybe (Maybe ModName, [Stmt])
forall a. Maybe a
Nothing
# else
_DoE :: Prism' Exp [Stmt]
_DoE
  = prism' reviewer remitter
  where
      reviewer = DoE
      remitter (DoE x) = Just x
      remitter _ = Nothing
# endif

_CompE :: Prism' Exp [Stmt]
_CompE :: Prism' Exp [Stmt]
_CompE
  = ([Stmt] -> Exp) -> (Exp -> Maybe [Stmt]) -> Prism' Exp [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 [Stmt]
x) = [Stmt] -> Maybe [Stmt]
forall a. a -> Maybe a
Just [Stmt]
x
      remitter Exp
_ = Maybe [Stmt]
forall a. Maybe a
Nothing

_ArithSeqE :: Prism' Exp Range
_ArithSeqE :: Prism' Exp Range
_ArithSeqE
  = (Range -> Exp) -> (Exp -> Maybe Range) -> Prism' Exp 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 Range
x) = Range -> Maybe Range
forall a. a -> Maybe a
Just Range
x
      remitter Exp
_ = Maybe Range
forall a. Maybe a
Nothing

_ListE :: Prism' Exp [Exp]
_ListE :: Prism' Exp [Exp]
_ListE
  = ([Exp] -> Exp) -> (Exp -> Maybe [Exp]) -> Prism' 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 [Exp]
x) = [Exp] -> Maybe [Exp]
forall a. a -> Maybe a
Just [Exp]
x
      remitter Exp
_ = Maybe [Exp]
forall a. Maybe a
Nothing

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

_RecConE :: Prism' Exp (Name, [FieldExp])
_RecConE :: Prism' Exp (Name, [FieldExp])
_RecConE
  = ((Name, [FieldExp]) -> Exp)
-> (Exp -> Maybe (Name, [FieldExp]))
-> Prism' Exp (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 (Name
x, [FieldExp]
y) = Name -> [FieldExp] -> Exp
RecConE Name
x [FieldExp]
y
      remitter :: Exp -> Maybe (Name, [FieldExp])
remitter (RecConE Name
x [FieldExp]
y) = (Name, [FieldExp]) -> Maybe (Name, [FieldExp])
forall a. a -> Maybe a
Just (Name
x, [FieldExp]
y)
      remitter Exp
_ = Maybe (Name, [FieldExp])
forall a. Maybe a
Nothing

_RecUpdE :: Prism' Exp (Exp, [FieldExp])
_RecUpdE :: Prism' Exp (Exp, [FieldExp])
_RecUpdE
  = ((Exp, [FieldExp]) -> Exp)
-> (Exp -> Maybe (Exp, [FieldExp])) -> Prism' Exp (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 (Exp
x, [FieldExp]
y) = Exp -> [FieldExp] -> Exp
RecUpdE Exp
x [FieldExp]
y
      remitter :: Exp -> Maybe (Exp, [FieldExp])
remitter (RecUpdE Exp
x [FieldExp]
y) = (Exp, [FieldExp]) -> Maybe (Exp, [FieldExp])
forall a. a -> Maybe a
Just (Exp
x, [FieldExp]
y)
      remitter Exp
_ = Maybe (Exp, [FieldExp])
forall a. Maybe a
Nothing

_StaticE :: Prism' Exp Exp
_StaticE :: Prism' Exp Exp
_StaticE
  = (Exp -> Exp) -> (Exp -> Maybe Exp) -> Prism' 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 Exp
x) = Exp -> Maybe Exp
forall a. a -> Maybe a
Just Exp
x
      remitter Exp
_ = Maybe Exp
forall a. Maybe a
Nothing

_UnboundVarE :: Prism' Exp Name
_UnboundVarE :: Prism' Exp Name
_UnboundVarE
  = (Name -> Exp) -> (Exp -> Maybe Name) -> Prism' Exp 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 Name
x) = Name -> Maybe Name
forall a. a -> Maybe a
Just Name
x
      remitter Exp
_ = Maybe Name
forall a. Maybe a
Nothing

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

#if MIN_VERSION_template_haskell(2,15,0)
-- |
-- @
-- _MDoE :: 'Prism'' 'Exp' ('Maybe' 'ModName', ['Stmt']) -- template-haskell-2.17+
-- _MDoE :: 'Prism'' 'Exp' ['Stmt']                  -- Earlier versions
-- @
# if MIN_VERSION_template_haskell(2,17,0)
_MDoE :: Prism' Exp (Maybe ModName, [Stmt])
_MDoE :: Prism' Exp (Maybe ModName, [Stmt])
_MDoE
  = ((Maybe ModName, [Stmt]) -> Exp)
-> (Exp -> Maybe (Maybe ModName, [Stmt]))
-> Prism' Exp (Maybe ModName, [Stmt])
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Maybe ModName, [Stmt]) -> Exp
reviewer Exp -> Maybe (Maybe ModName, [Stmt])
remitter
  where
      reviewer :: (Maybe ModName, [Stmt]) -> Exp
reviewer (Maybe ModName
x, [Stmt]
y) = Maybe ModName -> [Stmt] -> Exp
MDoE Maybe ModName
x [Stmt]
y
      remitter :: Exp -> Maybe (Maybe ModName, [Stmt])
remitter (MDoE Maybe ModName
x [Stmt]
y) = (Maybe ModName, [Stmt]) -> Maybe (Maybe ModName, [Stmt])
forall a. a -> Maybe a
Just (Maybe ModName
x, [Stmt]
y)
      remitter Exp
_ = Maybe (Maybe ModName, [Stmt])
forall a. Maybe a
Nothing
# else
_MDoE :: Prism' Exp [Stmt]
_MDoE
  = prism' reviewer remitter
  where
      reviewer = MDoE
      remitter (MDoE x) = Just x
      remitter _ = Nothing
# endif

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

#if MIN_VERSION_template_haskell(2,18,0)
_GetFieldE :: Prism' Exp (Exp, String)
_GetFieldE :: Prism' Exp (Exp, [Char])
_GetFieldE
  = ((Exp, [Char]) -> Exp)
-> (Exp -> Maybe (Exp, [Char])) -> Prism' Exp (Exp, [Char])
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Exp, [Char]) -> Exp
reviewer Exp -> Maybe (Exp, [Char])
remitter
  where
      reviewer :: (Exp, [Char]) -> Exp
reviewer (Exp
x, [Char]
y) = Exp -> [Char] -> Exp
GetFieldE Exp
x [Char]
y
      remitter :: Exp -> Maybe (Exp, [Char])
remitter (GetFieldE Exp
x [Char]
y) = (Exp, [Char]) -> Maybe (Exp, [Char])
forall a. a -> Maybe a
Just (Exp
x, [Char]
y)
      remitter Exp
_ = Maybe (Exp, [Char])
forall a. Maybe a
Nothing

_ProjectionE :: Prism' Exp (NonEmpty String)
_ProjectionE :: Prism' Exp (NonEmpty [Char])
_ProjectionE
  = (NonEmpty [Char] -> Exp)
-> (Exp -> Maybe (NonEmpty [Char])) -> Prism' Exp (NonEmpty [Char])
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' NonEmpty [Char] -> Exp
reviewer Exp -> Maybe (NonEmpty [Char])
remitter
  where
      reviewer :: NonEmpty [Char] -> Exp
reviewer = NonEmpty [Char] -> Exp
ProjectionE
      remitter :: Exp -> Maybe (NonEmpty [Char])
remitter (ProjectionE NonEmpty [Char]
x) = NonEmpty [Char] -> Maybe (NonEmpty [Char])
forall a. a -> Maybe a
Just NonEmpty [Char]
x
      remitter Exp
_ = Maybe (NonEmpty [Char])
forall a. Maybe a
Nothing
#endif

#if MIN_VERSION_template_haskell(2,19,0)
_LamCasesE :: Prism' Exp [Clause]
_LamCasesE :: Prism' Exp [Clause]
_LamCasesE
  = ([Clause] -> Exp) -> (Exp -> Maybe [Clause]) -> Prism' Exp [Clause]
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' [Clause] -> Exp
reviewer Exp -> Maybe [Clause]
remitter
  where
      reviewer :: [Clause] -> Exp
reviewer = [Clause] -> Exp
LamCasesE
      remitter :: Exp -> Maybe [Clause]
remitter (LamCasesE [Clause]
x) = [Clause] -> Maybe [Clause]
forall a. a -> Maybe a
Just [Clause]
x
      remitter Exp
_ = Maybe [Clause]
forall a. Maybe a
Nothing
#endif

#if MIN_VERSION_template_haskell(2,21,0)
_TypedBracketE :: Prism' Exp Exp
_TypedBracketE
  = prism' reviewer remitter
  where
      reviewer = TypedBracketE
      remitter (TypedBracketE x) = Just x
      remitter _ = Nothing

_TypedSpliceE :: Prism' Exp Exp
_TypedSpliceE
  = prism' reviewer remitter
  where
      reviewer = TypedSpliceE
      remitter (TypedSpliceE x) = Just x
      remitter _ = Nothing
#endif

#if MIN_VERSION_template_haskell(2,22,0)
_TypeE :: Prism' Exp Type
_TypeE
  = prism' reviewer remitter
  where
      reviewer = TypeE
      remitter (TypeE x) = Just x
      remitter _ = Nothing
#endif

_GuardedB :: Prism' Body [(Guard, Exp)]
_GuardedB :: Prism' Body [(Guard, Exp)]
_GuardedB
  = ([(Guard, Exp)] -> Body)
-> (Body -> Maybe [(Guard, Exp)]) -> Prism' Body [(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 [(Guard, Exp)]
x) = [(Guard, Exp)] -> Maybe [(Guard, Exp)]
forall a. a -> Maybe a
Just [(Guard, Exp)]
x
      remitter Body
_ = Maybe [(Guard, Exp)]
forall a. Maybe a
Nothing

_NormalB :: Prism' Body Exp
_NormalB :: Prism' Body Exp
_NormalB
  = (Exp -> Body) -> (Body -> Maybe Exp) -> Prism' Body 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 Exp
x) = Exp -> Maybe Exp
forall a. a -> Maybe a
Just Exp
x
      remitter Body
_ = Maybe Exp
forall a. Maybe a
Nothing

_NormalG :: Prism' Guard Exp
_NormalG :: Prism' Guard Exp
_NormalG
  = (Exp -> Guard) -> (Guard -> Maybe Exp) -> Prism' Guard 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 Exp
x) = Exp -> Maybe Exp
forall a. a -> Maybe a
Just Exp
x
      remitter Guard
_ = Maybe Exp
forall a. Maybe a
Nothing

_PatG :: Prism' Guard [Stmt]
_PatG :: Prism' Guard [Stmt]
_PatG
  = ([Stmt] -> Guard) -> (Guard -> Maybe [Stmt]) -> Prism' Guard [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 [Stmt]
x) = [Stmt] -> Maybe [Stmt]
forall a. a -> Maybe a
Just [Stmt]
x
      remitter Guard
_ = Maybe [Stmt]
forall a. Maybe a
Nothing

_BindS :: Prism' Stmt (Pat, Exp)
_BindS :: Prism' Stmt (Pat, Exp)
_BindS
  = ((Pat, Exp) -> Stmt)
-> (Stmt -> Maybe (Pat, Exp)) -> Prism' Stmt (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 (Pat
x, Exp
y) = Pat -> Exp -> Stmt
BindS Pat
x Exp
y
      remitter :: Stmt -> Maybe (Pat, Exp)
remitter (BindS Pat
x Exp
y) = (Pat, Exp) -> Maybe (Pat, Exp)
forall a. a -> Maybe a
Just (Pat
x, Exp
y)
      remitter Stmt
_ = Maybe (Pat, Exp)
forall a. Maybe a
Nothing

_LetS :: Prism' Stmt [Dec]
_LetS :: Prism' Stmt [Dec]
_LetS
  = ([Dec] -> Stmt) -> (Stmt -> Maybe [Dec]) -> Prism' Stmt [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 [Dec]
x) = [Dec] -> Maybe [Dec]
forall a. a -> Maybe a
Just [Dec]
x
      remitter Stmt
_ = Maybe [Dec]
forall a. Maybe a
Nothing

_NoBindS :: Prism' Stmt Exp
_NoBindS :: Prism' Stmt Exp
_NoBindS
  = (Exp -> Stmt) -> (Stmt -> Maybe Exp) -> Prism' Stmt 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 Exp
x) = Exp -> Maybe Exp
forall a. a -> Maybe a
Just Exp
x
      remitter Stmt
_ = Maybe Exp
forall a. Maybe a
Nothing

_ParS :: Prism' Stmt [[Stmt]]
_ParS :: Prism' Stmt [[Stmt]]
_ParS
  = ([[Stmt]] -> Stmt)
-> (Stmt -> Maybe [[Stmt]]) -> Prism' 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 [[Stmt]]
x) = [[Stmt]] -> Maybe [[Stmt]]
forall a. a -> Maybe a
Just [[Stmt]]
x
      remitter Stmt
_ = Maybe [[Stmt]]
forall a. Maybe a
Nothing

#if MIN_VERSION_template_haskell(2,15,0)
_RecS :: Prism' Stmt [Stmt]
_RecS :: Prism' Stmt [Stmt]
_RecS
  = ([Stmt] -> Stmt) -> (Stmt -> Maybe [Stmt]) -> Prism' 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 [Stmt]
x) = [Stmt] -> Maybe [Stmt]
forall a. a -> Maybe a
Just [Stmt]
x
      remitter Stmt
_ = Maybe [Stmt]
forall a. Maybe a
Nothing
#endif

_FromR :: Prism' Range Exp
_FromR :: Prism' Range Exp
_FromR
  = (Exp -> Range) -> (Range -> Maybe Exp) -> Prism' Range 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 Exp
x) = Exp -> Maybe Exp
forall a. a -> Maybe a
Just Exp
x
      remitter Range
_ = Maybe Exp
forall a. Maybe a
Nothing

_FromThenR :: Prism' Range (Exp, Exp)
_FromThenR :: Prism' Range (Exp, Exp)
_FromThenR
  = ((Exp, Exp) -> Range)
-> (Range -> Maybe (Exp, Exp)) -> Prism' Range (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 (Exp
x, Exp
y) = Exp -> Exp -> Range
FromThenR Exp
x Exp
y
      remitter :: Range -> Maybe (Exp, Exp)
remitter (FromThenR Exp
x Exp
y) = (Exp, Exp) -> Maybe (Exp, Exp)
forall a. a -> Maybe a
Just (Exp
x, Exp
y)
      remitter Range
_ = Maybe (Exp, Exp)
forall a. Maybe a
Nothing

_FromToR :: Prism' Range (Exp, Exp)
_FromToR :: Prism' Range (Exp, Exp)
_FromToR
  = ((Exp, Exp) -> Range)
-> (Range -> Maybe (Exp, Exp)) -> Prism' Range (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 (Exp
x, Exp
y) = Exp -> Exp -> Range
FromToR Exp
x Exp
y
      remitter :: Range -> Maybe (Exp, Exp)
remitter (FromToR Exp
x Exp
y) = (Exp, Exp) -> Maybe (Exp, Exp)
forall a. a -> Maybe a
Just (Exp
x, Exp
y)
      remitter Range
_ = Maybe (Exp, Exp)
forall a. Maybe a
Nothing

_FromThenToR :: Prism' Range (Exp, Exp, Exp)
_FromThenToR :: Prism' Range (Exp, Exp, Exp)
_FromThenToR
  = ((Exp, Exp, Exp) -> Range)
-> (Range -> Maybe (Exp, Exp, Exp)) -> Prism' Range (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 (Exp
x, Exp
y, Exp
z) = Exp -> Exp -> Exp -> Range
FromThenToR Exp
x Exp
y Exp
z
      remitter :: Range -> Maybe (Exp, Exp, Exp)
remitter (FromThenToR Exp
x Exp
y Exp
z) = (Exp, Exp, Exp) -> Maybe (Exp, Exp, Exp)
forall a. a -> Maybe a
Just (Exp
x, Exp
y, Exp
z)
      remitter Range
_ = Maybe (Exp, Exp, Exp)
forall a. Maybe a
Nothing

_CharL :: Prism' Lit Char
_CharL :: Prism' Lit Char
_CharL
  = (Char -> Lit) -> (Lit -> Maybe Char) -> Prism' Lit 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 Char
x) = Char -> Maybe Char
forall a. a -> Maybe a
Just Char
x
      remitter Lit
_ = Maybe Char
forall a. Maybe a
Nothing

_StringL :: Prism' Lit String
_StringL :: Prism' Lit [Char]
_StringL
  = ([Char] -> Lit) -> (Lit -> Maybe [Char]) -> Prism' Lit [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
StringL
      remitter :: Lit -> Maybe [Char]
remitter (StringL [Char]
x) = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
x
      remitter Lit
_ = Maybe [Char]
forall a. Maybe a
Nothing

_IntegerL :: Prism' Lit Integer
_IntegerL :: Prism' Lit Integer
_IntegerL
  = (Integer -> Lit) -> (Lit -> Maybe Integer) -> Prism' Lit 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 Integer
x) = Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
x
      remitter Lit
_ = Maybe Integer
forall a. Maybe a
Nothing

_RationalL :: Prism' Lit Rational
_RationalL :: Prism' Lit Rational
_RationalL
  = (Rational -> Lit) -> (Lit -> Maybe Rational) -> Prism' Lit 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 Rational
x) = Rational -> Maybe Rational
forall a. a -> Maybe a
Just Rational
x
      remitter Lit
_ = Maybe Rational
forall a. Maybe a
Nothing

_IntPrimL :: Prism' Lit Integer
_IntPrimL :: Prism' Lit Integer
_IntPrimL
  = (Integer -> Lit) -> (Lit -> Maybe Integer) -> Prism' Lit 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 Integer
x) = Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
x
      remitter Lit
_ = Maybe Integer
forall a. Maybe a
Nothing

_WordPrimL :: Prism' Lit Integer
_WordPrimL :: Prism' Lit Integer
_WordPrimL
  = (Integer -> Lit) -> (Lit -> Maybe Integer) -> Prism' Lit 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 Integer
x) = Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
x
      remitter Lit
_ = Maybe Integer
forall a. Maybe a
Nothing

_FloatPrimL :: Prism' Lit Rational
_FloatPrimL :: Prism' Lit Rational
_FloatPrimL
  = (Rational -> Lit) -> (Lit -> Maybe Rational) -> Prism' Lit 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 Rational
x) = Rational -> Maybe Rational
forall a. a -> Maybe a
Just Rational
x
      remitter Lit
_ = Maybe Rational
forall a. Maybe a
Nothing

_DoublePrimL :: Prism' Lit Rational
_DoublePrimL :: Prism' Lit Rational
_DoublePrimL
  = (Rational -> Lit) -> (Lit -> Maybe Rational) -> Prism' Lit 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 Rational
x) = Rational -> Maybe Rational
forall a. a -> Maybe a
Just Rational
x
      remitter Lit
_ = Maybe Rational
forall a. Maybe a
Nothing

_StringPrimL :: Prism' Lit [Word8]
_StringPrimL :: Prism' Lit [Word8]
_StringPrimL
  = ([Word8] -> Lit) -> (Lit -> Maybe [Word8]) -> Prism' Lit [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 [Word8]
x) = [Word8] -> Maybe [Word8]
forall a. a -> Maybe a
Just [Word8]
x
      remitter Lit
_ = Maybe [Word8]
forall a. Maybe a
Nothing

_CharPrimL :: Prism' Lit Char
_CharPrimL :: Prism' Lit Char
_CharPrimL
  = (Char -> Lit) -> (Lit -> Maybe Char) -> Prism' Lit 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 Char
x) = Char -> Maybe Char
forall a. a -> Maybe a
Just Char
x
      remitter Lit
_ = Maybe Char
forall a. Maybe a
Nothing

#if MIN_VERSION_template_haskell(2,16,0)
_BytesPrimL :: Prism' Lit Bytes
_BytesPrimL :: Prism' Lit Bytes
_BytesPrimL
  = (Bytes -> Lit) -> (Lit -> Maybe Bytes) -> Prism' Lit Bytes
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' Bytes -> Lit
reviewer Lit -> Maybe Bytes
remitter
  where
      reviewer :: Bytes -> Lit
reviewer = Bytes -> Lit
BytesPrimL
      remitter :: Lit -> Maybe Bytes
remitter (BytesPrimL Bytes
x) = Bytes -> Maybe Bytes
forall a. a -> Maybe a
Just Bytes
x
      remitter Lit
_ = Maybe Bytes
forall a. Maybe a
Nothing
#endif

_LitP :: Prism' Pat Lit
_LitP :: Prism' Pat Lit
_LitP
  = (Lit -> Pat) -> (Pat -> Maybe Lit) -> Prism' Pat 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 Lit
x) = Lit -> Maybe Lit
forall a. a -> Maybe a
Just Lit
x
      remitter Pat
_ = Maybe Lit
forall a. Maybe a
Nothing

_VarP :: Prism' Pat Name
_VarP :: Prism' Pat Name
_VarP
  = (Name -> Pat) -> (Pat -> Maybe Name) -> Prism' Pat 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 Name
x) = Name -> Maybe Name
forall a. a -> Maybe a
Just Name
x
      remitter Pat
_ = Maybe Name
forall a. Maybe a
Nothing

_TupP :: Prism' Pat [Pat]
_TupP :: Prism' Pat [Pat]
_TupP
  = ([Pat] -> Pat) -> (Pat -> Maybe [Pat]) -> Prism' 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 [Pat]
x) = [Pat] -> Maybe [Pat]
forall a. a -> Maybe a
Just [Pat]
x
      remitter Pat
_ = Maybe [Pat]
forall a. Maybe a
Nothing

_UnboxedTupP :: Prism' Pat [Pat]
_UnboxedTupP :: Prism' Pat [Pat]
_UnboxedTupP
  = ([Pat] -> Pat) -> (Pat -> Maybe [Pat]) -> Prism' 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 [Pat]
x) = [Pat] -> Maybe [Pat]
forall a. a -> Maybe a
Just [Pat]
x
      remitter Pat
_ = Maybe [Pat]
forall a. Maybe a
Nothing

#if MIN_VERSION_template_haskell(2,12,0)
_UnboxedSumP :: Prism' Pat (Pat, SumAlt, SumArity)
_UnboxedSumP :: Prism' Pat (Pat, Int, Int)
_UnboxedSumP
  = ((Pat, Int, Int) -> Pat)
-> (Pat -> Maybe (Pat, Int, Int)) -> Prism' Pat (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 (Pat
x, Int
y, Int
z) = Pat -> Int -> Int -> Pat
UnboxedSumP Pat
x Int
y Int
z
      remitter :: Pat -> Maybe (Pat, Int, Int)
remitter (UnboxedSumP Pat
x Int
y Int
z) = (Pat, Int, Int) -> Maybe (Pat, Int, Int)
forall a. a -> Maybe a
Just (Pat
x, Int
y, Int
z)
      remitter Pat
_ = Maybe (Pat, Int, Int)
forall a. Maybe a
Nothing
#endif

-- |
-- @
-- _ConP :: 'Prism'' 'Pat' ('Name', ['Type'], ['Pat']) -- template-haskell-2.18+
-- _ConP :: 'Prism'' 'Pat' ('Name',         ['Pat']) -- Earlier versions
-- @
#if MIN_VERSION_template_haskell(2,18,0)
_ConP :: Prism' Pat (Name, [Type], [Pat])
_ConP :: Prism' Pat (Name, Cxt, [Pat])
_ConP
  = ((Name, Cxt, [Pat]) -> Pat)
-> (Pat -> Maybe (Name, Cxt, [Pat]))
-> Prism' Pat (Name, Cxt, [Pat])
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Name, Cxt, [Pat]) -> Pat
reviewer Pat -> Maybe (Name, Cxt, [Pat])
remitter
  where
      reviewer :: (Name, Cxt, [Pat]) -> Pat
reviewer (Name
x, Cxt
y, [Pat]
z) = Name -> Cxt -> [Pat] -> Pat
ConP Name
x Cxt
y [Pat]
z
      remitter :: Pat -> Maybe (Name, Cxt, [Pat])
remitter (ConP Name
x Cxt
y [Pat]
z) = (Name, Cxt, [Pat]) -> Maybe (Name, Cxt, [Pat])
forall a. a -> Maybe a
Just (Name
x, Cxt
y, [Pat]
z)
      remitter Pat
_ = Maybe (Name, Cxt, [Pat])
forall a. Maybe a
Nothing
#else
_ConP :: Prism' Pat (Name, [Pat])
_ConP
  = prism' reviewer remitter
  where
      reviewer (x, y) = ConP x y
      remitter (ConP x y) = Just (x, y)
      remitter _ = Nothing
#endif

_InfixP :: Prism' Pat (Pat, Name, Pat)
_InfixP :: Prism' Pat (Pat, Name, Pat)
_InfixP
  = ((Pat, Name, Pat) -> Pat)
-> (Pat -> Maybe (Pat, Name, Pat)) -> Prism' 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 (Pat
x, Name
y, Pat
z) = Pat -> Name -> Pat -> Pat
InfixP Pat
x Name
y Pat
z
      remitter :: Pat -> Maybe (Pat, Name, Pat)
remitter (InfixP Pat
x Name
y Pat
z) = (Pat, Name, Pat) -> Maybe (Pat, Name, Pat)
forall a. a -> Maybe a
Just (Pat
x, Name
y, Pat
z)
      remitter Pat
_ = Maybe (Pat, Name, Pat)
forall a. Maybe a
Nothing

_UInfixP :: Prism' Pat (Pat, Name, Pat)
_UInfixP :: Prism' Pat (Pat, Name, Pat)
_UInfixP
  = ((Pat, Name, Pat) -> Pat)
-> (Pat -> Maybe (Pat, Name, Pat)) -> Prism' 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 (Pat
x, Name
y, Pat
z) = Pat -> Name -> Pat -> Pat
UInfixP Pat
x Name
y Pat
z
      remitter :: Pat -> Maybe (Pat, Name, Pat)
remitter (UInfixP Pat
x Name
y Pat
z) = (Pat, Name, Pat) -> Maybe (Pat, Name, Pat)
forall a. a -> Maybe a
Just (Pat
x, Name
y, Pat
z)
      remitter Pat
_ = Maybe (Pat, Name, Pat)
forall a. Maybe a
Nothing

_ParensP :: Prism' Pat Pat
_ParensP :: Prism' Pat Pat
_ParensP
  = (Pat -> Pat) -> (Pat -> Maybe Pat) -> Prism' 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 Pat
x) = Pat -> Maybe Pat
forall a. a -> Maybe a
Just Pat
x
      remitter Pat
_ = Maybe Pat
forall a. Maybe a
Nothing

_TildeP :: Prism' Pat Pat
_TildeP :: Prism' Pat Pat
_TildeP
  = (Pat -> Pat) -> (Pat -> Maybe Pat) -> Prism' 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 Pat
x) = Pat -> Maybe Pat
forall a. a -> Maybe a
Just Pat
x
      remitter Pat
_ = Maybe Pat
forall a. Maybe a
Nothing

_BangP :: Prism' Pat Pat
_BangP :: Prism' Pat Pat
_BangP
  = (Pat -> Pat) -> (Pat -> Maybe Pat) -> Prism' 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 Pat
x) = Pat -> Maybe Pat
forall a. a -> Maybe a
Just Pat
x
      remitter Pat
_ = Maybe Pat
forall a. Maybe a
Nothing

_AsP :: Prism' Pat (Name, Pat)
_AsP :: Prism' Pat FieldPat
_AsP
  = (FieldPat -> Pat) -> (Pat -> Maybe FieldPat) -> Prism' Pat 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 (Name
x, Pat
y) = Name -> Pat -> Pat
AsP Name
x Pat
y
      remitter :: Pat -> Maybe FieldPat
remitter (AsP Name
x Pat
y) = FieldPat -> Maybe FieldPat
forall a. a -> Maybe a
Just (Name
x, Pat
y)
      remitter Pat
_ = Maybe FieldPat
forall a. Maybe a
Nothing

_WildP :: Prism' Pat ()
_WildP :: Prism' Pat ()
_WildP
  = (() -> Pat) -> (Pat -> Maybe ()) -> Prism' 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 Pat
WildP = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Pat
_ = Maybe ()
forall a. Maybe a
Nothing

_RecP :: Prism' Pat (Name, [FieldPat])
_RecP :: Prism' Pat (Name, [FieldPat])
_RecP
  = ((Name, [FieldPat]) -> Pat)
-> (Pat -> Maybe (Name, [FieldPat]))
-> Prism' Pat (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 (Name
x, [FieldPat]
y) = Name -> [FieldPat] -> Pat
RecP Name
x [FieldPat]
y
      remitter :: Pat -> Maybe (Name, [FieldPat])
remitter (RecP Name
x [FieldPat]
y) = (Name, [FieldPat]) -> Maybe (Name, [FieldPat])
forall a. a -> Maybe a
Just (Name
x, [FieldPat]
y)
      remitter Pat
_ = Maybe (Name, [FieldPat])
forall a. Maybe a
Nothing

_ListP :: Prism' Pat [Pat]
_ListP :: Prism' Pat [Pat]
_ListP
  = ([Pat] -> Pat) -> (Pat -> Maybe [Pat]) -> Prism' 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 [Pat]
x) = [Pat] -> Maybe [Pat]
forall a. a -> Maybe a
Just [Pat]
x
      remitter Pat
_ = Maybe [Pat]
forall a. Maybe a
Nothing

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

_ViewP :: Prism' Pat (Exp, Pat)
_ViewP :: Prism' Pat (Exp, Pat)
_ViewP
  = ((Exp, Pat) -> Pat)
-> (Pat -> Maybe (Exp, Pat)) -> Prism' 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 (Exp
x, Pat
y) = Exp -> Pat -> Pat
ViewP Exp
x Pat
y
      remitter :: Pat -> Maybe (Exp, Pat)
remitter (ViewP Exp
x Pat
y) = (Exp, Pat) -> Maybe (Exp, Pat)
forall a. a -> Maybe a
Just (Exp
x, Pat
y)
      remitter Pat
_ = Maybe (Exp, Pat)
forall a. Maybe a
Nothing

#if MIN_VERSION_template_haskell(2,22,0)
_TypeP :: Prism' Pat Type
_TypeP
  = prism' reviewer remitter
  where
      reviewer = TypeP
      remitter (TypeP x) = Just x
      remitter _ = Nothing

_InvisP :: Prism' Pat Type
_InvisP
  = prism' reviewer remitter
  where
      reviewer = InvisP
      remitter (InvisP x) = Just x
      remitter _ = Nothing
#endif

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

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

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

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

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

_PromotedT :: Prism' Type Name
_PromotedT :: Prism' Type Name
_PromotedT
  = (Name -> Type) -> (Type -> Maybe Name) -> Prism' Type Name
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' Name -> Type
reviewer Type -> Maybe Name
remitter
  where
      reviewer :: Name -> Type
reviewer = Name -> Type
PromotedT
      remitter :: Type -> Maybe Name
remitter (PromotedT Name
x) = Name -> Maybe Name
forall a. a -> Maybe a
Just Name
x
      remitter Type
_ = Maybe Name
forall a. Maybe a
Nothing

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

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

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

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

_EqualityT :: Prism' Type ()
_EqualityT :: Prism' Type ()
_EqualityT
  = (() -> Type) -> (Type -> Maybe ()) -> Prism' Type ()
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' () -> Type
reviewer Type -> Maybe ()
remitter
  where
      reviewer :: () -> Type
reviewer () = Type
EqualityT
      remitter :: Type -> Maybe ()
remitter Type
EqualityT = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Type
_ = Maybe ()
forall a. Maybe a
Nothing

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

_PromotedTupleT :: Prism' Type Int
_PromotedTupleT :: Prism' Type Int
_PromotedTupleT
  = (Int -> Type) -> (Type -> Maybe Int) -> Prism' Type Int
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' Int -> Type
reviewer Type -> Maybe Int
remitter
  where
      reviewer :: Int -> Type
reviewer = Int -> Type
PromotedTupleT
      remitter :: Type -> Maybe Int
remitter (PromotedTupleT Int
x) = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
x
      remitter Type
_ = Maybe Int
forall a. Maybe a
Nothing

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

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

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

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

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

_InfixT :: Prism' Type (Type, Name, Type)
_InfixT :: Prism' Type (Type, Name, Type)
_InfixT
  = ((Type, Name, Type) -> Type)
-> (Type -> Maybe (Type, Name, Type))
-> Prism' Type (Type, Name, Type)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Type, Name, Type) -> Type
reviewer Type -> Maybe (Type, Name, Type)
remitter
  where
      reviewer :: (Type, Name, Type) -> Type
reviewer (Type
x, Name
y, Type
z) = Type -> Name -> Type -> Type
InfixT Type
x Name
y Type
z
      remitter :: Type -> Maybe (Type, Name, Type)
remitter (InfixT Type
x Name
y Type
z) = (Type, Name, Type) -> Maybe (Type, Name, Type)
forall a. a -> Maybe a
Just (Type
x, Name
y, Type
z)
      remitter Type
_ = Maybe (Type, Name, Type)
forall a. Maybe a
Nothing

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

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

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

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

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

#if MIN_VERSION_template_haskell(2,16,0)
_ForallVisT :: Prism' Type ([TyVarBndrUnit], Type)
_ForallVisT :: Prism' Type ([TyVarBndr ()], Type)
_ForallVisT
  = (([TyVarBndr ()], Type) -> Type)
-> (Type -> Maybe ([TyVarBndr ()], Type))
-> Prism' Type ([TyVarBndr ()], Type)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' ([TyVarBndr ()], Type) -> Type
reviewer Type -> Maybe ([TyVarBndr ()], Type)
remitter
  where
      reviewer :: ([TyVarBndr ()], Type) -> Type
reviewer ([TyVarBndr ()]
x, Type
y) = [TyVarBndr ()] -> Type -> Type
ForallVisT [TyVarBndr ()]
x Type
y
      remitter :: Type -> Maybe ([TyVarBndr ()], Type)
remitter (ForallVisT [TyVarBndr ()]
x Type
y) = ([TyVarBndr ()], Type) -> Maybe ([TyVarBndr ()], Type)
forall a. a -> Maybe a
Just ([TyVarBndr ()]
x, Type
y)
      remitter Type
_ = Maybe ([TyVarBndr ()], Type)
forall a. Maybe a
Nothing
#endif

#if MIN_VERSION_template_haskell(2,17,0)
_MulArrowT :: Prism' Type ()
_MulArrowT :: Prism' Type ()
_MulArrowT
  = (() -> Type) -> (Type -> Maybe ()) -> Prism' Type ()
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' () -> Type
reviewer Type -> Maybe ()
remitter
  where
      reviewer :: () -> Type
reviewer () = Type
MulArrowT
      remitter :: Type -> Maybe ()
remitter Type
MulArrowT = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Type
_ = Maybe ()
forall a. Maybe a
Nothing
#endif

#if MIN_VERSION_template_haskell(2,19,0)
_PromotedInfixT :: Prism' Type (Type, Name, Type)
_PromotedInfixT :: Prism' Type (Type, Name, Type)
_PromotedInfixT
  = ((Type, Name, Type) -> Type)
-> (Type -> Maybe (Type, Name, Type))
-> Prism' Type (Type, Name, Type)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Type, Name, Type) -> Type
reviewer Type -> Maybe (Type, Name, Type)
remitter
  where
      reviewer :: (Type, Name, Type) -> Type
reviewer (Type
x, Name
y, Type
z) = Type -> Name -> Type -> Type
PromotedInfixT Type
x Name
y Type
z
      remitter :: Type -> Maybe (Type, Name, Type)
remitter (PromotedInfixT Type
x Name
y Type
z) = (Type, Name, Type) -> Maybe (Type, Name, Type)
forall a. a -> Maybe a
Just (Type
x, Name
y, Type
z)
      remitter Type
_ = Maybe (Type, Name, Type)
forall a. Maybe a
Nothing

_PromotedUInfixT :: Prism' Type (Type, Name, Type)
_PromotedUInfixT :: Prism' Type (Type, Name, Type)
_PromotedUInfixT
  = ((Type, Name, Type) -> Type)
-> (Type -> Maybe (Type, Name, Type))
-> Prism' Type (Type, Name, Type)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Type, Name, Type) -> Type
reviewer Type -> Maybe (Type, Name, Type)
remitter
  where
      reviewer :: (Type, Name, Type) -> Type
reviewer (Type
x, Name
y, Type
z) = Type -> Name -> Type -> Type
PromotedUInfixT Type
x Name
y Type
z
      remitter :: Type -> Maybe (Type, Name, Type)
remitter (PromotedUInfixT Type
x Name
y Type
z) = (Type, Name, Type) -> Maybe (Type, Name, Type)
forall a. a -> Maybe a
Just (Type
x, Name
y, Type
z)
      remitter Type
_ = Maybe (Type, Name, Type)
forall a. Maybe a
Nothing
#endif

#if MIN_VERSION_template_haskell(2,17,0)
_SpecifiedSpec :: Prism' Specificity ()
_SpecifiedSpec :: Prism' Specificity ()
_SpecifiedSpec
  = (() -> Specificity)
-> (Specificity -> Maybe ()) -> Prism' Specificity ()
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' () -> Specificity
reviewer Specificity -> Maybe ()
remitter
  where
      reviewer :: () -> Specificity
reviewer () = Specificity
SpecifiedSpec
      remitter :: Specificity -> Maybe ()
remitter Specificity
SpecifiedSpec = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Specificity
_ = Maybe ()
forall a. Maybe a
Nothing

_InferredSpec :: Prism' Specificity ()
_InferredSpec :: Prism' Specificity ()
_InferredSpec
  = (() -> Specificity)
-> (Specificity -> Maybe ()) -> Prism' Specificity ()
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' () -> Specificity
reviewer Specificity -> Maybe ()
remitter
  where
      reviewer :: () -> Specificity
reviewer () = Specificity
InferredSpec
      remitter :: Specificity -> Maybe ()
remitter Specificity
InferredSpec = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Specificity
_ = Maybe ()
forall a. Maybe a
Nothing
#endif

#if MIN_VERSION_template_haskell(2,21,0)
_BndrReq :: Prism' BndrVis ()
_BndrReq
  = prism' reviewer remitter
  where
      reviewer () = BndrReq
      remitter BndrReq = Just ()
      remitter _ = Nothing

_BndrInvis :: Prism' BndrVis ()
_BndrInvis
  = prism' reviewer remitter
  where
      reviewer () = BndrInvis
      remitter BndrInvis = Just ()
      remitter _ = Nothing
#endif

-- |
-- @
-- _PlainTV :: 'Prism'' ('TyVarBndr' flag) ('Name', flag) -- template-haskell-2.17+
-- _PlainTV :: 'Prism''  'TyVarBndr'        'Name'        -- Earlier versions
-- @
#if MIN_VERSION_template_haskell(2,17,0)
_PlainTV :: Prism' (TyVarBndr flag) (Name, flag)
_PlainTV :: forall flag (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (Name, flag) (f (Name, flag))
-> p (TyVarBndr flag) (f (TyVarBndr flag))
_PlainTV
  = ((Name, flag) -> TyVarBndr flag)
-> (TyVarBndr flag -> Maybe (Name, flag))
-> Prism
     (TyVarBndr flag) (TyVarBndr flag) (Name, flag) (Name, flag)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Name, flag) -> TyVarBndr flag
forall {flag}. (Name, flag) -> TyVarBndr flag
reviewer TyVarBndr flag -> Maybe (Name, flag)
forall {b}. TyVarBndr b -> Maybe (Name, b)
remitter
  where
      reviewer :: (Name, flag) -> TyVarBndr flag
reviewer (Name
x, flag
y) = Name -> flag -> TyVarBndr flag
forall flag. Name -> flag -> TyVarBndr flag
PlainTV Name
x flag
y
      remitter :: TyVarBndr b -> Maybe (Name, b)
remitter (PlainTV Name
x b
y) = (Name, b) -> Maybe (Name, b)
forall a. a -> Maybe a
Just (Name
x, b
y)
      remitter TyVarBndr b
_ = Maybe (Name, b)
forall a. Maybe a
Nothing
#else
_PlainTV :: Prism' TyVarBndr Name
_PlainTV
  = prism' reviewer remitter
  where
      reviewer = PlainTV
      remitter (PlainTV x) = Just x
      remitter _ = Nothing
#endif

-- |
-- @
-- _KindedTV :: 'Prism'' ('TyVarBndr' flag) ('Name', flag, 'Kind') -- template-haskell-2.17+
-- _KindedTV :: 'Prism''  'TyVarBndr'       ('Name',       'Kind') -- Earlier versions
-- @
#if MIN_VERSION_template_haskell(2,17,0)
_KindedTV :: Prism' (TyVarBndr flag) (Name, flag, Kind)
_KindedTV :: forall flag (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p (Name, flag, Type) (f (Name, flag, Type))
-> p (TyVarBndr flag) (f (TyVarBndr flag))
_KindedTV
  = ((Name, flag, Type) -> TyVarBndr flag)
-> (TyVarBndr flag -> Maybe (Name, flag, Type))
-> Prism
     (TyVarBndr flag)
     (TyVarBndr flag)
     (Name, flag, Type)
     (Name, flag, Type)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Name, flag, Type) -> TyVarBndr flag
forall {flag}. (Name, flag, Type) -> TyVarBndr flag
reviewer TyVarBndr flag -> Maybe (Name, flag, Type)
forall {b}. TyVarBndr b -> Maybe (Name, b, Type)
remitter
  where
      reviewer :: (Name, flag, Type) -> TyVarBndr flag
reviewer (Name
x, flag
y, Type
z) = Name -> flag -> Type -> TyVarBndr flag
forall flag. Name -> flag -> Type -> TyVarBndr flag
KindedTV Name
x flag
y Type
z
      remitter :: TyVarBndr b -> Maybe (Name, b, Type)
remitter (KindedTV Name
x b
y Type
z) = (Name, b, Type) -> Maybe (Name, b, Type)
forall a. a -> Maybe a
Just (Name
x, b
y, Type
z)
      remitter TyVarBndr b
_ = Maybe (Name, b, Type)
forall a. Maybe a
Nothing
#else
_KindedTV :: Prism' TyVarBndr (Name, Kind)
_KindedTV
  = prism' reviewer remitter
  where
      reviewer (x, y) = KindedTV x y
      remitter (KindedTV x y) = Just (x, y)
      remitter _ = Nothing
#endif

_NoSig :: Prism' FamilyResultSig ()
_NoSig :: Prism' FamilyResultSig ()
_NoSig
  = (() -> FamilyResultSig)
-> (FamilyResultSig -> Maybe ()) -> Prism' 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 FamilyResultSig
NoSig = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter FamilyResultSig
_ = Maybe ()
forall a. Maybe a
Nothing

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

_TyVarSig :: Prism' FamilyResultSig TyVarBndrUnit
_TyVarSig :: Prism' FamilyResultSig (TyVarBndr ())
_TyVarSig
  = (TyVarBndr () -> FamilyResultSig)
-> (FamilyResultSig -> Maybe (TyVarBndr ()))
-> Prism' FamilyResultSig (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 TyVarBndr ()
x) = TyVarBndr () -> Maybe (TyVarBndr ())
forall a. a -> Maybe a
Just TyVarBndr ()
x
      remitter FamilyResultSig
_ = Maybe (TyVarBndr ())
forall a. Maybe a
Nothing

_NumTyLit :: Prism' TyLit Integer
_NumTyLit :: Prism' TyLit Integer
_NumTyLit
  = (Integer -> TyLit)
-> (TyLit -> Maybe Integer) -> Prism' TyLit 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 Integer
x) = Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
x
      remitter TyLit
_ = Maybe Integer
forall a. Maybe a
Nothing

_StrTyLit :: Prism' TyLit String
_StrTyLit :: Prism' TyLit [Char]
_StrTyLit
  = ([Char] -> TyLit) -> (TyLit -> Maybe [Char]) -> Prism' TyLit [Char]
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' [Char] -> TyLit
reviewer TyLit -> Maybe [Char]
remitter
  where
      reviewer :: [Char] -> TyLit
reviewer = [Char] -> TyLit
StrTyLit
      remitter :: TyLit -> Maybe [Char]
remitter (StrTyLit [Char]
x) = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
x
      remitter TyLit
_ = Maybe [Char]
forall a. Maybe a
Nothing

#if MIN_VERSION_template_haskell(2,18,0)
_CharTyLit :: Prism' TyLit Char
_CharTyLit :: Prism' TyLit Char
_CharTyLit
  = (Char -> TyLit) -> (TyLit -> Maybe Char) -> Prism' TyLit Char
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' Char -> TyLit
reviewer TyLit -> Maybe Char
remitter
  where
      reviewer :: Char -> TyLit
reviewer = Char -> TyLit
CharTyLit
      remitter :: TyLit -> Maybe Char
remitter (CharTyLit Char
x) = Char -> Maybe Char
forall a. a -> Maybe a
Just Char
x
      remitter TyLit
_ = Maybe Char
forall a. Maybe a
Nothing
#endif

_NominalR :: Prism' Role ()
_NominalR :: Prism' Role ()
_NominalR
  = (() -> Role) -> (Role -> Maybe ()) -> Prism' 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 Role
NominalR = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Role
_ = Maybe ()
forall a. Maybe a
Nothing

_RepresentationalR :: Prism' Role ()
_RepresentationalR :: Prism' Role ()
_RepresentationalR
  = (() -> Role) -> (Role -> Maybe ()) -> Prism' 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 Role
RepresentationalR = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Role
_ = Maybe ()
forall a. Maybe a
Nothing

_PhantomR :: Prism' Role ()
_PhantomR :: Prism' Role ()
_PhantomR
  = (() -> Role) -> (Role -> Maybe ()) -> Prism' 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 Role
PhantomR = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Role
_ = Maybe ()
forall a. Maybe a
Nothing

_InferR :: Prism' Role ()
_InferR :: Prism' Role ()
_InferR
  = (() -> Role) -> (Role -> Maybe ()) -> Prism' 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 Role
InferR = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter Role
_ = Maybe ()
forall a. Maybe a
Nothing

#if MIN_VERSION_template_haskell(2,12,0)
_StockStrategy :: Prism' DerivStrategy ()
_StockStrategy :: Prism' DerivStrategy ()
_StockStrategy
  = (() -> DerivStrategy)
-> (DerivStrategy -> Maybe ()) -> Prism' 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 DerivStrategy
StockStrategy = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter DerivStrategy
_ = Maybe ()
forall a. Maybe a
Nothing

_AnyclassStrategy :: Prism' DerivStrategy ()
_AnyclassStrategy :: Prism' DerivStrategy ()
_AnyclassStrategy
  = (() -> DerivStrategy)
-> (DerivStrategy -> Maybe ()) -> Prism' 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 DerivStrategy
AnyclassStrategy = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter DerivStrategy
_ = Maybe ()
forall a. Maybe a
Nothing

_NewtypeStrategy :: Prism' DerivStrategy ()
_NewtypeStrategy :: Prism' DerivStrategy ()
_NewtypeStrategy
  = (() -> DerivStrategy)
-> (DerivStrategy -> Maybe ()) -> Prism' 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 DerivStrategy
NewtypeStrategy = () -> Maybe ()
forall a. a -> Maybe a
Just ()
      remitter DerivStrategy
_ = Maybe ()
forall a. Maybe a
Nothing
#endif