Copyright	(c) Justin Le 2019
License	BSD3
Maintainer	justin@jle.im
Stability	experimental
Portability	non-portable
Safe Haskell	Safe-Inferred
Language	Haskell2010

Data.HFunctor.Interpret

Contents

Utilities

Description

This module provides tools for working with unary functor combinators that represent interpretable schemas.

These are types t that take a functor f and return a new functor t f, enhancing f with new structure and abilities.

For these, we have:

inject :: f a -> t f a

which lets you "lift" an f a into its transformed version, and also:

interpret
    :: C t g
    => (forall x. f a -> g a)
    -> t f a
    -> g a

that lets you "interpret" a t f a into a context g a, essentially "running" the computaiton that it encodes. The context is required to have a typeclass constraints that reflects what is "required" to be able to run a functor combinator.

Every single instance provides different tools. Check out the instance list for a nice list of useful combinators, or also the README for a high-level rundown.

See Data.Functor.Tensor for binary functor combinators that mix together two or more different functors.

Synopsis

class Inject t => Interpret t f where
- retract :: t f ~> f
- interpret :: (g ~> f) -> t g ~> f
forI :: Interpret t f => t g a -> (g ~> f) -> f a
iget :: Interpret t (AltConst b) => (forall x. f x -> b) -> t f a -> b
icollect :: (forall m. Monoid m => Interpret t (AltConst m)) => (forall x. f x -> b) -> t f a -> [b]
icollect1 :: (forall m. Semigroup m => Interpret t (AltConst m)) => (forall x. f x -> b) -> t f a -> NonEmpty b
itraverse :: (Functor h, Interpret t (Comp h (t g))) => (forall x. f x -> h (g x)) -> t f a -> h (t g a)
iapply :: Interpret t (Op b) => (forall x. f x -> x -> b) -> t f a -> a -> b
ifanout :: (forall m. Monoid m => Interpret t (Op m)) => (forall x. f x -> x -> b) -> t f a -> a -> [b]
ifanout1 :: (forall m. Semigroup m => Interpret t (Op m)) => (forall x. f x -> x -> b) -> t f a -> a -> NonEmpty b
getI :: Interpret t (AltConst b) => (forall x. f x -> b) -> t f a -> b
collectI :: (forall m. Monoid m => Interpret t (AltConst m)) => (forall x. f x -> b) -> t f a -> [b]
newtype AltConst w a = AltConst {
- getAltConst :: w
}
class (c a, d a) => AndC c d a
newtype WrapHF t f a = WrapHF {
- unwrapHF :: t f a
}

Documentation

class Inject t => Interpret t f where Source #

An Interpret lets us move in and out of the "enhanced" Functor (t f) and the functor it enhances (f). An instance Interpret t f means we have t f a -> f a.

For example, Free f is f enhanced with monadic structure. We get:

inject    :: f a -> Free f a
interpret :: Monad m => (forall x. f x -> m x) -> Free f a -> m a

inject will let us use our f inside the enhanced Free f. interpret will let us "extract" the f from a Free f if we can give an interpreting function that interprets f into some target Monad.

We enforce that:

interpret id . inject == id
-- or
retract . inject == id

That is, if we lift a value into our structure, then immediately interpret it out as itself, it should lave the value unchanged.

Note that instances of this class are intended to be written with t as a fixed type constructor, and f to be allowed to vary freely:

instance Monad f => Interpret Free f

Any other sort of instance and it's easy to run into problems with type inference. If you want to write an instance that's "polymorphic" on tensor choice, use the WrapHF newtype wrapper over a type variable, where the second argument also uses a type constructor:

instance Interpret (WrapHF t) (MyFunctor t)

This will prevent problems with overloaded instances.

Minimal complete definition

retract | interpret

Methods

retract :: t f ~> f Source #

Remove the f out of the enhanced t f structure, provided that f satisfies the necessary constraints. If it doesn't, it needs to be properly interpreted out.

interpret :: (g ~> f) -> t g ~> f Source #

Given an "interpeting function" from f to g, interpret the f out of the t f into a final context g.

Instances

Instances details

Alternative f => Interpret Alt (f :: Type -> Type) Source #	A free `Alternative`
Instance details Defined in Data.HFunctor.Interpret Methods retract :: Alt f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Alt g ~> f Source #
Applicative f => Interpret Ap (f :: Type -> Type) Source #	A free `Applicative`
Instance details Defined in Data.HFunctor.Interpret Methods retract :: Ap f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Ap g ~> f Source #
Applicative f => Interpret Ap (f :: Type -> Type) Source #	A free `Applicative`
Instance details Defined in Data.HFunctor.Interpret Methods retract :: Ap f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Ap g ~> f Source #
Applicative f => Interpret Ap (f :: Type -> Type) Source #	A free `Applicative`
Instance details Defined in Data.HFunctor.Interpret Methods retract :: Ap f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Ap g ~> f Source #
Monad f => Interpret Free (f :: Type -> Type) Source #	A free `Monad`
Instance details Defined in Data.HFunctor.Interpret Methods retract :: Free f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Free g ~> f Source #
Bind f => Interpret Free1 (f :: Type -> Type) Source #	A free `Bind`
Instance details Defined in Data.HFunctor.Interpret Methods retract :: Free1 f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Free1 g ~> f Source #
Apply f => Interpret Ap1 (f :: Type -> Type) Source #
Instance details Defined in Data.Functor.Apply.Free Methods retract :: Ap1 f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Ap1 g ~> f Source #
Conclude f => Interpret Dec (f :: Type -> Type) Source #
Instance details Defined in Data.Functor.Contravariant.Divisible.Free Methods retract :: Dec f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Dec g ~> f Source #
Decide f => Interpret Dec1 (f :: Type -> Type) Source #
Instance details Defined in Data.Functor.Contravariant.Divisible.Free Methods retract :: Dec1 f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Dec1 g ~> f Source #
Divisible f => Interpret Div (f :: Type -> Type) Source #
Instance details Defined in Data.Functor.Contravariant.Divisible.Free Methods retract :: Div f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Div g ~> f Source #
Divise f => Interpret Div1 (f :: Type -> Type) Source #
Instance details Defined in Data.Functor.Contravariant.Divisible.Free Methods retract :: Div1 f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Div1 g ~> f Source #
Inplus f => Interpret DecAlt (f :: Type -> TYPE LiftedRep) Source #	A free `Inplus`
Instance details Defined in Data.HFunctor.Chain.Internal Methods retract :: DecAlt f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> DecAlt g ~> f Source #
Inalt f => Interpret DecAlt1 (f :: Type -> TYPE LiftedRep) Source #	A free `Inalt`
Instance details Defined in Data.HFunctor.Chain.Internal Methods retract :: DecAlt1 f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> DecAlt1 g ~> f Source #
Contravariant f => Interpret Coyoneda (f :: Type -> Type) Source #	A free `Contravariant` Since: 0.3.0.0
Instance details Defined in Data.HFunctor.Interpret Methods retract :: Coyoneda f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Coyoneda g ~> f Source #
Functor f => Interpret Coyoneda (f :: Type -> Type) Source #	A free `Functor`
Instance details Defined in Data.HFunctor.Interpret Methods retract :: Coyoneda f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Coyoneda g ~> f Source #
Pointed f => Interpret MaybeApply (f :: Type -> Type) Source #	A free `Pointed`
Instance details Defined in Data.HFunctor.Interpret Methods retract :: MaybeApply f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> MaybeApply g ~> f Source #
Interpret WrappedApplicative (f :: Type -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods retract :: WrappedApplicative f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> WrappedApplicative g ~> f Source #
Pointed f => Interpret Lift (f :: Type -> Type) Source #	A free `Pointed`
Instance details Defined in Data.HFunctor.Interpret Methods retract :: Lift f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Lift g ~> f Source #
Monoid e => Interpret (EnvT e :: (Type -> Type) -> Type -> Type) (f :: Type -> Type) Source #	This ignores the environment, so `interpret /= hbind`
Instance details Defined in Data.HFunctor.Interpret Methods retract :: EnvT e f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> EnvT e g ~> f Source #
Plus f => Interpret (ListF :: (Type -> Type) -> Type -> TYPE LiftedRep) (f :: Type -> Type) Source #	A free `Plus`
Instance details Defined in Data.HFunctor.Interpret Methods retract :: ListF f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> ListF g ~> f Source #
Plus f => Interpret (MaybeF :: (Type -> Type) -> Type -> TYPE LiftedRep) (f :: Type -> Type) Source #	Technically, `f` is over-constrained: we only need `zero :: f a`, but we don't really have that typeclass in any standard hierarchies. We use `Plus` here instead, but we never use `<!>`. This would only go wrong in situations where your type supports `zero` but not `<!>`, like instances of `MonadFail` without `MonadPlus`.
Instance details Defined in Data.HFunctor.Interpret Methods retract :: MaybeF f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> MaybeF g ~> f Source #
Alt f => Interpret (NonEmptyF :: (Type -> Type) -> Type -> TYPE LiftedRep) (f :: Type -> Type) Source #	A free `Alt`
Instance details Defined in Data.HFunctor.Interpret Methods retract :: NonEmptyF f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> NonEmptyF g ~> f Source #
Alt f => Interpret (Steps :: (Type -> TYPE LiftedRep) -> Type -> TYPE LiftedRep) (f :: Type -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods retract :: Steps f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Steps g ~> f Source #
Monoid a => Interpret (Post a :: (Type -> Type) -> Type -> Type) (f :: Type -> Type) Source #
Instance details Defined in Data.HFunctor.Route Methods retract :: Post a f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Post a g ~> f Source #
Interpret t f => Interpret (PostT t :: (Type -> Type) -> Type -> Type) (f :: Type -> Type) Source #	Since: 0.3.4.2
Instance details Defined in Data.HFunctor.Route Methods retract :: PostT t f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> PostT t g ~> f Source #
a ~ Void => Interpret (Pre a :: (Type -> Type) -> Type -> Type) (f :: Type -> Type) Source #
Instance details Defined in Data.HFunctor.Route Methods retract :: Pre a f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Pre a g ~> f Source #
Interpret t f => Interpret (PreT t :: (Type -> Type) -> Type -> Type) (f :: Type -> Type) Source #
Instance details Defined in Data.HFunctor.Route Methods retract :: PreT t f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> PreT t g ~> f Source #
Plus f => Interpret (These1 g :: (Type -> Type) -> Type -> Type) (f :: Type -> Type) Source #	Technically, `f` is over-constrained: we only need `zero :: f a`, but we don't really have that typeclass in any standard hierarchies. We use `Plus` here instead, but we never use `<!>`. This would only go wrong in situations where your type supports `zero` but not `<!>`, like instances of `MonadFail` without `MonadPlus`.
Instance details Defined in Data.HFunctor.Interpret Methods retract :: These1 g f ~> f Source # interpret :: forall (g0 :: k -> Type). (g0 ~> f) -> These1 g g0 ~> f Source #
MonadReader r f => Interpret (ReaderT r :: (Type -> Type) -> Type -> TYPE LiftedRep) (f :: Type -> Type) Source #	A free `MonadReader`, but only when applied to a `Monad`.
Instance details Defined in Data.HFunctor.Interpret Methods retract :: ReaderT r f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> ReaderT r g ~> f Source #
Interpret (Flagged :: (k -> Type) -> k -> Type) (f :: k -> Type) Source #	Equivalent to instance for `EnvT Any` and `HLift IdentityT`.
Instance details Defined in Data.HFunctor.Interpret Methods retract :: Flagged f ~> f Source # interpret :: forall (g :: k0 -> Type). (g ~> f) -> Flagged g ~> f Source #
Interpret (Step :: (k -> Type) -> k -> Type) (f :: k -> Type) Source #	Equivalent to instance for `EnvT (Sum Natural)`.
Instance details Defined in Data.HFunctor.Interpret Methods retract :: Step f ~> f Source # interpret :: forall (g :: k0 -> Type). (g ~> f) -> Step g ~> f Source #
Interpret (Backwards :: (k -> Type) -> k -> Type) (f :: k -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods retract :: Backwards f ~> f Source # interpret :: forall (g :: k0 -> Type). (g ~> f) -> Backwards g ~> f Source #
Interpret (IdentityT :: (k -> Type) -> k -> Type) (f :: k -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods retract :: IdentityT f ~> f Source # interpret :: forall (g :: k0 -> Type). (g ~> f) -> IdentityT g ~> f Source #
Interpret (Reverse :: (k -> Type) -> k -> Type) (f :: k -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods retract :: Reverse f ~> f Source # interpret :: forall (g :: k0 -> Type). (g ~> f) -> Reverse g ~> f Source #
Plus g => Interpret (Product g :: (Type -> Type) -> Type -> Type) (f :: Type -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods retract :: Product g f ~> f Source # interpret :: forall (g0 :: k -> Type). (g0 ~> f) -> Product g g0 ~> f Source #
Plus f => Interpret (Sum g :: (Type -> Type) -> Type -> Type) (f :: Type -> Type) Source #	Technically, `f` is over-constrained: we only need `zero :: f a`, but we don't really have that typeclass in any standard hierarchies. We use `Plus` here instead, but we never use `<!>`. This would only go wrong in situations where your type supports `zero` but not `<!>`, like instances of `MonadFail` without `MonadPlus`.
Instance details Defined in Data.HFunctor.Interpret Methods retract :: Sum g f ~> f Source # interpret :: forall (g0 :: k -> Type). (g0 ~> f) -> Sum g g0 ~> f Source #
Plus g => Interpret ((:*:) g :: (Type -> Type) -> Type -> Type) (f :: Type -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods retract :: (g :: f) ~> f Source # interpret :: forall (g0 :: k -> Type). (g0 ~> f) -> (g :: g0) ~> f Source #
Plus f => Interpret ((:+:) g :: (Type -> Type) -> Type -> Type) (f :: Type -> Type) Source #	Technically, `f` is over-constrained: we only need `zero :: f a`, but we don't really have that typeclass in any standard hierarchies. We use `Plus` here instead, but we never use `<!>`. This would only go wrong in situations where your type supports `zero` but not `<!>`, like instances of `MonadFail` without `MonadPlus`.
Instance details Defined in Data.HFunctor.Interpret Methods retract :: (g :+: f) ~> f Source # interpret :: forall (g0 :: k -> Type). (g0 ~> f) -> (g :+: g0) ~> f Source #
(Monoid k, Plus f) => Interpret (MapF k :: (Type -> Type) -> Type -> TYPE LiftedRep) (f :: Type -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods retract :: MapF k f ~> f Source # interpret :: forall (g :: k0 -> Type). (g ~> f) -> MapF k g ~> f Source #
(Monoid k, Alt f) => Interpret (NEMapF k :: (Type -> TYPE LiftedRep) -> Type -> TYPE LiftedRep) (f :: Type -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods retract :: NEMapF k f ~> f Source # interpret :: forall (g :: k0 -> Type). (g ~> f) -> NEMapF k g ~> f Source #
SemigroupIn t f => Interpret (Chain1 t :: (Type -> Type) -> Type -> Type) (f :: Type -> Type) Source #
Instance details Defined in Data.HFunctor.Chain Methods retract :: Chain1 t f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Chain1 t g ~> f Source #
(Interpret s f, Interpret t f) => Interpret (ComposeT s t :: (Type -> Type) -> Type -> TYPE LiftedRep) (f :: Type -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods retract :: ComposeT s t f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> ComposeT s t g ~> f Source #
Interpret t f => Interpret (HFree t :: (k -> Type) -> k -> Type) (f :: k -> Type) Source #	Never uses `inject`
Instance details Defined in Data.HFunctor.Interpret Methods retract :: HFree t f ~> f Source # interpret :: forall (g :: k0 -> Type). (g ~> f) -> HFree t g ~> f Source #
Interpret t f => Interpret (HLift t :: (k -> Type) -> k -> Type) (f :: k -> Type) Source #	Never uses `inject`
Instance details Defined in Data.HFunctor.Interpret Methods retract :: HLift t f ~> f Source # interpret :: forall (g :: k0 -> Type). (g ~> f) -> HLift t g ~> f Source #
c f => Interpret (Final c :: (k -> Type) -> k -> TYPE LiftedRep) (f :: k -> Type) Source #
Instance details Defined in Data.HFunctor.Final Methods retract :: Final c f ~> f Source # interpret :: forall (g :: k0 -> Type). (g ~> f) -> Final c g ~> f Source #
Interpret (M1 i c :: (k -> Type) -> k -> Type) (f :: k -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods retract :: M1 i c f ~> f Source # interpret :: forall (g :: k0 -> Type). (g ~> f) -> M1 i c g ~> f Source #
Interpret (RightF g :: (k2 -> Type) -> k2 -> Type) (f :: k2 -> Type) Source #
Instance details Defined in Data.HBifunctor Methods retract :: RightF g f ~> f Source # interpret :: forall (g0 :: k -> Type). (g0 ~> f) -> RightF g g0 ~> f Source #
MonoidIn t i f => Interpret (Chain t i :: (Type -> Type) -> Type -> Type) (f :: Type -> Type) Source #	We can collapse and interpret an `Chain t i` if we have `Tensor t`.
Instance details Defined in Data.HFunctor.Chain Methods retract :: Chain t i f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Chain t i g ~> f Source #
Inplicative f => Interpret DivAp (f :: Type -> TYPE LiftedRep) Source #	A free `Inplicative`
Instance details Defined in Data.Functor.Invariant.Inplicative.Free Methods retract :: DivAp f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> DivAp g ~> f Source #
Inply f => Interpret DivAp1 (f :: Type -> TYPE LiftedRep) Source #	A free `Inply`
Instance details Defined in Data.Functor.Invariant.Inplicative.Free Methods retract :: DivAp1 f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> DivAp1 g ~> f Source #

forI :: Interpret t f => t g a -> (g ~> f) -> f a Source #

A convenient flipped version of interpret.

Utilities

iget :: Interpret t (AltConst b) => (forall x. f x -> b) -> t f a -> b Source #

Useful wrapper over interpret to allow you to directly extract a value b out of the t f a, if you can convert f x into b.

Note that depending on the constraints on f in Interpret t f, you may have extra constraints on b.

If f is unconstrained, there are no constraints on b
If f must be Apply, Alt, Divise, or Decide, b needs to be an instance of Semigroup.
If f is Applicative, Plus, Divisible, or Conclude, b needs to be an instance of Monoid

For some constraints (like Monad), this will not be usable.

-- get the length of the Map String in the Step.
icollect length
     :: Step (Map String) Bool
     -> Int

Note that in many cases, you can also use hfoldMap and hfoldMap1.

Since: 0.3.1.0

icollect :: (forall m. Monoid m => Interpret t (AltConst m)) => (forall x. f x -> b) -> t f a -> [b] Source #

Useful wrapper over iget to allow you to collect a b from all instances of f inside a t f a.

Will work if there is an instance of Interpret t (AltConst m) if Monoid m, which will be the case if the constraint on the target functor is Functor, Apply, Applicative, Alt, Plus, Decide, Divisible, Decide, Conclude, or unconstrained.

-- get the lengths of all Map Strings in the Ap.
icollect length
     :: Ap (Map String) Bool
     -> [Int]

Note that in many cases, you can also use htoList.

Since: 0.3.1.0

icollect1 :: (forall m. Semigroup m => Interpret t (AltConst m)) => (forall x. f x -> b) -> t f a -> NonEmpty b Source #

Useful wrapper over iget to allow you to collect a b from all instances of f inside a t f a, into a non-empty collection of bs.

Will work if there is an instance of Interpret t (AltConst m) if Semigroup m, which will be the case if the constraint on the target functor is Functor, Apply, Alt, Divise, Decide, or unconstrained.

-- get the lengths of all Map Strings in the Ap.
icollect1 length
     :: Ap1 (Map String) Bool
     -> NonEmpty Int

Note that in many cases, you can also use htoNonEmpty.

Since: 0.3.1.0

itraverse :: (Functor h, Interpret t (Comp h (t g))) => (forall x. f x -> h (g x)) -> t f a -> h (t g a) Source #

Useful wrapper over interpret to allow you to do an "effectful" hmap.

This can be useful in some situations, but if you want to do this, it's probably better to just use htraverse, which is a more principled system for effectful hmapping.

Since: 0.3.6.0

iapply :: Interpret t (Op b) => (forall x. f x -> x -> b) -> t f a -> a -> b Source #

Useful wrapper over interpret to allow you to directly consume a value of type a with a t f a to create a b. Do this by supplying the method by which each component f x can consume an x. This works for contravariant functor combinators, where t f a can be interpreted as a consumer of as.

Note that depending on the constraints on f in Interpret t f, you may have extra constraints on b.

If f is unconstrained, Decide, or Conclude, there are no constraints on b. This will be the case for combinators like contravariant Coyoneda, Dec, Dec1.
If f must be Divise, b needs to be an instance of Semigroup. This will be the case for combinators like Div1.
If f is Divisible, b needs to be an instance of Monoid. This will be the case for combinators like Div.

For any Functor or Invariant constraint, this is not usable.

Since: 0.3.2.0

ifanout :: (forall m. Monoid m => Interpret t (Op m)) => (forall x. f x -> x -> b) -> t f a -> a -> [b] Source #

Useful wrapper over interpret to allow you to directly consume a value of type a with a t f a to create a b, and create a list of all the bs created by all the fs. Do this by supplying the method by which each component f x can consume an x. This works for contravariant functor combinators, where t f a can be interpreted as a consumer of as.

Will work if there is an instance of Interpret t (Op m) if Monoid m, which will be the case if the constraint on the target functor is Contravariant, Decide, Conclude, Divise, Divisible, or unconstrained.

Note that this is really only useful outside of iapply for Div and Div1, where a Div f which is a collection of many different fs consuming types of different values. You can use this with Dec and Dec1 and the contravarient Coyoneda as well, but those would always just give you a singleton list, so you might as well use iapply. This is really only here for completion alongside icollect, or if you define your own custom functor combinators.

ifanout1 :: (forall m. Semigroup m => Interpret t (Op m)) => (forall x. f x -> x -> b) -> t f a -> a -> NonEmpty b Source #

Useful wrapper over interpret to allow you to directly consume a value of type a with a t f a to create a b, and create a list of all the bs created by all the fs. Do this by supplying the method by which each component f x can consume an x. This works for contravariant functor combinators, where t f a can be interpreted as a consumer of as.

Will work if there is an instance of Interpret t (Op m) if Monoid m, which will be the case if the constraint on the target functor is Contravariant, Decide, Divise, or unconstrained.

Note that this is really only useful outside of iapply and ifanout for Div1, where a Div1 f which is a collection of many different fs consuming types of different values. You can use this with Dec and Dec1 and the contravarient Coyoneda as well, but those would always just give you a singleton list, so you might as well use iapply. This is really only here for completion alongside icollect1, or if you define your own custom functor combinators.

getI :: Interpret t (AltConst b) => (forall x. f x -> b) -> t f a -> b Source #

Deprecated: Use iget instead

(Deprecated) Old name for getI; will be removed in a future version.

collectI :: (forall m. Monoid m => Interpret t (AltConst m)) => (forall x. f x -> b) -> t f a -> [b] Source #

Deprecated: Use icollect instead

(Deprecated) Old name for icollect; will be removed in a future version.

newtype AltConst w a Source #

A version of Const that supports Alt, Plus, Decide, and Conclude instances. It does this by avoiding having an Alternative or Decidable instance, which causes all sorts of problems with the interactions between Alternative/Applicative and Decidable/Divisible.

Since: 0.3.1.0

Constructors

AltConst
Fields getAltConst :: w

Instances

Instances details

Foldable (AltConst w :: TYPE LiftedRep -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods fold :: Monoid m => AltConst w m -> m # foldMap :: Monoid m => (a -> m) -> AltConst w a -> m # foldMap' :: Monoid m => (a -> m) -> AltConst w a -> m # foldr :: (a -> b -> b) -> b -> AltConst w a -> b # foldr' :: (a -> b -> b) -> b -> AltConst w a -> b # foldl :: (b -> a -> b) -> b -> AltConst w a -> b # foldl' :: (b -> a -> b) -> b -> AltConst w a -> b # foldr1 :: (a -> a -> a) -> AltConst w a -> a # foldl1 :: (a -> a -> a) -> AltConst w a -> a # toList :: AltConst w a -> [a] # null :: AltConst w a -> Bool # length :: AltConst w a -> Int # elem :: Eq a => a -> AltConst w a -> Bool # maximum :: Ord a => AltConst w a -> a # minimum :: Ord a => AltConst w a -> a # sum :: Num a => AltConst w a -> a # product :: Num a => AltConst w a -> a #
Eq w => Eq1 (AltConst w :: Type -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods liftEq :: (a -> b -> Bool) -> AltConst w a -> AltConst w b -> Bool #
Ord w => Ord1 (AltConst w :: Type -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods liftCompare :: (a -> b -> Ordering) -> AltConst w a -> AltConst w b -> Ordering #
Show w => Show1 (AltConst w :: TYPE LiftedRep -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> AltConst w a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [AltConst w a] -> ShowS #
Contravariant (AltConst w :: Type -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods contramap :: (a' -> a) -> AltConst w a -> AltConst w a' # (>$) :: b -> AltConst w b -> AltConst w a #
Traversable (AltConst w :: TYPE LiftedRep -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods traverse :: Applicative f => (a -> f b) -> AltConst w a -> f (AltConst w b) # sequenceA :: Applicative f => AltConst w (f a) -> f (AltConst w a) # mapM :: Monad m => (a -> m b) -> AltConst w a -> m (AltConst w b) # sequence :: Monad m => AltConst w (m a) -> m (AltConst w a) #
Monoid w => Applicative (AltConst w :: Type -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods pure :: a -> AltConst w a # (<>) :: AltConst w (a -> b) -> AltConst w a -> AltConst w b # liftA2 :: (a -> b -> c) -> AltConst w a -> AltConst w b -> AltConst w c # (>) :: AltConst w a -> AltConst w b -> AltConst w b # (<*) :: AltConst w a -> AltConst w b -> AltConst w a #
Functor (AltConst w :: TYPE LiftedRep -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods fmap :: (a -> b) -> AltConst w a -> AltConst w b # (<$) :: a -> AltConst w b -> AltConst w a #
Monoid w => Divisible (AltConst w :: Type -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods divide :: (a -> (b, c)) -> AltConst w b -> AltConst w c -> AltConst w a # conquer :: AltConst w a #
Monoid w => Conclude (AltConst w :: Type -> Type) Source #	Unlike for `Const`, this is possible because there is no `Decidable` instance to complicate things.
Instance details Defined in Data.HFunctor.Interpret Methods conclude :: (a -> Void) -> AltConst w a Source #
Semigroup w => Decide (AltConst w :: Type -> Type) Source #	Unlike for `Const`, this is possible because there is no `Decidable` instance to complicate things.
Instance details Defined in Data.HFunctor.Interpret Methods decide :: (a -> Either b c) -> AltConst w b -> AltConst w c -> AltConst w a Source #
Semigroup w => Divise (AltConst w :: Type -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods divise :: (a -> (b, c)) -> AltConst w b -> AltConst w c -> AltConst w a Source # divised :: AltConst w a -> AltConst w b -> AltConst w (a, b) Source #
Invariant (AltConst w :: Type -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods invmap :: (a -> b) -> (b -> a) -> AltConst w a -> AltConst w b #
Semigroup w => Alt (AltConst w :: Type -> Type) Source #	Unlike for `Const`, this is possible because there is no `Alternative` instance to complicate things.
Instance details Defined in Data.HFunctor.Interpret Methods (<!>) :: AltConst w a -> AltConst w a -> AltConst w a # some :: Applicative (AltConst w) => AltConst w a -> AltConst w [a] # many :: Applicative (AltConst w) => AltConst w a -> AltConst w [a] #
Semigroup w => Apply (AltConst w :: Type -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods (<.>) :: AltConst w (a -> b) -> AltConst w a -> AltConst w b # (.>) :: AltConst w a -> AltConst w b -> AltConst w b # (<.) :: AltConst w a -> AltConst w b -> AltConst w a # liftF2 :: (a -> b -> c) -> AltConst w a -> AltConst w b -> AltConst w c #
Monoid w => Plus (AltConst w :: Type -> Type) Source #	Unlike for `Const`, this is possible because there is no `Alternative` instance to complicate things.
Instance details Defined in Data.HFunctor.Interpret Methods zero :: AltConst w a #
(Typeable a, Typeable k, Data w) => Data (AltConst w a) Source #
Instance details Defined in Data.HFunctor.Interpret Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AltConst w a -> c (AltConst w a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AltConst w a) # toConstr :: AltConst w a -> Constr # dataTypeOf :: AltConst w a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AltConst w a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AltConst w a)) # gmapT :: (forall b. Data b => b -> b) -> AltConst w a -> AltConst w a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AltConst w a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AltConst w a -> r # gmapQ :: (forall d. Data d => d -> u) -> AltConst w a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AltConst w a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AltConst w a -> m (AltConst w a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AltConst w a -> m (AltConst w a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AltConst w a -> m (AltConst w a) #
Generic (AltConst w a) Source #
Instance details Defined in Data.HFunctor.Interpret Associated Types type Rep (AltConst w a) :: Type -> Type # Methods from :: AltConst w a -> Rep (AltConst w a) x # to :: Rep (AltConst w a) x -> AltConst w a #
Show w => Show (AltConst w a) Source #
Instance details Defined in Data.HFunctor.Interpret Methods showsPrec :: Int -> AltConst w a -> ShowS # show :: AltConst w a -> String # showList :: [AltConst w a] -> ShowS #
Eq w => Eq (AltConst w a) Source #
Instance details Defined in Data.HFunctor.Interpret Methods (==) :: AltConst w a -> AltConst w a -> Bool # (/=) :: AltConst w a -> AltConst w a -> Bool #
Ord w => Ord (AltConst w a) Source #
Instance details Defined in Data.HFunctor.Interpret Methods compare :: AltConst w a -> AltConst w a -> Ordering # (<) :: AltConst w a -> AltConst w a -> Bool # (<=) :: AltConst w a -> AltConst w a -> Bool # (>) :: AltConst w a -> AltConst w a -> Bool # (>=) :: AltConst w a -> AltConst w a -> Bool # max :: AltConst w a -> AltConst w a -> AltConst w a # min :: AltConst w a -> AltConst w a -> AltConst w a #
type Rep (AltConst w a) Source #
Instance details Defined in Data.HFunctor.Interpret type Rep (AltConst w a) = D1 ('MetaData "AltConst" "Data.HFunctor.Interpret" "functor-combinators-0.4.1.1-GvD6BEOdYqeEGstBK8j7zW" 'True) (C1 ('MetaCons "AltConst" 'PrefixI 'True) (S1 ('MetaSel ('Just "getAltConst") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 w)))

class (c a, d a) => AndC c d a Source #

A constraint on a for both c a and d a. Requiring AndC Show Eq a is the same as requiring (Show a, Eq a).

Instances

Instances details

(c a, d a) => AndC (c :: k -> Constraint) (d :: k -> Constraint) (a :: k) Source #
Instance details Defined in Data.HFunctor.Interpret

newtype WrapHF t f a Source #

A newtype wrapper meant to be used to define polymorphic Interpret instances. See documentation for Interpret for more information.

Please do not ever define an instance of Interpret "naked" on the second parameter:

instance Interpret (WrapHF t) f

As that would globally ruin everything using WrapHF.

Constructors

WrapHF
Fields unwrapHF :: t f a

Instances

Instances details

HFunctor t => HFunctor (WrapHF t :: (k -> Type) -> k1 -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods hmap :: forall (f :: k0 -> Type) (g :: k0 -> Type). (f ~> g) -> WrapHF t f ~> WrapHF t g Source #
HBind t => HBind (WrapHF t :: (k -> Type) -> k -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods hbind :: forall (f :: k0 -> Type) (g :: k0 -> Type). (f ~> WrapHF t g) -> WrapHF t f ~> WrapHF t g Source # hjoin :: forall (f :: k0 -> Type). WrapHF t (WrapHF t f) ~> WrapHF t f Source #
Inject t => Inject (WrapHF t :: (k -> Type) -> k -> Type) Source #
Instance details Defined in Data.HFunctor.Interpret Methods inject :: forall (f :: k0 -> Type). f ~> WrapHF t f Source #
Foldable (t f) => Foldable (WrapHF t f) Source #
Instance details Defined in Data.HFunctor.Interpret Methods fold :: Monoid m => WrapHF t f m -> m # foldMap :: Monoid m => (a -> m) -> WrapHF t f a -> m # foldMap' :: Monoid m => (a -> m) -> WrapHF t f a -> m # foldr :: (a -> b -> b) -> b -> WrapHF t f a -> b # foldr' :: (a -> b -> b) -> b -> WrapHF t f a -> b # foldl :: (b -> a -> b) -> b -> WrapHF t f a -> b # foldl' :: (b -> a -> b) -> b -> WrapHF t f a -> b # foldr1 :: (a -> a -> a) -> WrapHF t f a -> a # foldl1 :: (a -> a -> a) -> WrapHF t f a -> a # toList :: WrapHF t f a -> [a] # null :: WrapHF t f a -> Bool # length :: WrapHF t f a -> Int # elem :: Eq a => a -> WrapHF t f a -> Bool # maximum :: Ord a => WrapHF t f a -> a # minimum :: Ord a => WrapHF t f a -> a # sum :: Num a => WrapHF t f a -> a # product :: Num a => WrapHF t f a -> a #
Eq1 (t f) => Eq1 (WrapHF t f) Source #
Instance details Defined in Data.HFunctor.Interpret Methods liftEq :: (a -> b -> Bool) -> WrapHF t f a -> WrapHF t f b -> Bool #
Ord1 (t f) => Ord1 (WrapHF t f) Source #
Instance details Defined in Data.HFunctor.Interpret Methods liftCompare :: (a -> b -> Ordering) -> WrapHF t f a -> WrapHF t f b -> Ordering #
Show1 (t f) => Show1 (WrapHF t f) Source #
Instance details Defined in Data.HFunctor.Interpret Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> WrapHF t f a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [WrapHF t f a] -> ShowS #
Traversable (t f) => Traversable (WrapHF t f) Source #
Instance details Defined in Data.HFunctor.Interpret Methods traverse :: Applicative f0 => (a -> f0 b) -> WrapHF t f a -> f0 (WrapHF t f b) # sequenceA :: Applicative f0 => WrapHF t f (f0 a) -> f0 (WrapHF t f a) # mapM :: Monad m => (a -> m b) -> WrapHF t f a -> m (WrapHF t f b) # sequence :: Monad m => WrapHF t f (m a) -> m (WrapHF t f a) #
Functor (t f) => Functor (WrapHF t f) Source #
Instance details Defined in Data.HFunctor.Interpret Methods fmap :: (a -> b) -> WrapHF t f a -> WrapHF t f b # (<$) :: a -> WrapHF t f b -> WrapHF t f a #
(Typeable f, Typeable a, Typeable t, Typeable k1, Typeable k2, Data (t f a)) => Data (WrapHF t f a) Source #
Instance details Defined in Data.HFunctor.Interpret Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WrapHF t f a -> c (WrapHF t f a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WrapHF t f a) # toConstr :: WrapHF t f a -> Constr # dataTypeOf :: WrapHF t f a -> DataType # dataCast1 :: Typeable t0 => (forall d. Data d => c (t0 d)) -> Maybe (c (WrapHF t f a)) # dataCast2 :: Typeable t0 => (forall d e. (Data d, Data e) => c (t0 d e)) -> Maybe (c (WrapHF t f a)) # gmapT :: (forall b. Data b => b -> b) -> WrapHF t f a -> WrapHF t f a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrapHF t f a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrapHF t f a -> r # gmapQ :: (forall d. Data d => d -> u) -> WrapHF t f a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WrapHF t f a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WrapHF t f a -> m (WrapHF t f a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WrapHF t f a -> m (WrapHF t f a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WrapHF t f a -> m (WrapHF t f a) #
Generic (WrapHF t f a) Source #
Instance details Defined in Data.HFunctor.Interpret Associated Types type Rep (WrapHF t f a) :: Type -> Type # Methods from :: WrapHF t f a -> Rep (WrapHF t f a) x # to :: Rep (WrapHF t f a) x -> WrapHF t f a #
Read (t f a) => Read (WrapHF t f a) Source #
Instance details Defined in Data.HFunctor.Interpret Methods readsPrec :: Int -> ReadS (WrapHF t f a) # readList :: ReadS [WrapHF t f a] # readPrec :: ReadPrec (WrapHF t f a) # readListPrec :: ReadPrec [WrapHF t f a] #
Show (t f a) => Show (WrapHF t f a) Source #
Instance details Defined in Data.HFunctor.Interpret Methods showsPrec :: Int -> WrapHF t f a -> ShowS # show :: WrapHF t f a -> String # showList :: [WrapHF t f a] -> ShowS #
Eq (t f a) => Eq (WrapHF t f a) Source #
Instance details Defined in Data.HFunctor.Interpret Methods (==) :: WrapHF t f a -> WrapHF t f a -> Bool # (/=) :: WrapHF t f a -> WrapHF t f a -> Bool #
Ord (t f a) => Ord (WrapHF t f a) Source #
Instance details Defined in Data.HFunctor.Interpret Methods compare :: WrapHF t f a -> WrapHF t f a -> Ordering # (<) :: WrapHF t f a -> WrapHF t f a -> Bool # (<=) :: WrapHF t f a -> WrapHF t f a -> Bool # (>) :: WrapHF t f a -> WrapHF t f a -> Bool # (>=) :: WrapHF t f a -> WrapHF t f a -> Bool # max :: WrapHF t f a -> WrapHF t f a -> WrapHF t f a # min :: WrapHF t f a -> WrapHF t f a -> WrapHF t f a #
type Rep (WrapHF t f a) Source #
Instance details Defined in Data.HFunctor.Interpret type Rep (WrapHF t f a) = D1 ('MetaData "WrapHF" "Data.HFunctor.Interpret" "functor-combinators-0.4.1.1-GvD6BEOdYqeEGstBK8j7zW" 'True) (C1 ('MetaCons "WrapHF" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapHF") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (t f a))))