Data.HFunctor.Interpret

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.

Documentation

class Inject t => Interpret t f where

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

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

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

Instances

Decide f => Interpret Dec1 (f :: Type -> Type)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

retract :: Dec1 f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> Dec1 g ~> f

Conclude f => Interpret Dec (f :: Type -> Type)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

retract :: Dec f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> Dec g ~> f

Apply f => Interpret Ap1 (f :: Type -> Type)

Defined in Data.Functor.Apply.Free

Methods

retract :: Ap1 f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> Ap1 g ~> f

Interpret (Reverse :: (k -> Type) -> k -> Type) (f :: k -> Type)

Defined in Data.HFunctor.Interpret

Methods

retract :: Reverse f ~> f

interpret :: forall (g :: k0 -> Type). (g ~> f) -> Reverse g ~> f

Interpret (Backwards :: (k -> Type) -> k -> Type) (f :: k -> Type)

Defined in Data.HFunctor.Interpret

Methods

retract :: Backwards f ~> f

interpret :: forall (g :: k0 -> Type). (g ~> f) -> Backwards g ~> f

Interpret (IdentityT :: (k -> Type) -> k -> Type) (f :: k -> Type)

Defined in Data.HFunctor.Interpret

Methods

retract :: IdentityT f ~> f

interpret :: forall (g :: k0 -> Type). (g ~> f) -> IdentityT g ~> f

Interpret (Flagged :: (k -> Type) -> k -> Type) (f :: k -> Type)

Equivalent to instance for EnvT Any and HLift IdentityT.

Defined in Data.HFunctor.Interpret

Methods

retract :: Flagged f ~> f

interpret :: forall (g :: k0 -> Type). (g ~> f) -> Flagged g ~> f

Interpret (Step :: (k -> Type) -> k -> Type) (f :: k -> Type)

Equivalent to instance for EnvT (Sum Natural).

Defined in Data.HFunctor.Interpret

Methods

retract :: Step f ~> f

interpret :: forall (g :: k0 -> Type). (g ~> f) -> Step g ~> f

(HBifunctor t, SemigroupIn t f) => Interpret (Chain1 t :: (Type -> Type) -> Type -> Type) (f :: Type -> Type)

Defined in Data.HFunctor.Chain

Methods

retract :: Chain1 t f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> Chain1 t g ~> f

Interpret t f => Interpret (HFree t :: (k -> Type) -> k -> Type) (f :: k -> Type)

Never uses inject

Defined in Data.HFunctor.Interpret

Methods

retract :: HFree t f ~> f

interpret :: forall (g :: k0 -> Type). (g ~> f) -> HFree t g ~> f

Interpret t f => Interpret (HLift t :: (k -> Type) -> k -> Type) (f :: k -> Type)

Never uses inject

Defined in Data.HFunctor.Interpret

Methods

retract :: HLift t f ~> f

interpret :: forall (g :: k0 -> Type). (g ~> f) -> HLift t g ~> f

c f => Interpret (Final c :: (k -> Type) -> k -> Type) (f :: k -> Type)

Defined in Data.HFunctor.Final

Methods

retract :: Final c f ~> f

interpret :: forall (g :: k0 -> Type). (g ~> f) -> Final c g ~> f

Interpret (M1 i c :: (k -> Type) -> k -> Type) (f :: k -> Type)

Defined in Data.HFunctor.Interpret

Methods

retract :: M1 i c f ~> f

interpret :: forall (g :: k0 -> Type). (g ~> f) -> M1 i c g ~> f

Interpret (RightF g :: (k2 -> Type) -> k2 -> Type) (f :: k2 -> Type)

Defined in Data.HBifunctor

Methods

retract :: RightF g f ~> f

interpret :: forall (g0 :: k -> Type). (g0 ~> f) -> RightF g g0 ~> f

MonoidIn t i f => Interpret (Chain t i :: (Type -> Type) -> Type -> Type) (f :: Type -> Type)

We can collapse and interpret an Chain t i if we have Tensor t.

Defined in Data.HFunctor.Chain

Methods

retract :: Chain t i f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> Chain t i g ~> f

Applicative f => Interpret Ap (f :: Type -> Type)

A free Applicative

Defined in Data.HFunctor.Interpret

Methods

retract :: Ap f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> Ap g ~> f

Applicative f => Interpret Ap (f :: Type -> Type)

A free Applicative

Defined in Data.HFunctor.Interpret

Methods

retract :: Ap f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> Ap g ~> f

Applicative f => Interpret Ap (f :: Type -> Type)

A free Applicative

Defined in Data.HFunctor.Interpret

Methods

retract :: Ap f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> Ap g ~> f

Alternative f => Interpret Alt (f :: Type -> Type)

A free Alternative

Defined in Data.HFunctor.Interpret

Methods

retract :: Alt f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> Alt g ~> f

Functor f => Interpret Coyoneda (f :: Type -> Type)

A free Functor

Defined in Data.HFunctor.Interpret

Methods

retract :: Coyoneda f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> Coyoneda g ~> f

Contravariant f => Interpret Coyoneda (f :: Type -> Type)

A free Contravariant

Since: 0.3.0.0

Defined in Data.HFunctor.Interpret

Methods

retract :: Coyoneda f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> Coyoneda g ~> f

Interpret WrappedApplicative (f :: Type -> Type)

Defined in Data.HFunctor.Interpret

Methods

retract :: WrappedApplicative f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> WrappedApplicative g ~> f

Pointed f => Interpret MaybeApply (f :: Type -> Type)

A free Pointed

Defined in Data.HFunctor.Interpret

Methods

retract :: MaybeApply f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> MaybeApply g ~> f

Pointed f => Interpret Lift (f :: Type -> Type)

A free Pointed

Defined in Data.HFunctor.Interpret

Methods

retract :: Lift f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> Lift g ~> f

Bind f => Interpret Free1 (f :: Type -> Type)

A free Bind

Defined in Data.HFunctor.Interpret

Methods

retract :: Free1 f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> Free1 g ~> f

Monad f => Interpret Free (f :: Type -> Type)

A free Monad

Defined in Data.HFunctor.Interpret

Methods

retract :: Free f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> Free g ~> f

Divise f => Interpret Div1 (f :: Type -> Type)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

retract :: Div1 f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> Div1 g ~> f

Divisible f => Interpret Div (f :: Type -> Type)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

retract :: Div f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> Div g ~> f

Monoid e => Interpret (EnvT e :: (Type -> Type) -> Type -> Type) (f :: Type -> Type)

This ignores the environment, so interpret /= hbind

Defined in Data.HFunctor.Interpret

Methods

retract :: EnvT e f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> EnvT e g ~> f

MonadReader r f => Interpret (ReaderT r :: (Type -> Type) -> Type -> Type) (f :: Type -> Type)

A free MonadReader, but only when applied to a Monad.

Defined in Data.HFunctor.Interpret

Methods

retract :: ReaderT r f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> ReaderT r g ~> f

Plus f => Interpret (These1 g :: (Type -> Type) -> Type -> Type) (f :: Type -> Type)

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.

Defined in Data.HFunctor.Interpret

Methods

retract :: These1 g f ~> f

interpret :: forall (g0 :: k -> Type). (g0 ~> f) -> These1 g g0 ~> f

Alt f => Interpret (Steps :: (Type -> Type) -> Type -> Type) (f :: Type -> Type)

Defined in Data.HFunctor.Interpret

Methods

retract :: Steps f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> Steps g ~> f

Plus f => Interpret (ListF :: (Type -> Type) -> Type -> Type) (f :: Type -> Type)

A free Plus

Defined in Data.HFunctor.Interpret

Methods

retract :: ListF f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> ListF g ~> f

Alt f => Interpret (NonEmptyF :: (Type -> Type) -> Type -> Type) (f :: Type -> Type)

A free Alt

Defined in Data.HFunctor.Interpret

Methods

retract :: NonEmptyF f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> NonEmptyF g ~> f

Plus f => Interpret (MaybeF :: (Type -> Type) -> Type -> Type) (f :: Type -> Type)

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.

Defined in Data.HFunctor.Interpret

Methods

retract :: MaybeF f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> MaybeF g ~> f

Interpret t f => Interpret (PreT t :: (Type -> Type) -> Type -> Type) (f :: Type -> Type)

Defined in Data.HFunctor.Route

Methods

retract :: PreT t f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> PreT t g ~> f

Monoid a => Interpret (Post a :: (Type -> Type) -> Type -> Type) (f :: Type -> Type)

Defined in Data.HFunctor.Route

Methods

retract :: Post a f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> Post a g ~> f

a ~ Void => Interpret (Pre a :: (Type -> Type) -> Type -> Type) (f :: Type -> Type)

Defined in Data.HFunctor.Route

Methods

retract :: Pre a f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> Pre a g ~> f

Plus f => Interpret ((:+:) g :: (Type -> Type) -> Type -> Type) (f :: Type -> Type)

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.

Defined in Data.HFunctor.Interpret

Methods

retract :: (g :+: f) ~> f

interpret :: forall (g0 :: k -> Type). (g0 ~> f) -> (g :+: g0) ~> f

Plus g => Interpret ((:*:) g :: (Type -> Type) -> Type -> Type) (f :: Type -> Type)

Defined in Data.HFunctor.Interpret

Methods

retract :: (g :*: f) ~> f

interpret :: forall (g0 :: k -> Type). (g0 ~> f) -> (g :*: g0) ~> f

Plus g => Interpret (Product g :: (Type -> Type) -> Type -> Type) (f :: Type -> Type)

Defined in Data.HFunctor.Interpret

Methods

retract :: Product g f ~> f

interpret :: forall (g0 :: k -> Type). (g0 ~> f) -> Product g g0 ~> f

Plus f => Interpret (Sum g :: (Type -> Type) -> Type -> Type) (f :: Type -> Type)

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.

Defined in Data.HFunctor.Interpret

Methods

retract :: Sum g f ~> f

interpret :: forall (g0 :: k -> Type). (g0 ~> f) -> Sum g g0 ~> f

(Interpret s f, Interpret t f) => Interpret (ComposeT s t :: (Type -> Type) -> Type -> Type) (f :: Type -> Type)

Defined in Data.HFunctor.Interpret

Methods

retract :: ComposeT s t f ~> f

interpret :: forall (g :: k -> Type). (g ~> f) -> ComposeT s t g ~> f

(Monoid k, Plus f) => Interpret (MapF k :: (Type -> Type) -> Type -> Type) (f :: Type -> Type)

Defined in Data.HFunctor.Interpret

Methods

retract :: MapF k f ~> f

interpret :: forall (g :: k0 -> Type). (g ~> f) -> MapF k g ~> f

(Monoid k, Alt f) => Interpret (NEMapF k :: (Type -> Type) -> Type -> Type) (f :: Type -> Type)

Defined in Data.HFunctor.Interpret

Methods

retract :: NEMapF k f ~> f

interpret :: forall (g :: k0 -> Type). (g ~> f) -> NEMapF k g ~> f

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

A convenient flipped version of interpret.

Utilities

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

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

Since: 0.3.1.0

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

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]

Since: 0.3.1.0

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

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

Since: 0.3.1.0

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

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]

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

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

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]

Deprecated: Use icollect instead

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

newtype AltConst w a

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

Functor (AltConst w :: Type -> Type)

Defined in Data.HFunctor.Interpret

Methods

fmap :: (a -> b) -> AltConst w a -> AltConst w b

(<$) :: a -> AltConst w b -> AltConst w a

Monoid w => Applicative (AltConst w :: Type -> Type)

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

Foldable (AltConst w :: Type -> Type)

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

Traversable (AltConst w :: Type -> Type)

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)

Contravariant (AltConst w :: Type -> Type)

Defined in Data.HFunctor.Interpret

Methods

contramap :: (a -> b) -> AltConst w b -> AltConst w a

(>$) :: b -> AltConst w b -> AltConst w a

Eq w => Eq1 (AltConst w :: Type -> Type)

Defined in Data.HFunctor.Interpret

Methods

liftEq :: (a -> b -> Bool) -> AltConst w a -> AltConst w b -> Bool

Ord w => Ord1 (AltConst w :: Type -> Type)

Defined in Data.HFunctor.Interpret

Methods

liftCompare :: (a -> b -> Ordering) -> AltConst w a -> AltConst w b -> Ordering

Show w => Show1 (AltConst w :: Type -> Type)

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

Monoid w => Divisible (AltConst w :: Type -> Type)

Defined in Data.HFunctor.Interpret

Methods

divide :: (a -> (b, c)) -> AltConst w b -> AltConst w c -> AltConst w a

conquer :: AltConst w a

Invariant (AltConst w :: Type -> Type)

Defined in Data.HFunctor.Interpret

Methods

invmap :: (a -> b) -> (b -> a) -> AltConst w a -> AltConst w b

Semigroup w => Apply (AltConst w :: Type -> Type)

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)

Unlike for Const, this is possible because there is no Alternative instance to complicate things.

Defined in Data.HFunctor.Interpret

Methods

zero :: AltConst w a

Semigroup w => Alt (AltConst w :: Type -> Type)

Unlike for Const, this is possible because there is no Alternative instance to complicate things.

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 => Divise (AltConst w :: Type -> Type)

Defined in Data.HFunctor.Interpret

Methods

divise :: (a -> (b, c)) -> AltConst w b -> AltConst w c -> AltConst w a

Semigroup w => Decide (AltConst w :: Type -> Type)

Unlike for Const, this is possible because there is no Decidable instance to complicate things.

Defined in Data.HFunctor.Interpret

Methods

decide :: (a -> Either b c) -> AltConst w b -> AltConst w c -> AltConst w a

Monoid w => Conclude (AltConst w :: Type -> Type)

Unlike for Const, this is possible because there is no Decidable instance to complicate things.

Defined in Data.HFunctor.Interpret

Methods

conclude :: (a -> Void) -> AltConst w a

Eq w => Eq (AltConst w a)

Defined in Data.HFunctor.Interpret

Methods

(==) :: AltConst w a -> AltConst w a -> Bool

(/=) :: AltConst w a -> AltConst w a -> Bool

(Typeable a, Typeable k, Data w) => Data (AltConst w a)

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)

Ord w => Ord (AltConst w a)

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

Show w => Show (AltConst w a)

Defined in Data.HFunctor.Interpret

Methods

showsPrec :: Int -> AltConst w a -> ShowS

show :: AltConst w a -> String

showList :: [AltConst w a] -> ShowS

Generic (AltConst w a)

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

type Rep (AltConst w a)

Defined in Data.HFunctor.Interpret

type Rep (AltConst w a) = D1 ('MetaData "AltConst" "Data.HFunctor.Interpret" "functor-combinators-0.3.4.0-inplace" 'True) (C1 ('MetaCons "AltConst" 'PrefixI 'True) (S1 ('MetaSel ('Just "getAltConst") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 w)))

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

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

(c a, d a) => AndC (c :: k -> Constraint) (d :: k -> Constraint) (a :: k)

Defined in Data.HFunctor.Interpret

newtype WrapHF t f a

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

HFunctor t => HFunctor (WrapHF t :: (k1 -> Type) -> k2 -> Type)

Defined in Data.HFunctor.Interpret

Methods

hmap :: forall (f :: k -> Type) (g :: k -> Type). (f ~> g) -> WrapHF t f ~> WrapHF t g

HBind t => HBind (WrapHF t :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Interpret

Methods

hbind :: forall (f :: k0 -> Type) (g :: k0 -> Type). (f ~> WrapHF t g) -> WrapHF t f ~> WrapHF t g

hjoin :: forall (f :: k0 -> Type). WrapHF t (WrapHF t f) ~> WrapHF t f

Inject t => Inject (WrapHF t :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Interpret

Methods

inject :: forall (f :: k0 -> Type). f ~> WrapHF t f

Functor (t f) => Functor (WrapHF t f)

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

Foldable (t f) => Foldable (WrapHF t f)

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

Traversable (t f) => Traversable (WrapHF t f)

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)

Eq1 (t f) => Eq1 (WrapHF t f)

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)

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)

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

Eq (t f a) => Eq (WrapHF t f a)

Defined in Data.HFunctor.Interpret

Methods

(==) :: WrapHF t f a -> WrapHF t f a -> Bool

(/=) :: WrapHF t f a -> WrapHF t f a -> Bool

(Typeable f, Typeable a, Typeable t, Typeable k1, Typeable k2, Data (t f a)) => Data (WrapHF t f a)

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)

Ord (t f a) => Ord (WrapHF t f a)

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

Read (t f a) => Read (WrapHF t f a)

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)

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

Generic (WrapHF t f a)

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

type Rep (WrapHF t f a)

Defined in Data.HFunctor.Interpret

type Rep (WrapHF t f a) = D1 ('MetaData "WrapHF" "Data.HFunctor.Interpret" "functor-combinators-0.3.4.0-inplace" 'True) (C1 ('MetaCons "WrapHF" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapHF") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (t f a))))