Safe Haskell	Safe-Inferred
Language	Haskell2010

Data.Functor.Base.TH

Contents

Orphan instances

Documentation

data ConF r Source #

Constructors

NormalCF Name [(Bang, Type)]
RecCF Name [(Name, Bang, Type)]
InfixCF (Bang, Type) Name (Bang, Type)
ForallCF [TyVarBndr Specificity] [Type] r
GadtCF [Name] [(Bang, Type)] Type
RecGadtCF [Name] [(Name, Bang, Type)] Type

Instances

Instances details

Foldable ConF Source #
Instance details Defined in Data.Functor.Base.TH Methods fold :: Monoid m => ConF m -> m # foldMap :: Monoid m => (a -> m) -> ConF a -> m # foldMap' :: Monoid m => (a -> m) -> ConF a -> m # foldr :: (a -> b -> b) -> b -> ConF a -> b # foldr' :: (a -> b -> b) -> b -> ConF a -> b # foldl :: (b -> a -> b) -> b -> ConF a -> b # foldl' :: (b -> a -> b) -> b -> ConF a -> b # foldr1 :: (a -> a -> a) -> ConF a -> a # foldl1 :: (a -> a -> a) -> ConF a -> a # toList :: ConF a -> [a] # null :: ConF a -> Bool # length :: ConF a -> Int # elem :: Eq a => a -> ConF a -> Bool # maximum :: Ord a => ConF a -> a # minimum :: Ord a => ConF a -> a # sum :: Num a => ConF a -> a # product :: Num a => ConF a -> a #
Traversable ConF Source #
Instance details Defined in Data.Functor.Base.TH Methods traverse :: Applicative f => (a -> f b) -> ConF a -> f (ConF b) # sequenceA :: Applicative f => ConF (f a) -> f (ConF a) # mapM :: Monad m => (a -> m b) -> ConF a -> m (ConF b) # sequence :: Monad m => ConF (m a) -> m (ConF a) #
Functor ConF Source #
Instance details Defined in Data.Functor.Base.TH Methods fmap :: (a -> b) -> ConF a -> ConF b # (<$) :: a -> ConF b -> ConF a #

data DecF r Source #

Constructors

FunDF Name [Clause]
ValDF Pat Body [r]
DataDF [Type] Name [TyVarBndr ()] (Maybe Type) [Con] [DerivClause]
NewtypeDF [Type] Name [TyVarBndr ()] (Maybe Type) Con [DerivClause]
TySynDF Name [TyVarBndr ()] Type
ClassDF [Type] Name [TyVarBndr ()] [FunDep] [r]
InstanceDF (Maybe Overlap) [Type] Type [r]
SigDF Name Type
KiSigDF Name Type
ForeignDF Foreign
InfixDF Fixity Name
DefaultDF [Type]
PragmaDF Pragma
DataFamilyDF Name [TyVarBndr ()] (Maybe Type)
DataInstDF [Type] (Maybe [TyVarBndr ()]) Type (Maybe Type) [Con] [DerivClause]
NewtypeInstDF [Type] (Maybe [TyVarBndr ()]) Type (Maybe Type) Con [DerivClause]
TySynInstDF TySynEqn
OpenTypeFamilyDF TypeFamilyHead
ClosedTypeFamilyDF TypeFamilyHead [TySynEqn]
RoleAnnotDF Name [Role]
StandaloneDerivDF (Maybe DerivStrategy) [Type] Type
DefaultSigDF Name Type
PatSynDF Name PatSynArgs PatSynDir Pat
PatSynSigDF Name Type
ImplicitParamBindDF [Char] Exp

Instances

Instances details

Foldable DecF Source #
Instance details Defined in Data.Functor.Base.TH Methods fold :: Monoid m => DecF m -> m # foldMap :: Monoid m => (a -> m) -> DecF a -> m # foldMap' :: Monoid m => (a -> m) -> DecF a -> m # foldr :: (a -> b -> b) -> b -> DecF a -> b # foldr' :: (a -> b -> b) -> b -> DecF a -> b # foldl :: (b -> a -> b) -> b -> DecF a -> b # foldl' :: (b -> a -> b) -> b -> DecF a -> b # foldr1 :: (a -> a -> a) -> DecF a -> a # foldl1 :: (a -> a -> a) -> DecF a -> a # toList :: DecF a -> [a] # null :: DecF a -> Bool # length :: DecF a -> Int # elem :: Eq a => a -> DecF a -> Bool # maximum :: Ord a => DecF a -> a # minimum :: Ord a => DecF a -> a # sum :: Num a => DecF a -> a # product :: Num a => DecF a -> a #
Traversable DecF Source #
Instance details Defined in Data.Functor.Base.TH Methods traverse :: Applicative f => (a -> f b) -> DecF a -> f (DecF b) # sequenceA :: Applicative f => DecF (f a) -> f (DecF a) # mapM :: Monad m => (a -> m b) -> DecF a -> m (DecF b) # sequence :: Monad m => DecF (m a) -> m (DecF a) #
Functor DecF Source #
Instance details Defined in Data.Functor.Base.TH Methods fmap :: (a -> b) -> DecF a -> DecF b # (<$) :: a -> DecF b -> DecF a #

data ExpF r Source #

Constructors

VarEF Name
ConEF Name
LitEF Lit
AppEF r r
AppTypeEF r Type
InfixEF (Maybe r) r (Maybe r)
UInfixEF r r r
ParensEF r
LamEF [Pat] r
LamCaseEF [Match]
LamCasesEF [Clause]
TupEF [Maybe r]
UnboxedTupEF [Maybe r]
UnboxedSumEF r Int Int
CondEF r r r
MultiIfEF [(Guard, r)]
LetEF [Dec] r
CaseEF r [Match]
DoEF (Maybe ModName) [Stmt]
MDoEF (Maybe ModName) [Stmt]
CompEF [Stmt]
ArithSeqEF Range
ListEF [r]
SigEF r Type
RecConEF Name [(Name, r)]
RecUpdEF r [(Name, r)]
StaticEF r
UnboundVarEF Name
LabelEF [Char]
ImplicitParamVarEF [Char]
GetFieldEF r [Char]
ProjectionEF (NonEmpty [Char])

Instances

Instances details

Foldable ExpF Source #
Instance details Defined in Data.Functor.Base.TH Methods fold :: Monoid m => ExpF m -> m # foldMap :: Monoid m => (a -> m) -> ExpF a -> m # foldMap' :: Monoid m => (a -> m) -> ExpF a -> m # foldr :: (a -> b -> b) -> b -> ExpF a -> b # foldr' :: (a -> b -> b) -> b -> ExpF a -> b # foldl :: (b -> a -> b) -> b -> ExpF a -> b # foldl' :: (b -> a -> b) -> b -> ExpF a -> b # foldr1 :: (a -> a -> a) -> ExpF a -> a # foldl1 :: (a -> a -> a) -> ExpF a -> a # toList :: ExpF a -> [a] # null :: ExpF a -> Bool # length :: ExpF a -> Int # elem :: Eq a => a -> ExpF a -> Bool # maximum :: Ord a => ExpF a -> a # minimum :: Ord a => ExpF a -> a # sum :: Num a => ExpF a -> a # product :: Num a => ExpF a -> a #
Traversable ExpF Source #
Instance details Defined in Data.Functor.Base.TH Methods traverse :: Applicative f => (a -> f b) -> ExpF a -> f (ExpF b) # sequenceA :: Applicative f => ExpF (f a) -> f (ExpF a) # mapM :: Monad m => (a -> m b) -> ExpF a -> m (ExpF b) # sequence :: Monad m => ExpF (m a) -> m (ExpF a) #
Functor ExpF Source #
Instance details Defined in Data.Functor.Base.TH Methods fmap :: (a -> b) -> ExpF a -> ExpF b # (<$) :: a -> ExpF b -> ExpF a #

data PatF r Source #

Constructors

LitPF Lit
VarPF Name
TupPF [r]
UnboxedTupPF [r]
UnboxedSumPF r Int Int
ConPF Name [Type] [r]
InfixPF r Name r
UInfixPF r Name r
ParensPF r
TildePF r
BangPF r
AsPF Name r
WildPF
RecPF Name [(Name, r)]
ListPF [r]
SigPF r Type
ViewPF Exp r

Instances

Instances details

Foldable PatF Source #
Instance details Defined in Data.Functor.Base.TH Methods fold :: Monoid m => PatF m -> m # foldMap :: Monoid m => (a -> m) -> PatF a -> m # foldMap' :: Monoid m => (a -> m) -> PatF a -> m # foldr :: (a -> b -> b) -> b -> PatF a -> b # foldr' :: (a -> b -> b) -> b -> PatF a -> b # foldl :: (b -> a -> b) -> b -> PatF a -> b # foldl' :: (b -> a -> b) -> b -> PatF a -> b # foldr1 :: (a -> a -> a) -> PatF a -> a # foldl1 :: (a -> a -> a) -> PatF a -> a # toList :: PatF a -> [a] # null :: PatF a -> Bool # length :: PatF a -> Int # elem :: Eq a => a -> PatF a -> Bool # maximum :: Ord a => PatF a -> a # minimum :: Ord a => PatF a -> a # sum :: Num a => PatF a -> a # product :: Num a => PatF a -> a #
Traversable PatF Source #
Instance details Defined in Data.Functor.Base.TH Methods traverse :: Applicative f => (a -> f b) -> PatF a -> f (PatF b) # sequenceA :: Applicative f => PatF (f a) -> f (PatF a) # mapM :: Monad m => (a -> m b) -> PatF a -> m (PatF b) # sequence :: Monad m => PatF (m a) -> m (PatF a) #
Functor PatF Source #
Instance details Defined in Data.Functor.Base.TH Methods fmap :: (a -> b) -> PatF a -> PatF b # (<$) :: a -> PatF b -> PatF a #

data StmtF r Source #

Constructors

BindSF Pat Exp
LetSF [Dec]
NoBindSF Exp
ParSF [[r]]
RecSF [r]

Instances

Instances details

Foldable StmtF Source #
Instance details Defined in Data.Functor.Base.TH Methods fold :: Monoid m => StmtF m -> m # foldMap :: Monoid m => (a -> m) -> StmtF a -> m # foldMap' :: Monoid m => (a -> m) -> StmtF a -> m # foldr :: (a -> b -> b) -> b -> StmtF a -> b # foldr' :: (a -> b -> b) -> b -> StmtF a -> b # foldl :: (b -> a -> b) -> b -> StmtF a -> b # foldl' :: (b -> a -> b) -> b -> StmtF a -> b # foldr1 :: (a -> a -> a) -> StmtF a -> a # foldl1 :: (a -> a -> a) -> StmtF a -> a # toList :: StmtF a -> [a] # null :: StmtF a -> Bool # length :: StmtF a -> Int # elem :: Eq a => a -> StmtF a -> Bool # maximum :: Ord a => StmtF a -> a # minimum :: Ord a => StmtF a -> a # sum :: Num a => StmtF a -> a # product :: Num a => StmtF a -> a #
Traversable StmtF Source #
Instance details Defined in Data.Functor.Base.TH Methods traverse :: Applicative f => (a -> f b) -> StmtF a -> f (StmtF b) # sequenceA :: Applicative f => StmtF (f a) -> f (StmtF a) # mapM :: Monad m => (a -> m b) -> StmtF a -> m (StmtF b) # sequence :: Monad m => StmtF (m a) -> m (StmtF a) #
Functor StmtF Source #
Instance details Defined in Data.Functor.Base.TH Methods fmap :: (a -> b) -> StmtF a -> StmtF b # (<$) :: a -> StmtF b -> StmtF a #

data TypeF r Source #

Constructors

ForallTF [TyVarBndr Specificity] [r] r
ForallVisTF [TyVarBndr ()] r
AppTF r r
AppKindTF r r
SigTF r r
VarTF Name
ConTF Name
PromotedTF Name
InfixTF r Name r
UInfixTF r Name r
PromotedInfixTF r Name r
PromotedUInfixTF r Name r
ParensTF r
TupleTF Int
UnboxedTupleTF Int
UnboxedSumTF Int
ArrowTF
MulArrowTF
EqualityTF
ListTF
PromotedTupleTF Int
PromotedNilTF
PromotedConsTF
StarTF
ConstraintTF
LitTF TyLit
WildCardTF
ImplicitParamTF [Char] r

Instances

Instances details

Foldable TypeF Source #
Instance details Defined in Data.Functor.Base.TH Methods fold :: Monoid m => TypeF m -> m # foldMap :: Monoid m => (a -> m) -> TypeF a -> m # foldMap' :: Monoid m => (a -> m) -> TypeF a -> m # foldr :: (a -> b -> b) -> b -> TypeF a -> b # foldr' :: (a -> b -> b) -> b -> TypeF a -> b # foldl :: (b -> a -> b) -> b -> TypeF a -> b # foldl' :: (b -> a -> b) -> b -> TypeF a -> b # foldr1 :: (a -> a -> a) -> TypeF a -> a # foldl1 :: (a -> a -> a) -> TypeF a -> a # toList :: TypeF a -> [a] # null :: TypeF a -> Bool # length :: TypeF a -> Int # elem :: Eq a => a -> TypeF a -> Bool # maximum :: Ord a => TypeF a -> a # minimum :: Ord a => TypeF a -> a # sum :: Num a => TypeF a -> a # product :: Num a => TypeF a -> a #
Traversable TypeF Source #
Instance details Defined in Data.Functor.Base.TH Methods traverse :: Applicative f => (a -> f b) -> TypeF a -> f (TypeF b) # sequenceA :: Applicative f => TypeF (f a) -> f (TypeF a) # mapM :: Monad m => (a -> m b) -> TypeF a -> m (TypeF b) # sequence :: Monad m => TypeF (m a) -> m (TypeF a) #
Functor TypeF Source #
Instance details Defined in Data.Functor.Base.TH Methods fmap :: (a -> b) -> TypeF a -> TypeF b # (<$) :: a -> TypeF b -> TypeF a #

Orphan instances

Corecursive Con Source #
Instance details Methods embed :: Base Con Con -> Con ana :: (a -> Base Con a) -> a -> Con apo :: (a -> Base Con (Either Con a)) -> a -> Con postpro :: Recursive Con => (forall b. Base Con b -> Base Con b) -> (a -> Base Con a) -> a -> Con gpostpro :: (Recursive Con, Monad m) => (forall b. m (Base Con b) -> Base Con (m b)) -> (forall c. Base Con c -> Base Con c) -> (a -> Base Con (m a)) -> a -> Con
Corecursive Dec Source #
Instance details Methods embed :: Base Dec Dec -> Dec ana :: (a -> Base Dec a) -> a -> Dec apo :: (a -> Base Dec (Either Dec a)) -> a -> Dec postpro :: Recursive Dec => (forall b. Base Dec b -> Base Dec b) -> (a -> Base Dec a) -> a -> Dec gpostpro :: (Recursive Dec, Monad m) => (forall b. m (Base Dec b) -> Base Dec (m b)) -> (forall c. Base Dec c -> Base Dec c) -> (a -> Base Dec (m a)) -> a -> Dec
Corecursive Exp Source #
Instance details Methods embed :: Base Exp Exp -> Exp ana :: (a -> Base Exp a) -> a -> Exp apo :: (a -> Base Exp (Either Exp a)) -> a -> Exp postpro :: Recursive Exp => (forall b. Base Exp b -> Base Exp b) -> (a -> Base Exp a) -> a -> Exp gpostpro :: (Recursive Exp, Monad m) => (forall b. m (Base Exp b) -> Base Exp (m b)) -> (forall c. Base Exp c -> Base Exp c) -> (a -> Base Exp (m a)) -> a -> Exp
Corecursive Pat Source #
Instance details Methods embed :: Base Pat Pat -> Pat ana :: (a -> Base Pat a) -> a -> Pat apo :: (a -> Base Pat (Either Pat a)) -> a -> Pat postpro :: Recursive Pat => (forall b. Base Pat b -> Base Pat b) -> (a -> Base Pat a) -> a -> Pat gpostpro :: (Recursive Pat, Monad m) => (forall b. m (Base Pat b) -> Base Pat (m b)) -> (forall c. Base Pat c -> Base Pat c) -> (a -> Base Pat (m a)) -> a -> Pat
Corecursive Stmt Source #
Instance details Methods embed :: Base Stmt Stmt -> Stmt ana :: (a -> Base Stmt a) -> a -> Stmt apo :: (a -> Base Stmt (Either Stmt a)) -> a -> Stmt postpro :: Recursive Stmt => (forall b. Base Stmt b -> Base Stmt b) -> (a -> Base Stmt a) -> a -> Stmt gpostpro :: (Recursive Stmt, Monad m) => (forall b. m (Base Stmt b) -> Base Stmt (m b)) -> (forall c. Base Stmt c -> Base Stmt c) -> (a -> Base Stmt (m a)) -> a -> Stmt
Corecursive Type Source #
Instance details Methods embed :: Base Type Type -> Type ana :: (a -> Base Type a) -> a -> Type apo :: (a -> Base Type (Either Type a)) -> a -> Type postpro :: Recursive Type => (forall b. Base Type b -> Base Type b) -> (a -> Base Type a) -> a -> Type gpostpro :: (Recursive Type, Monad m) => (forall b. m (Base Type b) -> Base Type (m b)) -> (forall c. Base Type c -> Base Type c) -> (a -> Base Type (m a)) -> a -> Type
Recursive Con Source #
Instance details Methods project :: Con -> Base Con Con cata :: (Base Con a -> a) -> Con -> a para :: (Base Con (Con, a) -> a) -> Con -> a gpara :: (Corecursive Con, Comonad w) => (forall b. Base Con (w b) -> w (Base Con b)) -> (Base Con (EnvT Con w a) -> a) -> Con -> a prepro :: Corecursive Con => (forall b. Base Con b -> Base Con b) -> (Base Con a -> a) -> Con -> a gprepro :: (Corecursive Con, Comonad w) => (forall b. Base Con (w b) -> w (Base Con b)) -> (forall c. Base Con c -> Base Con c) -> (Base Con (w a) -> a) -> Con -> a
Recursive Dec Source #
Instance details Methods project :: Dec -> Base Dec Dec cata :: (Base Dec a -> a) -> Dec -> a para :: (Base Dec (Dec, a) -> a) -> Dec -> a gpara :: (Corecursive Dec, Comonad w) => (forall b. Base Dec (w b) -> w (Base Dec b)) -> (Base Dec (EnvT Dec w a) -> a) -> Dec -> a prepro :: Corecursive Dec => (forall b. Base Dec b -> Base Dec b) -> (Base Dec a -> a) -> Dec -> a gprepro :: (Corecursive Dec, Comonad w) => (forall b. Base Dec (w b) -> w (Base Dec b)) -> (forall c. Base Dec c -> Base Dec c) -> (Base Dec (w a) -> a) -> Dec -> a
Recursive Exp Source #
Instance details Methods project :: Exp -> Base Exp Exp cata :: (Base Exp a -> a) -> Exp -> a para :: (Base Exp (Exp, a) -> a) -> Exp -> a gpara :: (Corecursive Exp, Comonad w) => (forall b. Base Exp (w b) -> w (Base Exp b)) -> (Base Exp (EnvT Exp w a) -> a) -> Exp -> a prepro :: Corecursive Exp => (forall b. Base Exp b -> Base Exp b) -> (Base Exp a -> a) -> Exp -> a gprepro :: (Corecursive Exp, Comonad w) => (forall b. Base Exp (w b) -> w (Base Exp b)) -> (forall c. Base Exp c -> Base Exp c) -> (Base Exp (w a) -> a) -> Exp -> a
Recursive Pat Source #
Instance details Methods project :: Pat -> Base Pat Pat cata :: (Base Pat a -> a) -> Pat -> a para :: (Base Pat (Pat, a) -> a) -> Pat -> a gpara :: (Corecursive Pat, Comonad w) => (forall b. Base Pat (w b) -> w (Base Pat b)) -> (Base Pat (EnvT Pat w a) -> a) -> Pat -> a prepro :: Corecursive Pat => (forall b. Base Pat b -> Base Pat b) -> (Base Pat a -> a) -> Pat -> a gprepro :: (Corecursive Pat, Comonad w) => (forall b. Base Pat (w b) -> w (Base Pat b)) -> (forall c. Base Pat c -> Base Pat c) -> (Base Pat (w a) -> a) -> Pat -> a
Recursive Stmt Source #
Instance details Methods project :: Stmt -> Base Stmt Stmt cata :: (Base Stmt a -> a) -> Stmt -> a para :: (Base Stmt (Stmt, a) -> a) -> Stmt -> a gpara :: (Corecursive Stmt, Comonad w) => (forall b. Base Stmt (w b) -> w (Base Stmt b)) -> (Base Stmt (EnvT Stmt w a) -> a) -> Stmt -> a prepro :: Corecursive Stmt => (forall b. Base Stmt b -> Base Stmt b) -> (Base Stmt a -> a) -> Stmt -> a gprepro :: (Corecursive Stmt, Comonad w) => (forall b. Base Stmt (w b) -> w (Base Stmt b)) -> (forall c. Base Stmt c -> Base Stmt c) -> (Base Stmt (w a) -> a) -> Stmt -> a
Recursive Type Source #
Instance details Methods project :: Type -> Base Type Type cata :: (Base Type a -> a) -> Type -> a para :: (Base Type (Type, a) -> a) -> Type -> a gpara :: (Corecursive Type, Comonad w) => (forall b. Base Type (w b) -> w (Base Type b)) -> (Base Type (EnvT Type w a) -> a) -> Type -> a prepro :: Corecursive Type => (forall b. Base Type b -> Base Type b) -> (Base Type a -> a) -> Type -> a gprepro :: (Corecursive Type, Comonad w) => (forall b. Base Type (w b) -> w (Base Type b)) -> (forall c. Base Type c -> Base Type c) -> (Base Type (w a) -> a) -> Type -> a