Data.Functor.Combinator

Functor combinators and tools (typeclasses and utiility functions) to manipulate them. This is the main "entrypoint" of the library.

Classes include:

• HFunctor and HBifunctor, used to swap out the functors that the combinators modify
• Interpret, Associative, Monoidal, used to inject and interpret functor values with respect to their combinators.

We have some helpful utility functions, as well, built on top of these typeclasses.

The second half of this module exports the various useful functor combinators that can modify functors to add extra functionality, or join two functors together and mix them in different ways. Use them to build your final structure by combining simpler ones in composable ways!

See https://blog.jle.im/entry/functor-combinatorpedia.html and the README for a tutorial and a rundown on each different functor combinator.

Classes

A lot of type signatures are stated in terms of ~>. ~> represents a "natural transformation" between two functors: a value of type f ~> g is a value of type 'f a -> g a that works for any a@.

type (~>) (f :: k -> Type) (g :: k -> Type) = forall (x :: k). f x -> g x infixr 0

A natural transformation from f to g.

type (<~>) f g = forall p a. Profunctor p => p (g a) (g a) -> p (f a) (f a) infixr 0

The type of an isomorphism between two functors. f <~> g means that f and g are isomorphic to each other.

We can effectively use an f <~> g with:

viewF   :: (f <~> g) -> f a -> g a
reviewF :: (f <~> g) -> g a -> a a

Use viewF to extract the "f to g" function, and reviewF to extract the "g to f" function. Reviewing and viewing the same value (or vice versa) leaves the value unchanged.

One nice thing is that we can compose isomorphisms using . from Prelude:

(.) :: f <~> g
    -> g <~> h
    -> f <~> h

Another nice thing about this representation is that we have the "identity" isomorphism by using id from Prelude.

id :: f <~> g

As a convention, most isomorphisms have form "X-ing", where the forwards function is "ing". For example, we have:

splittingSF :: Monoidal t => SF t a <~> t f (MF t f)
splitSF     :: Monoidal t => SF t a  ~> t f (MF t f)

Single Functors

Classes that deal with single-functor combinators, that enhance a single functor.

class HFunctor t where

An HFunctor can be thought of a unary "functor transformer" --- a basic functor combinator. It takes a functor as input and returns a functor as output.

It "enhances" a functor with extra structure (sort of like how a monad transformer enhances a Monad with extra structure).

As a uniform inteface, we can "swap the underlying functor" (also sometimes called "hoisting"). This is what hmap does: it lets us swap out the f in a t f for a t g.

For example, the free monad Free takes a Functor and returns a new Functor. In the process, it provides a monadic structure over f. hmap lets us turn a Free f into a Free g: a monad built over f can be turned into a monad built over g.

For the ability to move in and out of the enhanced functor, see Inject and Interpret.

This class is similar to MFunctor from Control.Monad.Morph, but instances must work without a Monad constraint.

This class is also found in the hschema library with the same name.

Methods

hmap :: (f ~> g) -> t f ~> t g

If we can turn an f into a g, then we can turn a t f into a t g.

It must be the case that

hmap id == id

Essentially, t f adds some "extra structure" to f. hmap must swap out the functor, without affecting the added structure.

For example, ListF f a is essentially a list of f as. If we hmap to swap out the f as for g as, then we must ensure that the "added structure" (here, the number of items in the list, and the ordering of those items) remains the same. So, hmap must preserve the number of items in the list, and must maintain the ordering.

The law hmap id == id is a way of formalizing this property.

Instances

HFunctor Ap1

Defined in Data.Functor.Apply.Free

Methods

hmap :: (f ~> g) -> Ap1 f ~> Ap1 g

HFunctor (Reverse :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Reverse f ~> Reverse g

HFunctor (Backwards :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Backwards f ~> Backwards g

HFunctor (IdentityT :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> IdentityT f ~> IdentityT g

HFunctor (Flagged :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Flagged f ~> Flagged g

HFunctor (Steps :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Steps f ~> Steps g

HFunctor (Step :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Step f ~> Step g

HFunctor (Void2 :: (k1 -> Type) -> k2 -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Void2 f ~> Void2 g

HFunctor (ReaderT r :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> ReaderT r f ~> ReaderT r g

HFunctor (Sum f :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f0 ~> g) -> Sum f f0 ~> Sum f g

HFunctor (Product f :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f0 ~> g) -> Product f f0 ~> Product f g

HFunctor ((:+:) f :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f0 ~> g) -> (f :+: f0) ~> (f :+: g)

HFunctor ((:*:) f :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f0 ~> g) -> (f :*: f0) ~> (f :*: g)

HFunctor (ProxyF :: (k1 -> Type) -> k2 -> Type)

Defined in Data.HFunctor

Methods

hmap :: (f ~> g) -> ProxyF f ~> ProxyF g

HFunctor t => HFunctor (HLift t :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

hmap :: (f ~> g) -> HLift t f ~> HLift t g

HFunctor t => HFunctor (HFree t :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

hmap :: (f ~> g) -> HFree t f ~> HFree t g

HBifunctor t => HFunctor (Chain1 t :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Chain

Methods

hmap :: (f ~> g) -> Chain1 t f ~> Chain1 t g

HFunctor (M1 i c :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> M1 i c f ~> M1 i c g

Functor f => HFunctor ((:.:) f :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f0 ~> g) -> (f :.: f0) ~> (f :.: g)

HFunctor (Joker f :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f0 ~> g) -> Joker f f0 ~> Joker f g

HFunctor (ConstF e :: (k1 -> Type) -> k2 -> Type)

Defined in Data.HFunctor

Methods

hmap :: (f ~> g) -> ConstF e f ~> ConstF e g

HFunctor (LeftF f :: (k -> Type) -> k -> Type)

Defined in Data.HBifunctor

Methods

hmap :: (f0 ~> g) -> LeftF f f0 ~> LeftF f g

HFunctor (RightF f :: (k1 -> Type) -> k1 -> Type)

Defined in Data.HBifunctor

Methods

hmap :: (f0 ~> g) -> RightF f f0 ~> RightF f g

HFunctor (RightF f :: (k -> Type) -> k -> Type)

Defined in Data.HBifunctor

Methods

hmap :: (f0 ~> g) -> RightF f f0 ~> RightF f g

HBifunctor t => HFunctor (WrappedHBifunctor t f :: (k1 -> Type) -> k2 -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f0 ~> g) -> WrappedHBifunctor t f f0 ~> WrappedHBifunctor t f g

HFunctor (Void3 f :: (k2 -> Type) -> k1 -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f0 ~> g) -> Void3 f f0 ~> Void3 f g

HBifunctor t => HFunctor (Chain t i :: (k1 -> Type) -> k2 -> Type)

Defined in Data.HFunctor.Chain

Methods

hmap :: (f ~> g) -> Chain t i f ~> Chain t i g

HFunctor (CoRec :: (k -> Type) -> [k] -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> CoRec f ~> CoRec g

HFunctor (Rec :: (k -> Type) -> [k] -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Rec f ~> Rec g

HFunctor (Tagged :: (k -> Type) -> Type -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Tagged f ~> Tagged g

HFunctor MaybeT

Note that there is no Interpret or Bind instance, because inject requires Functor f.

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> MaybeT f ~> MaybeT g

HFunctor F

Note that there is no Interpret or Bind instance, because inject requires Functor f.

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> F f ~> F g

HFunctor Ap

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Ap f ~> Ap g

HFunctor Ap

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Ap f ~> Ap g

HFunctor Ap

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Ap f ~> Ap g

HFunctor Alt

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Alt f ~> Alt g

HFunctor Yoneda

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Yoneda f ~> Yoneda g

HFunctor Coyoneda

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Coyoneda f ~> Coyoneda g

HFunctor WrappedApplicative

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> WrappedApplicative f ~> WrappedApplicative g

HFunctor MaybeApply

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> MaybeApply f ~> MaybeApply g

HFunctor Lift

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Lift f ~> Lift g

HFunctor ListF

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> ListF f ~> ListF g

HFunctor NonEmptyF

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> NonEmptyF f ~> NonEmptyF g

HFunctor MaybeF

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> MaybeF f ~> MaybeF g

HFunctor Free1

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Free1 f ~> Free1 g

HFunctor Free

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Free f ~> Free g

HFunctor (EnvT e :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> EnvT e f ~> EnvT e g

HFunctor (Day f :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f0 ~> g) -> Day f f0 ~> Day f g

HFunctor (These1 f :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f0 ~> g) -> These1 f f0 ~> These1 f g

HFunctor (MapF k :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> MapF k f ~> MapF k g

HFunctor (NEMapF k :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> NEMapF k f ~> NEMapF k g

HFunctor (Comp f :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f0 ~> g) -> Comp f f0 ~> Comp f g

HFunctor (Final c :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Final

Methods

hmap :: (f ~> g) -> Final c f ~> Final c g

(HFunctor s, HFunctor t) => HFunctor (ComposeT s t :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> ComposeT s t f ~> ComposeT s t g

class HFunctor t => Inject t where

A typeclass for HFunctors where you can "inject" an f a into a t f a:

inject :: f a -> t f a

If you think of t f a as an "enhanced f", then inject allows you to use an f as its enhanced form.

With the exception of directly pattern matching on the result, inject itself is not too useful in the general case without Interpret to allow us to interpret or retrieve back the f.

Methods

inject :: f ~> t f

Lift from f into the enhanced t f structure. Analogous to lift from MonadTrans.

Note that this lets us "lift" a f a; if you want to lift an a with a -> t f a, check if t f is an instance of Applicative or Pointed.

Instances

Inject Ap1

Defined in Data.Functor.Apply.Free

Methods

inject :: f ~> Ap1 f

Inject (Reverse :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

inject :: f ~> Reverse f

Inject (Backwards :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

inject :: f ~> Backwards f

Inject (IdentityT :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

inject :: f ~> IdentityT f

Inject (Flagged :: (k -> Type) -> k -> Type)

Injects with False.

Equivalent to instance for EnvT Any and HLift IdentityT.

Defined in Data.HFunctor

Methods

inject :: f ~> Flagged f

Inject (Steps :: (k -> Type) -> k -> Type)

Injects into a singleton map at 0; same behavior as NEMapF (Sum Natural).

Defined in Data.HFunctor

Methods

inject :: f ~> Steps f

Inject (Step :: (k -> Type) -> k -> Type)

Injects with 0.

Equivalent to instance for EnvT (Sum Natural).

Defined in Data.HFunctor

Methods

inject :: f ~> Step f

HFunctor t => Inject (HFree t :: (k -> Type) -> k -> Type)

HFree is the "free HBind and Inject" for any HFunctor

Defined in Data.HFunctor

Methods

inject :: f ~> HFree t f

HFunctor t => Inject (HLift t :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

inject :: f ~> HLift t f

Inject (ProxyF :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

inject :: f ~> ProxyF f

Inject (ReaderT r :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

inject :: f ~> ReaderT r f

Inject (Sum f :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

inject :: f0 ~> Sum f f0

Inject ((:+:) f :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

inject :: f0 ~> (f :+: f0)

HBifunctor t => Inject (Chain1 t :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Chain

Methods

inject :: f ~> Chain1 t f

Monoid e => Inject (ConstF e :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

inject :: f ~> ConstF e f

Inject (M1 i c :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

inject :: f ~> M1 i c f

Applicative f => Inject ((:.:) f :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

inject :: f0 ~> (f :.: f0)

Inject (RightF f :: (k1 -> Type) -> k1 -> Type)

Defined in Data.HBifunctor

Methods

inject :: f0 ~> RightF f f0

Inject Ap

Defined in Data.HFunctor

Methods

inject :: f ~> Ap f

Inject Ap

Defined in Data.HFunctor

Methods

inject :: f ~> Ap f

Inject Ap

Defined in Data.HFunctor

Methods

inject :: f ~> Ap f

Inject Alt

Defined in Data.HFunctor

Methods

inject :: f ~> Alt f

Inject Coyoneda

Defined in Data.HFunctor

Methods

inject :: f ~> Coyoneda f

Inject WrappedApplicative

Defined in Data.HFunctor

Methods

inject :: f ~> WrappedApplicative f

Inject MaybeApply

Defined in Data.HFunctor

Methods

inject :: f ~> MaybeApply f

Inject Lift

Defined in Data.HFunctor

Methods

inject :: f ~> Lift f

Inject ListF

Defined in Data.HFunctor

Methods

inject :: f ~> ListF f

Inject NonEmptyF

Defined in Data.HFunctor

Methods

inject :: f ~> NonEmptyF f

Inject MaybeF

Defined in Data.HFunctor

Methods

inject :: f ~> MaybeF f

Inject Free1

Defined in Data.HFunctor

Methods

inject :: f ~> Free1 f

Inject Free

Defined in Data.HFunctor

Methods

inject :: f ~> Free f

Monoid e => Inject (EnvT e :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor

Methods

inject :: f ~> EnvT e f

Inject (These1 f :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor

Methods

inject :: f0 ~> These1 f f0

Monoid k => Inject (MapF k :: (Type -> Type) -> Type -> Type)

Injects into a singleton map at mempty.

Defined in Data.HFunctor

Methods

inject :: f ~> MapF k f

Monoid k => Inject (NEMapF k :: (Type -> Type) -> Type -> Type)

Injects into a singleton map at mempty.

Defined in Data.HFunctor

Methods

inject :: f ~> NEMapF k f

Applicative f => Inject (Comp f :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor

Methods

inject :: f0 ~> Comp f f0

Inject (Final c :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Final

Methods

inject :: f ~> Final c f

Plus f => Inject ((:*:) f :: (Type -> Type) -> Type -> Type)

Only uses zero

Defined in Data.HFunctor

Methods

inject :: f0 ~> (f :*: f0)

Plus f => Inject (Product f :: (Type -> Type) -> Type -> Type)

Only uses zero

Defined in Data.HFunctor

Methods

inject :: f0 ~> Product f f0

(Inject s, Inject t) => Inject (ComposeT s t :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor

Methods

inject :: f ~> ComposeT s t f

(Tensor t, i ~ I t) => Inject (Chain t i :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Chain

Methods

inject :: f ~> Chain t i f

class Inject t => Interpret t where

An Interpret lets us move in and out of the "enhanced" Functor.

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.

The type family C tells us the typeclass constraint of the "target" functor. For Free, it is Monad, but for other Interpret instances, we might have other constraints.

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.

Minimal complete definition

retract | interpret

Associated Types

type C t :: (Type -> Type) -> Constraint

The constraint on the target context of interpret. It's basically the constraint that allows you to "exit" or "run" an Interpret.

Methods

retract :: C t f => 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 :: C t g => (f ~> g) -> t f ~> g

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

Instances

Interpret Ap

A free Applicative

Defined in Data.HFunctor.Interpret

Associated Types

type C Ap :: (Type -> Type) -> Constraint

Methods

retract :: C Ap f => Ap f ~> f

interpret :: C Ap g => (f ~> g) -> Ap f ~> g

Interpret Ap

A free Applicative

Defined in Data.HFunctor.Interpret

Associated Types

type C Ap :: (Type -> Type) -> Constraint

Methods

retract :: C Ap f => Ap f ~> f

interpret :: C Ap g => (f ~> g) -> Ap f ~> g

Interpret Ap

A free Applicative

Defined in Data.HFunctor.Interpret

Associated Types

type C Ap :: (Type -> Type) -> Constraint

Methods

retract :: C Ap f => Ap f ~> f

interpret :: C Ap g => (f ~> g) -> Ap f ~> g

Interpret Alt

A free Alternative

Defined in Data.HFunctor.Interpret

Associated Types

type C Alt :: (Type -> Type) -> Constraint

Methods

retract :: C Alt f => Alt f ~> f

interpret :: C Alt g => (f ~> g) -> Alt f ~> g

Interpret Coyoneda

A free Functor

Defined in Data.HFunctor.Interpret

Associated Types

type C Coyoneda :: (Type -> Type) -> Constraint

Methods

retract :: C Coyoneda f => Coyoneda f ~> f

interpret :: C Coyoneda g => (f ~> g) -> Coyoneda f ~> g

Interpret WrappedApplicative

Defined in Data.HFunctor.Interpret

Associated Types

type C WrappedApplicative :: (Type -> Type) -> Constraint

Methods

retract :: C WrappedApplicative f => WrappedApplicative f ~> f

interpret :: C WrappedApplicative g => (f ~> g) -> WrappedApplicative f ~> g

Interpret MaybeApply

A free Pointed

Defined in Data.HFunctor.Interpret

Associated Types

type C MaybeApply :: (Type -> Type) -> Constraint

Methods

retract :: C MaybeApply f => MaybeApply f ~> f

interpret :: C MaybeApply g => (f ~> g) -> MaybeApply f ~> g

Interpret Lift

A free Pointed

Defined in Data.HFunctor.Interpret

Associated Types

type C Lift :: (Type -> Type) -> Constraint

Methods

retract :: C Lift f => Lift f ~> f

interpret :: C Lift g => (f ~> g) -> Lift f ~> g

Interpret ListF

A free Plus

Defined in Data.HFunctor.Interpret

Associated Types

type C ListF :: (Type -> Type) -> Constraint

Methods

retract :: C ListF f => ListF f ~> f

interpret :: C ListF g => (f ~> g) -> ListF f ~> g

Interpret NonEmptyF

A free Alt

Defined in Data.HFunctor.Interpret

Associated Types

type C NonEmptyF :: (Type -> Type) -> Constraint

Methods

retract :: C NonEmptyF f => NonEmptyF f ~> f

interpret :: C NonEmptyF g => (f ~> g) -> NonEmptyF f ~> g

Interpret MaybeF

Technically, C 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

Associated Types

type C MaybeF :: (Type -> Type) -> Constraint

Methods

retract :: C MaybeF f => MaybeF f ~> f

interpret :: C MaybeF g => (f ~> g) -> MaybeF f ~> g

Interpret Free1

A free Bind

Defined in Data.HFunctor.Interpret

Associated Types

type C Free1 :: (Type -> Type) -> Constraint

Methods

retract :: C Free1 f => Free1 f ~> f

interpret :: C Free1 g => (f ~> g) -> Free1 f ~> g

Interpret Free

A free Monad

Defined in Data.HFunctor.Interpret

Associated Types

type C Free :: (Type -> Type) -> Constraint

Methods

retract :: C Free f => Free f ~> f

interpret :: C Free g => (f ~> g) -> Free f ~> g

Interpret Ap1

Defined in Data.Functor.Apply.Free

Associated Types

type C Ap1 :: (Type -> Type) -> Constraint

Methods

retract :: C Ap1 f => Ap1 f ~> f

interpret :: C Ap1 g => (f ~> g) -> Ap1 f ~> g

Monoid e => Interpret (EnvT e)

This ignores the environment, so interpret /= hbind

Defined in Data.HFunctor.Interpret

Associated Types

type C (EnvT e) :: (Type -> Type) -> Constraint

Methods

retract :: C (EnvT e) f => EnvT e f ~> f

interpret :: C (EnvT e) g => (f ~> g) -> EnvT e f ~> g

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

A free Unconstrained

Defined in Data.HFunctor.Interpret

Associated Types

type C IdentityT :: (Type -> Type) -> Constraint

Methods

retract :: C IdentityT f => IdentityT f ~> f

interpret :: C IdentityT g => (f ~> g) -> IdentityT f ~> g

Interpret (These1 f)

Technically, C 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

Associated Types

type C (These1 f) :: (Type -> Type) -> Constraint

Methods

retract :: C (These1 f) f0 => These1 f f0 ~> f0

interpret :: C (These1 f) g => (f0 ~> g) -> These1 f f0 ~> g

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

Defined in Data.HFunctor.Interpret

Associated Types

type C Reverse :: (Type -> Type) -> Constraint

Methods

retract :: C Reverse f => Reverse f ~> f

interpret :: C Reverse g => (f ~> g) -> Reverse f ~> g

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

Defined in Data.HFunctor.Interpret

Associated Types

type C Backwards :: (Type -> Type) -> Constraint

Methods

retract :: C Backwards f => Backwards f ~> f

interpret :: C Backwards g => (f ~> g) -> Backwards f ~> g

Monoid k => Interpret (MapF k)

Defined in Data.HFunctor.Interpret

Associated Types

type C (MapF k) :: (Type -> Type) -> Constraint

Methods

retract :: C (MapF k) f => MapF k f ~> f

interpret :: C (MapF k) g => (f ~> g) -> MapF k f ~> g

Monoid k => Interpret (NEMapF k)

Defined in Data.HFunctor.Interpret

Associated Types

type C (NEMapF k) :: (Type -> Type) -> Constraint

Methods

retract :: C (NEMapF k) f => NEMapF k f ~> f

interpret :: C (NEMapF k) g => (f ~> g) -> NEMapF k f ~> g

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

Equivalent to instance for EnvT (Sum Natural).

Defined in Data.HFunctor.Interpret

Associated Types

type C Step :: (Type -> Type) -> Constraint

Methods

retract :: C Step f => Step f ~> f

interpret :: C Step g => (f ~> g) -> Step f ~> g

Interpret (Steps :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Interpret

Associated Types

type C Steps :: (Type -> Type) -> Constraint

Methods

retract :: C Steps f => Steps f ~> f

interpret :: C Steps g => (f ~> g) -> Steps f ~> g

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

Equivalent to instance for EnvT Any and HLift IdentityT.

Defined in Data.HFunctor.Interpret

Associated Types

type C Flagged :: (Type -> Type) -> Constraint

Methods

retract :: C Flagged f => Flagged f ~> f

interpret :: C Flagged g => (f ~> g) -> Flagged f ~> g

Interpret (Final c)

Defined in Data.HFunctor.Final

Associated Types

type C (Final c) :: (Type -> Type) -> Constraint

Methods

retract :: C (Final c) f => Final c f ~> f

interpret :: C (Final c) g => (f ~> g) -> Final c f ~> g

Interpret ((:+:) f)

Technically, C 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

Associated Types

type C ((:+:) f) :: (Type -> Type) -> Constraint

Methods

retract :: C ((:+:) f) f0 => (f :+: f0) ~> f0

interpret :: C ((:+:) f) g => (f0 ~> g) -> (f :+: f0) ~> g

Plus f => Interpret ((:*:) f)

Defined in Data.HFunctor.Interpret

Associated Types

type C ((:*:) f) :: (Type -> Type) -> Constraint

Methods

retract :: C ((:*:) f) f0 => (f :*: f0) ~> f0

interpret :: C ((:*:) f) g => (f0 ~> g) -> (f :*: f0) ~> g

Plus f => Interpret (Product f)

Defined in Data.HFunctor.Interpret

Associated Types

type C (Product f) :: (Type -> Type) -> Constraint

Methods

retract :: C (Product f) f0 => Product f f0 ~> f0

interpret :: C (Product f) g => (f0 ~> g) -> Product f f0 ~> g

Interpret (Sum f)

Technically, C 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

Associated Types

type C (Sum f) :: (Type -> Type) -> Constraint

Methods

retract :: C (Sum f) f0 => Sum f f0 ~> f0

interpret :: C (Sum f) g => (f0 ~> g) -> Sum f f0 ~> g

(Interpret s, Interpret t) => Interpret (ComposeT s t)

Defined in Data.HFunctor.Interpret

Associated Types

type C (ComposeT s t) :: (Type -> Type) -> Constraint

Methods

retract :: C (ComposeT s t) f => ComposeT s t f ~> f

interpret :: C (ComposeT s t) g => (f ~> g) -> ComposeT s t f ~> g

Interpret (ReaderT r :: (Type -> Type) -> Type -> Type)

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

Defined in Data.HFunctor.Interpret

Associated Types

type C (ReaderT r) :: (Type -> Type) -> Constraint

Methods

retract :: C (ReaderT r) f => ReaderT r f ~> f

interpret :: C (ReaderT r) g => (f ~> g) -> ReaderT r f ~> g

Interpret (ProxyF :: (Type -> Type) -> Type -> Type)

The only way for this to obey retract . inject == id is to have it impossible to retract out of.

Defined in Data.HFunctor.Interpret

Associated Types

type C ProxyF :: (Type -> Type) -> Constraint

Methods

retract :: C ProxyF f => ProxyF f ~> f

interpret :: C ProxyF g => (f ~> g) -> ProxyF f ~> g

Interpret t => Interpret (HFree t)

Never uses inject

Defined in Data.HFunctor.Interpret

Associated Types

type C (HFree t) :: (Type -> Type) -> Constraint

Methods

retract :: C (HFree t) f => HFree t f ~> f

interpret :: C (HFree t) g => (f ~> g) -> HFree t f ~> g

Interpret t => Interpret (HLift t)

Never uses inject

Defined in Data.HFunctor.Interpret

Associated Types

type C (HLift t) :: (Type -> Type) -> Constraint

Methods

retract :: C (HLift t) f => HLift t f ~> f

interpret :: C (HLift t) g => (f ~> g) -> HLift t f ~> g

(HBifunctor t, Semigroupoidal t) => Interpret (Chain1 t)

Defined in Data.HFunctor.Chain

Associated Types

type C (Chain1 t) :: (Type -> Type) -> Constraint

Methods

retract :: C (Chain1 t) f => Chain1 t f ~> f

interpret :: C (Chain1 t) g => (f ~> g) -> Chain1 t f ~> g

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

Defined in Data.HFunctor.Interpret

Associated Types

type C (M1 i c) :: (Type -> Type) -> Constraint

Methods

retract :: C (M1 i c) f => M1 i c f ~> f

interpret :: C (M1 i c) g => (f ~> g) -> M1 i c f ~> g

Monoid e => Interpret (ConstF e :: (Type -> Type) -> Type -> Type)

The only way for this to obey retract . inject == id is to have it impossible to retract out of.

Defined in Data.HFunctor.Interpret

Associated Types

type C (ConstF e) :: (Type -> Type) -> Constraint

Methods

retract :: C (ConstF e) f => ConstF e f ~> f

interpret :: C (ConstF e) g => (f ~> g) -> ConstF e f ~> g

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

Defined in Data.HBifunctor

Associated Types

type C (RightF f) :: (Type -> Type) -> Constraint

Methods

retract :: C (RightF f) f0 => RightF f f0 ~> f0

interpret :: C (RightF f) g => (f0 ~> g) -> RightF f f0 ~> g

(Monoidal t, i ~ I t) => Interpret (Chain t i)

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

Defined in Data.HFunctor.Chain

Associated Types

type C (Chain t i) :: (Type -> Type) -> Constraint

Methods

retract :: C (Chain t i) f => Chain t i f ~> f

interpret :: C (Chain t i) g => (f ~> g) -> Chain t i f ~> g

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

A convenient flipped version of interpret.

getI :: (Interpret t, C t (Const 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 the interpretation of t, you may have extra constraints on b.

• If C t is Unconstrained, there are no constraints on b
• If C t is Apply, b needs to be an instance of Semigroup
• If C t is Applicative, 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.
collectI length
     :: Step (Map String) Bool
     -> Int

collectI :: (Interpret t, C t (Const [b])) => (forall x. f x -> b) -> t f a -> [b]

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

This will work if C t is Unconstrained, Apply, or Applicative.

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

Multi-Functors

Classes that deal with two-functor combinators, that "mix" two functors together in some way.

class HBifunctor t where

A HBifunctor is like an HFunctor, but it enhances two different functors instead of just one.

Usually, it enhaces them "together" in some sort of combining way.

This typeclass provides a uniform instance for "swapping out" or "hoisting" the enhanced functors. We can hoist the first one with hleft, the second one with hright, or both at the same time with hbimap.

For example, the f :*: g type gives us "both f and g":

data (f :*: g) a = f a :*: g a

It combines both f and g into a unified structure --- here, it does it by providing both f and g.

The single law is:

hbimap id id == id

This ensures that hleft, hright, and hbimap do not affect the structure that t adds on top of the underlying functors.

Minimal complete definition

hleft, hright | hbimap

Methods

hleft :: (f ~> j) -> t f g ~> t j g

Swap out the first transformed functor.

hright :: (g ~> k) -> t f g ~> t f k

Swap out the second transformed functor.

hbimap :: (f ~> j) -> (g ~> k) -> t f g ~> t j k

Swap out both transformed functors at the same time.

Instances

HBifunctor (Sum :: (k -> Type) -> (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hleft :: (f ~> j) -> Sum f g ~> Sum j g

hright :: (g ~> k0) -> Sum f g ~> Sum f k0

hbimap :: (f ~> j) -> (g ~> k0) -> Sum f g ~> Sum j k0

HBifunctor ((:+:) :: (k -> Type) -> (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hleft :: (f ~> j) -> (f :+: g) ~> (j :+: g)

hright :: (g ~> k0) -> (f :+: g) ~> (f :+: k0)

hbimap :: (f ~> j) -> (g ~> k0) -> (f :+: g) ~> (j :+: k0)

HBifunctor (Product :: (k -> Type) -> (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hleft :: (f ~> j) -> Product f g ~> Product j g

hright :: (g ~> k0) -> Product f g ~> Product f k0

hbimap :: (f ~> j) -> (g ~> k0) -> Product f g ~> Product j k0

HBifunctor ((:*:) :: (k -> Type) -> (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hleft :: (f ~> j) -> (f :*: g) ~> (j :*: g)

hright :: (g ~> k0) -> (f :*: g) ~> (f :*: k0)

hbimap :: (f ~> j) -> (g ~> k0) -> (f :*: g) ~> (j :*: k0)

HBifunctor (Joker :: (k2 -> Type) -> (k1 -> Type) -> k2 -> Type)

Defined in Data.HFunctor.Internal

Methods

hleft :: (f ~> j) -> Joker f g ~> Joker j g

hright :: (g ~> k) -> Joker f g ~> Joker f k

hbimap :: (f ~> j) -> (g ~> k) -> Joker f g ~> Joker j k

HBifunctor (LeftF :: (k2 -> Type) -> (k1 -> Type) -> k2 -> Type)

Defined in Data.HBifunctor

Methods

hleft :: (f ~> j) -> LeftF f g ~> LeftF j g

hright :: (g ~> k) -> LeftF f g ~> LeftF f k

hbimap :: (f ~> j) -> (g ~> k) -> LeftF f g ~> LeftF j k

HBifunctor (RightF :: (k1 -> Type) -> (k2 -> Type) -> k2 -> Type)

Defined in Data.HBifunctor

Methods

hleft :: (f ~> j) -> RightF f g ~> RightF j g

hright :: (g ~> k) -> RightF f g ~> RightF f k

hbimap :: (f ~> j) -> (g ~> k) -> RightF f g ~> RightF j k

HBifunctor (Void3 :: (k1 -> Type) -> (k2 -> Type) -> k3 -> Type)

Defined in Data.HFunctor.Internal

Methods

hleft :: (f ~> j) -> Void3 f g ~> Void3 j g

hright :: (g ~> k) -> Void3 f g ~> Void3 f k

hbimap :: (f ~> j) -> (g ~> k) -> Void3 f g ~> Void3 j k

HBifunctor Day

Defined in Data.HFunctor.Internal

Methods

hleft :: (f ~> j) -> Day f g ~> Day j g

hright :: (g ~> k) -> Day f g ~> Day f k

hbimap :: (f ~> j) -> (g ~> k) -> Day f g ~> Day j k

HBifunctor These1

Defined in Data.HFunctor.Internal

Methods

hleft :: (f ~> j) -> These1 f g ~> These1 j g

hright :: (g ~> k) -> These1 f g ~> These1 f k

hbimap :: (f ~> j) -> (g ~> k) -> These1 f g ~> These1 j k

HBifunctor Comp

Defined in Data.HFunctor.Internal

Methods

hleft :: (f ~> j) -> Comp f g ~> Comp j g

hright :: (g ~> k) -> Comp f g ~> Comp f k

hbimap :: (f ~> j) -> (g ~> k) -> Comp f g ~> Comp j k

Associative

class HBifunctor t => Associative t where

An HBifunctor where it doesn't matter which binds first is Associative. Knowing this gives us a lot of power to rearrange the internals of our HFunctor at will.

For example, for the functor product:

data (f :*: g) a = f a :*: g a

We know that f :*: (g :*: h) is the same as (f :*: g) :*: h.

Methods

associating :: (Functor f, Functor g, Functor h) => t f (t g h) <~> t (t f g) h

The isomorphism between t f (t g h) a and t (t f g) h a. To use this isomorphism, see assoc and disassoc.

Instances

Associative Day

Defined in Data.HBifunctor.Associative

Methods

associating :: (Functor f, Functor g, Functor h) => Day f (Day g h) <~> Day (Day f g) h

Associative These1

Defined in Data.HBifunctor.Associative

Methods

associating :: (Functor f, Functor g, Functor h) => These1 f (These1 g h) <~> These1 (These1 f g) h

Associative Comp

Defined in Data.HBifunctor.Associative

Methods

associating :: (Functor f, Functor g, Functor h) => Comp f (Comp g h) <~> Comp (Comp f g) h

Associative ((:+:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Methods

associating :: (Functor f, Functor g, Functor h) => (f :+: (g :+: h)) <~> ((f :+: g) :+: h)

Associative ((:*:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Methods

associating :: (Functor f, Functor g, Functor h) => (f :*: (g :*: h)) <~> ((f :*: g) :*: h)

Associative (Product :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Methods

associating :: (Functor f, Functor g, Functor h) => Product f (Product g h) <~> Product (Product f g) h

Associative (Sum :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Methods

associating :: (Functor f, Functor g, Functor h) => Sum f (Sum g h) <~> Sum (Sum f g) h

Associative (Joker :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Methods

associating :: (Functor f, Functor g, Functor h) => Joker f (Joker g h) <~> Joker (Joker f g) h

Associative (LeftF :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Methods

associating :: (Functor f, Functor g, Functor h) => LeftF f (LeftF g h) <~> LeftF (LeftF f g) h

Associative (RightF :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Methods

associating :: (Functor f, Functor g, Functor h) => RightF f (RightF g h) <~> RightF (RightF f g) h

Associative (Void3 :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Methods

associating :: (Functor f, Functor g, Functor h) => Void3 f (Void3 g h) <~> Void3 (Void3 f g) h

class (Associative t, Interpret (SF t)) => Semigroupoidal t where

For some ts, you can represent the act of applying a functor f to t many times, as a single type. That is, there is some type SF t f that is equivalent to one of:

• f a -- 1 time
• t f f a -- 2 times
• t f (t f f) a -- 3 times
• t f (t f (t f f)) a -- 4 times
• t f (t f (t f (t f f))) a -- 5 times
• .. etc

This typeclass associates each t with its "induced semigroupoidal functor combinator" SF t.

This is useful because sometimes you might want to describe a type that can be t f f, t f (t f f), t f (t f (t f f)), etc.; "f applied to itself", with at least one f. This typeclass lets you use a type like NonEmptyF in terms of repeated applications of :*:, or Ap1 in terms of repeated applications of Day, or Free1 in terms of repeated applications of Comp, etc.

For example, f :*: f can be interpreted as "a free selection of two fs", allowing you to specify "I have to fs that I can use". If you want to specify "I want 1, 2, or many different fs that I can use", you can use NonEmptyF f.

At the high level, the main way to use a Semigroupoidal is with biretract and binterpret:

biretract :: t f f ~> f
binterpret :: (f ~> h) -> (g ~> h) -> t f g ~> h

which are like the HBifunctor versions of retract and interpret: they fully "mix" together the two inputs of t.

Also useful is:

toSF :: t f f a -> SF t f a

Which converts a t into its aggregate type SF.

In reality, most Semigroupoidal instances are also Monoidal instances, so you can think of the separation as mostly to help organize functionality. However, there are two non-monoidal semigroupoidal instances of note: LeftF and RightF, which are higher order analogues of the First and Last semigroups, roughly.

Minimal complete definition

appendSF, matchSF

Associated Types

type SF t :: (Type -> Type) -> Type -> Type

The "semigroup functor combinator" generated by t.

A value of type SF t f a is equivalent to one of:

• f a

• t f f a

• t f (t f f) a

• t f (t f (t f f)) a

• t f (t f (t f (t f f))) a

• .. etc

For example, for :*:, we have NonEmptyF. This is because:

x             ~ NonEmptyF (x :| [])      ~ inject x
x :*: y       ~ NonEmptyF (x :| [y])     ~ toSF (x :*: y)
x :*: y :*: z ~ NonEmptyF (x :| [y,z])
-- etc.

You can create an "singleton" one with inject, or else one from a single t f f with toSF.

Methods

appendSF :: t (SF t f) (SF t f) ~> SF t f

If a SF t f represents multiple applications of t f to itself, then we can also "append" two SF t fs applied to themselves into one giant SF t f containing all of the t fs.

consSF :: t f (SF t f) ~> SF t f

Prepend an application of t f to the front of a SF t f.

toSF :: t f f ~> SF t f

Embed a direct application of f to itself into a SF t f.

biretract :: CS t f => t f f ~> f

The HBifunctor analogy of retract. It retracts both fs into a single f, effectively fully mixing them together.

binterpret :: CS t h => (f ~> h) -> (g ~> h) -> t f g ~> h

The HBifunctor analogy of interpret. It takes two interpreting functions, and mixes them together into a target functor h.

Instances

Semigroupoidal Day

Defined in Data.HBifunctor.Associative

Associated Types

type SF Day :: (Type -> Type) -> Type -> Type

Methods

appendSF :: Day (SF Day f) (SF Day f) ~> SF Day f

matchSF :: Functor f => SF Day f ~> (f :+: Day f (SF Day f))

consSF :: Day f (SF Day f) ~> SF Day f

toSF :: Day f f ~> SF Day f

biretract :: CS Day f => Day f f ~> f

binterpret :: CS Day h => (f ~> h) -> (g ~> h) -> Day f g ~> h

Semigroupoidal These1

Ideally here SF would be equivalent to MF, just like for :+:. This should be possible if we can write a bijection. This bijection should be possible in theory --- but it has not yet been implemented.

Defined in Data.HBifunctor.Associative

Associated Types

type SF These1 :: (Type -> Type) -> Type -> Type

Methods

appendSF :: These1 (SF These1 f) (SF These1 f) ~> SF These1 f

matchSF :: Functor f => SF These1 f ~> (f :+: These1 f (SF These1 f))

consSF :: These1 f (SF These1 f) ~> SF These1 f

toSF :: These1 f f ~> SF These1 f

biretract :: CS These1 f => These1 f f ~> f

binterpret :: CS These1 h => (f ~> h) -> (g ~> h) -> These1 f g ~> h

Semigroupoidal Comp

Defined in Data.HBifunctor.Associative

Associated Types

type SF Comp :: (Type -> Type) -> Type -> Type

Methods

appendSF :: Comp (SF Comp f) (SF Comp f) ~> SF Comp f

matchSF :: Functor f => SF Comp f ~> (f :+: Comp f (SF Comp f))

consSF :: Comp f (SF Comp f) ~> SF Comp f

toSF :: Comp f f ~> SF Comp f

biretract :: CS Comp f => Comp f f ~> f

binterpret :: CS Comp h => (f ~> h) -> (g ~> h) -> Comp f g ~> h

Semigroupoidal ((:+:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Associated Types

type SF (:+:) :: (Type -> Type) -> Type -> Type

Methods

appendSF :: (SF (:+:) f :+: SF (:+:) f) ~> SF (:+:) f

matchSF :: Functor f => SF (:+:) f ~> (f :+: (f :+: SF (:+:) f))

consSF :: (f :+: SF (:+:) f) ~> SF (:+:) f

toSF :: (f :+: f) ~> SF (:+:) f

biretract :: CS (:+:) f => (f :+: f) ~> f

binterpret :: CS (:+:) h => (f ~> h) -> (g ~> h) -> (f :+: g) ~> h

Semigroupoidal ((:*:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Associated Types

type SF (:*:) :: (Type -> Type) -> Type -> Type

Methods

appendSF :: (SF (:*:) f :*: SF (:*:) f) ~> SF (:*:) f

matchSF :: Functor f => SF (:*:) f ~> (f :+: (f :*: SF (:*:) f))

consSF :: (f :*: SF (:*:) f) ~> SF (:*:) f

toSF :: (f :*: f) ~> SF (:*:) f

biretract :: CS (:*:) f => (f :*: f) ~> f

binterpret :: CS (:*:) h => (f ~> h) -> (g ~> h) -> (f :*: g) ~> h

Semigroupoidal (Product :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Associated Types

type SF Product :: (Type -> Type) -> Type -> Type

Methods

appendSF :: Product (SF Product f) (SF Product f) ~> SF Product f

matchSF :: Functor f => SF Product f ~> (f :+: Product f (SF Product f))

consSF :: Product f (SF Product f) ~> SF Product f

toSF :: Product f f ~> SF Product f

biretract :: CS Product f => Product f f ~> f

binterpret :: CS Product h => (f ~> h) -> (g ~> h) -> Product f g ~> h

Semigroupoidal (Sum :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Associated Types

type SF Sum :: (Type -> Type) -> Type -> Type

Methods

appendSF :: Sum (SF Sum f) (SF Sum f) ~> SF Sum f

matchSF :: Functor f => SF Sum f ~> (f :+: Sum f (SF Sum f))

consSF :: Sum f (SF Sum f) ~> SF Sum f

toSF :: Sum f f ~> SF Sum f

biretract :: CS Sum f => Sum f f ~> f

binterpret :: CS Sum h => (f ~> h) -> (g ~> h) -> Sum f g ~> h

Semigroupoidal (Joker :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Associated Types

type SF Joker :: (Type -> Type) -> Type -> Type

Methods

appendSF :: Joker (SF Joker f) (SF Joker f) ~> SF Joker f

matchSF :: Functor f => SF Joker f ~> (f :+: Joker f (SF Joker f))

consSF :: Joker f (SF Joker f) ~> SF Joker f

toSF :: Joker f f ~> SF Joker f

biretract :: CS Joker f => Joker f f ~> f

binterpret :: CS Joker h => (f ~> h) -> (g ~> h) -> Joker f g ~> h

Semigroupoidal (LeftF :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Associated Types

type SF LeftF :: (Type -> Type) -> Type -> Type

Methods

appendSF :: LeftF (SF LeftF f) (SF LeftF f) ~> SF LeftF f

matchSF :: Functor f => SF LeftF f ~> (f :+: LeftF f (SF LeftF f))

consSF :: LeftF f (SF LeftF f) ~> SF LeftF f

toSF :: LeftF f f ~> SF LeftF f

biretract :: CS LeftF f => LeftF f f ~> f

binterpret :: CS LeftF h => (f ~> h) -> (g ~> h) -> LeftF f g ~> h

Semigroupoidal (RightF :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Associated Types

type SF RightF :: (Type -> Type) -> Type -> Type

Methods

appendSF :: RightF (SF RightF f) (SF RightF f) ~> SF RightF f

matchSF :: Functor f => SF RightF f ~> (f :+: RightF f (SF RightF f))

consSF :: RightF f (SF RightF f) ~> SF RightF f

toSF :: RightF f f ~> SF RightF f

biretract :: CS RightF f => RightF f f ~> f

binterpret :: CS RightF h => (f ~> h) -> (g ~> h) -> RightF f g ~> h

type CS t = C (SF t)

Convenient alias for the constraint required for biretract, binterpret, etc.

It's usually a constraint on the target/result context of interpretation that allows you to "exit" or "run" a Semigroupoidal t.

biget :: (Semigroupoidal t, CS t (Const b)) => (forall x. f x -> b) -> (forall x. g x -> b) -> t f g a -> b

Useful wrapper over binterpret 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 the interpretation of t, you may have extra constraints on b.

• If C (SF t) is Unconstrained, there are no constraints on b
• If C (SF t) is Apply, b needs to be an instance of Semigroup
• If C (SF t) is Applicative, b needs to be an instance of Monoid

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

-- Return the length of either the list, or the Map, depending on which
--   one s in the +
biget length length
    :: ([] :+: Map Int) Char
    -> Int

-- Return the length of both the list and the map, added together
biget (Sum . length) (Sum . length)
    :: Day [] (Map Int) Char
    -> Sum Int

bicollect :: (Semigroupoidal t, CS t (Const [b])) => (forall x. f x -> b) -> (forall x. g x -> b) -> t f g a -> [b]

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

This will work if C t is Unconstrained, Apply, or Applicative.

(!*!) :: (Semigroupoidal t, CS t h) => (f ~> h) -> (g ~> h) -> t f g ~> h infixr 5

Infix alias for binterpret

(!$!) :: (Semigroupoidal t, CS t (Const b)) => (forall x. f x -> b) -> (forall x. g x -> b) -> t f g a -> b infixr 5

Infix alias for biget

-- Return the length of either the list, or the Map, depending on which
--   one s in the +
length !$! length
    :: ([] :+: Map Int) Char
    -> Int

-- Return the length of both the list and the map, added together
Sum . length !$! Sum . length
    :: Day [] (Map Int) Char
    -> Sum Int

Tensor

class Associative t => Tensor t where

An Associative HBifunctor can be a Tensor if there is some identity i where t i f is equivalent to just f.

That is, "enhancing" f with t i does nothing.

The methods in this class provide us useful ways of navigating a Tensor t with respect to this property.

The Tensor is essentially the HBifunctor equivalent of Inject, with intro1 and intro2 taking the place of inject.

Associated Types

type I t :: Type -> Type

The identity of Tensor t. If you "combine" f with the identity, it leaves f unchanged.

For example, the identity of :*: is Proxy. This is because

(Proxy :*: f) a

is equivalent to just

f a

:*:-ing f with Proxy gives you no additional structure.

Another example:

(V1 :+: f) a

is equivalent to just

f a

because the L1 case is unconstructable.

Methods

intro1 :: f ~> t f (I t)

Because t f (I t) is equivalent to f, we can always "insert" f into t f (I t).

This is analogous to inject from Inject, but for HBifunctors.

intro2 :: g ~> t (I t) g

Because t (I t) g is equivalent to f, we can always "insert" g into t (I t) g.

This is analogous to inject from Inject, but for HBifunctors.

elim1 :: Functor f => t f (I t) ~> f

Witnesses the property that I t is the identity of t: t f (I t) always leaves f unchanged, so we can always just drop the I t.

elim2 :: Functor g => t (I t) g ~> g

Witnesses the property that I t is the identity of t: t (I t) g always leaves g unchanged, so we can always just drop the I t.

Instances

Tensor Day

Defined in Data.HBifunctor.Tensor

Associated Types

type I Day :: Type -> Type

Methods

intro1 :: f ~> Day f (I Day)

intro2 :: g ~> Day (I Day) g

elim1 :: Functor f => Day f (I Day) ~> f

elim2 :: Functor g => Day (I Day) g ~> g

Tensor These1

Defined in Data.HBifunctor.Tensor

Associated Types

type I These1 :: Type -> Type

Methods

intro1 :: f ~> These1 f (I These1)

intro2 :: g ~> These1 (I These1) g

elim1 :: Functor f => These1 f (I These1) ~> f

elim2 :: Functor g => These1 (I These1) g ~> g

Tensor Comp

Defined in Data.HBifunctor.Tensor

Associated Types

type I Comp :: Type -> Type

Methods

intro1 :: f ~> Comp f (I Comp)

intro2 :: g ~> Comp (I Comp) g

elim1 :: Functor f => Comp f (I Comp) ~> f

elim2 :: Functor g => Comp (I Comp) g ~> g

Tensor ((:+:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Tensor

Associated Types

type I (:+:) :: Type -> Type

Methods

intro1 :: f ~> (f :+: I (:+:))

intro2 :: g ~> (I (:+:) :+: g)

elim1 :: Functor f => (f :+: I (:+:)) ~> f

elim2 :: Functor g => (I (:+:) :+: g) ~> g

Tensor ((:*:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Tensor

Associated Types

type I (:*:) :: Type -> Type

Methods

intro1 :: f ~> (f :*: I (:*:))

intro2 :: g ~> (I (:*:) :*: g)

elim1 :: Functor f => (f :*: I (:*:)) ~> f

elim2 :: Functor g => (I (:*:) :*: g) ~> g

Tensor (Product :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Tensor

Associated Types

type I Product :: Type -> Type

Methods

intro1 :: f ~> Product f (I Product)

intro2 :: g ~> Product (I Product) g

elim1 :: Functor f => Product f (I Product) ~> f

elim2 :: Functor g => Product (I Product) g ~> g

Tensor (Sum :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Tensor

Associated Types

type I Sum :: Type -> Type

Methods

intro1 :: f ~> Sum f (I Sum)

intro2 :: g ~> Sum (I Sum) g

elim1 :: Functor f => Sum f (I Sum) ~> f

elim2 :: Functor g => Sum (I Sum) g ~> g

class (Tensor t, Semigroupoidal t, Interpret (MF t)) => Monoidal t where

A Monoidal t is a Semigroupoidal, in that it provides some type MF t f that is equivalent to one of:

• I a -- 0 times
• f a -- 1 time
• t f f a -- 2 times
• t f (t f f) a -- 3 times
• t f (t f (t f f)) a -- 4 times
• t f (t f (t f (t f f))) a -- 5 times
• .. etc

The difference is that unlike SF t, MF t has the "zero times" value.

This typeclass lets you use a type like ListF in terms of repeated applications of :*:, or Ap in terms of repeated applications of Day, or Free in terms of repeated applications of Comp, etc.

For example, f :*: f can be interpreted as "a free selection of two fs", allowing you to specify "I have to fs that I can use". If you want to specify "I want 0, 1, or many different fs that I can use", you can use ListF f.

At the high level, the thing that Monoidal adds to Semigroupoidal is inL, inR, and nilMF:

inL    :: f a -> t f g a
inR    :: g a -> t f g a
nilMF  :: I a -> MF t f a

which are like the HBifunctor versions of inject: it lets you inject an f into t f g, so you can start doing useful mixing operations with it. nilMF lets you construct an "empty" MF t.

Also useful is:

toMF :: t f f a -> MF t f a

Which converts a t into its aggregate type MF

Minimal complete definition

appendMF, splitSF, splittingMF, upgradeC

Associated Types

type MF t :: (Type -> Type) -> Type -> Type

The "monoidal functor combinator" induced by t.

A value of type MF t f a is equivalent to one of:

• I a -- zero fs
• f a -- one f
• t f f a -- two fs
• t f (t f f) a -- three fs

• t f (t f (t f f)) a

• t f (t f (t f (t f f))) a

• .. etc

For example, for :*:, we have ListF. This is because:

Proxy         ~ ListF []         ~ nilMF @(:*:)
x             ~ ListF [x]        ~ inject x
x :*: y       ~ ListF [x,y]      ~ toMF (x :*: y)
x :*: y :*: z ~ ListF [x,y,z]
-- etc.

You can create an "empty" one with nilMF, a "singleton" one with inject, or else one from a single t f f with toMF.

Methods

appendMF :: t (MF t f) (MF t f) ~> MF t f

If a MF t f represents multiple applications of t f to itself, then we can also "append" two MF t fs applied to themselves into one giant MF t f containing all of the t fs.

splitSF :: SF t f ~> t f (MF t f)

Lets you convert an SF t f into a single application of f to MF t f.

Analogous to a function NonEmpty a -> (a, [a])

Note that this is not reversible in general unless we have Matchable t.

toMF :: t f f ~> MF t f

Embed a direct application of f to itself into a MF t f.

fromSF :: SF t f ~> MF t f

SF t f is "one or more fs", and 'MF t f is "zero or more fs". This function lets us convert from one to the other.

This is analogous to a function NonEmpty a -> [a].

Note that because t is not inferrable from the input or output type, you should call this using -XTypeApplications:

fromSF @(:*:) :: NonEmptyF f a -> ListF f a
fromSF @Comp  :: Free1 f a -> Free f a

pureT :: CM t f => I t ~> f

If we have an I t, we can generate an f based on how it interacts with t.

Specialized (and simplified), this type is:

pureT @Day   :: Applicative f => Identity a -> f a  -- pure
pureT @Comp  :: Monad f => Identity a -> f a        -- return
pureT @(:*:) :: Plus f => Proxy a -> f a            -- zero

Note that because t appears nowhere in the input or output types, you must always use this with explicit type application syntax (like pureT @Day)

upgradeC :: CM t f => proxy f -> (CS t f => r) -> r

If we have a constraint on the Monoidal satisfied, it should also imply the constraint on the Semigroupoidal.

This is basically saying that C (SF t) should be a superclass of C (MF t).

For example, for :*:, this type signature says that Alt is a superclass of Plus, so whenever you have Plus, you should always also have Alt.

For Day, this type signature says that Apply is a superclass of Applicative, so whenever you have Applicative, you should always also have Apply.

This is necessary because in the current class hierarchy, Apply isn't a true superclass of Applicative. upgradeC basically "imbues" f with an Apply instance based on its Applicative instance, so things can be easier to use.

For example, let's say I have a type Parser that is an Applicative instance, but the source library does not define an Apply instance. I cannot use biretract or binterpret with it, even though I should be able to, because they require Apply.

That is:

biretract :: Day Parser Parser a -> Parser a

is a type error, because it requires Apply Parser.

But, if we know that Parser has an Applicative instance, we can use:

upgradeC @Day (Proxy @Parser) biretract
  :: Day Parser Parser a -> a

and this will now typecheck properly.

Ideally, Parser would also have an Apply instance. But we cannot control this if an external library defines Parser.

(Alternatively you can just use biretractT.)

Note that you should only use this if f doesn't already have the SF constraint. If it does, this could lead to conflicting instances. Only use this with specific, concrete fs. Otherwise this is unsafe and can possibly break coherence guarantees.

The proxy argument can be provided using something like Proxy @f, to specify which f you want to upgrade.

Instances

Monoidal Day

Defined in Data.HBifunctor.Tensor

Associated Types

type MF Day :: (Type -> Type) -> Type -> Type

Methods

appendMF :: Day (MF Day f) (MF Day f) ~> MF Day f

splitSF :: SF Day f ~> Day f (MF Day f)

splittingMF :: MF Day f <~> (I Day :+: Day f (MF Day f))

toMF :: Day f f ~> MF Day f

fromSF :: SF Day f ~> MF Day f

pureT :: CM Day f => I Day ~> f

upgradeC :: CM Day f => proxy f -> (CS Day f -> r) -> r

Monoidal These1

Defined in Data.HBifunctor.Tensor

Associated Types

type MF These1 :: (Type -> Type) -> Type -> Type

Methods

appendMF :: These1 (MF These1 f) (MF These1 f) ~> MF These1 f

splitSF :: SF These1 f ~> These1 f (MF These1 f)

splittingMF :: MF These1 f <~> (I These1 :+: These1 f (MF These1 f))

toMF :: These1 f f ~> MF These1 f

fromSF :: SF These1 f ~> MF These1 f

pureT :: CM These1 f => I These1 ~> f

upgradeC :: CM These1 f => proxy f -> (CS These1 f -> r) -> r

Monoidal Comp

Defined in Data.HBifunctor.Tensor

Associated Types

type MF Comp :: (Type -> Type) -> Type -> Type

Methods

appendMF :: Comp (MF Comp f) (MF Comp f) ~> MF Comp f

splitSF :: SF Comp f ~> Comp f (MF Comp f)

splittingMF :: MF Comp f <~> (I Comp :+: Comp f (MF Comp f))

toMF :: Comp f f ~> MF Comp f

fromSF :: SF Comp f ~> MF Comp f

pureT :: CM Comp f => I Comp ~> f

upgradeC :: CM Comp f => proxy f -> (CS Comp f -> r) -> r

Monoidal ((:+:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Tensor

Associated Types

type MF (:+:) :: (Type -> Type) -> Type -> Type

Methods

appendMF :: (MF (:+:) f :+: MF (:+:) f) ~> MF (:+:) f

splitSF :: SF (:+:) f ~> (f :+: MF (:+:) f)

splittingMF :: MF (:+:) f <~> (I (:+:) :+: (f :+: MF (:+:) f))

toMF :: (f :+: f) ~> MF (:+:) f

fromSF :: SF (:+:) f ~> MF (:+:) f

pureT :: CM (:+:) f => I (:+:) ~> f

upgradeC :: CM (:+:) f => proxy f -> (CS (:+:) f -> r) -> r

Monoidal ((:*:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Tensor

Associated Types

type MF (:*:) :: (Type -> Type) -> Type -> Type

Methods

appendMF :: (MF (:*:) f :*: MF (:*:) f) ~> MF (:*:) f

splitSF :: SF (:*:) f ~> (f :*: MF (:*:) f)

splittingMF :: MF (:*:) f <~> (I (:*:) :+: (f :*: MF (:*:) f))

toMF :: (f :*: f) ~> MF (:*:) f

fromSF :: SF (:*:) f ~> MF (:*:) f

pureT :: CM (:*:) f => I (:*:) ~> f

upgradeC :: CM (:*:) f => proxy f -> (CS (:*:) f -> r) -> r

Monoidal (Product :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Tensor

Associated Types

type MF Product :: (Type -> Type) -> Type -> Type

Methods

appendMF :: Product (MF Product f) (MF Product f) ~> MF Product f

splitSF :: SF Product f ~> Product f (MF Product f)

splittingMF :: MF Product f <~> (I Product :+: Product f (MF Product f))

toMF :: Product f f ~> MF Product f

fromSF :: SF Product f ~> MF Product f

pureT :: CM Product f => I Product ~> f

upgradeC :: CM Product f => proxy f -> (CS Product f -> r) -> r

Monoidal (Sum :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Tensor

Associated Types

type MF Sum :: (Type -> Type) -> Type -> Type

Methods

appendMF :: Sum (MF Sum f) (MF Sum f) ~> MF Sum f

splitSF :: SF Sum f ~> Sum f (MF Sum f)

splittingMF :: MF Sum f <~> (I Sum :+: Sum f (MF Sum f))

toMF :: Sum f f ~> MF Sum f

fromSF :: SF Sum f ~> MF Sum f

pureT :: CM Sum f => I Sum ~> f

upgradeC :: CM Sum f => proxy f -> (CS Sum f -> r) -> r

type CM t = C (MF t)

Convenient alias for the constraint required for inL, inR, pureT, etc.

It's usually a constraint on the target/result context of interpretation that allows you to "exit" or "run" a Monoidal t.

nilMF :: forall t f. Monoidal t => I t ~> MF t f

Create the "empty MF@.

If MF t f represents multiple applications of t f with itself, then nilMF gives us "zero applications of f".

Note that t cannot be inferred from the input or output type of nilMF, so this function must always be called with -XTypeApplications:

nilMF @Day :: Identity ~> Ap f
nilMF @Comp :: Identity ~> Free f
nilMF @(:*:) :: Proxy ~> ListF f

consMF :: Monoidal t => t f (MF t f) ~> MF t f

Lets us "cons" an application of f to the front of an MF t f.

inL :: forall t f g. (Monoidal t, CM t g) => f ~> t f g

Convenient wrapper over intro1 that lets us introduce an arbitrary functor g to the right of an f.

You can think of this as an HBifunctor analogue of inject.

inR :: forall t f g. (Monoidal t, CM t f) => g ~> t f g

Convenient wrapper over intro2 that lets us introduce an arbitrary functor f to the right of a g.

You can think of this as an HBifunctor analogue of inject.

outL :: (Tensor t, I t ~ Proxy, Functor f) => t f g ~> f

Convenient wrapper over elim1 that lets us drop one of the arguments of a Tensor for free, without requiring any extra constraints (like for binterpret).

See prodOutL for a version that does not require Functor f, specifically for :*:.

outR :: (Tensor t, I t ~ Proxy, Functor g) => t f g ~> g

Convenient wrapper over elim2 that lets us drop one of the arguments of a Tensor for free, without requiring any constraints (like for binterpret).

See prodOutR for a version that does not require Functor g, specifically for :*:.

Combinators

Functor combinators ** Single

data Coyoneda (f :: Type -> Type) a where

A covariant Functor suitable for Yoneda reduction

Constructors

Coyoneda :: forall (f :: Type -> Type) a b. (b -> a) -> f b -> Coyoneda f a

Instances

ComonadTrans Coyoneda

Defined in Data.Functor.Coyoneda

Methods

lower :: Comonad w => Coyoneda w a -> w a

MonadTrans Coyoneda

Defined in Data.Functor.Coyoneda

Methods

lift :: Monad m => m a -> Coyoneda m a

Interpret Coyoneda

A free Functor

Defined in Data.HFunctor.Interpret

Associated Types

type C Coyoneda :: (Type -> Type) -> Constraint

Methods

retract :: C Coyoneda f => Coyoneda f ~> f

interpret :: C Coyoneda g => (f ~> g) -> Coyoneda f ~> g

FreeOf Functor Coyoneda

Defined in Data.HFunctor.Final

Methods

fromFree :: Coyoneda f ~> Final Functor f

toFree :: Functor f => Final Functor f ~> Coyoneda f

Monad m => Monad (Coyoneda m)

Defined in Data.Functor.Coyoneda

Methods

(>>=) :: Coyoneda m a -> (a -> Coyoneda m b) -> Coyoneda m b

(>>) :: Coyoneda m a -> Coyoneda m b -> Coyoneda m b

return :: a -> Coyoneda m a

fail :: String -> Coyoneda m a

Functor (Coyoneda f)

Defined in Data.Functor.Coyoneda

Methods

fmap :: (a -> b) -> Coyoneda f a -> Coyoneda f b

(<$) :: a -> Coyoneda f b -> Coyoneda f a

MonadFix f => MonadFix (Coyoneda f)

Defined in Data.Functor.Coyoneda

Methods

mfix :: (a -> Coyoneda f a) -> Coyoneda f a

Applicative f => Applicative (Coyoneda f)

Defined in Data.Functor.Coyoneda

Methods

pure :: a -> Coyoneda f a

(<*>) :: Coyoneda f (a -> b) -> Coyoneda f a -> Coyoneda f b

liftA2 :: (a -> b -> c) -> Coyoneda f a -> Coyoneda f b -> Coyoneda f c

(*>) :: Coyoneda f a -> Coyoneda f b -> Coyoneda f b

(<*) :: Coyoneda f a -> Coyoneda f b -> Coyoneda f a

Foldable f => Foldable (Coyoneda f)

Defined in Data.Functor.Coyoneda

Methods

fold :: Monoid m => Coyoneda f m -> m

foldMap :: Monoid m => (a -> m) -> Coyoneda f a -> m

foldr :: (a -> b -> b) -> b -> Coyoneda f a -> b

foldr' :: (a -> b -> b) -> b -> Coyoneda f a -> b

foldl :: (b -> a -> b) -> b -> Coyoneda f a -> b

foldl' :: (b -> a -> b) -> b -> Coyoneda f a -> b

foldr1 :: (a -> a -> a) -> Coyoneda f a -> a

foldl1 :: (a -> a -> a) -> Coyoneda f a -> a

toList :: Coyoneda f a -> [a]

null :: Coyoneda f a -> Bool

length :: Coyoneda f a -> Int

elem :: Eq a => a -> Coyoneda f a -> Bool

maximum :: Ord a => Coyoneda f a -> a

minimum :: Ord a => Coyoneda f a -> a

sum :: Num a => Coyoneda f a -> a

product :: Num a => Coyoneda f a -> a

Traversable f => Traversable (Coyoneda f)

Defined in Data.Functor.Coyoneda

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Coyoneda f a -> f0 (Coyoneda f b)

sequenceA :: Applicative f0 => Coyoneda f (f0 a) -> f0 (Coyoneda f a)

mapM :: Monad m => (a -> m b) -> Coyoneda f a -> m (Coyoneda f b)

sequence :: Monad m => Coyoneda f (m a) -> m (Coyoneda f a)

Distributive f => Distributive (Coyoneda f)

Defined in Data.Functor.Coyoneda

Methods

distribute :: Functor f0 => f0 (Coyoneda f a) -> Coyoneda f (f0 a)

collect :: Functor f0 => (a -> Coyoneda f b) -> f0 a -> Coyoneda f (f0 b)

distributeM :: Monad m => m (Coyoneda f a) -> Coyoneda f (m a)

collectM :: Monad m => (a -> Coyoneda f b) -> m a -> Coyoneda f (m b)

Representable f => Representable (Coyoneda f)

Defined in Data.Functor.Coyoneda

Associated Types

type Rep (Coyoneda f) :: Type

Methods

tabulate :: (Rep (Coyoneda f) -> a) -> Coyoneda f a

index :: Coyoneda f a -> Rep (Coyoneda f) -> a

Alternative f => Alternative (Coyoneda f)

Defined in Data.Functor.Coyoneda

Methods

empty :: Coyoneda f a

(<|>) :: Coyoneda f a -> Coyoneda f a -> Coyoneda f a

some :: Coyoneda f a -> Coyoneda f [a]

many :: Coyoneda f a -> Coyoneda f [a]

MonadPlus f => MonadPlus (Coyoneda f)

Defined in Data.Functor.Coyoneda

Methods

mzero :: Coyoneda f a

mplus :: Coyoneda f a -> Coyoneda f a -> Coyoneda f a

Eq1 f => Eq1 (Coyoneda f)

Defined in Data.Functor.Coyoneda

Methods

liftEq :: (a -> b -> Bool) -> Coyoneda f a -> Coyoneda f b -> Bool

Ord1 f => Ord1 (Coyoneda f)

Defined in Data.Functor.Coyoneda

Methods

liftCompare :: (a -> b -> Ordering) -> Coyoneda f a -> Coyoneda f b -> Ordering

Read1 f => Read1 (Coyoneda f)

Defined in Data.Functor.Coyoneda

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Coyoneda f a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Coyoneda f a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Coyoneda f a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Coyoneda f a]

(Functor f, Show1 f) => Show1 (Coyoneda f)

Defined in Data.Functor.Coyoneda

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Coyoneda f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Coyoneda f a] -> ShowS

Comonad w => Comonad (Coyoneda w)

Defined in Data.Functor.Coyoneda

Methods

extract :: Coyoneda w a -> a

duplicate :: Coyoneda w a -> Coyoneda w (Coyoneda w a)

extend :: (Coyoneda w a -> b) -> Coyoneda w a -> Coyoneda w b

Foldable1 f => Foldable1 (Coyoneda f)

Defined in Data.Functor.Coyoneda

Methods

fold1 :: Semigroup m => Coyoneda f m -> m

foldMap1 :: Semigroup m => (a -> m) -> Coyoneda f a -> m

toNonEmpty :: Coyoneda f a -> NonEmpty a

Apply f => Apply (Coyoneda f)

Defined in Data.Functor.Coyoneda

Methods

(<.>) :: Coyoneda f (a -> b) -> Coyoneda f a -> Coyoneda f b

(.>) :: Coyoneda f a -> Coyoneda f b -> Coyoneda f b

(<.) :: Coyoneda f a -> Coyoneda f b -> Coyoneda f a

liftF2 :: (a -> b -> c) -> Coyoneda f a -> Coyoneda f b -> Coyoneda f c

Traversable1 f => Traversable1 (Coyoneda f)

Defined in Data.Functor.Coyoneda

Methods

traverse1 :: Apply f0 => (a -> f0 b) -> Coyoneda f a -> f0 (Coyoneda f b)

sequence1 :: Apply f0 => Coyoneda f (f0 b) -> f0 (Coyoneda f b)

Plus f => Plus (Coyoneda f)

Defined in Data.Functor.Coyoneda

Methods

zero :: Coyoneda f a

Alt f => Alt (Coyoneda f)

Defined in Data.Functor.Coyoneda

Methods

(<!>) :: Coyoneda f a -> Coyoneda f a -> Coyoneda f a

some :: Applicative (Coyoneda f) => Coyoneda f a -> Coyoneda f [a]

many :: Applicative (Coyoneda f) => Coyoneda f a -> Coyoneda f [a]

Bind m => Bind (Coyoneda m)

Defined in Data.Functor.Coyoneda

Methods

(>>-) :: Coyoneda m a -> (a -> Coyoneda m b) -> Coyoneda m b

join :: Coyoneda m (Coyoneda m a) -> Coyoneda m a

Extend w => Extend (Coyoneda w)

Defined in Data.Functor.Coyoneda

Methods

duplicated :: Coyoneda w a -> Coyoneda w (Coyoneda w a)

extended :: (Coyoneda w a -> b) -> Coyoneda w a -> Coyoneda w b

HBind Coyoneda

Defined in Data.HFunctor

Methods

hbind :: (f ~> Coyoneda g) -> Coyoneda f ~> Coyoneda g

hjoin :: Coyoneda (Coyoneda f) ~> Coyoneda f

Inject Coyoneda

Defined in Data.HFunctor

Methods

inject :: f ~> Coyoneda f

Adjunction f g => Adjunction (Coyoneda f) (Coyoneda g)

Defined in Data.Functor.Coyoneda

Methods

unit :: a -> Coyoneda g (Coyoneda f a)

counit :: Coyoneda f (Coyoneda g a) -> a

leftAdjunct :: (Coyoneda f a -> b) -> a -> Coyoneda g b

rightAdjunct :: (a -> Coyoneda g b) -> Coyoneda f a -> b

HFunctor Coyoneda

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Coyoneda f ~> Coyoneda g

(Functor f, Eq1 f, Eq a) => Eq (Coyoneda f a)

Defined in Data.Functor.Coyoneda

Methods

(==) :: Coyoneda f a -> Coyoneda f a -> Bool

(/=) :: Coyoneda f a -> Coyoneda f a -> Bool

(Functor f, Ord1 f, Ord a) => Ord (Coyoneda f a)

Defined in Data.Functor.Coyoneda

Methods

compare :: Coyoneda f a -> Coyoneda f a -> Ordering

(<) :: Coyoneda f a -> Coyoneda f a -> Bool

(<=) :: Coyoneda f a -> Coyoneda f a -> Bool

(>) :: Coyoneda f a -> Coyoneda f a -> Bool

(>=) :: Coyoneda f a -> Coyoneda f a -> Bool

max :: Coyoneda f a -> Coyoneda f a -> Coyoneda f a

min :: Coyoneda f a -> Coyoneda f a -> Coyoneda f a

Read (f a) => Read (Coyoneda f a)

Defined in Data.Functor.Coyoneda

Methods

readsPrec :: Int -> ReadS (Coyoneda f a)

readList :: ReadS [Coyoneda f a]

readPrec :: ReadPrec (Coyoneda f a)

readListPrec :: ReadPrec [Coyoneda f a]

(Functor f, Show1 f, Show a) => Show (Coyoneda f a)

Defined in Data.Functor.Coyoneda

Methods

showsPrec :: Int -> Coyoneda f a -> ShowS

show :: Coyoneda f a -> String

showList :: [Coyoneda f a] -> ShowS

type C Coyoneda

Defined in Data.HFunctor.Interpret

type C Coyoneda = Functor

type Rep (Coyoneda f)

Defined in Data.Functor.Coyoneda

type Rep (Coyoneda f) = Rep f

newtype ListF f a

A list of f as. Can be used to describe a product of many different values of type f a.

This is the Free Plus.

Constructors

ListF

Fields

• runListF :: [f a]

Instances

Interpret ListF

A free Plus

Defined in Data.HFunctor.Interpret

Associated Types

type C ListF :: (Type -> Type) -> Constraint

Methods

retract :: C ListF f => ListF f ~> f

interpret :: C ListF g => (f ~> g) -> ListF f ~> g

FreeOf Plus ListF

Defined in Data.HFunctor.Final

Methods

fromFree :: ListF f ~> Final Plus f

toFree :: Functor f => Final Plus f ~> ListF f

Functor f => Functor (ListF f)

Defined in Control.Applicative.ListF

Methods

fmap :: (a -> b) -> ListF f a -> ListF f b

(<$) :: a -> ListF f b -> ListF f a

Applicative f => Applicative (ListF f)

Defined in Control.Applicative.ListF

Methods

pure :: a -> ListF f a

(<*>) :: ListF f (a -> b) -> ListF f a -> ListF f b

liftA2 :: (a -> b -> c) -> ListF f a -> ListF f b -> ListF f c

(*>) :: ListF f a -> ListF f b -> ListF f b

(<*) :: ListF f a -> ListF f b -> ListF f a

Foldable f => Foldable (ListF f)

Defined in Control.Applicative.ListF

Methods

fold :: Monoid m => ListF f m -> m

foldMap :: Monoid m => (a -> m) -> ListF f a -> m

foldr :: (a -> b -> b) -> b -> ListF f a -> b

foldr' :: (a -> b -> b) -> b -> ListF f a -> b

foldl :: (b -> a -> b) -> b -> ListF f a -> b

foldl' :: (b -> a -> b) -> b -> ListF f a -> b

foldr1 :: (a -> a -> a) -> ListF f a -> a

foldl1 :: (a -> a -> a) -> ListF f a -> a

toList :: ListF f a -> [a]

null :: ListF f a -> Bool

length :: ListF f a -> Int

elem :: Eq a => a -> ListF f a -> Bool

maximum :: Ord a => ListF f a -> a

minimum :: Ord a => ListF f a -> a

sum :: Num a => ListF f a -> a

product :: Num a => ListF f a -> a

Traversable f => Traversable (ListF f)

Defined in Control.Applicative.ListF

Methods

traverse :: Applicative f0 => (a -> f0 b) -> ListF f a -> f0 (ListF f b)

sequenceA :: Applicative f0 => ListF f (f0 a) -> f0 (ListF f a)

mapM :: Monad m => (a -> m b) -> ListF f a -> m (ListF f b)

sequence :: Monad m => ListF f (m a) -> m (ListF f a)

Applicative f => Alternative (ListF f)

Defined in Control.Applicative.ListF

Methods

empty :: ListF f a

(<|>) :: ListF f a -> ListF f a -> ListF f a

some :: ListF f a -> ListF f [a]

many :: ListF f a -> ListF f [a]

Eq1 f => Eq1 (ListF f)

Defined in Control.Applicative.ListF

Methods

liftEq :: (a -> b -> Bool) -> ListF f a -> ListF f b -> Bool

Ord1 f => Ord1 (ListF f)

Defined in Control.Applicative.ListF

Methods

liftCompare :: (a -> b -> Ordering) -> ListF f a -> ListF f b -> Ordering

Read1 f => Read1 (ListF f)

Defined in Control.Applicative.ListF

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (ListF f a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [ListF f a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (ListF f a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [ListF f a]

Show1 f => Show1 (ListF f)

Defined in Control.Applicative.ListF

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> ListF f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [ListF f a] -> ShowS

Apply f => Apply (ListF f)

Defined in Control.Applicative.ListF

Methods

(<.>) :: ListF f (a -> b) -> ListF f a -> ListF f b

(.>) :: ListF f a -> ListF f b -> ListF f b

(<.) :: ListF f a -> ListF f b -> ListF f a

liftF2 :: (a -> b -> c) -> ListF f a -> ListF f b -> ListF f c

Pointed f => Pointed (ListF f)

Defined in Control.Applicative.ListF

Methods

point :: a -> ListF f a

Functor f => Plus (ListF f)

Defined in Control.Applicative.ListF

Methods

zero :: ListF f a

Functor f => Alt (ListF f)

Defined in Control.Applicative.ListF

Methods

(<!>) :: ListF f a -> ListF f a -> ListF f a

some :: Applicative (ListF f) => ListF f a -> ListF f [a]

many :: Applicative (ListF f) => ListF f a -> ListF f [a]

HBind ListF

Defined in Data.HFunctor

Methods

hbind :: (f ~> ListF g) -> ListF f ~> ListF g

hjoin :: ListF (ListF f) ~> ListF f

Inject ListF

Defined in Data.HFunctor

Methods

inject :: f ~> ListF f

HFunctor ListF

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> ListF f ~> ListF g

Eq (f a) => Eq (ListF f a)

Defined in Control.Applicative.ListF

Methods

(==) :: ListF f a -> ListF f a -> Bool

(/=) :: ListF f a -> ListF f a -> Bool

(Typeable f, Typeable a, Data (f a)) => Data (ListF f a)

Defined in Control.Applicative.ListF

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ListF f a -> c (ListF f a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ListF f a)

toConstr :: ListF f a -> Constr

dataTypeOf :: ListF f a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ListF f a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ListF f a))

gmapT :: (forall b. Data b => b -> b) -> ListF f a -> ListF f a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ListF f a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ListF f a -> r

gmapQ :: (forall d. Data d => d -> u) -> ListF f a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ListF f a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ListF f a -> m (ListF f a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ListF f a -> m (ListF f a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ListF f a -> m (ListF f a)

Ord (f a) => Ord (ListF f a)

Defined in Control.Applicative.ListF

Methods

compare :: ListF f a -> ListF f a -> Ordering

(<) :: ListF f a -> ListF f a -> Bool

(<=) :: ListF f a -> ListF f a -> Bool

(>) :: ListF f a -> ListF f a -> Bool

(>=) :: ListF f a -> ListF f a -> Bool

max :: ListF f a -> ListF f a -> ListF f a

min :: ListF f a -> ListF f a -> ListF f a

Read (f a) => Read (ListF f a)

Defined in Control.Applicative.ListF

Methods

readsPrec :: Int -> ReadS (ListF f a)

readList :: ReadS [ListF f a]

readPrec :: ReadPrec (ListF f a)

readListPrec :: ReadPrec [ListF f a]

Show (f a) => Show (ListF f a)

Defined in Control.Applicative.ListF

Methods

showsPrec :: Int -> ListF f a -> ShowS

show :: ListF f a -> String

showList :: [ListF f a] -> ShowS

Generic (ListF f a)

Defined in Control.Applicative.ListF

Associated Types

type Rep (ListF f a) :: Type -> Type

Methods

from :: ListF f a -> Rep (ListF f a) x

to :: Rep (ListF f a) x -> ListF f a

Semigroup (ListF f a)

Defined in Control.Applicative.ListF

Methods

(<>) :: ListF f a -> ListF f a -> ListF f a

sconcat :: NonEmpty (ListF f a) -> ListF f a

stimes :: Integral b => b -> ListF f a -> ListF f a

Monoid (ListF f a)

Defined in Control.Applicative.ListF

Methods

mempty :: ListF f a

mappend :: ListF f a -> ListF f a -> ListF f a

mconcat :: [ListF f a] -> ListF f a

type C ListF

Defined in Data.HFunctor.Interpret

type C ListF = Plus

type Rep (ListF f a)

Defined in Control.Applicative.ListF

type Rep (ListF f a) = D1 (MetaData "ListF" "Control.Applicative.ListF" "functor-combinators-0.1.1.1-B2oyFu2GVTM8ySAuzVPoNk" True) (C1 (MetaCons "ListF" PrefixI True) (S1 (MetaSel (Just "runListF") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [f a])))

newtype NonEmptyF f a

A non-empty list of f as. Can be used to describe a product between many different possible values of type f a.

Essentially:

NonEmptyF f
    ~ f                          -- one f
  :+: (f :*: f)              -- two f's
  :+: (f :*: f :*: f)            -- three f's
  :+: (f :*: f :*: f :*: f)      -- four f's
  :+: ...                        -- etc.

This is the Free Plus.

Constructors

NonEmptyF

Fields

• runNonEmptyF :: NonEmpty (f a)

Bundled Patterns

pattern ProdNonEmpty :: (f :*: ListF f) a -> NonEmptyF f a

Treat a NonEmptyF f as a product between an f and a ListF f.

nonEmptyProd is the record accessor.

Instances

Interpret NonEmptyF

A free Alt

Defined in Data.HFunctor.Interpret

Associated Types

type C NonEmptyF :: (Type -> Type) -> Constraint

Methods

retract :: C NonEmptyF f => NonEmptyF f ~> f

interpret :: C NonEmptyF g => (f ~> g) -> NonEmptyF f ~> g

FreeOf Alt NonEmptyF

Defined in Data.HFunctor.Final

Methods

fromFree :: NonEmptyF f ~> Final Alt f

toFree :: Functor f => Final Alt f ~> NonEmptyF f

Functor f => Functor (NonEmptyF f)

Defined in Control.Applicative.ListF

Methods

fmap :: (a -> b) -> NonEmptyF f a -> NonEmptyF f b

(<$) :: a -> NonEmptyF f b -> NonEmptyF f a

Applicative f => Applicative (NonEmptyF f)

Defined in Control.Applicative.ListF

Methods

pure :: a -> NonEmptyF f a

(<*>) :: NonEmptyF f (a -> b) -> NonEmptyF f a -> NonEmptyF f b

liftA2 :: (a -> b -> c) -> NonEmptyF f a -> NonEmptyF f b -> NonEmptyF f c

(*>) :: NonEmptyF f a -> NonEmptyF f b -> NonEmptyF f b

(<*) :: NonEmptyF f a -> NonEmptyF f b -> NonEmptyF f a

Foldable f => Foldable (NonEmptyF f)

Defined in Control.Applicative.ListF

Methods

fold :: Monoid m => NonEmptyF f m -> m

foldMap :: Monoid m => (a -> m) -> NonEmptyF f a -> m

foldr :: (a -> b -> b) -> b -> NonEmptyF f a -> b

foldr' :: (a -> b -> b) -> b -> NonEmptyF f a -> b

foldl :: (b -> a -> b) -> b -> NonEmptyF f a -> b

foldl' :: (b -> a -> b) -> b -> NonEmptyF f a -> b

foldr1 :: (a -> a -> a) -> NonEmptyF f a -> a

foldl1 :: (a -> a -> a) -> NonEmptyF f a -> a

toList :: NonEmptyF f a -> [a]

null :: NonEmptyF f a -> Bool

length :: NonEmptyF f a -> Int

elem :: Eq a => a -> NonEmptyF f a -> Bool

maximum :: Ord a => NonEmptyF f a -> a

minimum :: Ord a => NonEmptyF f a -> a

sum :: Num a => NonEmptyF f a -> a

product :: Num a => NonEmptyF f a -> a

Traversable f => Traversable (NonEmptyF f)

Defined in Control.Applicative.ListF

Methods

traverse :: Applicative f0 => (a -> f0 b) -> NonEmptyF f a -> f0 (NonEmptyF f b)

sequenceA :: Applicative f0 => NonEmptyF f (f0 a) -> f0 (NonEmptyF f a)

mapM :: Monad m => (a -> m b) -> NonEmptyF f a -> m (NonEmptyF f b)

sequence :: Monad m => NonEmptyF f (m a) -> m (NonEmptyF f a)

Eq1 f => Eq1 (NonEmptyF f)

Defined in Control.Applicative.ListF

Methods

liftEq :: (a -> b -> Bool) -> NonEmptyF f a -> NonEmptyF f b -> Bool

Ord1 f => Ord1 (NonEmptyF f)

Defined in Control.Applicative.ListF

Methods

liftCompare :: (a -> b -> Ordering) -> NonEmptyF f a -> NonEmptyF f b -> Ordering

Read1 f => Read1 (NonEmptyF f)

Defined in Control.Applicative.ListF

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (NonEmptyF f a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [NonEmptyF f a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (NonEmptyF f a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [NonEmptyF f a]

Show1 f => Show1 (NonEmptyF f)

Defined in Control.Applicative.ListF

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> NonEmptyF f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [NonEmptyF f a] -> ShowS

Pointed f => Pointed (NonEmptyF f)

Defined in Control.Applicative.ListF

Methods

point :: a -> NonEmptyF f a

Functor f => Alt (NonEmptyF f)

Defined in Control.Applicative.ListF

Methods

(<!>) :: NonEmptyF f a -> NonEmptyF f a -> NonEmptyF f a

some :: Applicative (NonEmptyF f) => NonEmptyF f a -> NonEmptyF f [a]

many :: Applicative (NonEmptyF f) => NonEmptyF f a -> NonEmptyF f [a]

HBind NonEmptyF

Defined in Data.HFunctor

Methods

hbind :: (f ~> NonEmptyF g) -> NonEmptyF f ~> NonEmptyF g

hjoin :: NonEmptyF (NonEmptyF f) ~> NonEmptyF f

Inject NonEmptyF

Defined in Data.HFunctor

Methods

inject :: f ~> NonEmptyF f

HFunctor NonEmptyF

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> NonEmptyF f ~> NonEmptyF g

Eq (f a) => Eq (NonEmptyF f a)

Defined in Control.Applicative.ListF

Methods

(==) :: NonEmptyF f a -> NonEmptyF f a -> Bool

(/=) :: NonEmptyF f a -> NonEmptyF f a -> Bool

(Typeable f, Typeable a, Data (f a)) => Data (NonEmptyF f a)

Defined in Control.Applicative.ListF

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NonEmptyF f a -> c (NonEmptyF f a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (NonEmptyF f a)

toConstr :: NonEmptyF f a -> Constr

dataTypeOf :: NonEmptyF f a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (NonEmptyF f a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NonEmptyF f a))

gmapT :: (forall b. Data b => b -> b) -> NonEmptyF f a -> NonEmptyF f a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NonEmptyF f a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NonEmptyF f a -> r

gmapQ :: (forall d. Data d => d -> u) -> NonEmptyF f a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> NonEmptyF f a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NonEmptyF f a -> m (NonEmptyF f a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmptyF f a -> m (NonEmptyF f a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmptyF f a -> m (NonEmptyF f a)

Ord (f a) => Ord (NonEmptyF f a)

Defined in Control.Applicative.ListF

Methods

compare :: NonEmptyF f a -> NonEmptyF f a -> Ordering

(<) :: NonEmptyF f a -> NonEmptyF f a -> Bool

(<=) :: NonEmptyF f a -> NonEmptyF f a -> Bool

(>) :: NonEmptyF f a -> NonEmptyF f a -> Bool

(>=) :: NonEmptyF f a -> NonEmptyF f a -> Bool

max :: NonEmptyF f a -> NonEmptyF f a -> NonEmptyF f a

min :: NonEmptyF f a -> NonEmptyF f a -> NonEmptyF f a

Read (f a) => Read (NonEmptyF f a)

Defined in Control.Applicative.ListF

Methods

readsPrec :: Int -> ReadS (NonEmptyF f a)

readList :: ReadS [NonEmptyF f a]

readPrec :: ReadPrec (NonEmptyF f a)

readListPrec :: ReadPrec [NonEmptyF f a]

Show (f a) => Show (NonEmptyF f a)

Defined in Control.Applicative.ListF

Methods

showsPrec :: Int -> NonEmptyF f a -> ShowS

show :: NonEmptyF f a -> String

showList :: [NonEmptyF f a] -> ShowS

Generic (NonEmptyF f a)

Defined in Control.Applicative.ListF

Associated Types

type Rep (NonEmptyF f a) :: Type -> Type

Methods

from :: NonEmptyF f a -> Rep (NonEmptyF f a) x

to :: Rep (NonEmptyF f a) x -> NonEmptyF f a

Semigroup (NonEmptyF f a)

Defined in Control.Applicative.ListF

Methods

(<>) :: NonEmptyF f a -> NonEmptyF f a -> NonEmptyF f a

sconcat :: NonEmpty (NonEmptyF f a) -> NonEmptyF f a

stimes :: Integral b => b -> NonEmptyF f a -> NonEmptyF f a

type C NonEmptyF

Defined in Data.HFunctor.Interpret

type C NonEmptyF = Alt

type Rep (NonEmptyF f a)

Defined in Control.Applicative.ListF

type Rep (NonEmptyF f a) = D1 (MetaData "NonEmptyF" "Control.Applicative.ListF" "functor-combinators-0.1.1.1-B2oyFu2GVTM8ySAuzVPoNk" True) (C1 (MetaCons "NonEmptyF" PrefixI True) (S1 (MetaSel (Just "runNonEmptyF") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (f a)))))

newtype MaybeF f a

A maybe f a.

Can be useful for describing a "an f a that may or may not be there".

This is the free structure for a "fail"-like typeclass that would only have zero :: f a.

Constructors

MaybeF

Fields

• runMaybeF :: Maybe (f a)

Instances

Interpret MaybeF

Technically, C 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

Associated Types

type C MaybeF :: (Type -> Type) -> Constraint

Methods

retract :: C MaybeF f => MaybeF f ~> f

interpret :: C MaybeF g => (f ~> g) -> MaybeF f ~> g

Functor f => Functor (MaybeF f)

Defined in Control.Applicative.ListF

Methods

fmap :: (a -> b) -> MaybeF f a -> MaybeF f b

(<$) :: a -> MaybeF f b -> MaybeF f a

Applicative f => Applicative (MaybeF f)

Defined in Control.Applicative.ListF

Methods

pure :: a -> MaybeF f a

(<*>) :: MaybeF f (a -> b) -> MaybeF f a -> MaybeF f b

liftA2 :: (a -> b -> c) -> MaybeF f a -> MaybeF f b -> MaybeF f c

(*>) :: MaybeF f a -> MaybeF f b -> MaybeF f b

(<*) :: MaybeF f a -> MaybeF f b -> MaybeF f a

Foldable f => Foldable (MaybeF f)

Defined in Control.Applicative.ListF

Methods

fold :: Monoid m => MaybeF f m -> m

foldMap :: Monoid m => (a -> m) -> MaybeF f a -> m

foldr :: (a -> b -> b) -> b -> MaybeF f a -> b

foldr' :: (a -> b -> b) -> b -> MaybeF f a -> b

foldl :: (b -> a -> b) -> b -> MaybeF f a -> b

foldl' :: (b -> a -> b) -> b -> MaybeF f a -> b

foldr1 :: (a -> a -> a) -> MaybeF f a -> a

foldl1 :: (a -> a -> a) -> MaybeF f a -> a

toList :: MaybeF f a -> [a]

null :: MaybeF f a -> Bool

length :: MaybeF f a -> Int

elem :: Eq a => a -> MaybeF f a -> Bool

maximum :: Ord a => MaybeF f a -> a

minimum :: Ord a => MaybeF f a -> a

sum :: Num a => MaybeF f a -> a

product :: Num a => MaybeF f a -> a

Traversable f => Traversable (MaybeF f)

Defined in Control.Applicative.ListF

Methods

traverse :: Applicative f0 => (a -> f0 b) -> MaybeF f a -> f0 (MaybeF f b)

sequenceA :: Applicative f0 => MaybeF f (f0 a) -> f0 (MaybeF f a)

mapM :: Monad m => (a -> m b) -> MaybeF f a -> m (MaybeF f b)

sequence :: Monad m => MaybeF f (m a) -> m (MaybeF f a)

Applicative f => Alternative (MaybeF f)

Defined in Control.Applicative.ListF

Methods

empty :: MaybeF f a

(<|>) :: MaybeF f a -> MaybeF f a -> MaybeF f a

some :: MaybeF f a -> MaybeF f [a]

many :: MaybeF f a -> MaybeF f [a]

Eq1 f => Eq1 (MaybeF f)

Defined in Control.Applicative.ListF

Methods

liftEq :: (a -> b -> Bool) -> MaybeF f a -> MaybeF f b -> Bool

Ord1 f => Ord1 (MaybeF f)

Defined in Control.Applicative.ListF

Methods

liftCompare :: (a -> b -> Ordering) -> MaybeF f a -> MaybeF f b -> Ordering

Read1 f => Read1 (MaybeF f)

Defined in Control.Applicative.ListF

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (MaybeF f a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [MaybeF f a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (MaybeF f a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [MaybeF f a]

Show1 f => Show1 (MaybeF f)

Defined in Control.Applicative.ListF

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> MaybeF f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [MaybeF f a] -> ShowS

Pointed f => Pointed (MaybeF f)

Defined in Control.Applicative.ListF

Methods

point :: a -> MaybeF f a

Functor f => Plus (MaybeF f)

Defined in Control.Applicative.ListF

Methods

zero :: MaybeF f a

Functor f => Alt (MaybeF f)

Defined in Control.Applicative.ListF

Methods

(<!>) :: MaybeF f a -> MaybeF f a -> MaybeF f a

some :: Applicative (MaybeF f) => MaybeF f a -> MaybeF f [a]

many :: Applicative (MaybeF f) => MaybeF f a -> MaybeF f [a]

HBind MaybeF

Defined in Data.HFunctor

Methods

hbind :: (f ~> MaybeF g) -> MaybeF f ~> MaybeF g

hjoin :: MaybeF (MaybeF f) ~> MaybeF f

Inject MaybeF

Defined in Data.HFunctor

Methods

inject :: f ~> MaybeF f

HFunctor MaybeF

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> MaybeF f ~> MaybeF g

Eq (f a) => Eq (MaybeF f a)

Defined in Control.Applicative.ListF

Methods

(==) :: MaybeF f a -> MaybeF f a -> Bool

(/=) :: MaybeF f a -> MaybeF f a -> Bool

(Typeable f, Typeable a, Data (f a)) => Data (MaybeF f a)

Defined in Control.Applicative.ListF

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MaybeF f a -> c (MaybeF f a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (MaybeF f a)

toConstr :: MaybeF f a -> Constr

dataTypeOf :: MaybeF f a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (MaybeF f a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MaybeF f a))

gmapT :: (forall b. Data b => b -> b) -> MaybeF f a -> MaybeF f a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MaybeF f a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MaybeF f a -> r

gmapQ :: (forall d. Data d => d -> u) -> MaybeF f a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> MaybeF f a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MaybeF f a -> m (MaybeF f a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MaybeF f a -> m (MaybeF f a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MaybeF f a -> m (MaybeF f a)

Ord (f a) => Ord (MaybeF f a)

Defined in Control.Applicative.ListF

Methods

compare :: MaybeF f a -> MaybeF f a -> Ordering

(<) :: MaybeF f a -> MaybeF f a -> Bool

(<=) :: MaybeF f a -> MaybeF f a -> Bool

(>) :: MaybeF f a -> MaybeF f a -> Bool

(>=) :: MaybeF f a -> MaybeF f a -> Bool

max :: MaybeF f a -> MaybeF f a -> MaybeF f a

min :: MaybeF f a -> MaybeF f a -> MaybeF f a

Read (f a) => Read (MaybeF f a)

Defined in Control.Applicative.ListF

Methods

readsPrec :: Int -> ReadS (MaybeF f a)

readList :: ReadS [MaybeF f a]

readPrec :: ReadPrec (MaybeF f a)

readListPrec :: ReadPrec [MaybeF f a]

Show (f a) => Show (MaybeF f a)

Defined in Control.Applicative.ListF

Methods

showsPrec :: Int -> MaybeF f a -> ShowS

show :: MaybeF f a -> String

showList :: [MaybeF f a] -> ShowS

Generic (MaybeF f a)

Defined in Control.Applicative.ListF

Associated Types

type Rep (MaybeF f a) :: Type -> Type

Methods

from :: MaybeF f a -> Rep (MaybeF f a) x

to :: Rep (MaybeF f a) x -> MaybeF f a

Semigroup (MaybeF f a)

Picks the first Just.

Defined in Control.Applicative.ListF

Methods

(<>) :: MaybeF f a -> MaybeF f a -> MaybeF f a

sconcat :: NonEmpty (MaybeF f a) -> MaybeF f a

stimes :: Integral b => b -> MaybeF f a -> MaybeF f a

Monoid (MaybeF f a)

Defined in Control.Applicative.ListF

Methods

mempty :: MaybeF f a

mappend :: MaybeF f a -> MaybeF f a -> MaybeF f a

mconcat :: [MaybeF f a] -> MaybeF f a

type C MaybeF

Defined in Data.HFunctor.Interpret

type C MaybeF = Plus

type Rep (MaybeF f a)

Defined in Control.Applicative.ListF

type Rep (MaybeF f a) = D1 (MetaData "MaybeF" "Control.Applicative.ListF" "functor-combinators-0.1.1.1-B2oyFu2GVTM8ySAuzVPoNk" True) (C1 (MetaCons "MaybeF" PrefixI True) (S1 (MetaSel (Just "runMaybeF") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (f a)))))

newtype MapF k f a

A map of f as, indexed by keys of type k. It can be useful for represeting a product of many different values of type f a, each "at" a different k location.

Can be considered a combination of EnvT and ListF, in a way --- a MapF k f a is like a ListF (EnvT k f) a with unique (and ordered) keys.

One use case might be to extend a schema with many "options", indexed by some string.

For example, if you had a command line argument parser for a single command

data Command a

Then you can represent a command line argument parser for multiple named commands with

type Commands = MapF String Command

See NEMapF for a non-empty variant, if you want to enforce that your bag has at least one f a.

Constructors

MapF

Fields

• runMapF :: Map k (f a)

Instances

Monoid k => Interpret (MapF k)

Defined in Data.HFunctor.Interpret

Associated Types

type C (MapF k) :: (Type -> Type) -> Constraint

Methods

retract :: C (MapF k) f => MapF k f ~> f

interpret :: C (MapF k) g => (f ~> g) -> MapF k f ~> g

Monoid k => Inject (MapF k :: (Type -> Type) -> Type -> Type)

Injects into a singleton map at mempty.

Defined in Data.HFunctor

Methods

inject :: f ~> MapF k f

HFunctor (MapF k :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> MapF k f ~> MapF k g

Functor f => Functor (MapF k f)

Defined in Control.Applicative.ListF

Methods

fmap :: (a -> b) -> MapF k f a -> MapF k f b

(<$) :: a -> MapF k f b -> MapF k f a

Foldable f => Foldable (MapF k f)

Defined in Control.Applicative.ListF

Methods

fold :: Monoid m => MapF k f m -> m

foldMap :: Monoid m => (a -> m) -> MapF k f a -> m

foldr :: (a -> b -> b) -> b -> MapF k f a -> b

foldr' :: (a -> b -> b) -> b -> MapF k f a -> b

foldl :: (b -> a -> b) -> b -> MapF k f a -> b

foldl' :: (b -> a -> b) -> b -> MapF k f a -> b

foldr1 :: (a -> a -> a) -> MapF k f a -> a

foldl1 :: (a -> a -> a) -> MapF k f a -> a

toList :: MapF k f a -> [a]

null :: MapF k f a -> Bool

length :: MapF k f a -> Int

elem :: Eq a => a -> MapF k f a -> Bool

maximum :: Ord a => MapF k f a -> a

minimum :: Ord a => MapF k f a -> a

sum :: Num a => MapF k f a -> a

product :: Num a => MapF k f a -> a

Traversable f => Traversable (MapF k f)

Defined in Control.Applicative.ListF

Methods

traverse :: Applicative f0 => (a -> f0 b) -> MapF k f a -> f0 (MapF k f b)

sequenceA :: Applicative f0 => MapF k f (f0 a) -> f0 (MapF k f a)

mapM :: Monad m => (a -> m b) -> MapF k f a -> m (MapF k f b)

sequence :: Monad m => MapF k f (m a) -> m (MapF k f a)

(Eq k, Eq1 f) => Eq1 (MapF k f)

Defined in Control.Applicative.ListF

Methods

liftEq :: (a -> b -> Bool) -> MapF k f a -> MapF k f b -> Bool

(Ord k, Ord1 f) => Ord1 (MapF k f)

Defined in Control.Applicative.ListF

Methods

liftCompare :: (a -> b -> Ordering) -> MapF k f a -> MapF k f b -> Ordering

(Ord k, Read k, Read1 f) => Read1 (MapF k f)

Defined in Control.Applicative.ListF

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (MapF k f a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [MapF k f a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (MapF k f a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [MapF k f a]

(Show k, Show1 f) => Show1 (MapF k f)

Defined in Control.Applicative.ListF

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> MapF k f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [MapF k f a] -> ShowS

(Monoid k, Pointed f) => Pointed (MapF k f)

Defined in Control.Applicative.ListF

Methods

point :: a -> MapF k f a

(Functor f, Ord k) => Plus (MapF k f)

Defined in Control.Applicative.ListF

Methods

zero :: MapF k f a

(Functor f, Ord k) => Alt (MapF k f)

Left-biased union

Defined in Control.Applicative.ListF

Methods

(<!>) :: MapF k f a -> MapF k f a -> MapF k f a

some :: Applicative (MapF k f) => MapF k f a -> MapF k f [a]

many :: Applicative (MapF k f) => MapF k f a -> MapF k f [a]

(Eq k, Eq (f a)) => Eq (MapF k f a)

Defined in Control.Applicative.ListF

Methods

(==) :: MapF k f a -> MapF k f a -> Bool

(/=) :: MapF k f a -> MapF k f a -> Bool

(Typeable f, Typeable a, Data k, Data (f a), Ord k) => Data (MapF k f a)

Defined in Control.Applicative.ListF

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MapF k f a -> c (MapF k f a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (MapF k f a)

toConstr :: MapF k f a -> Constr

dataTypeOf :: MapF k f a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (MapF k f a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MapF k f a))

gmapT :: (forall b. Data b => b -> b) -> MapF k f a -> MapF k f a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MapF k f a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MapF k f a -> r

gmapQ :: (forall d. Data d => d -> u) -> MapF k f a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> MapF k f a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MapF k f a -> m (MapF k f a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MapF k f a -> m (MapF k f a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MapF k f a -> m (MapF k f a)

(Ord k, Ord (f a)) => Ord (MapF k f a)

Defined in Control.Applicative.ListF

Methods

compare :: MapF k f a -> MapF k f a -> Ordering

(<) :: MapF k f a -> MapF k f a -> Bool

(<=) :: MapF k f a -> MapF k f a -> Bool

(>) :: MapF k f a -> MapF k f a -> Bool

(>=) :: MapF k f a -> MapF k f a -> Bool

max :: MapF k f a -> MapF k f a -> MapF k f a

min :: MapF k f a -> MapF k f a -> MapF k f a

(Ord k, Read k, Read (f a)) => Read (MapF k f a)

Defined in Control.Applicative.ListF

Methods

readsPrec :: Int -> ReadS (MapF k f a)

readList :: ReadS [MapF k f a]

readPrec :: ReadPrec (MapF k f a)

readListPrec :: ReadPrec [MapF k f a]

(Show k, Show (f a)) => Show (MapF k f a)

Defined in Control.Applicative.ListF

Methods

showsPrec :: Int -> MapF k f a -> ShowS

show :: MapF k f a -> String

showList :: [MapF k f a] -> ShowS

Generic (MapF k f a)

Defined in Control.Applicative.ListF

Associated Types

type Rep (MapF k f a) :: Type -> Type

Methods

from :: MapF k f a -> Rep (MapF k f a) x

to :: Rep (MapF k f a) x -> MapF k f a

(Ord k, Alt f) => Semigroup (MapF k f a)

A union, combining matching keys with <!>.

Defined in Control.Applicative.ListF

Methods

(<>) :: MapF k f a -> MapF k f a -> MapF k f a

sconcat :: NonEmpty (MapF k f a) -> MapF k f a

stimes :: Integral b => b -> MapF k f a -> MapF k f a

(Ord k, Alt f) => Monoid (MapF k f a)

Defined in Control.Applicative.ListF

Methods

mempty :: MapF k f a

mappend :: MapF k f a -> MapF k f a -> MapF k f a

mconcat :: [MapF k f a] -> MapF k f a

type C (MapF k)

Defined in Data.HFunctor.Interpret

type C (MapF k) = Plus

type Rep (MapF k f a)

Defined in Control.Applicative.ListF

type Rep (MapF k f a) = D1 (MetaData "MapF" "Control.Applicative.ListF" "functor-combinators-0.1.1.1-B2oyFu2GVTM8ySAuzVPoNk" True) (C1 (MetaCons "MapF" PrefixI True) (S1 (MetaSel (Just "runMapF") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Map k (f a)))))

newtype NEMapF k f a

A non-empty map of f as, indexed by keys of type k. It can be useful for represeting a product of many different values of type f a, each "at" a different k location, where you need to have at least one f a at all times.

Can be considered a combination of EnvT and NonEmptyF, in a way --- an NEMapF k f a is like a NonEmptyF (EnvT k f) a with unique (and ordered) keys.

See MapF for some use cases.

Constructors

NEMapF

Fields

• runNEMapF :: NEMap k (f a)

Instances

Monoid k => Interpret (NEMapF k)

Defined in Data.HFunctor.Interpret

Associated Types

type C (NEMapF k) :: (Type -> Type) -> Constraint

Methods

retract :: C (NEMapF k) f => NEMapF k f ~> f

interpret :: C (NEMapF k) g => (f ~> g) -> NEMapF k f ~> g

Monoid k => Inject (NEMapF k :: (Type -> Type) -> Type -> Type)

Injects into a singleton map at mempty.

Defined in Data.HFunctor

Methods

inject :: f ~> NEMapF k f

HFunctor (NEMapF k :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> NEMapF k f ~> NEMapF k g

Functor f => Functor (NEMapF k f)

Defined in Control.Applicative.ListF

Methods

fmap :: (a -> b) -> NEMapF k f a -> NEMapF k f b

(<$) :: a -> NEMapF k f b -> NEMapF k f a

Foldable f => Foldable (NEMapF k f)

Defined in Control.Applicative.ListF

Methods

fold :: Monoid m => NEMapF k f m -> m

foldMap :: Monoid m => (a -> m) -> NEMapF k f a -> m

foldr :: (a -> b -> b) -> b -> NEMapF k f a -> b

foldr' :: (a -> b -> b) -> b -> NEMapF k f a -> b

foldl :: (b -> a -> b) -> b -> NEMapF k f a -> b

foldl' :: (b -> a -> b) -> b -> NEMapF k f a -> b

foldr1 :: (a -> a -> a) -> NEMapF k f a -> a

foldl1 :: (a -> a -> a) -> NEMapF k f a -> a

toList :: NEMapF k f a -> [a]

null :: NEMapF k f a -> Bool

length :: NEMapF k f a -> Int

elem :: Eq a => a -> NEMapF k f a -> Bool

maximum :: Ord a => NEMapF k f a -> a

minimum :: Ord a => NEMapF k f a -> a

sum :: Num a => NEMapF k f a -> a

product :: Num a => NEMapF k f a -> a

Traversable f => Traversable (NEMapF k f)

Defined in Control.Applicative.ListF

Methods

traverse :: Applicative f0 => (a -> f0 b) -> NEMapF k f a -> f0 (NEMapF k f b)

sequenceA :: Applicative f0 => NEMapF k f (f0 a) -> f0 (NEMapF k f a)

mapM :: Monad m => (a -> m b) -> NEMapF k f a -> m (NEMapF k f b)

sequence :: Monad m => NEMapF k f (m a) -> m (NEMapF k f a)

(Eq k, Eq1 f) => Eq1 (NEMapF k f)

Defined in Control.Applicative.ListF

Methods

liftEq :: (a -> b -> Bool) -> NEMapF k f a -> NEMapF k f b -> Bool

(Ord k, Ord1 f) => Ord1 (NEMapF k f)

Defined in Control.Applicative.ListF

Methods

liftCompare :: (a -> b -> Ordering) -> NEMapF k f a -> NEMapF k f b -> Ordering

(Ord k, Read k, Read1 f) => Read1 (NEMapF k f)

Defined in Control.Applicative.ListF

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (NEMapF k f a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [NEMapF k f a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (NEMapF k f a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [NEMapF k f a]

(Show k, Show1 f) => Show1 (NEMapF k f)

Defined in Control.Applicative.ListF

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> NEMapF k f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [NEMapF k f a] -> ShowS

Foldable1 f => Foldable1 (NEMapF k f)

Defined in Control.Applicative.ListF

Methods

fold1 :: Semigroup m => NEMapF k f m -> m

foldMap1 :: Semigroup m => (a -> m) -> NEMapF k f a -> m

toNonEmpty :: NEMapF k f a -> NonEmpty a

(Monoid k, Pointed f) => Pointed (NEMapF k f)

Defined in Control.Applicative.ListF

Methods

point :: a -> NEMapF k f a

Traversable1 f => Traversable1 (NEMapF k f)

Defined in Control.Applicative.ListF

Methods

traverse1 :: Apply f0 => (a -> f0 b) -> NEMapF k f a -> f0 (NEMapF k f b)

sequence1 :: Apply f0 => NEMapF k f (f0 b) -> f0 (NEMapF k f b)

(Functor f, Ord k) => Alt (NEMapF k f)

Left-biased union

Defined in Control.Applicative.ListF

Methods

(<!>) :: NEMapF k f a -> NEMapF k f a -> NEMapF k f a

some :: Applicative (NEMapF k f) => NEMapF k f a -> NEMapF k f [a]

many :: Applicative (NEMapF k f) => NEMapF k f a -> NEMapF k f [a]

(Eq k, Eq (f a)) => Eq (NEMapF k f a)

Defined in Control.Applicative.ListF

Methods

(==) :: NEMapF k f a -> NEMapF k f a -> Bool

(/=) :: NEMapF k f a -> NEMapF k f a -> Bool

(Typeable f, Typeable a, Data k, Data (f a), Ord k) => Data (NEMapF k f a)

Defined in Control.Applicative.ListF

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NEMapF k f a -> c (NEMapF k f a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (NEMapF k f a)

toConstr :: NEMapF k f a -> Constr

dataTypeOf :: NEMapF k f a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (NEMapF k f a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NEMapF k f a))

gmapT :: (forall b. Data b => b -> b) -> NEMapF k f a -> NEMapF k f a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NEMapF k f a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NEMapF k f a -> r

gmapQ :: (forall d. Data d => d -> u) -> NEMapF k f a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> NEMapF k f a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NEMapF k f a -> m (NEMapF k f a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NEMapF k f a -> m (NEMapF k f a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NEMapF k f a -> m (NEMapF k f a)

(Ord k, Ord (f a)) => Ord (NEMapF k f a)

Defined in Control.Applicative.ListF

Methods

compare :: NEMapF k f a -> NEMapF k f a -> Ordering

(<) :: NEMapF k f a -> NEMapF k f a -> Bool

(<=) :: NEMapF k f a -> NEMapF k f a -> Bool

(>) :: NEMapF k f a -> NEMapF k f a -> Bool

(>=) :: NEMapF k f a -> NEMapF k f a -> Bool

max :: NEMapF k f a -> NEMapF k f a -> NEMapF k f a

min :: NEMapF k f a -> NEMapF k f a -> NEMapF k f a

(Ord k, Read k, Read (f a)) => Read (NEMapF k f a)

Defined in Control.Applicative.ListF

Methods

readsPrec :: Int -> ReadS (NEMapF k f a)

readList :: ReadS [NEMapF k f a]

readPrec :: ReadPrec (NEMapF k f a)

readListPrec :: ReadPrec [NEMapF k f a]

(Show k, Show (f a)) => Show (NEMapF k f a)

Defined in Control.Applicative.ListF

Methods

showsPrec :: Int -> NEMapF k f a -> ShowS

show :: NEMapF k f a -> String

showList :: [NEMapF k f a] -> ShowS

Generic (NEMapF k f a)

Defined in Control.Applicative.ListF

Associated Types

type Rep (NEMapF k f a) :: Type -> Type

Methods

from :: NEMapF k f a -> Rep (NEMapF k f a) x

to :: Rep (NEMapF k f a) x -> NEMapF k f a

(Ord k, Alt f) => Semigroup (NEMapF k f a)

A union, combining matching keys with <!>.

Defined in Control.Applicative.ListF

Methods

(<>) :: NEMapF k f a -> NEMapF k f a -> NEMapF k f a

sconcat :: NonEmpty (NEMapF k f a) -> NEMapF k f a

stimes :: Integral b => b -> NEMapF k f a -> NEMapF k f a

type C (NEMapF k)

Defined in Data.HFunctor.Interpret

type C (NEMapF k) = Alt

type Rep (NEMapF k f a)

Defined in Control.Applicative.ListF

type Rep (NEMapF k f a) = D1 (MetaData "NEMapF" "Control.Applicative.ListF" "functor-combinators-0.1.1.1-B2oyFu2GVTM8ySAuzVPoNk" True) (C1 (MetaCons "NEMapF" PrefixI True) (S1 (MetaSel (Just "runNEMapF") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NEMap k (f a)))))

data Ap (f :: Type -> Type) a

The free Applicative for a Functor f.

Instances

Interpret Ap

A free Applicative

Defined in Data.HFunctor.Interpret

Associated Types

type C Ap :: (Type -> Type) -> Constraint

Methods

retract :: C Ap f => Ap f ~> f

interpret :: C Ap g => (f ~> g) -> Ap f ~> g

FreeOf Applicative Ap

Defined in Data.HFunctor.Final

Methods

fromFree :: Ap f ~> Final Applicative f

toFree :: Functor f => Final Applicative f ~> Ap f

Functor (Ap f)

Defined in Control.Applicative.Free

Methods

fmap :: (a -> b) -> Ap f a -> Ap f b

(<$) :: a -> Ap f b -> Ap f a

Applicative (Ap f)

Defined in Control.Applicative.Free

Methods

pure :: a -> Ap f a

(<*>) :: Ap f (a -> b) -> Ap f a -> Ap f b

liftA2 :: (a -> b -> c) -> Ap f a -> Ap f b -> Ap f c

(*>) :: Ap f a -> Ap f b -> Ap f b

(<*) :: Ap f a -> Ap f b -> Ap f a

Comonad f => Comonad (Ap f)

Defined in Control.Applicative.Free

Methods

extract :: Ap f a -> a

duplicate :: Ap f a -> Ap f (Ap f a)

extend :: (Ap f a -> b) -> Ap f a -> Ap f b

Apply (Ap f)

Defined in Control.Applicative.Free

Methods

(<.>) :: Ap f (a -> b) -> Ap f a -> Ap f b

(.>) :: Ap f a -> Ap f b -> Ap f b

(<.) :: Ap f a -> Ap f b -> Ap f a

liftF2 :: (a -> b -> c) -> Ap f a -> Ap f b -> Ap f c

HBind Ap

Defined in Data.HFunctor

Methods

hbind :: (f ~> Ap g) -> Ap f ~> Ap g

hjoin :: Ap (Ap f) ~> Ap f

Inject Ap

Defined in Data.HFunctor

Methods

inject :: f ~> Ap f

HFunctor Ap

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Ap f ~> Ap g

type C Ap

Defined in Data.HFunctor.Interpret

type C Ap = Applicative

data Ap1 :: (Type -> Type) -> Type -> Type where

One or more fs convolved with itself.

Essentially:

Ap1 f
    ~ f                            -- one f
  :+: (f `Day' f)          -- two f's
  :+: (f `Day` f `Day` f)           -- three f's
  :+: (f `Day` f `Day` f `Day` f)  -- four f's
  :+: ...                          -- etc.

Useful if you want to promote an f to a situation with "at least one f sequenced with itself".

Mostly useful for its HFunctor and Interpret instance, along with its relationship with Ap and Day.

This is the free Apply --- Basically a "non-empty" Ap.

The construction here is based on Ap, similar to now NonEmpty is built on list.

Constructors

Ap1 :: f a -> Ap f (a -> b) -> Ap1 f b

Bundled Patterns

pattern DayAp1 :: Day f (Ap f) a -> Ap1 f a

An Ap1 f is just a Day f (Ap f). This bidirectional pattern synonym lets you treat it as such.

Instances

Interpret Ap1

Defined in Data.Functor.Apply.Free

Associated Types

type C Ap1 :: (Type -> Type) -> Constraint

Methods

retract :: C Ap1 f => Ap1 f ~> f

interpret :: C Ap1 g => (f ~> g) -> Ap1 f ~> g

HBind Ap1

Defined in Data.Functor.Apply.Free

Methods

hbind :: (f ~> Ap1 g) -> Ap1 f ~> Ap1 g

hjoin :: Ap1 (Ap1 f) ~> Ap1 f

Inject Ap1

Defined in Data.Functor.Apply.Free

Methods

inject :: f ~> Ap1 f

FreeOf Apply Ap1

Defined in Data.HFunctor.Final

Methods

fromFree :: Ap1 f ~> Final Apply f

toFree :: Functor f => Final Apply f ~> Ap1 f

HFunctor Ap1

Defined in Data.Functor.Apply.Free

Methods

hmap :: (f ~> g) -> Ap1 f ~> Ap1 g

Functor (Ap1 f)

Defined in Data.Functor.Apply.Free

Methods

fmap :: (a -> b) -> Ap1 f a -> Ap1 f b

(<$) :: a -> Ap1 f b -> Ap1 f a

Apply (Ap1 f)

Defined in Data.Functor.Apply.Free

Methods

(<.>) :: Ap1 f (a -> b) -> Ap1 f a -> Ap1 f b

(.>) :: Ap1 f a -> Ap1 f b -> Ap1 f b

(<.) :: Ap1 f a -> Ap1 f b -> Ap1 f a

liftF2 :: (a -> b -> c) -> Ap1 f a -> Ap1 f b -> Ap1 f c

type C Ap1

Defined in Data.Functor.Apply.Free

type C Ap1 = Apply

data Alt (f :: Type -> Type) a

Instances

Interpret Alt

A free Alternative

Defined in Data.HFunctor.Interpret

Associated Types

type C Alt :: (Type -> Type) -> Constraint

Methods

retract :: C Alt f => Alt f ~> f

interpret :: C Alt g => (f ~> g) -> Alt f ~> g

FreeOf Alternative Alt

Defined in Data.HFunctor.Final

Methods

fromFree :: Alt f ~> Final Alternative f

toFree :: Functor f => Final Alternative f ~> Alt f

Functor (Alt f)

Defined in Control.Alternative.Free

Methods

fmap :: (a -> b) -> Alt f a -> Alt f b

(<$) :: a -> Alt f b -> Alt f a

Applicative (Alt f)

Defined in Control.Alternative.Free

Methods

pure :: a -> Alt f a

(<*>) :: Alt f (a -> b) -> Alt f a -> Alt f b

liftA2 :: (a -> b -> c) -> Alt f a -> Alt f b -> Alt f c

(*>) :: Alt f a -> Alt f b -> Alt f b

(<*) :: Alt f a -> Alt f b -> Alt f a

Alternative (Alt f)

Defined in Control.Alternative.Free

Methods

empty :: Alt f a

(<|>) :: Alt f a -> Alt f a -> Alt f a

some :: Alt f a -> Alt f [a]

many :: Alt f a -> Alt f [a]

Apply (Alt f)

Defined in Control.Alternative.Free

Methods

(<.>) :: Alt f (a -> b) -> Alt f a -> Alt f b

(.>) :: Alt f a -> Alt f b -> Alt f b

(<.) :: Alt f a -> Alt f b -> Alt f a

liftF2 :: (a -> b -> c) -> Alt f a -> Alt f b -> Alt f c

Alt (Alt f)

Defined in Control.Alternative.Free

Methods

(<!>) :: Alt f a -> Alt f a -> Alt f a

some :: Applicative (Alt f) => Alt f a -> Alt f [a]

many :: Applicative (Alt f) => Alt f a -> Alt f [a]

HBind Alt

Defined in Data.HFunctor

Methods

hbind :: (f ~> Alt g) -> Alt f ~> Alt g

hjoin :: Alt (Alt f) ~> Alt f

Inject Alt

Defined in Data.HFunctor

Methods

inject :: f ~> Alt f

HFunctor Alt

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Alt f ~> Alt g

Semigroup (Alt f a)

Defined in Control.Alternative.Free

Methods

(<>) :: Alt f a -> Alt f a -> Alt f a

sconcat :: NonEmpty (Alt f a) -> Alt f a

stimes :: Integral b => b -> Alt f a -> Alt f a

Monoid (Alt f a)

Defined in Control.Alternative.Free

Methods

mempty :: Alt f a

mappend :: Alt f a -> Alt f a -> Alt f a

mconcat :: [Alt f a] -> Alt f a

type C Alt

Defined in Data.HFunctor.Interpret

type C Alt = Alternative

data Free f a

A Free f is f enhanced with "sequential binding" capabilities. It allows you to sequence multiple fs one after the other, and also to determine "what f to sequence" based on the result of the computation so far.

Essentially, you can think of this as "giving f a Monad instance", with all that that entails (return, >>=, etc.).

Lift f into it with inject :: f a -> Free f a. When you finally want to "use" it, you can interpret it into any monadic context:

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

Structurally, this is equivalent to many "nested" f's. A value of type Free f a is either:

• a

• f a

• f (f a)

• f (f (f a))

• .. etc.

Under the hood, this is the Church-encoded Freer monad. It's Free, or F, but in a way that is compatible with HFunctor and Interpret.

Instances

Interpret Free

A free Monad

Defined in Data.HFunctor.Interpret

Associated Types

type C Free :: (Type -> Type) -> Constraint

Methods

retract :: C Free f => Free f ~> f

interpret :: C Free g => (f ~> g) -> Free f ~> g

FreeOf Monad Free

Defined in Data.HFunctor.Final

Methods

fromFree :: Free f ~> Final Monad f

toFree :: Functor f => Final Monad f ~> Free f

MonadFree f (Free f)

Defined in Control.Monad.Freer.Church

Methods

wrap :: f (Free f a) -> Free f a

Monad (Free f)

Defined in Control.Monad.Freer.Church

Methods

(>>=) :: Free f a -> (a -> Free f b) -> Free f b

(>>) :: Free f a -> Free f b -> Free f b

return :: a -> Free f a

fail :: String -> Free f a

Functor (Free f)

Defined in Control.Monad.Freer.Church

Methods

fmap :: (a -> b) -> Free f a -> Free f b

(<$) :: a -> Free f b -> Free f a

Applicative (Free f)

Defined in Control.Monad.Freer.Church

Methods

pure :: a -> Free f a

(<*>) :: Free f (a -> b) -> Free f a -> Free f b

liftA2 :: (a -> b -> c) -> Free f a -> Free f b -> Free f c

(*>) :: Free f a -> Free f b -> Free f b

(<*) :: Free f a -> Free f b -> Free f a

Foldable f => Foldable (Free f)

Defined in Control.Monad.Freer.Church

Methods

fold :: Monoid m => Free f m -> m

foldMap :: Monoid m => (a -> m) -> Free f a -> m

foldr :: (a -> b -> b) -> b -> Free f a -> b

foldr' :: (a -> b -> b) -> b -> Free f a -> b

foldl :: (b -> a -> b) -> b -> Free f a -> b

foldl' :: (b -> a -> b) -> b -> Free f a -> b

foldr1 :: (a -> a -> a) -> Free f a -> a

foldl1 :: (a -> a -> a) -> Free f a -> a

toList :: Free f a -> [a]

null :: Free f a -> Bool

length :: Free f a -> Int

elem :: Eq a => a -> Free f a -> Bool

maximum :: Ord a => Free f a -> a

minimum :: Ord a => Free f a -> a

sum :: Num a => Free f a -> a

product :: Num a => Free f a -> a

Traversable f => Traversable (Free f)

Defined in Control.Monad.Freer.Church

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Free f a -> f0 (Free f b)

sequenceA :: Applicative f0 => Free f (f0 a) -> f0 (Free f a)

mapM :: Monad m => (a -> m b) -> Free f a -> m (Free f b)

sequence :: Monad m => Free f (m a) -> m (Free f a)

(Functor f, Eq1 f) => Eq1 (Free f)

Defined in Control.Monad.Freer.Church

Methods

liftEq :: (a -> b -> Bool) -> Free f a -> Free f b -> Bool

(Functor f, Ord1 f) => Ord1 (Free f)

Defined in Control.Monad.Freer.Church

Methods

liftCompare :: (a -> b -> Ordering) -> Free f a -> Free f b -> Ordering

(Functor f, Read1 f) => Read1 (Free f)

Defined in Control.Monad.Freer.Church

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Free f a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Free f a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Free f a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Free f a]

(Functor f, Show1 f) => Show1 (Free f)

Defined in Control.Monad.Freer.Church

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Free f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Free f a] -> ShowS

Apply (Free f)

Defined in Control.Monad.Freer.Church

Methods

(<.>) :: Free f (a -> b) -> Free f a -> Free f b

(.>) :: Free f a -> Free f b -> Free f b

(<.) :: Free f a -> Free f b -> Free f a

liftF2 :: (a -> b -> c) -> Free f a -> Free f b -> Free f c

Pointed (Free f)

Defined in Control.Monad.Freer.Church

Methods

point :: a -> Free f a

Bind (Free f)

Defined in Control.Monad.Freer.Church

Methods

(>>-) :: Free f a -> (a -> Free f b) -> Free f b

join :: Free f (Free f a) -> Free f a

HBind Free

Defined in Data.HFunctor

Methods

hbind :: (f ~> Free g) -> Free f ~> Free g

hjoin :: Free (Free f) ~> Free f

Inject Free

Defined in Data.HFunctor

Methods

inject :: f ~> Free f

HFunctor Free

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Free f ~> Free g

(Functor f, Eq1 f, Eq a) => Eq (Free f a)

Defined in Control.Monad.Freer.Church

Methods

(==) :: Free f a -> Free f a -> Bool

(/=) :: Free f a -> Free f a -> Bool

(Functor f, Ord1 f, Ord a) => Ord (Free f a)

Defined in Control.Monad.Freer.Church

Methods

compare :: Free f a -> Free f a -> Ordering

(<) :: Free f a -> Free f a -> Bool

(<=) :: Free f a -> Free f a -> Bool

(>) :: Free f a -> Free f a -> Bool

(>=) :: Free f a -> Free f a -> Bool

max :: Free f a -> Free f a -> Free f a

min :: Free f a -> Free f a -> Free f a

(Functor f, Read1 f, Read a) => Read (Free f a)

Read in terms of pure and wrap.

Defined in Control.Monad.Freer.Church

Methods

readsPrec :: Int -> ReadS (Free f a)

readList :: ReadS [Free f a]

readPrec :: ReadPrec (Free f a)

readListPrec :: ReadPrec [Free f a]

(Functor f, Show1 f, Show a) => Show (Free f a)

Show in terms of pure and wrap.

Defined in Control.Monad.Freer.Church

Methods

showsPrec :: Int -> Free f a -> ShowS

show :: Free f a -> String

showList :: [Free f a] -> ShowS

type C Free

Defined in Data.HFunctor.Interpret

type C Free = Monad

data Free1 f a

The Free Bind. Imbues any functor f with a Bind instance.

Conceptually, this is "Free without pure". That is, while normally Free f a is an a, a f a, a f (f a), etc., a Free1 f a is an f a, f (f a), f (f (f a)), etc. It's a Free with "at least one layer of f", excluding the a case.

It can be useful as the semigroup formed by :.: (functor composition): Sometimes we want an f :.: f, or an f :.: f :.: f, or an f :.: f :.: f :.: f...just as long as we have at least one f.

Instances

Interpret Free1

A free Bind

Defined in Data.HFunctor.Interpret

Associated Types

type C Free1 :: (Type -> Type) -> Constraint

Methods

retract :: C Free1 f => Free1 f ~> f

interpret :: C Free1 g => (f ~> g) -> Free1 f ~> g

FreeOf Bind Free1

Defined in Data.HFunctor.Final

Methods

fromFree :: Free1 f ~> Final Bind f

toFree :: Functor f => Final Bind f ~> Free1 f

Functor (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

fmap :: (a -> b) -> Free1 f a -> Free1 f b

(<$) :: a -> Free1 f b -> Free1 f a

Foldable f => Foldable (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

fold :: Monoid m => Free1 f m -> m

foldMap :: Monoid m => (a -> m) -> Free1 f a -> m

foldr :: (a -> b -> b) -> b -> Free1 f a -> b

foldr' :: (a -> b -> b) -> b -> Free1 f a -> b

foldl :: (b -> a -> b) -> b -> Free1 f a -> b

foldl' :: (b -> a -> b) -> b -> Free1 f a -> b

foldr1 :: (a -> a -> a) -> Free1 f a -> a

foldl1 :: (a -> a -> a) -> Free1 f a -> a

toList :: Free1 f a -> [a]

null :: Free1 f a -> Bool

length :: Free1 f a -> Int

elem :: Eq a => a -> Free1 f a -> Bool

maximum :: Ord a => Free1 f a -> a

minimum :: Ord a => Free1 f a -> a

sum :: Num a => Free1 f a -> a

product :: Num a => Free1 f a -> a

Traversable f => Traversable (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Free1 f a -> f0 (Free1 f b)

sequenceA :: Applicative f0 => Free1 f (f0 a) -> f0 (Free1 f a)

mapM :: Monad m => (a -> m b) -> Free1 f a -> m (Free1 f b)

sequence :: Monad m => Free1 f (m a) -> m (Free1 f a)

(Functor f, Eq1 f) => Eq1 (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

liftEq :: (a -> b -> Bool) -> Free1 f a -> Free1 f b -> Bool

(Functor f, Ord1 f) => Ord1 (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

liftCompare :: (a -> b -> Ordering) -> Free1 f a -> Free1 f b -> Ordering

(Functor f, Read1 f) => Read1 (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Free1 f a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Free1 f a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Free1 f a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Free1 f a]

(Functor f, Show1 f) => Show1 (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Free1 f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Free1 f a] -> ShowS

Foldable1 f => Foldable1 (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

fold1 :: Semigroup m => Free1 f m -> m

foldMap1 :: Semigroup m => (a -> m) -> Free1 f a -> m

toNonEmpty :: Free1 f a -> NonEmpty a

Apply (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

(<.>) :: Free1 f (a -> b) -> Free1 f a -> Free1 f b

(.>) :: Free1 f a -> Free1 f b -> Free1 f b

(<.) :: Free1 f a -> Free1 f b -> Free1 f a

liftF2 :: (a -> b -> c) -> Free1 f a -> Free1 f b -> Free1 f c

Traversable1 f => Traversable1 (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

traverse1 :: Apply f0 => (a -> f0 b) -> Free1 f a -> f0 (Free1 f b)

sequence1 :: Apply f0 => Free1 f (f0 b) -> f0 (Free1 f b)

Bind (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

(>>-) :: Free1 f a -> (a -> Free1 f b) -> Free1 f b

join :: Free1 f (Free1 f a) -> Free1 f a

HBind Free1

Defined in Data.HFunctor

Methods

hbind :: (f ~> Free1 g) -> Free1 f ~> Free1 g

hjoin :: Free1 (Free1 f) ~> Free1 f

Inject Free1

Defined in Data.HFunctor

Methods

inject :: f ~> Free1 f

HFunctor Free1

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Free1 f ~> Free1 g

(Functor f, Eq1 f, Eq a) => Eq (Free1 f a)

Defined in Control.Monad.Freer.Church

Methods

(==) :: Free1 f a -> Free1 f a -> Bool

(/=) :: Free1 f a -> Free1 f a -> Bool

(Functor f, Ord1 f, Ord a) => Ord (Free1 f a)

Defined in Control.Monad.Freer.Church

Methods

compare :: Free1 f a -> Free1 f a -> Ordering

(<) :: Free1 f a -> Free1 f a -> Bool

(<=) :: Free1 f a -> Free1 f a -> Bool

(>) :: Free1 f a -> Free1 f a -> Bool

(>=) :: Free1 f a -> Free1 f a -> Bool

max :: Free1 f a -> Free1 f a -> Free1 f a

min :: Free1 f a -> Free1 f a -> Free1 f a

(Functor f, Read1 f, Read a) => Read (Free1 f a)

Read in terms of DoneF1 and MoreF1.

Defined in Control.Monad.Freer.Church

Methods

readsPrec :: Int -> ReadS (Free1 f a)

readList :: ReadS [Free1 f a]

readPrec :: ReadPrec (Free1 f a)

readListPrec :: ReadPrec [Free1 f a]

(Functor f, Show1 f, Show a) => Show (Free1 f a)

Show in terms of DoneF1 and MoreF1.

Defined in Control.Monad.Freer.Church

Methods

showsPrec :: Int -> Free1 f a -> ShowS

show :: Free1 f a -> String

showList :: [Free1 f a] -> ShowS

type C Free1

Defined in Data.HFunctor.Interpret

type C Free1 = Bind

data Lift (f :: Type -> Type) a

Applicative functor formed by adding pure computations to a given applicative functor.

Instances

Interpret Lift

A free Pointed

Defined in Data.HFunctor.Interpret

Associated Types

type C Lift :: (Type -> Type) -> Constraint

Methods

retract :: C Lift f => Lift f ~> f

interpret :: C Lift g => (f ~> g) -> Lift f ~> g

FreeOf Pointed Lift

Defined in Data.HFunctor.Final

Methods

fromFree :: Lift f ~> Final Pointed f

toFree :: Functor f => Final Pointed f ~> Lift f

Functor f => Functor (Lift f)

Defined in Control.Applicative.Lift

Methods

fmap :: (a -> b) -> Lift f a -> Lift f b

(<$) :: a -> Lift f b -> Lift f a

Applicative f => Applicative (Lift f)

A combination is Pure only if both parts are.

Defined in Control.Applicative.Lift

Methods

pure :: a -> Lift f a

(<*>) :: Lift f (a -> b) -> Lift f a -> Lift f b

liftA2 :: (a -> b -> c) -> Lift f a -> Lift f b -> Lift f c

(*>) :: Lift f a -> Lift f b -> Lift f b

(<*) :: Lift f a -> Lift f b -> Lift f a

Foldable f => Foldable (Lift f)

Defined in Control.Applicative.Lift

Methods

fold :: Monoid m => Lift f m -> m

foldMap :: Monoid m => (a -> m) -> Lift f a -> m

foldr :: (a -> b -> b) -> b -> Lift f a -> b

foldr' :: (a -> b -> b) -> b -> Lift f a -> b

foldl :: (b -> a -> b) -> b -> Lift f a -> b

foldl' :: (b -> a -> b) -> b -> Lift f a -> b

foldr1 :: (a -> a -> a) -> Lift f a -> a

foldl1 :: (a -> a -> a) -> Lift f a -> a

toList :: Lift f a -> [a]

null :: Lift f a -> Bool

length :: Lift f a -> Int

elem :: Eq a => a -> Lift f a -> Bool

maximum :: Ord a => Lift f a -> a

minimum :: Ord a => Lift f a -> a

sum :: Num a => Lift f a -> a

product :: Num a => Lift f a -> a

Traversable f => Traversable (Lift f)

Defined in Control.Applicative.Lift

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Lift f a -> f0 (Lift f b)

sequenceA :: Applicative f0 => Lift f (f0 a) -> f0 (Lift f a)

mapM :: Monad m => (a -> m b) -> Lift f a -> m (Lift f b)

sequence :: Monad m => Lift f (m a) -> m (Lift f a)

Alternative f => Alternative (Lift f)

A combination is Pure only either part is.

Defined in Control.Applicative.Lift

Methods

empty :: Lift f a

(<|>) :: Lift f a -> Lift f a -> Lift f a

some :: Lift f a -> Lift f [a]

many :: Lift f a -> Lift f [a]

Eq1 f => Eq1 (Lift f)

Defined in Control.Applicative.Lift

Methods

liftEq :: (a -> b -> Bool) -> Lift f a -> Lift f b -> Bool

Ord1 f => Ord1 (Lift f)

Defined in Control.Applicative.Lift

Methods

liftCompare :: (a -> b -> Ordering) -> Lift f a -> Lift f b -> Ordering

Read1 f => Read1 (Lift f)

Defined in Control.Applicative.Lift

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Lift f a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Lift f a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Lift f a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Lift f a]

Show1 f => Show1 (Lift f)

Defined in Control.Applicative.Lift

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Lift f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Lift f a] -> ShowS

Foldable1 f => Foldable1 (Lift f)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => Lift f m -> m

foldMap1 :: Semigroup m => (a -> m) -> Lift f a -> m

toNonEmpty :: Lift f a -> NonEmpty a

Apply f => Apply (Lift f)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Lift f (a -> b) -> Lift f a -> Lift f b

(.>) :: Lift f a -> Lift f b -> Lift f b

(<.) :: Lift f a -> Lift f b -> Lift f a

liftF2 :: (a -> b -> c) -> Lift f a -> Lift f b -> Lift f c

Pointed (Lift f)

Defined in Data.Pointed

Methods

point :: a -> Lift f a

Traversable1 f => Traversable1 (Lift f)

Defined in Data.Semigroup.Traversable.Class

Methods

traverse1 :: Apply f0 => (a -> f0 b) -> Lift f a -> f0 (Lift f b)

sequence1 :: Apply f0 => Lift f (f0 b) -> f0 (Lift f b)

Plus f => Plus (Lift f)

Defined in Data.Functor.Plus

Methods

zero :: Lift f a

Alt f => Alt (Lift f)

Defined in Data.Functor.Alt

Methods

(<!>) :: Lift f a -> Lift f a -> Lift f a

some :: Applicative (Lift f) => Lift f a -> Lift f [a]

many :: Applicative (Lift f) => Lift f a -> Lift f [a]

HBind Lift

Defined in Data.HFunctor

Methods

hbind :: (f ~> Lift g) -> Lift f ~> Lift g

hjoin :: Lift (Lift f) ~> Lift f

Inject Lift

Defined in Data.HFunctor

Methods

inject :: f ~> Lift f

HFunctor Lift

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Lift f ~> Lift g

(Eq1 f, Eq a) => Eq (Lift f a)

Defined in Control.Applicative.Lift

Methods

(==) :: Lift f a -> Lift f a -> Bool

(/=) :: Lift f a -> Lift f a -> Bool

(Ord1 f, Ord a) => Ord (Lift f a)

Defined in Control.Applicative.Lift

Methods

compare :: Lift f a -> Lift f a -> Ordering

(<) :: Lift f a -> Lift f a -> Bool

(<=) :: Lift f a -> Lift f a -> Bool

(>) :: Lift f a -> Lift f a -> Bool

(>=) :: Lift f a -> Lift f a -> Bool

max :: Lift f a -> Lift f a -> Lift f a

min :: Lift f a -> Lift f a -> Lift f a

(Read1 f, Read a) => Read (Lift f a)

Defined in Control.Applicative.Lift

Methods

readsPrec :: Int -> ReadS (Lift f a)

readList :: ReadS [Lift f a]

readPrec :: ReadPrec (Lift f a)

readListPrec :: ReadPrec [Lift f a]

(Show1 f, Show a) => Show (Lift f a)

Defined in Control.Applicative.Lift

Methods

showsPrec :: Int -> Lift f a -> ShowS

show :: Lift f a -> String

showList :: [Lift f a] -> ShowS

type C Lift

Defined in Data.HFunctor.Interpret

type C Lift = Pointed

data Step f a

An f a, along with a Natural index.

Step f a ~ (Natural, f a)
Step f   ~ ((,) Natural) :.: f       -- functor composition

It is the fixed point of infinite applications of :+: (functor sums).

Intuitively, in an infinite f :+: f :+: f :+: f ..., you have exactly one f somewhere. A Step f a has that f, with a Natural giving you "where" the f is in the long chain.

Can be useful for using with the Monoidal instance of :+:.

interpreting it requires no constraint on the target context.

Note that this type and its instances equivalent to EnvT (Sum Natural).

Constructors

Step

Fields

• stepPos :: Natural
• stepVal :: f a

Instances

HFunctor (Step :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Step f ~> Step g

HBind (Step :: (k -> Type) -> k -> Type)

Equivalent to instance for EnvT (Sum Natural).

Defined in Data.HFunctor

Methods

hbind :: (f ~> Step g) -> Step f ~> Step g

hjoin :: Step (Step f) ~> Step f

Inject (Step :: (k -> Type) -> k -> Type)

Injects with 0.

Equivalent to instance for EnvT (Sum Natural).

Defined in Data.HFunctor

Methods

inject :: f ~> Step f

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

Equivalent to instance for EnvT (Sum Natural).

Defined in Data.HFunctor.Interpret

Associated Types

type C Step :: (Type -> Type) -> Constraint

Methods

retract :: C Step f => Step f ~> f

interpret :: C Step g => (f ~> g) -> Step f ~> g

Functor f => Functor (Step f)

Defined in Control.Applicative.Step

Methods

fmap :: (a -> b) -> Step f a -> Step f b

(<$) :: a -> Step f b -> Step f a

Applicative f => Applicative (Step f)

Defined in Control.Applicative.Step

Methods

pure :: a -> Step f a

(<*>) :: Step f (a -> b) -> Step f a -> Step f b

liftA2 :: (a -> b -> c) -> Step f a -> Step f b -> Step f c

(*>) :: Step f a -> Step f b -> Step f b

(<*) :: Step f a -> Step f b -> Step f a

Foldable f => Foldable (Step f)

Defined in Control.Applicative.Step

Methods

fold :: Monoid m => Step f m -> m

foldMap :: Monoid m => (a -> m) -> Step f a -> m

foldr :: (a -> b -> b) -> b -> Step f a -> b

foldr' :: (a -> b -> b) -> b -> Step f a -> b

foldl :: (b -> a -> b) -> b -> Step f a -> b

foldl' :: (b -> a -> b) -> b -> Step f a -> b

foldr1 :: (a -> a -> a) -> Step f a -> a

foldl1 :: (a -> a -> a) -> Step f a -> a

toList :: Step f a -> [a]

null :: Step f a -> Bool

length :: Step f a -> Int

elem :: Eq a => a -> Step f a -> Bool

maximum :: Ord a => Step f a -> a

minimum :: Ord a => Step f a -> a

sum :: Num a => Step f a -> a

product :: Num a => Step f a -> a

Traversable f => Traversable (Step f)

Defined in Control.Applicative.Step

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Step f a -> f0 (Step f b)

sequenceA :: Applicative f0 => Step f (f0 a) -> f0 (Step f a)

mapM :: Monad m => (a -> m b) -> Step f a -> m (Step f b)

sequence :: Monad m => Step f (m a) -> m (Step f a)

Eq1 f => Eq1 (Step f)

Defined in Control.Applicative.Step

Methods

liftEq :: (a -> b -> Bool) -> Step f a -> Step f b -> Bool

Ord1 f => Ord1 (Step f)

Defined in Control.Applicative.Step

Methods

liftCompare :: (a -> b -> Ordering) -> Step f a -> Step f b -> Ordering

Read1 f => Read1 (Step f)

Defined in Control.Applicative.Step

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Step f a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Step f a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Step f a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Step f a]

Show1 f => Show1 (Step f)

Defined in Control.Applicative.Step

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Step f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Step f a] -> ShowS

Foldable1 f => Foldable1 (Step f)

Defined in Control.Applicative.Step

Methods

fold1 :: Semigroup m => Step f m -> m

foldMap1 :: Semigroup m => (a -> m) -> Step f a -> m

toNonEmpty :: Step f a -> NonEmpty a

Pointed f => Pointed (Step f)

Defined in Control.Applicative.Step

Methods

point :: a -> Step f a

Traversable1 f => Traversable1 (Step f)

Defined in Control.Applicative.Step

Methods

traverse1 :: Apply f0 => (a -> f0 b) -> Step f a -> f0 (Step f b)

sequence1 :: Apply f0 => Step f (f0 b) -> f0 (Step f b)

Eq (f a) => Eq (Step f a)

Defined in Control.Applicative.Step

Methods

(==) :: Step f a -> Step f a -> Bool

(/=) :: Step f a -> Step f a -> Bool

(Typeable a, Typeable f, Typeable k, Data (f a)) => Data (Step f a)

Defined in Control.Applicative.Step

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Step f a -> c (Step f a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Step f a)

toConstr :: Step f a -> Constr

dataTypeOf :: Step f a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Step f a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Step f a))

gmapT :: (forall b. Data b => b -> b) -> Step f a -> Step f a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Step f a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Step f a -> r

gmapQ :: (forall d. Data d => d -> u) -> Step f a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Step f a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Step f a -> m (Step f a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Step f a -> m (Step f a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Step f a -> m (Step f a)

Ord (f a) => Ord (Step f a)

Defined in Control.Applicative.Step

Methods

compare :: Step f a -> Step f a -> Ordering

(<) :: Step f a -> Step f a -> Bool

(<=) :: Step f a -> Step f a -> Bool

(>) :: Step f a -> Step f a -> Bool

(>=) :: Step f a -> Step f a -> Bool

max :: Step f a -> Step f a -> Step f a

min :: Step f a -> Step f a -> Step f a

Read (f a) => Read (Step f a)

Defined in Control.Applicative.Step

Methods

readsPrec :: Int -> ReadS (Step f a)

readList :: ReadS [Step f a]

readPrec :: ReadPrec (Step f a)

readListPrec :: ReadPrec [Step f a]

Show (f a) => Show (Step f a)

Defined in Control.Applicative.Step

Methods

showsPrec :: Int -> Step f a -> ShowS

show :: Step f a -> String

showList :: [Step f a] -> ShowS

Generic (Step f a)

Defined in Control.Applicative.Step

Associated Types

type Rep (Step f a) :: Type -> Type

Methods

from :: Step f a -> Rep (Step f a) x

to :: Rep (Step f a) x -> Step f a

type C (Step :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Interpret

type C (Step :: (Type -> Type) -> Type -> Type) = (Unconstrained :: (Type -> Type) -> Constraint)

type Rep (Step f a)

Defined in Control.Applicative.Step

type Rep (Step f a) = D1 (MetaData "Step" "Control.Applicative.Step" "functor-combinators-0.1.1.1-B2oyFu2GVTM8ySAuzVPoNk" False) (C1 (MetaCons "Step" PrefixI True) (S1 (MetaSel (Just "stepPos") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Natural) :*: S1 (MetaSel (Just "stepVal") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f a))))

newtype Steps f a

A non-empty map of Natural to f a. Basically, contains multiple f as, each at a given Natural index.

Steps f a ~ Map Natural (f a)
Steps f   ~ Map Natural :.: f       -- functor composition

It is the fixed point of applications of TheseT.

You can think of this as an infinite sparse array of f as.

Intuitively, in an infinite f `TheseT` f `TheseT` f `TheseT` f ..., each of those infinite positions may have an f in them. However, because of the at-least-one nature of TheseT, we know we have at least one f at one position somewhere.

A Steps f a has potentially many fs, each stored at a different Natural position, with the guaruntee that at least one f exists.

Can be useful for using with the Monoidal instance of TheseT.

interpreting it requires at least an Alt instance in the target context, since we have to handle potentially more than one f.

This type is essentailly the same as NEMapF (Sum Natural) (except with a different Semigroup instance).

Constructors

Steps

Fields

• getSteps :: NEMap Natural (f a)

Instances

HFunctor (Steps :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Steps f ~> Steps g

Inject (Steps :: (k -> Type) -> k -> Type)

Injects into a singleton map at 0; same behavior as NEMapF (Sum Natural).

Defined in Data.HFunctor

Methods

inject :: f ~> Steps f

Interpret (Steps :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Interpret

Associated Types

type C Steps :: (Type -> Type) -> Constraint

Methods

retract :: C Steps f => Steps f ~> f

interpret :: C Steps g => (f ~> g) -> Steps f ~> g

Functor f => Functor (Steps f)

Defined in Control.Applicative.Step

Methods

fmap :: (a -> b) -> Steps f a -> Steps f b

(<$) :: a -> Steps f b -> Steps f a

Foldable f => Foldable (Steps f)

Defined in Control.Applicative.Step

Methods

fold :: Monoid m => Steps f m -> m

foldMap :: Monoid m => (a -> m) -> Steps f a -> m

foldr :: (a -> b -> b) -> b -> Steps f a -> b

foldr' :: (a -> b -> b) -> b -> Steps f a -> b

foldl :: (b -> a -> b) -> b -> Steps f a -> b

foldl' :: (b -> a -> b) -> b -> Steps f a -> b

foldr1 :: (a -> a -> a) -> Steps f a -> a

foldl1 :: (a -> a -> a) -> Steps f a -> a

toList :: Steps f a -> [a]

null :: Steps f a -> Bool

length :: Steps f a -> Int

elem :: Eq a => a -> Steps f a -> Bool

maximum :: Ord a => Steps f a -> a

minimum :: Ord a => Steps f a -> a

sum :: Num a => Steps f a -> a

product :: Num a => Steps f a -> a

Traversable f => Traversable (Steps f)

Defined in Control.Applicative.Step

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Steps f a -> f0 (Steps f b)

sequenceA :: Applicative f0 => Steps f (f0 a) -> f0 (Steps f a)

mapM :: Monad m => (a -> m b) -> Steps f a -> m (Steps f b)

sequence :: Monad m => Steps f (m a) -> m (Steps f a)

Eq1 f => Eq1 (Steps f)

Defined in Control.Applicative.Step

Methods

liftEq :: (a -> b -> Bool) -> Steps f a -> Steps f b -> Bool

Ord1 f => Ord1 (Steps f)

Defined in Control.Applicative.Step

Methods

liftCompare :: (a -> b -> Ordering) -> Steps f a -> Steps f b -> Ordering

Read1 f => Read1 (Steps f)

Defined in Control.Applicative.Step

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Steps f a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Steps f a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Steps f a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Steps f a]

Show1 f => Show1 (Steps f)

Defined in Control.Applicative.Step

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Steps f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Steps f a] -> ShowS

Foldable1 f => Foldable1 (Steps f)

Defined in Control.Applicative.Step

Methods

fold1 :: Semigroup m => Steps f m -> m

foldMap1 :: Semigroup m => (a -> m) -> Steps f a -> m

toNonEmpty :: Steps f a -> NonEmpty a

Pointed f => Pointed (Steps f)

Defined in Control.Applicative.Step

Methods

point :: a -> Steps f a

Traversable1 f => Traversable1 (Steps f)

Defined in Control.Applicative.Step

Methods

traverse1 :: Apply f0 => (a -> f0 b) -> Steps f a -> f0 (Steps f b)

sequence1 :: Apply f0 => Steps f (f0 b) -> f0 (Steps f b)

Functor f => Alt (Steps f)

Left-biased untion

Defined in Control.Applicative.Step

Methods

(<!>) :: Steps f a -> Steps f a -> Steps f a

some :: Applicative (Steps f) => Steps f a -> Steps f [a]

many :: Applicative (Steps f) => Steps f a -> Steps f [a]

Eq (f a) => Eq (Steps f a)

Defined in Control.Applicative.Step

Methods

(==) :: Steps f a -> Steps f a -> Bool

(/=) :: Steps f a -> Steps f a -> Bool

(Typeable a, Typeable f, Typeable k, Data (f a)) => Data (Steps f a)

Defined in Control.Applicative.Step

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Steps f a -> c (Steps f a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Steps f a)

toConstr :: Steps f a -> Constr

dataTypeOf :: Steps f a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Steps f a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Steps f a))

gmapT :: (forall b. Data b => b -> b) -> Steps f a -> Steps f a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Steps f a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Steps f a -> r

gmapQ :: (forall d. Data d => d -> u) -> Steps f a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Steps f a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Steps f a -> m (Steps f a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Steps f a -> m (Steps f a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Steps f a -> m (Steps f a)

Ord (f a) => Ord (Steps f a)

Defined in Control.Applicative.Step

Methods

compare :: Steps f a -> Steps f a -> Ordering

(<) :: Steps f a -> Steps f a -> Bool

(<=) :: Steps f a -> Steps f a -> Bool

(>) :: Steps f a -> Steps f a -> Bool

(>=) :: Steps f a -> Steps f a -> Bool

max :: Steps f a -> Steps f a -> Steps f a

min :: Steps f a -> Steps f a -> Steps f a

Read (f a) => Read (Steps f a)

Defined in Control.Applicative.Step

Methods

readsPrec :: Int -> ReadS (Steps f a)

readList :: ReadS [Steps f a]

readPrec :: ReadPrec (Steps f a)

readListPrec :: ReadPrec [Steps f a]

Show (f a) => Show (Steps f a)

Defined in Control.Applicative.Step

Methods

showsPrec :: Int -> Steps f a -> ShowS

show :: Steps f a -> String

showList :: [Steps f a] -> ShowS

Generic (Steps f a)

Defined in Control.Applicative.Step

Associated Types

type Rep (Steps f a) :: Type -> Type

Methods

from :: Steps f a -> Rep (Steps f a) x

to :: Rep (Steps f a) x -> Steps f a

Semigroup (Steps f a)

Appends the items back-to-back, shifting all of the items in the second map. Matches the behavior as the fixed-point of These1.

Defined in Control.Applicative.Step

Methods

(<>) :: Steps f a -> Steps f a -> Steps f a

sconcat :: NonEmpty (Steps f a) -> Steps f a

stimes :: Integral b => b -> Steps f a -> Steps f a

type C (Steps :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Interpret

type C (Steps :: (Type -> Type) -> Type -> Type) = Alt

type Rep (Steps f a)

Defined in Control.Applicative.Step

type Rep (Steps f a) = D1 (MetaData "Steps" "Control.Applicative.Step" "functor-combinators-0.1.1.1-B2oyFu2GVTM8ySAuzVPoNk" True) (C1 (MetaCons "Steps" PrefixI True) (S1 (MetaSel (Just "getSteps") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NEMap Natural (f a)))))

data ProxyF f a

The functor combinator that forgets all structure in the input. Ignores the input structure and stores no information.

Acts like the "zero" with respect to functor combinator composition.

ComposeT ProxyF f      ~ ProxyF
ComposeT f      ProxyF ~ ProxyF

It can be injected into (losing all information), but it is impossible to ever retract or interpret it.

This is essentially ConstF ().

Constructors

ProxyF

Instances

HFunctor (ProxyF :: (k1 -> Type) -> k2 -> Type)

Defined in Data.HFunctor

Methods

hmap :: (f ~> g) -> ProxyF f ~> ProxyF g

HBind (ProxyF :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

hbind :: (f ~> ProxyF g) -> ProxyF f ~> ProxyF g

hjoin :: ProxyF (ProxyF f) ~> ProxyF f

Inject (ProxyF :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

inject :: f ~> ProxyF f

Interpret (ProxyF :: (Type -> Type) -> Type -> Type)

The only way for this to obey retract . inject == id is to have it impossible to retract out of.

Defined in Data.HFunctor.Interpret

Associated Types

type C ProxyF :: (Type -> Type) -> Constraint

Methods

retract :: C ProxyF f => ProxyF f ~> f

interpret :: C ProxyF g => (f ~> g) -> ProxyF f ~> g

Functor (ProxyF f :: Type -> Type)

Defined in Data.HFunctor

Methods

fmap :: (a -> b) -> ProxyF f a -> ProxyF f b

(<$) :: a -> ProxyF f b -> ProxyF f a

Foldable (ProxyF f :: Type -> Type)

Defined in Data.HFunctor

Methods

fold :: Monoid m => ProxyF f m -> m

foldMap :: Monoid m => (a -> m) -> ProxyF f a -> m

foldr :: (a -> b -> b) -> b -> ProxyF f a -> b

foldr' :: (a -> b -> b) -> b -> ProxyF f a -> b

foldl :: (b -> a -> b) -> b -> ProxyF f a -> b

foldl' :: (b -> a -> b) -> b -> ProxyF f a -> b

foldr1 :: (a -> a -> a) -> ProxyF f a -> a

foldl1 :: (a -> a -> a) -> ProxyF f a -> a

toList :: ProxyF f a -> [a]

null :: ProxyF f a -> Bool

length :: ProxyF f a -> Int

elem :: Eq a => a -> ProxyF f a -> Bool

maximum :: Ord a => ProxyF f a -> a

minimum :: Ord a => ProxyF f a -> a

sum :: Num a => ProxyF f a -> a

product :: Num a => ProxyF f a -> a

Traversable (ProxyF f :: Type -> Type)

Defined in Data.HFunctor

Methods

traverse :: Applicative f0 => (a -> f0 b) -> ProxyF f a -> f0 (ProxyF f b)

sequenceA :: Applicative f0 => ProxyF f (f0 a) -> f0 (ProxyF f a)

mapM :: Monad m => (a -> m b) -> ProxyF f a -> m (ProxyF f b)

sequence :: Monad m => ProxyF f (m a) -> m (ProxyF f a)

Eq1 (ProxyF f :: Type -> Type)

Defined in Data.HFunctor

Methods

liftEq :: (a -> b -> Bool) -> ProxyF f a -> ProxyF f b -> Bool

Ord1 (ProxyF f :: Type -> Type)

Defined in Data.HFunctor

Methods

liftCompare :: (a -> b -> Ordering) -> ProxyF f a -> ProxyF f b -> Ordering

Read1 (ProxyF f :: Type -> Type)

Defined in Data.HFunctor

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (ProxyF f a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [ProxyF f a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (ProxyF f a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [ProxyF f a]

Show1 (ProxyF f :: Type -> Type)

Defined in Data.HFunctor

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> ProxyF f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [ProxyF f a] -> ShowS

Eq (ProxyF f a)

Defined in Data.HFunctor

Methods

(==) :: ProxyF f a -> ProxyF f a -> Bool

(/=) :: ProxyF f a -> ProxyF f a -> Bool

(Typeable f, Typeable a, Typeable k1, Typeable k2) => Data (ProxyF f a)

Defined in Data.HFunctor

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ProxyF f a -> c (ProxyF f a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ProxyF f a)

toConstr :: ProxyF f a -> Constr

dataTypeOf :: ProxyF f a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ProxyF f a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ProxyF f a))

gmapT :: (forall b. Data b => b -> b) -> ProxyF f a -> ProxyF f a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ProxyF f a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ProxyF f a -> r

gmapQ :: (forall d. Data d => d -> u) -> ProxyF f a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ProxyF f a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ProxyF f a -> m (ProxyF f a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ProxyF f a -> m (ProxyF f a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ProxyF f a -> m (ProxyF f a)

Ord (ProxyF f a)

Defined in Data.HFunctor

Methods

compare :: ProxyF f a -> ProxyF f a -> Ordering

(<) :: ProxyF f a -> ProxyF f a -> Bool

(<=) :: ProxyF f a -> ProxyF f a -> Bool

(>) :: ProxyF f a -> ProxyF f a -> Bool

(>=) :: ProxyF f a -> ProxyF f a -> Bool

max :: ProxyF f a -> ProxyF f a -> ProxyF f a

min :: ProxyF f a -> ProxyF f a -> ProxyF f a

Read (ProxyF f a)

Defined in Data.HFunctor

Methods

readsPrec :: Int -> ReadS (ProxyF f a)

readList :: ReadS [ProxyF f a]

readPrec :: ReadPrec (ProxyF f a)

readListPrec :: ReadPrec [ProxyF f a]

Show (ProxyF f a)

Defined in Data.HFunctor

Methods

showsPrec :: Int -> ProxyF f a -> ShowS

show :: ProxyF f a -> String

showList :: [ProxyF f a] -> ShowS

Generic (ProxyF f a)

Defined in Data.HFunctor

Associated Types

type Rep (ProxyF f a) :: Type -> Type

Methods

from :: ProxyF f a -> Rep (ProxyF f a) x

to :: Rep (ProxyF f a) x -> ProxyF f a

type C (ProxyF :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Interpret

type C (ProxyF :: (Type -> Type) -> Type -> Type) = (Impossible :: (Type -> Type) -> Constraint)

type Rep (ProxyF f a)

Defined in Data.HFunctor

type Rep (ProxyF f a) = D1 (MetaData "ProxyF" "Data.HFunctor" "functor-combinators-0.1.1.1-B2oyFu2GVTM8ySAuzVPoNk" False) (C1 (MetaCons "ProxyF" PrefixI False) (U1 :: Type -> Type))

data ConstF e f a

Functor combinator that forgets all structure on the input, and instead stores a value of type e.

Like ProxyF, acts like a "zero" with functor combinator composition.

It can be injected into (losing all information), but it is impossible to ever retract or interpret it.

Constructors

ConstF

Fields

• getConstF :: e

Instances

HFunctor (ConstF e :: (k1 -> Type) -> k2 -> Type)

Defined in Data.HFunctor

Methods

hmap :: (f ~> g) -> ConstF e f ~> ConstF e g

Monoid e => Inject (ConstF e :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

inject :: f ~> ConstF e f

Monoid e => Interpret (ConstF e :: (Type -> Type) -> Type -> Type)

The only way for this to obey retract . inject == id is to have it impossible to retract out of.

Defined in Data.HFunctor.Interpret

Associated Types

type C (ConstF e) :: (Type -> Type) -> Constraint

Methods

retract :: C (ConstF e) f => ConstF e f ~> f

interpret :: C (ConstF e) g => (f ~> g) -> ConstF e f ~> g

Functor (ConstF e f :: Type -> Type)

Defined in Data.HFunctor

Methods

fmap :: (a -> b) -> ConstF e f a -> ConstF e f b

(<$) :: a -> ConstF e f b -> ConstF e f a

Foldable (ConstF e f :: Type -> Type)

Defined in Data.HFunctor

Methods

fold :: Monoid m => ConstF e f m -> m

foldMap :: Monoid m => (a -> m) -> ConstF e f a -> m

foldr :: (a -> b -> b) -> b -> ConstF e f a -> b

foldr' :: (a -> b -> b) -> b -> ConstF e f a -> b

foldl :: (b -> a -> b) -> b -> ConstF e f a -> b

foldl' :: (b -> a -> b) -> b -> ConstF e f a -> b

foldr1 :: (a -> a -> a) -> ConstF e f a -> a

foldl1 :: (a -> a -> a) -> ConstF e f a -> a

toList :: ConstF e f a -> [a]

null :: ConstF e f a -> Bool

length :: ConstF e f a -> Int

elem :: Eq a => a -> ConstF e f a -> Bool

maximum :: Ord a => ConstF e f a -> a

minimum :: Ord a => ConstF e f a -> a

sum :: Num a => ConstF e f a -> a

product :: Num a => ConstF e f a -> a

Traversable (ConstF e f :: Type -> Type)

Defined in Data.HFunctor

Methods

traverse :: Applicative f0 => (a -> f0 b) -> ConstF e f a -> f0 (ConstF e f b)

sequenceA :: Applicative f0 => ConstF e f (f0 a) -> f0 (ConstF e f a)

mapM :: Monad m => (a -> m b) -> ConstF e f a -> m (ConstF e f b)

sequence :: Monad m => ConstF e f (m a) -> m (ConstF e f a)

Eq e => Eq1 (ConstF e f :: Type -> Type)

Defined in Data.HFunctor

Methods

liftEq :: (a -> b -> Bool) -> ConstF e f a -> ConstF e f b -> Bool

Ord e => Ord1 (ConstF e f :: Type -> Type)

Defined in Data.HFunctor

Methods

liftCompare :: (a -> b -> Ordering) -> ConstF e f a -> ConstF e f b -> Ordering

Read e => Read1 (ConstF e f :: Type -> Type)

Defined in Data.HFunctor

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (ConstF e f a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [ConstF e f a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (ConstF e f a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [ConstF e f a]

Show e => Show1 (ConstF e f :: Type -> Type)

Defined in Data.HFunctor

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> ConstF e f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [ConstF e f a] -> ShowS

Eq e => Eq (ConstF e f a)

Defined in Data.HFunctor

Methods

(==) :: ConstF e f a -> ConstF e f a -> Bool

(/=) :: ConstF e f a -> ConstF e f a -> Bool

(Typeable f, Typeable a, Typeable k1, Typeable k2, Data e) => Data (ConstF e f a)

Defined in Data.HFunctor

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConstF e f a -> c (ConstF e f a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ConstF e f a)

toConstr :: ConstF e f a -> Constr

dataTypeOf :: ConstF e f a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ConstF e f a))

dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (ConstF e f a))

gmapT :: (forall b. Data b => b -> b) -> ConstF e f a -> ConstF e f a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConstF e f a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConstF e f a -> r

gmapQ :: (forall d. Data d => d -> u) -> ConstF e f a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ConstF e f a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConstF e f a -> m (ConstF e f a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstF e f a -> m (ConstF e f a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstF e f a -> m (ConstF e f a)

Ord e => Ord (ConstF e f a)

Defined in Data.HFunctor

Methods

compare :: ConstF e f a -> ConstF e f a -> Ordering

(<) :: ConstF e f a -> ConstF e f a -> Bool

(<=) :: ConstF e f a -> ConstF e f a -> Bool

(>) :: ConstF e f a -> ConstF e f a -> Bool

(>=) :: ConstF e f a -> ConstF e f a -> Bool

max :: ConstF e f a -> ConstF e f a -> ConstF e f a

min :: ConstF e f a -> ConstF e f a -> ConstF e f a

Read e => Read (ConstF e f a)

Defined in Data.HFunctor

Methods

readsPrec :: Int -> ReadS (ConstF e f a)

readList :: ReadS [ConstF e f a]

readPrec :: ReadPrec (ConstF e f a)

readListPrec :: ReadPrec [ConstF e f a]

Show e => Show (ConstF e f a)

Defined in Data.HFunctor

Methods

showsPrec :: Int -> ConstF e f a -> ShowS

show :: ConstF e f a -> String

showList :: [ConstF e f a] -> ShowS

Generic (ConstF e f a)

Defined in Data.HFunctor

Associated Types

type Rep (ConstF e f a) :: Type -> Type

Methods

from :: ConstF e f a -> Rep (ConstF e f a) x

to :: Rep (ConstF e f a) x -> ConstF e f a

type C (ConstF e :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Interpret

type C (ConstF e :: (Type -> Type) -> Type -> Type) = (Impossible :: (Type -> Type) -> Constraint)

type Rep (ConstF e f a)

Defined in Data.HFunctor

type Rep (ConstF e f a) = D1 (MetaData "ConstF" "Data.HFunctor" "functor-combinators-0.1.1.1-B2oyFu2GVTM8ySAuzVPoNk" False) (C1 (MetaCons "ConstF" PrefixI True) (S1 (MetaSel (Just "getConstF") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 e)))

data EnvT e (w :: Type -> Type) a

Constructors

EnvT e (w a)

Instances

ComonadTrans (EnvT e)

Defined in Control.Comonad.Trans.Env

Methods

lower :: Comonad w => EnvT e w a -> w a

ComonadHoist (EnvT e)

Defined in Control.Comonad.Trans.Env

Methods

cohoist :: (Comonad w, Comonad v) => (forall x. w x -> v x) -> EnvT e w a -> EnvT e v a

Monoid e => Interpret (EnvT e)

This ignores the environment, so interpret /= hbind

Defined in Data.HFunctor.Interpret

Associated Types

type C (EnvT e) :: (Type -> Type) -> Constraint

Methods

retract :: C (EnvT e) f => EnvT e f ~> f

interpret :: C (EnvT e) g => (f ~> g) -> EnvT e f ~> g

Monoid e => HBind (EnvT e :: (Type -> Type) -> Type -> Type)

Combines the accumulators, Writer-style

Defined in Data.HFunctor

Methods

hbind :: (f ~> EnvT e g) -> EnvT e f ~> EnvT e g

hjoin :: EnvT e (EnvT e f) ~> EnvT e f

Monoid e => Inject (EnvT e :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor

Methods

inject :: f ~> EnvT e f

HFunctor (EnvT e :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> EnvT e f ~> EnvT e g

Functor w => Functor (EnvT e w)

Defined in Control.Comonad.Trans.Env

Methods

fmap :: (a -> b) -> EnvT e w a -> EnvT e w b

(<$) :: a -> EnvT e w b -> EnvT e w a

(Monoid e, Applicative m) => Applicative (EnvT e m)

Defined in Control.Comonad.Trans.Env

Methods

pure :: a -> EnvT e m a

(<*>) :: EnvT e m (a -> b) -> EnvT e m a -> EnvT e m b

liftA2 :: (a -> b -> c) -> EnvT e m a -> EnvT e m b -> EnvT e m c

(*>) :: EnvT e m a -> EnvT e m b -> EnvT e m b

(<*) :: EnvT e m a -> EnvT e m b -> EnvT e m a

Foldable w => Foldable (EnvT e w)

Defined in Control.Comonad.Trans.Env

Methods

fold :: Monoid m => EnvT e w m -> m

foldMap :: Monoid m => (a -> m) -> EnvT e w a -> m

foldr :: (a -> b -> b) -> b -> EnvT e w a -> b

foldr' :: (a -> b -> b) -> b -> EnvT e w a -> b

foldl :: (b -> a -> b) -> b -> EnvT e w a -> b

foldl' :: (b -> a -> b) -> b -> EnvT e w a -> b

foldr1 :: (a -> a -> a) -> EnvT e w a -> a

foldl1 :: (a -> a -> a) -> EnvT e w a -> a

toList :: EnvT e w a -> [a]

null :: EnvT e w a -> Bool

length :: EnvT e w a -> Int

elem :: Eq a => a -> EnvT e w a -> Bool

maximum :: Ord a => EnvT e w a -> a

minimum :: Ord a => EnvT e w a -> a

sum :: Num a => EnvT e w a -> a

product :: Num a => EnvT e w a -> a

Traversable w => Traversable (EnvT e w)

Defined in Control.Comonad.Trans.Env

Methods

traverse :: Applicative f => (a -> f b) -> EnvT e w a -> f (EnvT e w b)

sequenceA :: Applicative f => EnvT e w (f a) -> f (EnvT e w a)

mapM :: Monad m => (a -> m b) -> EnvT e w a -> m (EnvT e w b)

sequence :: Monad m => EnvT e w (m a) -> m (EnvT e w a)

Comonad w => Comonad (EnvT e w)

Defined in Control.Comonad.Trans.Env

Methods

extract :: EnvT e w a -> a

duplicate :: EnvT e w a -> EnvT e w (EnvT e w a)

extend :: (EnvT e w a -> b) -> EnvT e w a -> EnvT e w b

(Semigroup e, ComonadApply w) => ComonadApply (EnvT e w)

Defined in Control.Comonad.Trans.Env

Methods

(<@>) :: EnvT e w (a -> b) -> EnvT e w a -> EnvT e w b

(@>) :: EnvT e w a -> EnvT e w b -> EnvT e w b

(<@) :: EnvT e w a -> EnvT e w b -> EnvT e w a

(Semigroup e, Apply w) => Apply (EnvT e w)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: EnvT e w (a -> b) -> EnvT e w a -> EnvT e w b

(.>) :: EnvT e w a -> EnvT e w b -> EnvT e w b

(<.) :: EnvT e w a -> EnvT e w b -> EnvT e w a

liftF2 :: (a -> b -> c) -> EnvT e w a -> EnvT e w b -> EnvT e w c

(Data e, Typeable w, Data (w a), Data a) => Data (EnvT e w a)

Defined in Control.Comonad.Trans.Env

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EnvT e w a -> c (EnvT e w a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (EnvT e w a)

toConstr :: EnvT e w a -> Constr

dataTypeOf :: EnvT e w a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (EnvT e w a))

dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (EnvT e w a))

gmapT :: (forall b. Data b => b -> b) -> EnvT e w a -> EnvT e w a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EnvT e w a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EnvT e w a -> r

gmapQ :: (forall d. Data d => d -> u) -> EnvT e w a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> EnvT e w a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> EnvT e w a -> m (EnvT e w a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EnvT e w a -> m (EnvT e w a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EnvT e w a -> m (EnvT e w a)

type C (EnvT e)

Defined in Data.HFunctor.Interpret

type C (EnvT e) = (Unconstrained :: (Type -> Type) -> Constraint)

newtype ReaderT r (m :: k -> Type) (a :: k) :: forall k. Type -> (k -> Type) -> k -> Type

The reader monad transformer, which adds a read-only environment to the given monad.

The return function ignores the environment, while >>= passes the inherited environment to both subcomputations.

Constructors

ReaderT

Fields

• runReaderT :: r -> m a

Instances

HFunctor (ReaderT r :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> ReaderT r f ~> ReaderT r g

Inject (ReaderT r :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

inject :: f ~> ReaderT r f

Monad m => MonadReader r (ReaderT r m)

Defined in Control.Monad.Reader.Class

Methods

ask :: ReaderT r m r

local :: (r -> r) -> ReaderT r m a -> ReaderT r m a

reader :: (r -> a) -> ReaderT r m a

(Functor f, MonadFree f m) => MonadFree f (ReaderT e m)

Defined in Control.Monad.Free.Class

Methods

wrap :: f (ReaderT e m a) -> ReaderT e m a

MonadTrans (ReaderT r :: (Type -> Type) -> Type -> Type)

Defined in Control.Monad.Trans.Reader

Methods

lift :: Monad m => m a -> ReaderT r m a

Interpret (ReaderT r :: (Type -> Type) -> Type -> Type)

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

Defined in Data.HFunctor.Interpret

Associated Types

type C (ReaderT r) :: (Type -> Type) -> Constraint

Methods

retract :: C (ReaderT r) f => ReaderT r f ~> f

interpret :: C (ReaderT r) g => (f ~> g) -> ReaderT r f ~> g

Monad m => Monad (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

(>>=) :: ReaderT r m a -> (a -> ReaderT r m b) -> ReaderT r m b

(>>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b

return :: a -> ReaderT r m a

fail :: String -> ReaderT r m a

Functor m => Functor (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

fmap :: (a -> b) -> ReaderT r m a -> ReaderT r m b

(<$) :: a -> ReaderT r m b -> ReaderT r m a

MonadFix m => MonadFix (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

mfix :: (a -> ReaderT r m a) -> ReaderT r m a

MonadFail m => MonadFail (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

fail :: String -> ReaderT r m a

Applicative m => Applicative (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

pure :: a -> ReaderT r m a

(<*>) :: ReaderT r m (a -> b) -> ReaderT r m a -> ReaderT r m b

liftA2 :: (a -> b -> c) -> ReaderT r m a -> ReaderT r m b -> ReaderT r m c

(*>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b

(<*) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m a

Contravariant m => Contravariant (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

contramap :: (a -> b) -> ReaderT r m b -> ReaderT r m a

(>$) :: b -> ReaderT r m b -> ReaderT r m a

Representable m => Representable (ReaderT e m)

Defined in Data.Functor.Rep

Associated Types

type Rep (ReaderT e m) :: Type

Methods

tabulate :: (Rep (ReaderT e m) -> a) -> ReaderT e m a

index :: ReaderT e m a -> Rep (ReaderT e m) -> a

Alternative m => Alternative (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

empty :: ReaderT r m a

(<|>) :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a

some :: ReaderT r m a -> ReaderT r m [a]

many :: ReaderT r m a -> ReaderT r m [a]

MonadPlus m => MonadPlus (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

mzero :: ReaderT r m a

mplus :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a

MonadZip m => MonadZip (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

mzip :: ReaderT r m a -> ReaderT r m b -> ReaderT r m (a, b)

mzipWith :: (a -> b -> c) -> ReaderT r m a -> ReaderT r m b -> ReaderT r m c

munzip :: ReaderT r m (a, b) -> (ReaderT r m a, ReaderT r m b)

MonadIO m => MonadIO (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

liftIO :: IO a -> ReaderT r m a

Apply m => Apply (ReaderT e m)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: ReaderT e m (a -> b) -> ReaderT e m a -> ReaderT e m b

(.>) :: ReaderT e m a -> ReaderT e m b -> ReaderT e m b

(<.) :: ReaderT e m a -> ReaderT e m b -> ReaderT e m a

liftF2 :: (a -> b -> c) -> ReaderT e m a -> ReaderT e m b -> ReaderT e m c

Pointed m => Pointed (ReaderT r m)

Defined in Data.Pointed

Methods

point :: a -> ReaderT r m a

PrimMonad m => PrimMonad (ReaderT r m)

Defined in Control.Monad.Primitive

Associated Types

type PrimState (ReaderT r m) :: Type

Methods

primitive :: (State# (PrimState (ReaderT r m)) -> (#State# (PrimState (ReaderT r m)), a#)) -> ReaderT r m a

Plus f => Plus (ReaderT e f)

Defined in Data.Functor.Plus

Methods

zero :: ReaderT e f a

Alt f => Alt (ReaderT e f)

Defined in Data.Functor.Alt

Methods

(<!>) :: ReaderT e f a -> ReaderT e f a -> ReaderT e f a

some :: Applicative (ReaderT e f) => ReaderT e f a -> ReaderT e f [a]

many :: Applicative (ReaderT e f) => ReaderT e f a -> ReaderT e f [a]

Bind m => Bind (ReaderT e m)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: ReaderT e m a -> (a -> ReaderT e m b) -> ReaderT e m b

join :: ReaderT e m (ReaderT e m a) -> ReaderT e m a

type C (ReaderT r :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Interpret

type C (ReaderT r :: (Type -> Type) -> Type -> Type) = MonadReader r

type Rep (ReaderT e m)

Defined in Data.Functor.Rep

type Rep (ReaderT e m) = (e, Rep m)

type PrimState (ReaderT r m)

Defined in Control.Monad.Primitive

type PrimState (ReaderT r m) = PrimState m

data Flagged f a

An f a, along with a Bool flag

Flagged f a ~ (Bool, f a)
Flagged f   ~ ((,) Bool) :.: f       -- functor composition

Creation with inject or pure uses False as the boolean.

You can think of it as an f a that is "flagged" with a boolean value, and that value can indicuate whether or not it is "pure" (made with inject or pure) as False, or "impure" (made from some other source) as True. However, False may be always created directly, of course, using the constructor.

You can think of it like a Step that is either 0 or 1, as well.

interpreting it requires no constraint on the target context.

This type is equivalent (along with its instances) to:

• HLift IdentityT

• EnvT Any

Constructors

Flagged

Fields

• flaggedFlag :: Bool
• flaggedVal :: f a

Instances

HFunctor (Flagged :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Flagged f ~> Flagged g

HBind (Flagged :: (k -> Type) -> k -> Type)

Equivalent to instance for EnvT Any and HLift IdentityT.

Defined in Data.HFunctor

Methods

hbind :: (f ~> Flagged g) -> Flagged f ~> Flagged g

hjoin :: Flagged (Flagged f) ~> Flagged f

Inject (Flagged :: (k -> Type) -> k -> Type)

Injects with False.

Equivalent to instance for EnvT Any and HLift IdentityT.

Defined in Data.HFunctor

Methods

inject :: f ~> Flagged f

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

Equivalent to instance for EnvT Any and HLift IdentityT.

Defined in Data.HFunctor.Interpret

Associated Types

type C Flagged :: (Type -> Type) -> Constraint

Methods

retract :: C Flagged f => Flagged f ~> f

interpret :: C Flagged g => (f ~> g) -> Flagged f ~> g

Functor f => Functor (Flagged f)

Defined in Control.Applicative.Step

Methods

fmap :: (a -> b) -> Flagged f a -> Flagged f b

(<$) :: a -> Flagged f b -> Flagged f a

Applicative f => Applicative (Flagged f)

Uses False for pure, and || for <*>.

Defined in Control.Applicative.Step

Methods

pure :: a -> Flagged f a

(<*>) :: Flagged f (a -> b) -> Flagged f a -> Flagged f b

liftA2 :: (a -> b -> c) -> Flagged f a -> Flagged f b -> Flagged f c

(*>) :: Flagged f a -> Flagged f b -> Flagged f b

(<*) :: Flagged f a -> Flagged f b -> Flagged f a

Foldable f => Foldable (Flagged f)

Defined in Control.Applicative.Step

Methods

fold :: Monoid m => Flagged f m -> m

foldMap :: Monoid m => (a -> m) -> Flagged f a -> m

foldr :: (a -> b -> b) -> b -> Flagged f a -> b

foldr' :: (a -> b -> b) -> b -> Flagged f a -> b

foldl :: (b -> a -> b) -> b -> Flagged f a -> b

foldl' :: (b -> a -> b) -> b -> Flagged f a -> b

foldr1 :: (a -> a -> a) -> Flagged f a -> a

foldl1 :: (a -> a -> a) -> Flagged f a -> a

toList :: Flagged f a -> [a]

null :: Flagged f a -> Bool

length :: Flagged f a -> Int

elem :: Eq a => a -> Flagged f a -> Bool

maximum :: Ord a => Flagged f a -> a

minimum :: Ord a => Flagged f a -> a

sum :: Num a => Flagged f a -> a

product :: Num a => Flagged f a -> a

Traversable f => Traversable (Flagged f)

Defined in Control.Applicative.Step

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Flagged f a -> f0 (Flagged f b)

sequenceA :: Applicative f0 => Flagged f (f0 a) -> f0 (Flagged f a)

mapM :: Monad m => (a -> m b) -> Flagged f a -> m (Flagged f b)

sequence :: Monad m => Flagged f (m a) -> m (Flagged f a)

Eq1 f => Eq1 (Flagged f)

Defined in Control.Applicative.Step

Methods

liftEq :: (a -> b -> Bool) -> Flagged f a -> Flagged f b -> Bool

Ord1 f => Ord1 (Flagged f)

Defined in Control.Applicative.Step

Methods

liftCompare :: (a -> b -> Ordering) -> Flagged f a -> Flagged f b -> Ordering

Read1 f => Read1 (Flagged f)

Defined in Control.Applicative.Step

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Flagged f a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Flagged f a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Flagged f a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Flagged f a]

Show1 f => Show1 (Flagged f)

Defined in Control.Applicative.Step

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Flagged f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Flagged f a] -> ShowS

Foldable1 f => Foldable1 (Flagged f)

Defined in Control.Applicative.Step

Methods

fold1 :: Semigroup m => Flagged f m -> m

foldMap1 :: Semigroup m => (a -> m) -> Flagged f a -> m

toNonEmpty :: Flagged f a -> NonEmpty a

Pointed f => Pointed (Flagged f)

Uses False for point.

Defined in Control.Applicative.Step

Methods

point :: a -> Flagged f a

Traversable1 f => Traversable1 (Flagged f)

Defined in Control.Applicative.Step

Methods

traverse1 :: Apply f0 => (a -> f0 b) -> Flagged f a -> f0 (Flagged f b)

sequence1 :: Apply f0 => Flagged f (f0 b) -> f0 (Flagged f b)

Eq (f a) => Eq (Flagged f a)

Defined in Control.Applicative.Step

Methods

(==) :: Flagged f a -> Flagged f a -> Bool

(/=) :: Flagged f a -> Flagged f a -> Bool

(Typeable a, Typeable f, Typeable k, Data (f a)) => Data (Flagged f a)

Defined in Control.Applicative.Step

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Flagged f a -> c (Flagged f a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Flagged f a)

toConstr :: Flagged f a -> Constr

dataTypeOf :: Flagged f a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Flagged f a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Flagged f a))

gmapT :: (forall b. Data b => b -> b) -> Flagged f a -> Flagged f a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flagged f a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Flagged f a -> r

gmapQ :: (forall d. Data d => d -> u) -> Flagged f a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Flagged f a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Flagged f a -> m (Flagged f a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Flagged f a -> m (Flagged f a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Flagged f a -> m (Flagged f a)

Ord (f a) => Ord (Flagged f a)

Defined in Control.Applicative.Step

Methods

compare :: Flagged f a -> Flagged f a -> Ordering

(<) :: Flagged f a -> Flagged f a -> Bool

(<=) :: Flagged f a -> Flagged f a -> Bool

(>) :: Flagged f a -> Flagged f a -> Bool

(>=) :: Flagged f a -> Flagged f a -> Bool

max :: Flagged f a -> Flagged f a -> Flagged f a

min :: Flagged f a -> Flagged f a -> Flagged f a

Read (f a) => Read (Flagged f a)

Defined in Control.Applicative.Step

Methods

readsPrec :: Int -> ReadS (Flagged f a)

readList :: ReadS [Flagged f a]

readPrec :: ReadPrec (Flagged f a)

readListPrec :: ReadPrec [Flagged f a]

Show (f a) => Show (Flagged f a)

Defined in Control.Applicative.Step

Methods

showsPrec :: Int -> Flagged f a -> ShowS

show :: Flagged f a -> String

showList :: [Flagged f a] -> ShowS

Generic (Flagged f a)

Defined in Control.Applicative.Step

Associated Types

type Rep (Flagged f a) :: Type -> Type

Methods

from :: Flagged f a -> Rep (Flagged f a) x

to :: Rep (Flagged f a) x -> Flagged f a

type C (Flagged :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Interpret

type C (Flagged :: (Type -> Type) -> Type -> Type) = (Unconstrained :: (Type -> Type) -> Constraint)

type Rep (Flagged f a)

Defined in Control.Applicative.Step

type Rep (Flagged f a) = D1 (MetaData "Flagged" "Control.Applicative.Step" "functor-combinators-0.1.1.1-B2oyFu2GVTM8ySAuzVPoNk" False) (C1 (MetaCons "Flagged" PrefixI True) (S1 (MetaSel (Just "flaggedFlag") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool) :*: S1 (MetaSel (Just "flaggedVal") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f a))))

newtype IdentityT (f :: k -> Type) (a :: k) :: forall k. (k -> Type) -> k -> Type

The trivial monad transformer, which maps a monad to an equivalent monad.

Constructors

IdentityT

Fields

• runIdentityT :: f a

Instances

HFunctor (IdentityT :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> IdentityT f ~> IdentityT g

HBind (IdentityT :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

hbind :: (f ~> IdentityT g) -> IdentityT f ~> IdentityT g

hjoin :: IdentityT (IdentityT f) ~> IdentityT f

Inject (IdentityT :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

inject :: f ~> IdentityT f

MonadReader r m => MonadReader r (IdentityT m)

Defined in Control.Monad.Reader.Class

Methods

ask :: IdentityT m r

local :: (r -> r) -> IdentityT m a -> IdentityT m a

reader :: (r -> a) -> IdentityT m a

(Functor f, MonadFree f m) => MonadFree f (IdentityT m)

Defined in Control.Monad.Free.Class

Methods

wrap :: f (IdentityT m a) -> IdentityT m a

MonadTrans (IdentityT :: (Type -> Type) -> Type -> Type)

Defined in Control.Monad.Trans.Identity

Methods

lift :: Monad m => m a -> IdentityT m a

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

A free Unconstrained

Defined in Data.HFunctor.Interpret

Associated Types

type C IdentityT :: (Type -> Type) -> Constraint

Methods

retract :: C IdentityT f => IdentityT f ~> f

interpret :: C IdentityT g => (f ~> g) -> IdentityT f ~> g

FreeOf (Unconstrained :: (Type -> Type) -> Constraint) (IdentityT :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Final

Methods

fromFree :: IdentityT f ~> Final Unconstrained f

toFree :: Functor f => Final Unconstrained f ~> IdentityT f

Monad m => Monad (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

(>>=) :: IdentityT m a -> (a -> IdentityT m b) -> IdentityT m b

(>>) :: IdentityT m a -> IdentityT m b -> IdentityT m b

return :: a -> IdentityT m a

fail :: String -> IdentityT m a

Functor m => Functor (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

fmap :: (a -> b) -> IdentityT m a -> IdentityT m b

(<$) :: a -> IdentityT m b -> IdentityT m a

MonadFix m => MonadFix (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

mfix :: (a -> IdentityT m a) -> IdentityT m a

MonadFail m => MonadFail (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

fail :: String -> IdentityT m a

Applicative m => Applicative (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

pure :: a -> IdentityT m a

(<*>) :: IdentityT m (a -> b) -> IdentityT m a -> IdentityT m b

liftA2 :: (a -> b -> c) -> IdentityT m a -> IdentityT m b -> IdentityT m c

(*>) :: IdentityT m a -> IdentityT m b -> IdentityT m b

(<*) :: IdentityT m a -> IdentityT m b -> IdentityT m a

Foldable f => Foldable (IdentityT f)

Defined in Control.Monad.Trans.Identity

Methods

fold :: Monoid m => IdentityT f m -> m

foldMap :: Monoid m => (a -> m) -> IdentityT f a -> m

foldr :: (a -> b -> b) -> b -> IdentityT f a -> b

foldr' :: (a -> b -> b) -> b -> IdentityT f a -> b

foldl :: (b -> a -> b) -> b -> IdentityT f a -> b

foldl' :: (b -> a -> b) -> b -> IdentityT f a -> b

foldr1 :: (a -> a -> a) -> IdentityT f a -> a

foldl1 :: (a -> a -> a) -> IdentityT f a -> a

toList :: IdentityT f a -> [a]

null :: IdentityT f a -> Bool

length :: IdentityT f a -> Int

elem :: Eq a => a -> IdentityT f a -> Bool

maximum :: Ord a => IdentityT f a -> a

minimum :: Ord a => IdentityT f a -> a

sum :: Num a => IdentityT f a -> a

product :: Num a => IdentityT f a -> a

Traversable f => Traversable (IdentityT f)

Defined in Control.Monad.Trans.Identity

Methods

traverse :: Applicative f0 => (a -> f0 b) -> IdentityT f a -> f0 (IdentityT f b)

sequenceA :: Applicative f0 => IdentityT f (f0 a) -> f0 (IdentityT f a)

mapM :: Monad m => (a -> m b) -> IdentityT f a -> m (IdentityT f b)

sequence :: Monad m => IdentityT f (m a) -> m (IdentityT f a)

Contravariant f => Contravariant (IdentityT f)

Defined in Control.Monad.Trans.Identity

Methods

contramap :: (a -> b) -> IdentityT f b -> IdentityT f a

(>$) :: b -> IdentityT f b -> IdentityT f a

Representable m => Representable (IdentityT m)

Defined in Data.Functor.Rep

Associated Types

type Rep (IdentityT m) :: Type

Methods

tabulate :: (Rep (IdentityT m) -> a) -> IdentityT m a

index :: IdentityT m a -> Rep (IdentityT m) -> a

Alternative m => Alternative (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

empty :: IdentityT m a

(<|>) :: IdentityT m a -> IdentityT m a -> IdentityT m a

some :: IdentityT m a -> IdentityT m [a]

many :: IdentityT m a -> IdentityT m [a]

MonadPlus m => MonadPlus (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

mzero :: IdentityT m a

mplus :: IdentityT m a -> IdentityT m a -> IdentityT m a

Eq1 f => Eq1 (IdentityT f)

Defined in Control.Monad.Trans.Identity

Methods

liftEq :: (a -> b -> Bool) -> IdentityT f a -> IdentityT f b -> Bool

Ord1 f => Ord1 (IdentityT f)

Defined in Control.Monad.Trans.Identity

Methods

liftCompare :: (a -> b -> Ordering) -> IdentityT f a -> IdentityT f b -> Ordering

Read1 f => Read1 (IdentityT f)

Defined in Control.Monad.Trans.Identity

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (IdentityT f a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [IdentityT f a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (IdentityT f a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [IdentityT f a]

Show1 f => Show1 (IdentityT f)

Defined in Control.Monad.Trans.Identity

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> IdentityT f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [IdentityT f a] -> ShowS

MonadZip m => MonadZip (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

mzip :: IdentityT m a -> IdentityT m b -> IdentityT m (a, b)

mzipWith :: (a -> b -> c) -> IdentityT m a -> IdentityT m b -> IdentityT m c

munzip :: IdentityT m (a, b) -> (IdentityT m a, IdentityT m b)

MonadIO m => MonadIO (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

liftIO :: IO a -> IdentityT m a

Comonad w => Comonad (IdentityT w)

Defined in Control.Comonad

Methods

extract :: IdentityT w a -> a

duplicate :: IdentityT w a -> IdentityT w (IdentityT w a)

extend :: (IdentityT w a -> b) -> IdentityT w a -> IdentityT w b

ComonadApply w => ComonadApply (IdentityT w)

Defined in Control.Comonad

Methods

(<@>) :: IdentityT w (a -> b) -> IdentityT w a -> IdentityT w b

(@>) :: IdentityT w a -> IdentityT w b -> IdentityT w b

(<@) :: IdentityT w a -> IdentityT w b -> IdentityT w a

Foldable1 m => Foldable1 (IdentityT m)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m0 => IdentityT m m0 -> m0

foldMap1 :: Semigroup m0 => (a -> m0) -> IdentityT m a -> m0

toNonEmpty :: IdentityT m a -> NonEmpty a

Apply w => Apply (IdentityT w)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: IdentityT w (a -> b) -> IdentityT w a -> IdentityT w b

(.>) :: IdentityT w a -> IdentityT w b -> IdentityT w b

(<.) :: IdentityT w a -> IdentityT w b -> IdentityT w a

liftF2 :: (a -> b -> c) -> IdentityT w a -> IdentityT w b -> IdentityT w c

Pointed m => Pointed (IdentityT m)

Defined in Data.Pointed

Methods

point :: a -> IdentityT m a

PrimMonad m => PrimMonad (IdentityT m)

Defined in Control.Monad.Primitive

Associated Types

type PrimState (IdentityT m) :: Type

Methods

primitive :: (State# (PrimState (IdentityT m)) -> (#State# (PrimState (IdentityT m)), a#)) -> IdentityT m a

PrimBase m => PrimBase (IdentityT m)

Since: primitive-0.6.2.0

Defined in Control.Monad.Primitive

Methods

internal :: IdentityT m a -> State# (PrimState (IdentityT m)) -> (#State# (PrimState (IdentityT m)), a#)

Traversable1 f => Traversable1 (IdentityT f)

Defined in Data.Semigroup.Traversable.Class

Methods

traverse1 :: Apply f0 => (a -> f0 b) -> IdentityT f a -> f0 (IdentityT f b)

sequence1 :: Apply f0 => IdentityT f (f0 b) -> f0 (IdentityT f b)

Plus f => Plus (IdentityT f)

Defined in Data.Functor.Plus

Methods

zero :: IdentityT f a

Alt f => Alt (IdentityT f)

Defined in Data.Functor.Alt

Methods

(<!>) :: IdentityT f a -> IdentityT f a -> IdentityT f a

some :: Applicative (IdentityT f) => IdentityT f a -> IdentityT f [a]

many :: Applicative (IdentityT f) => IdentityT f a -> IdentityT f [a]

Bind m => Bind (IdentityT m)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: IdentityT m a -> (a -> IdentityT m b) -> IdentityT m b

join :: IdentityT m (IdentityT m a) -> IdentityT m a

(Eq1 f, Eq a) => Eq (IdentityT f a)

Defined in Control.Monad.Trans.Identity

Methods

(==) :: IdentityT f a -> IdentityT f a -> Bool

(/=) :: IdentityT f a -> IdentityT f a -> Bool

(Ord1 f, Ord a) => Ord (IdentityT f a)

Defined in Control.Monad.Trans.Identity

Methods

compare :: IdentityT f a -> IdentityT f a -> Ordering

(<) :: IdentityT f a -> IdentityT f a -> Bool

(<=) :: IdentityT f a -> IdentityT f a -> Bool

(>) :: IdentityT f a -> IdentityT f a -> Bool

(>=) :: IdentityT f a -> IdentityT f a -> Bool

max :: IdentityT f a -> IdentityT f a -> IdentityT f a

min :: IdentityT f a -> IdentityT f a -> IdentityT f a

(Read1 f, Read a) => Read (IdentityT f a)

Defined in Control.Monad.Trans.Identity

Methods

readsPrec :: Int -> ReadS (IdentityT f a)

readList :: ReadS [IdentityT f a]

readPrec :: ReadPrec (IdentityT f a)

readListPrec :: ReadPrec [IdentityT f a]

(Show1 f, Show a) => Show (IdentityT f a)

Defined in Control.Monad.Trans.Identity

Methods

showsPrec :: Int -> IdentityT f a -> ShowS

show :: IdentityT f a -> String

showList :: [IdentityT f a] -> ShowS

type C (IdentityT :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Interpret

type C (IdentityT :: (Type -> Type) -> Type -> Type) = (Unconstrained :: (Type -> Type) -> Constraint)

type Rep (IdentityT m)

Defined in Data.Functor.Rep

type Rep (IdentityT m) = Rep m

type PrimState (IdentityT m)

Defined in Control.Monad.Primitive

type PrimState (IdentityT m) = PrimState m

data Void2 a b

Void2 a b is uninhabited for all a and b.

Instances

HFunctor (Void2 :: (k1 -> Type) -> k2 -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Void2 f ~> Void2 g

Functor (Void2 a :: Type -> Type)

Defined in Control.Applicative.Step

Methods

fmap :: (a0 -> b) -> Void2 a a0 -> Void2 a b

(<$) :: a0 -> Void2 a b -> Void2 a a0

Foldable (Void2 a :: Type -> Type)

Defined in Control.Applicative.Step

Methods

fold :: Monoid m => Void2 a m -> m

foldMap :: Monoid m => (a0 -> m) -> Void2 a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Void2 a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Void2 a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Void2 a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Void2 a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Void2 a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Void2 a a0 -> a0

toList :: Void2 a a0 -> [a0]

null :: Void2 a a0 -> Bool

length :: Void2 a a0 -> Int

elem :: Eq a0 => a0 -> Void2 a a0 -> Bool

maximum :: Ord a0 => Void2 a a0 -> a0

minimum :: Ord a0 => Void2 a a0 -> a0

sum :: Num a0 => Void2 a a0 -> a0

product :: Num a0 => Void2 a a0 -> a0

Traversable (Void2 a :: Type -> Type)

Defined in Control.Applicative.Step

Methods

traverse :: Applicative f => (a0 -> f b) -> Void2 a a0 -> f (Void2 a b)

sequenceA :: Applicative f => Void2 a (f a0) -> f (Void2 a a0)

mapM :: Monad m => (a0 -> m b) -> Void2 a a0 -> m (Void2 a b)

sequence :: Monad m => Void2 a (m a0) -> m (Void2 a a0)

Eq1 (Void2 a :: Type -> Type)

Defined in Control.Applicative.Step

Methods

liftEq :: (a0 -> b -> Bool) -> Void2 a a0 -> Void2 a b -> Bool

Ord1 (Void2 a :: Type -> Type)

Defined in Control.Applicative.Step

Methods

liftCompare :: (a0 -> b -> Ordering) -> Void2 a a0 -> Void2 a b -> Ordering

Read1 (Void2 a :: Type -> Type)

Defined in Control.Applicative.Step

Methods

liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Void2 a a0)

liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Void2 a a0]

liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Void2 a a0)

liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Void2 a a0]

Show1 (Void2 a :: Type -> Type)

Defined in Control.Applicative.Step

Methods

liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> Void2 a a0 -> ShowS

liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [Void2 a a0] -> ShowS

Apply (Void2 a :: Type -> Type)

Defined in Control.Applicative.Step

Methods

(<.>) :: Void2 a (a0 -> b) -> Void2 a a0 -> Void2 a b

(.>) :: Void2 a a0 -> Void2 a b -> Void2 a b

(<.) :: Void2 a a0 -> Void2 a b -> Void2 a a0

liftF2 :: (a0 -> b -> c) -> Void2 a a0 -> Void2 a b -> Void2 a c

Alt (Void2 a :: Type -> Type)

Defined in Control.Applicative.Step

Methods

(<!>) :: Void2 a a0 -> Void2 a a0 -> Void2 a a0

some :: Applicative (Void2 a) => Void2 a a0 -> Void2 a [a0]

many :: Applicative (Void2 a) => Void2 a a0 -> Void2 a [a0]

Bind (Void2 a :: Type -> Type)

Defined in Control.Applicative.Step

Methods

(>>-) :: Void2 a a0 -> (a0 -> Void2 a b) -> Void2 a b

join :: Void2 a (Void2 a a0) -> Void2 a a0

Eq (Void2 a b)

Defined in Control.Applicative.Step

Methods

(==) :: Void2 a b -> Void2 a b -> Bool

(/=) :: Void2 a b -> Void2 a b -> Bool

(Typeable a, Typeable b, Typeable k1, Typeable k2) => Data (Void2 a b)

Defined in Control.Applicative.Step

Methods

gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Void2 a b -> c (Void2 a b)

gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Void2 a b)

toConstr :: Void2 a b -> Constr

dataTypeOf :: Void2 a b -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Void2 a b))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Void2 a b))

gmapT :: (forall b0. Data b0 => b0 -> b0) -> Void2 a b -> Void2 a b

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Void2 a b -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Void2 a b -> r

gmapQ :: (forall d. Data d => d -> u) -> Void2 a b -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Void2 a b -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Void2 a b -> m (Void2 a b)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Void2 a b -> m (Void2 a b)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Void2 a b -> m (Void2 a b)

Ord (Void2 a b)

Defined in Control.Applicative.Step

Methods

compare :: Void2 a b -> Void2 a b -> Ordering

(<) :: Void2 a b -> Void2 a b -> Bool

(<=) :: Void2 a b -> Void2 a b -> Bool

(>) :: Void2 a b -> Void2 a b -> Bool

(>=) :: Void2 a b -> Void2 a b -> Bool

max :: Void2 a b -> Void2 a b -> Void2 a b

min :: Void2 a b -> Void2 a b -> Void2 a b

Read (Void2 a b)

Defined in Control.Applicative.Step

Methods

readsPrec :: Int -> ReadS (Void2 a b)

readList :: ReadS [Void2 a b]

readPrec :: ReadPrec (Void2 a b)

readListPrec :: ReadPrec [Void2 a b]

Show (Void2 a b)

Defined in Control.Applicative.Step

Methods

showsPrec :: Int -> Void2 a b -> ShowS

show :: Void2 a b -> String

showList :: [Void2 a b] -> ShowS

Generic (Void2 a b)

Defined in Control.Applicative.Step

Associated Types

type Rep (Void2 a b) :: Type -> Type

Methods

from :: Void2 a b -> Rep (Void2 a b) x

to :: Rep (Void2 a b) x -> Void2 a b

Semigroup (Void2 a b)

Defined in Control.Applicative.Step

Methods

(<>) :: Void2 a b -> Void2 a b -> Void2 a b

sconcat :: NonEmpty (Void2 a b) -> Void2 a b

stimes :: Integral b0 => b0 -> Void2 a b -> Void2 a b

type Rep (Void2 a b)

Defined in Control.Applicative.Step

type Rep (Void2 a b) = D1 (MetaData "Void2" "Control.Applicative.Step" "functor-combinators-0.1.1.1-B2oyFu2GVTM8ySAuzVPoNk" False) (V1 :: Type -> Type)

newtype Final c f a

A simple way to inject/reject into any eventual typeclass.

In a way, this is the "ultimate" multi-purpose Interpret instance. You can use this to inject an f into a free structure of any typeclass. If you want f to have a Monad instance, for example, just use

inject :: f a -> Final Monad f a

When you want to eventually interpret out the data, use:

interpret :: (f ~> g) -> Final c f a -> g a

Essentially, Final c is the "free c". Final Monad is the free Monad, etc.

Final can theoretically replace Ap, Ap1, ListF, NonEmptyF, MaybeF, Free, Identity, Coyoneda, and other instances of FreeOf, if you don't care about being able to pattern match on explicit structure.

However, it cannot replace Interpret instances that are not free structures, like Step, Steps, Backwards, etc.

Note that this doesn't have instances for all the typeclasses you could lift things into; you probably have to define your own if you want to use Final c as an instance of c (using liftFinal0, liftFinal1, liftFinal2 for help).

Constructors

Final

Fields

• runFinal :: forall g. c g => (forall x. f x -> g x) -> g a

Instances

MonadReader r (Final (MonadReader r) f)

Defined in Data.HFunctor.Final

Methods

ask :: Final (MonadReader r) f r

local :: (r -> r) -> Final (MonadReader r) f a -> Final (MonadReader r) f a

reader :: (r -> a) -> Final (MonadReader r) f a

Interpret (Final c)

Defined in Data.HFunctor.Final

Associated Types

type C (Final c) :: (Type -> Type) -> Constraint

Methods

retract :: C (Final c) f => Final c f ~> f

interpret :: C (Final c) g => (f ~> g) -> Final c f ~> g

Inject (Final c :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Final

Methods

inject :: f ~> Final c f

HFunctor (Final c :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Final

Methods

hmap :: (f ~> g) -> Final c f ~> Final c g

Monad (Final Monad f)

Defined in Data.HFunctor.Final

Methods

(>>=) :: Final Monad f a -> (a -> Final Monad f b) -> Final Monad f b

(>>) :: Final Monad f a -> Final Monad f b -> Final Monad f b

return :: a -> Final Monad f a

fail :: String -> Final Monad f a

Monad (Final (MonadReader r) f)

Defined in Data.HFunctor.Final

Methods

(>>=) :: Final (MonadReader r) f a -> (a -> Final (MonadReader r) f b) -> Final (MonadReader r) f b

(>>) :: Final (MonadReader r) f a -> Final (MonadReader r) f b -> Final (MonadReader r) f b

return :: a -> Final (MonadReader r) f a

fail :: String -> Final (MonadReader r) f a

Monad (Final MonadPlus f)

Defined in Data.HFunctor.Final

Methods

(>>=) :: Final MonadPlus f a -> (a -> Final MonadPlus f b) -> Final MonadPlus f b

(>>) :: Final MonadPlus f a -> Final MonadPlus f b -> Final MonadPlus f b

return :: a -> Final MonadPlus f a

fail :: String -> Final MonadPlus f a

Functor (Final Monad f)

Defined in Data.HFunctor.Final

Methods

fmap :: (a -> b) -> Final Monad f a -> Final Monad f b

(<$) :: a -> Final Monad f b -> Final Monad f a

Functor (Final Functor f)

Defined in Data.HFunctor.Final

Methods

fmap :: (a -> b) -> Final Functor f a -> Final Functor f b

(<$) :: a -> Final Functor f b -> Final Functor f a

Functor (Final Applicative f)

Defined in Data.HFunctor.Final

Methods

fmap :: (a -> b) -> Final Applicative f a -> Final Applicative f b

(<$) :: a -> Final Applicative f b -> Final Applicative f a

Functor (Final (MonadReader r) f)

Defined in Data.HFunctor.Final

Methods

fmap :: (a -> b) -> Final (MonadReader r) f a -> Final (MonadReader r) f b

(<$) :: a -> Final (MonadReader r) f b -> Final (MonadReader r) f a

Functor (Final Alternative f)

Defined in Data.HFunctor.Final

Methods

fmap :: (a -> b) -> Final Alternative f a -> Final Alternative f b

(<$) :: a -> Final Alternative f b -> Final Alternative f a

Functor (Final MonadPlus f)

Defined in Data.HFunctor.Final

Methods

fmap :: (a -> b) -> Final MonadPlus f a -> Final MonadPlus f b

(<$) :: a -> Final MonadPlus f b -> Final MonadPlus f a

Functor (Final Apply f)

Defined in Data.HFunctor.Final

Methods

fmap :: (a -> b) -> Final Apply f a -> Final Apply f b

(<$) :: a -> Final Apply f b -> Final Apply f a

Functor (Final Plus f)

Defined in Data.HFunctor.Final

Methods

fmap :: (a -> b) -> Final Plus f a -> Final Plus f b

(<$) :: a -> Final Plus f b -> Final Plus f a

Functor (Final Alt f)

Defined in Data.HFunctor.Final

Methods

fmap :: (a -> b) -> Final Alt f a -> Final Alt f b

(<$) :: a -> Final Alt f b -> Final Alt f a

Functor (Final Bind f)

Defined in Data.HFunctor.Final

Methods

fmap :: (a -> b) -> Final Bind f a -> Final Bind f b

(<$) :: a -> Final Bind f b -> Final Bind f a

Applicative (Final Monad f)

Defined in Data.HFunctor.Final

Methods

pure :: a -> Final Monad f a

(<*>) :: Final Monad f (a -> b) -> Final Monad f a -> Final Monad f b

liftA2 :: (a -> b -> c) -> Final Monad f a -> Final Monad f b -> Final Monad f c

(*>) :: Final Monad f a -> Final Monad f b -> Final Monad f b

(<*) :: Final Monad f a -> Final Monad f b -> Final Monad f a

Applicative (Final Applicative f)

Defined in Data.HFunctor.Final

Methods

pure :: a -> Final Applicative f a

(<*>) :: Final Applicative f (a -> b) -> Final Applicative f a -> Final Applicative f b

liftA2 :: (a -> b -> c) -> Final Applicative f a -> Final Applicative f b -> Final Applicative f c

(*>) :: Final Applicative f a -> Final Applicative f b -> Final Applicative f b

(<*) :: Final Applicative f a -> Final Applicative f b -> Final Applicative f a

Applicative (Final (MonadReader r) f)

Defined in Data.HFunctor.Final

Methods

pure :: a -> Final (MonadReader r) f a

(<*>) :: Final (MonadReader r) f (a -> b) -> Final (MonadReader r) f a -> Final (MonadReader r) f b

liftA2 :: (a -> b -> c) -> Final (MonadReader r) f a -> Final (MonadReader r) f b -> Final (MonadReader r) f c

(*>) :: Final (MonadReader r) f a -> Final (MonadReader r) f b -> Final (MonadReader r) f b

(<*) :: Final (MonadReader r) f a -> Final (MonadReader r) f b -> Final (MonadReader r) f a

Applicative (Final Alternative f)

Defined in Data.HFunctor.Final

Methods

pure :: a -> Final Alternative f a

(<*>) :: Final Alternative f (a -> b) -> Final Alternative f a -> Final Alternative f b

liftA2 :: (a -> b -> c) -> Final Alternative f a -> Final Alternative f b -> Final Alternative f c

(*>) :: Final Alternative f a -> Final Alternative f b -> Final Alternative f b

(<*) :: Final Alternative f a -> Final Alternative f b -> Final Alternative f a

Applicative (Final MonadPlus f)

Defined in Data.HFunctor.Final

Methods

pure :: a -> Final MonadPlus f a

(<*>) :: Final MonadPlus f (a -> b) -> Final MonadPlus f a -> Final MonadPlus f b

liftA2 :: (a -> b -> c) -> Final MonadPlus f a -> Final MonadPlus f b -> Final MonadPlus f c

(*>) :: Final MonadPlus f a -> Final MonadPlus f b -> Final MonadPlus f b

(<*) :: Final MonadPlus f a -> Final MonadPlus f b -> Final MonadPlus f a

Alternative (Final Alternative f)

Defined in Data.HFunctor.Final

Methods

empty :: Final Alternative f a

(<|>) :: Final Alternative f a -> Final Alternative f a -> Final Alternative f a

some :: Final Alternative f a -> Final Alternative f [a]

many :: Final Alternative f a -> Final Alternative f [a]

Alternative (Final MonadPlus f)

Defined in Data.HFunctor.Final

Methods

empty :: Final MonadPlus f a

(<|>) :: Final MonadPlus f a -> Final MonadPlus f a -> Final MonadPlus f a

some :: Final MonadPlus f a -> Final MonadPlus f [a]

many :: Final MonadPlus f a -> Final MonadPlus f [a]

MonadPlus (Final MonadPlus f)

Defined in Data.HFunctor.Final

Methods

mzero :: Final MonadPlus f a

mplus :: Final MonadPlus f a -> Final MonadPlus f a -> Final MonadPlus f a

Apply (Final Monad f)

Defined in Data.HFunctor.Final

Methods

(<.>) :: Final Monad f (a -> b) -> Final Monad f a -> Final Monad f b

(.>) :: Final Monad f a -> Final Monad f b -> Final Monad f b

(<.) :: Final Monad f a -> Final Monad f b -> Final Monad f a

liftF2 :: (a -> b -> c) -> Final Monad f a -> Final Monad f b -> Final Monad f c

Apply (Final Applicative f)

Defined in Data.HFunctor.Final

Methods

(<.>) :: Final Applicative f (a -> b) -> Final Applicative f a -> Final Applicative f b

(.>) :: Final Applicative f a -> Final Applicative f b -> Final Applicative f b

(<.) :: Final Applicative f a -> Final Applicative f b -> Final Applicative f a

liftF2 :: (a -> b -> c) -> Final Applicative f a -> Final Applicative f b -> Final Applicative f c

Apply (Final (MonadReader r) f)

Defined in Data.HFunctor.Final

Methods

(<.>) :: Final (MonadReader r) f (a -> b) -> Final (MonadReader r) f a -> Final (MonadReader r) f b

(.>) :: Final (MonadReader r) f a -> Final (MonadReader r) f b -> Final (MonadReader r) f b

(<.) :: Final (MonadReader r) f a -> Final (MonadReader r) f b -> Final (MonadReader r) f a

liftF2 :: (a -> b -> c) -> Final (MonadReader r) f a -> Final (MonadReader r) f b -> Final (MonadReader r) f c

Apply (Final Alternative f)

Defined in Data.HFunctor.Final

Methods

(<.>) :: Final Alternative f (a -> b) -> Final Alternative f a -> Final Alternative f b

(.>) :: Final Alternative f a -> Final Alternative f b -> Final Alternative f b

(<.) :: Final Alternative f a -> Final Alternative f b -> Final Alternative f a

liftF2 :: (a -> b -> c) -> Final Alternative f a -> Final Alternative f b -> Final Alternative f c

Apply (Final Apply f)

Defined in Data.HFunctor.Final

Methods

(<.>) :: Final Apply f (a -> b) -> Final Apply f a -> Final Apply f b

(.>) :: Final Apply f a -> Final Apply f b -> Final Apply f b

(<.) :: Final Apply f a -> Final Apply f b -> Final Apply f a

liftF2 :: (a -> b -> c) -> Final Apply f a -> Final Apply f b -> Final Apply f c

Apply (Final Bind f)

Defined in Data.HFunctor.Final

Methods

(<.>) :: Final Bind f (a -> b) -> Final Bind f a -> Final Bind f b

(.>) :: Final Bind f a -> Final Bind f b -> Final Bind f b

(<.) :: Final Bind f a -> Final Bind f b -> Final Bind f a

liftF2 :: (a -> b -> c) -> Final Bind f a -> Final Bind f b -> Final Bind f c

Pointed (Final Pointed f)

Defined in Data.HFunctor.Final

Methods

point :: a -> Final Pointed f a

Plus (Final Plus f)

Defined in Data.HFunctor.Final

Methods

zero :: Final Plus f a

Alt (Final Plus f)

Defined in Data.HFunctor.Final

Methods

(<!>) :: Final Plus f a -> Final Plus f a -> Final Plus f a

some :: Applicative (Final Plus f) => Final Plus f a -> Final Plus f [a]

many :: Applicative (Final Plus f) => Final Plus f a -> Final Plus f [a]

Alt (Final Alt f)

Defined in Data.HFunctor.Final

Methods

(<!>) :: Final Alt f a -> Final Alt f a -> Final Alt f a

some :: Applicative (Final Alt f) => Final Alt f a -> Final Alt f [a]

many :: Applicative (Final Alt f) => Final Alt f a -> Final Alt f [a]

Bind (Final Bind f)

Defined in Data.HFunctor.Final

Methods

(>>-) :: Final Bind f a -> (a -> Final Bind f b) -> Final Bind f b

join :: Final Bind f (Final Bind f a) -> Final Bind f a

type C (Final c)

Defined in Data.HFunctor.Final

type C (Final c) = c

class Interpret t => FreeOf c t | t -> c where

A typeclass associating a free structure with the typeclass it is free on.

This essentially lists instances of Interpret where a "trip" through Final will leave it unchanged.

fromFree . toFree == id
toFree . fromFree == id

This can be useful because Final doesn't have a concrete structure that you can pattern match on and inspect, but t might. This lets you work on a concrete structure if you desire.

Minimal complete definition

Nothing

Methods

fromFree :: t f ~> Final c f

toFree :: Functor f => Final c f ~> t f

fromFree :: C t (Final c f) => t f ~> Final c f

toFree :: c (t f) => Final c f ~> t f

Instances

FreeOf Monad Free

Defined in Data.HFunctor.Final

Methods

fromFree :: Free f ~> Final Monad f

toFree :: Functor f => Final Monad f ~> Free f

FreeOf Functor Coyoneda

Defined in Data.HFunctor.Final

Methods

fromFree :: Coyoneda f ~> Final Functor f

toFree :: Functor f => Final Functor f ~> Coyoneda f

FreeOf Applicative Ap

Defined in Data.HFunctor.Final

Methods

fromFree :: Ap f ~> Final Applicative f

toFree :: Functor f => Final Applicative f ~> Ap f

FreeOf Applicative Ap

Defined in Data.HFunctor.Final

Methods

fromFree :: Ap f ~> Final Applicative f

toFree :: Functor f => Final Applicative f ~> Ap f

FreeOf Alternative Alt

Defined in Data.HFunctor.Final

Methods

fromFree :: Alt f ~> Final Alternative f

toFree :: Functor f => Final Alternative f ~> Alt f

FreeOf Apply Ap1

Defined in Data.HFunctor.Final

Methods

fromFree :: Ap1 f ~> Final Apply f

toFree :: Functor f => Final Apply f ~> Ap1 f

FreeOf Pointed MaybeApply

Defined in Data.HFunctor.Final

Methods

fromFree :: MaybeApply f ~> Final Pointed f

toFree :: Functor f => Final Pointed f ~> MaybeApply f

FreeOf Pointed Lift

Defined in Data.HFunctor.Final

Methods

fromFree :: Lift f ~> Final Pointed f

toFree :: Functor f => Final Pointed f ~> Lift f

FreeOf Plus ListF

Defined in Data.HFunctor.Final

Methods

fromFree :: ListF f ~> Final Plus f

toFree :: Functor f => Final Plus f ~> ListF f

FreeOf Alt NonEmptyF

Defined in Data.HFunctor.Final

Methods

fromFree :: NonEmptyF f ~> Final Alt f

toFree :: Functor f => Final Alt f ~> NonEmptyF f

FreeOf Bind Free1

Defined in Data.HFunctor.Final

Methods

fromFree :: Free1 f ~> Final Bind f

toFree :: Functor f => Final Bind f ~> Free1 f

FreeOf (Unconstrained :: (Type -> Type) -> Constraint) (IdentityT :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Final

Methods

fromFree :: IdentityT f ~> Final Unconstrained f

toFree :: Functor f => Final Unconstrained f ~> IdentityT f

newtype ComposeT (f :: (Type -> Type) -> Type -> Type) (g :: (Type -> Type) -> Type -> Type) (m :: Type -> Type) a infixr 9

Composition of monad transformers.

Constructors

ComposeT infixr 9

Fields

• getComposeT :: f (g m) a

Instances

MonadRWS r w s (f (g m)) => MonadRWS r w s (ComposeT f g m)

Defined in Control.Monad.Trans.Compose

MonadReader r (f (g m)) => MonadReader r (ComposeT f g m)

Defined in Control.Monad.Trans.Compose

Methods

ask :: ComposeT f g m r

local :: (r -> r) -> ComposeT f g m a -> ComposeT f g m a

reader :: (r -> a) -> ComposeT f g m a

MonadState s (f (g m)) => MonadState s (ComposeT f g m)

Defined in Control.Monad.Trans.Compose

Methods

get :: ComposeT f g m s

put :: s -> ComposeT f g m ()

state :: (s -> (a, s)) -> ComposeT f g m a

MonadWriter w (f (g m)) => MonadWriter w (ComposeT f g m)

Defined in Control.Monad.Trans.Compose

Methods

writer :: (a, w) -> ComposeT f g m a

tell :: w -> ComposeT f g m ()

listen :: ComposeT f g m a -> ComposeT f g m (a, w)

pass :: ComposeT f g m (a, w -> w) -> ComposeT f g m a

MonadError e (f (g m)) => MonadError e (ComposeT f g m)

Defined in Control.Monad.Trans.Compose

Methods

throwError :: e -> ComposeT f g m a

catchError :: ComposeT f g m a -> (e -> ComposeT f g m a) -> ComposeT f g m a

(HFunctor s, HFunctor t) => HFunctor (ComposeT s t :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> ComposeT s t f ~> ComposeT s t g

(MFunctor f, MFunctor g, forall (m :: Type -> Type). Monad m => Monad (g m)) => MFunctor (ComposeT f g :: (Type -> Type) -> Type -> Type)

Defined in Control.Monad.Trans.Compose

Methods

hoist :: Monad m => (forall a. m a -> n a) -> ComposeT f g m b -> ComposeT f g n b

(Inject s, Inject t) => Inject (ComposeT s t :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor

Methods

inject :: f ~> ComposeT s t f

(MFunctor f, MonadTrans f, MonadTrans g) => MonadTrans (ComposeT f g)

Defined in Control.Monad.Trans.Compose

Methods

lift :: Monad m => m a -> ComposeT f g m a

(Interpret s, Interpret t) => Interpret (ComposeT s t)

Defined in Data.HFunctor.Interpret

Associated Types

type C (ComposeT s t) :: (Type -> Type) -> Constraint

Methods

retract :: C (ComposeT s t) f => ComposeT s t f ~> f

interpret :: C (ComposeT s t) g => (f ~> g) -> ComposeT s t f ~> g

Monad (f (g m)) => Monad (ComposeT f g m)

Defined in Control.Monad.Trans.Compose

Methods

(>>=) :: ComposeT f g m a -> (a -> ComposeT f g m b) -> ComposeT f g m b

(>>) :: ComposeT f g m a -> ComposeT f g m b -> ComposeT f g m b

return :: a -> ComposeT f g m a

fail :: String -> ComposeT f g m a

Functor (f (g m)) => Functor (ComposeT f g m)

Defined in Control.Monad.Trans.Compose

Methods

fmap :: (a -> b) -> ComposeT f g m a -> ComposeT f g m b

(<$) :: a -> ComposeT f g m b -> ComposeT f g m a

MonadFail (f (g m)) => MonadFail (ComposeT f g m)

Defined in Control.Monad.Trans.Compose

Methods

fail :: String -> ComposeT f g m a

Applicative (f (g m)) => Applicative (ComposeT f g m)

Defined in Control.Monad.Trans.Compose

Methods

pure :: a -> ComposeT f g m a

(<*>) :: ComposeT f g m (a -> b) -> ComposeT f g m a -> ComposeT f g m b

liftA2 :: (a -> b -> c) -> ComposeT f g m a -> ComposeT f g m b -> ComposeT f g m c

(*>) :: ComposeT f g m a -> ComposeT f g m b -> ComposeT f g m b

(<*) :: ComposeT f g m a -> ComposeT f g m b -> ComposeT f g m a

Foldable (f (g m)) => Foldable (ComposeT f g m)

Defined in Control.Monad.Trans.Compose

Methods

fold :: Monoid m0 => ComposeT f g m m0 -> m0

foldMap :: Monoid m0 => (a -> m0) -> ComposeT f g m a -> m0

foldr :: (a -> b -> b) -> b -> ComposeT f g m a -> b

foldr' :: (a -> b -> b) -> b -> ComposeT f g m a -> b

foldl :: (b -> a -> b) -> b -> ComposeT f g m a -> b

foldl' :: (b -> a -> b) -> b -> ComposeT f g m a -> b

foldr1 :: (a -> a -> a) -> ComposeT f g m a -> a

foldl1 :: (a -> a -> a) -> ComposeT f g m a -> a

toList :: ComposeT f g m a -> [a]

null :: ComposeT f g m a -> Bool

length :: ComposeT f g m a -> Int

elem :: Eq a => a -> ComposeT f g m a -> Bool

maximum :: Ord a => ComposeT f g m a -> a

minimum :: Ord a => ComposeT f g m a -> a

sum :: Num a => ComposeT f g m a -> a

product :: Num a => ComposeT f g m a -> a

Traversable (f (g m)) => Traversable (ComposeT f g m)

Defined in Control.Monad.Trans.Compose

Methods

traverse :: Applicative f0 => (a -> f0 b) -> ComposeT f g m a -> f0 (ComposeT f g m b)

sequenceA :: Applicative f0 => ComposeT f g m (f0 a) -> f0 (ComposeT f g m a)

mapM :: Monad m0 => (a -> m0 b) -> ComposeT f g m a -> m0 (ComposeT f g m b)

sequence :: Monad m0 => ComposeT f g m (m0 a) -> m0 (ComposeT f g m a)

Alternative (f (g m)) => Alternative (ComposeT f g m)

Defined in Control.Monad.Trans.Compose

Methods

empty :: ComposeT f g m a

(<|>) :: ComposeT f g m a -> ComposeT f g m a -> ComposeT f g m a

some :: ComposeT f g m a -> ComposeT f g m [a]

many :: ComposeT f g m a -> ComposeT f g m [a]

MonadPlus (f (g m)) => MonadPlus (ComposeT f g m)

Defined in Control.Monad.Trans.Compose

Methods

mzero :: ComposeT f g m a

mplus :: ComposeT f g m a -> ComposeT f g m a -> ComposeT f g m a

MonadIO (f (g m)) => MonadIO (ComposeT f g m)

Defined in Control.Monad.Trans.Compose

Methods

liftIO :: IO a -> ComposeT f g m a

MonadCont (f (g m)) => MonadCont (ComposeT f g m)

Defined in Control.Monad.Trans.Compose

Methods

callCC :: ((a -> ComposeT f g m b) -> ComposeT f g m a) -> ComposeT f g m a

Eq (f (g m) a) => Eq (ComposeT f g m a)

Defined in Control.Monad.Trans.Compose

Methods

(==) :: ComposeT f g m a -> ComposeT f g m a -> Bool

(/=) :: ComposeT f g m a -> ComposeT f g m a -> Bool

Ord (f (g m) a) => Ord (ComposeT f g m a)

Defined in Control.Monad.Trans.Compose

Methods

compare :: ComposeT f g m a -> ComposeT f g m a -> Ordering

(<) :: ComposeT f g m a -> ComposeT f g m a -> Bool

(<=) :: ComposeT f g m a -> ComposeT f g m a -> Bool

(>) :: ComposeT f g m a -> ComposeT f g m a -> Bool

(>=) :: ComposeT f g m a -> ComposeT f g m a -> Bool

max :: ComposeT f g m a -> ComposeT f g m a -> ComposeT f g m a

min :: ComposeT f g m a -> ComposeT f g m a -> ComposeT f g m a

Read (f (g m) a) => Read (ComposeT f g m a)

Defined in Control.Monad.Trans.Compose

Methods

readsPrec :: Int -> ReadS (ComposeT f g m a)

readList :: ReadS [ComposeT f g m a]

readPrec :: ReadPrec (ComposeT f g m a)

readListPrec :: ReadPrec [ComposeT f g m a]

Show (f (g m) a) => Show (ComposeT f g m a)

Defined in Control.Monad.Trans.Compose

Methods

showsPrec :: Int -> ComposeT f g m a -> ShowS

show :: ComposeT f g m a -> String

showList :: [ComposeT f g m a] -> ShowS

type C (ComposeT s t)

Defined in Data.HFunctor.Interpret

type C (ComposeT s t) = AndC (C s) (C t)

Multi

data Day (f :: Type -> Type) (g :: Type -> Type) a where

The Day convolution of two covariant functors.

Constructors

Day :: forall (f :: Type -> Type) (g :: Type -> Type) a b c. f b -> g c -> (b -> c -> a) -> Day f g a

Instances

Semigroupoidal Day

Defined in Data.HBifunctor.Associative

Associated Types

type SF Day :: (Type -> Type) -> Type -> Type

Methods

appendSF :: Day (SF Day f) (SF Day f) ~> SF Day f

matchSF :: Functor f => SF Day f ~> (f :+: Day f (SF Day f))

consSF :: Day f (SF Day f) ~> SF Day f

toSF :: Day f f ~> SF Day f

biretract :: CS Day f => Day f f ~> f

binterpret :: CS Day h => (f ~> h) -> (g ~> h) -> Day f g ~> h

Associative Day

Defined in Data.HBifunctor.Associative

Methods

associating :: (Functor f, Functor g, Functor h) => Day f (Day g h) <~> Day (Day f g) h

Matchable Day

Defined in Data.HBifunctor.Tensor

Methods

unsplitSF :: Day f (MF Day f) ~> SF Day f

matchMF :: MF Day f ~> (I Day :+: SF Day f)

Monoidal Day

Defined in Data.HBifunctor.Tensor

Associated Types

type MF Day :: (Type -> Type) -> Type -> Type

Methods

appendMF :: Day (MF Day f) (MF Day f) ~> MF Day f

splitSF :: SF Day f ~> Day f (MF Day f)

splittingMF :: MF Day f <~> (I Day :+: Day f (MF Day f))

toMF :: Day f f ~> MF Day f

fromSF :: SF Day f ~> MF Day f

pureT :: CM Day f => I Day ~> f

upgradeC :: CM Day f => proxy f -> (CS Day f -> r) -> r

Tensor Day

Defined in Data.HBifunctor.Tensor

Associated Types

type I Day :: Type -> Type

Methods

intro1 :: f ~> Day f (I Day)

intro2 :: g ~> Day (I Day) g

elim1 :: Functor f => Day f (I Day) ~> f

elim2 :: Functor g => Day (I Day) g ~> g

Comonad f => ComonadTrans (Day f)

Defined in Data.Functor.Day

Methods

lower :: Comonad w => Day f w a -> w a

HFunctor (Day f :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f0 ~> g) -> Day f f0 ~> Day f g

HBifunctor Day

Defined in Data.HFunctor.Internal

Methods

hleft :: (f ~> j) -> Day f g ~> Day j g

hright :: (g ~> k) -> Day f g ~> Day f k

hbimap :: (f ~> j) -> (g ~> k) -> Day f g ~> Day j k

Functor (Day f g)

Defined in Data.Functor.Day

Methods

fmap :: (a -> b) -> Day f g a -> Day f g b

(<$) :: a -> Day f g b -> Day f g a

(Applicative f, Applicative g) => Applicative (Day f g)

Defined in Data.Functor.Day

Methods

pure :: a -> Day f g a

(<*>) :: Day f g (a -> b) -> Day f g a -> Day f g b

liftA2 :: (a -> b -> c) -> Day f g a -> Day f g b -> Day f g c

(*>) :: Day f g a -> Day f g b -> Day f g b

(<*) :: Day f g a -> Day f g b -> Day f g a

(Representable f, Representable g) => Distributive (Day f g)

Defined in Data.Functor.Day

Methods

distribute :: Functor f0 => f0 (Day f g a) -> Day f g (f0 a)

collect :: Functor f0 => (a -> Day f g b) -> f0 a -> Day f g (f0 b)

distributeM :: Monad m => m (Day f g a) -> Day f g (m a)

collectM :: Monad m => (a -> Day f g b) -> m a -> Day f g (m b)

(Representable f, Representable g) => Representable (Day f g)

Defined in Data.Functor.Day

Associated Types

type Rep (Day f g) :: Type

Methods

tabulate :: (Rep (Day f g) -> a) -> Day f g a

index :: Day f g a -> Rep (Day f g) -> a

(Comonad f, Comonad g) => Comonad (Day f g)

Defined in Data.Functor.Day

Methods

extract :: Day f g a -> a

duplicate :: Day f g a -> Day f g (Day f g a)

extend :: (Day f g a -> b) -> Day f g a -> Day f g b

(ComonadApply f, ComonadApply g) => ComonadApply (Day f g)

Defined in Data.Functor.Day

Methods

(<@>) :: Day f g (a -> b) -> Day f g a -> Day f g b

(@>) :: Day f g a -> Day f g b -> Day f g b

(<@) :: Day f g a -> Day f g b -> Day f g a

type SF Day

Defined in Data.HBifunctor.Associative

type SF Day = Ap1

type MF Day

Defined in Data.HBifunctor.Tensor

type MF Day = Ap

type I Day

Defined in Data.HBifunctor.Tensor

type I Day = Identity

type Rep (Day f g)

Defined in Data.Functor.Day

type Rep (Day f g) = (Rep f, Rep g)

data ((f :: k -> Type) :*: (g :: k -> Type)) (p :: k) :: forall k. (k -> Type) -> (k -> Type) -> k -> Type infixr 6

Products: encode multiple arguments to constructors

Constructors

(f p) :*: (g p) infixr 6

Instances

HBifunctor ((:*:) :: (k -> Type) -> (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hleft :: (f ~> j) -> (f :*: g) ~> (j :*: g)

hright :: (g ~> k0) -> (f :*: g) ~> (f :*: k0)

hbimap :: (f ~> j) -> (g ~> k0) -> (f :*: g) ~> (j :*: k0)

HFunctor ((:*:) f :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f0 ~> g) -> (f :*: f0) ~> (f :*: g)

Generic1 (f :*: g :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (f :*: g) :: k -> Type

Methods

from1 :: (f :*: g) a -> Rep1 (f :*: g) a

to1 :: Rep1 (f :*: g) a -> (f :*: g) a

Semigroupoidal ((:*:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Associated Types

type SF (:*:) :: (Type -> Type) -> Type -> Type

Methods

appendSF :: (SF (:*:) f :*: SF (:*:) f) ~> SF (:*:) f

matchSF :: Functor f => SF (:*:) f ~> (f :+: (f :*: SF (:*:) f))

consSF :: (f :*: SF (:*:) f) ~> SF (:*:) f

toSF :: (f :*: f) ~> SF (:*:) f

biretract :: CS (:*:) f => (f :*: f) ~> f

binterpret :: CS (:*:) h => (f ~> h) -> (g ~> h) -> (f :*: g) ~> h

Associative ((:*:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Methods

associating :: (Functor f, Functor g, Functor h) => (f :*: (g :*: h)) <~> ((f :*: g) :*: h)

Matchable ((:*:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Tensor

Methods

unsplitSF :: (f :*: MF (:*:) f) ~> SF (:*:) f

matchMF :: MF (:*:) f ~> (I (:*:) :+: SF (:*:) f)

Monoidal ((:*:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Tensor

Associated Types

type MF (:*:) :: (Type -> Type) -> Type -> Type

Methods

appendMF :: (MF (:*:) f :*: MF (:*:) f) ~> MF (:*:) f

splitSF :: SF (:*:) f ~> (f :*: MF (:*:) f)

splittingMF :: MF (:*:) f <~> (I (:*:) :+: (f :*: MF (:*:) f))

toMF :: (f :*: f) ~> MF (:*:) f

fromSF :: SF (:*:) f ~> MF (:*:) f

pureT :: CM (:*:) f => I (:*:) ~> f

upgradeC :: CM (:*:) f => proxy f -> (CS (:*:) f -> r) -> r

Tensor ((:*:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Tensor

Associated Types

type I (:*:) :: Type -> Type

Methods

intro1 :: f ~> (f :*: I (:*:))

intro2 :: g ~> (I (:*:) :*: g)

elim1 :: Functor f => (f :*: I (:*:)) ~> f

elim2 :: Functor g => (I (:*:) :*: g) ~> g

Plus f => HBind ((:*:) f :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor

Methods

hbind :: (f0 ~> (f :*: g)) -> (f :*: f0) ~> (f :*: g)

hjoin :: (f :*: (f :*: f0)) ~> (f :*: f0)

Plus f => Inject ((:*:) f :: (Type -> Type) -> Type -> Type)

Only uses zero

Defined in Data.HFunctor

Methods

inject :: f0 ~> (f :*: f0)

Plus f => Interpret ((:*:) f)

Defined in Data.HFunctor.Interpret

Associated Types

type C ((:*:) f) :: (Type -> Type) -> Constraint

Methods

retract :: C ((:*:) f) f0 => (f :*: f0) ~> f0

interpret :: C ((:*:) f) g => (f0 ~> g) -> (f :*: f0) ~> g

(Monad f, Monad g) => Monad (f :*: g)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(>>=) :: (f :*: g) a -> (a -> (f :*: g) b) -> (f :*: g) b

(>>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b

return :: a -> (f :*: g) a

fail :: String -> (f :*: g) a

(Functor f, Functor g) => Functor (f :*: g)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> (f :*: g) a -> (f :*: g) b

(<$) :: a -> (f :*: g) b -> (f :*: g) a

(MonadFix f, MonadFix g) => MonadFix (f :*: g)

Since: base-4.9.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> (f :*: g) a) -> (f :*: g) a

(Applicative f, Applicative g) => Applicative (f :*: g)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> (f :*: g) a

(<*>) :: (f :*: g) (a -> b) -> (f :*: g) a -> (f :*: g) b

liftA2 :: (a -> b -> c) -> (f :*: g) a -> (f :*: g) b -> (f :*: g) c

(*>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b

(<*) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) a

(Foldable f, Foldable g) => Foldable (f :*: g)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => (f :*: g) m -> m

foldMap :: Monoid m => (a -> m) -> (f :*: g) a -> m

foldr :: (a -> b -> b) -> b -> (f :*: g) a -> b

foldr' :: (a -> b -> b) -> b -> (f :*: g) a -> b

foldl :: (b -> a -> b) -> b -> (f :*: g) a -> b

foldl' :: (b -> a -> b) -> b -> (f :*: g) a -> b

foldr1 :: (a -> a -> a) -> (f :*: g) a -> a

foldl1 :: (a -> a -> a) -> (f :*: g) a -> a

toList :: (f :*: g) a -> [a]

null :: (f :*: g) a -> Bool

length :: (f :*: g) a -> Int

elem :: Eq a => a -> (f :*: g) a -> Bool

maximum :: Ord a => (f :*: g) a -> a

minimum :: Ord a => (f :*: g) a -> a

sum :: Num a => (f :*: g) a -> a

product :: Num a => (f :*: g) a -> a

(Traversable f, Traversable g) => Traversable (f :*: g)

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f0 => (a -> f0 b) -> (f :*: g) a -> f0 ((f :*: g) b)

sequenceA :: Applicative f0 => (f :*: g) (f0 a) -> f0 ((f :*: g) a)

mapM :: Monad m => (a -> m b) -> (f :*: g) a -> m ((f :*: g) b)

sequence :: Monad m => (f :*: g) (m a) -> m ((f :*: g) a)

(Contravariant f, Contravariant g) => Contravariant (f :*: g)

Defined in Data.Functor.Contravariant

Methods

contramap :: (a -> b) -> (f :*: g) b -> (f :*: g) a

(>$) :: b -> (f :*: g) b -> (f :*: g) a

(Representable f, Representable g) => Representable (f :*: g)

Defined in Data.Functor.Rep

Associated Types

type Rep (f :*: g) :: Type

Methods

tabulate :: (Rep (f :*: g) -> a) -> (f :*: g) a

index :: (f :*: g) a -> Rep (f :*: g) -> a

(Alternative f, Alternative g) => Alternative (f :*: g)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

empty :: (f :*: g) a

(<|>) :: (f :*: g) a -> (f :*: g) a -> (f :*: g) a

some :: (f :*: g) a -> (f :*: g) [a]

many :: (f :*: g) a -> (f :*: g) [a]

(MonadPlus f, MonadPlus g) => MonadPlus (f :*: g)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

mzero :: (f :*: g) a

mplus :: (f :*: g) a -> (f :*: g) a -> (f :*: g) a

(Foldable1 f, Foldable1 g) => Foldable1 (f :*: g)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => (f :*: g) m -> m

foldMap1 :: Semigroup m => (a -> m) -> (f :*: g) a -> m

toNonEmpty :: (f :*: g) a -> NonEmpty a

(Apply f, Apply g) => Apply (f :*: g)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: (f :*: g) (a -> b) -> (f :*: g) a -> (f :*: g) b

(.>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b

(<.) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) a

liftF2 :: (a -> b -> c) -> (f :*: g) a -> (f :*: g) b -> (f :*: g) c

(Pointed f, Pointed g) => Pointed (f :*: g)

Defined in Data.Pointed

Methods

point :: a -> (f :*: g) a

(Traversable1 f, Traversable1 g) => Traversable1 (f :*: g)

Defined in Data.Semigroup.Traversable.Class

Methods

traverse1 :: Apply f0 => (a -> f0 b) -> (f :*: g) a -> f0 ((f :*: g) b)

sequence1 :: Apply f0 => (f :*: g) (f0 b) -> f0 ((f :*: g) b)

(Plus f, Plus g) => Plus (f :*: g)

Defined in Data.Functor.Plus

Methods

zero :: (f :*: g) a

(Alt f, Alt g) => Alt (f :*: g)

Defined in Data.Functor.Alt

Methods

(<!>) :: (f :*: g) a -> (f :*: g) a -> (f :*: g) a

some :: Applicative (f :*: g) => (f :*: g) a -> (f :*: g) [a]

many :: Applicative (f :*: g) => (f :*: g) a -> (f :*: g) [a]

(GIndex f, GIndex g) => GIndex (f :*: g)

Defined in Data.Functor.Rep

Methods

gindex' :: (f :*: g) a -> GRep' (f :*: g) -> a

(GTabulate f, GTabulate g) => GTabulate (f :*: g)

Defined in Data.Functor.Rep

Methods

gtabulate' :: (GRep' (f :*: g) -> a) -> (f :*: g) a

(GDefault a, GDefault b) => GDefault (a :*: b)

Defined in Data.Default.Class

Methods

gdef :: (a :*: b) a0

(Eq (f p), Eq (g p)) => Eq ((f :*: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

Methods

(==) :: (f :*: g) p -> (f :*: g) p -> Bool

(/=) :: (f :*: g) p -> (f :*: g) p -> Bool

(Typeable f, Typeable g, Data p, Data (f p), Data (g p)) => Data ((f :*: g) p)

Since: base-4.9.0.0

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f :*: g) p -> c ((f :*: g) p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((f :*: g) p)

toConstr :: (f :*: g) p -> Constr

dataTypeOf :: (f :*: g) p -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ((f :*: g) p))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((f :*: g) p))

gmapT :: (forall b. Data b => b -> b) -> (f :*: g) p -> (f :*: g) p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (f :*: g) p -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (f :*: g) p -> r

gmapQ :: (forall d. Data d => d -> u) -> (f :*: g) p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> (f :*: g) p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (f :*: g) p -> m ((f :*: g) p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :*: g) p -> m ((f :*: g) p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :*: g) p -> m ((f :*: g) p)

(Ord (f p), Ord (g p)) => Ord ((f :*: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

Methods

compare :: (f :*: g) p -> (f :*: g) p -> Ordering

(<) :: (f :*: g) p -> (f :*: g) p -> Bool

(<=) :: (f :*: g) p -> (f :*: g) p -> Bool

(>) :: (f :*: g) p -> (f :*: g) p -> Bool

(>=) :: (f :*: g) p -> (f :*: g) p -> Bool

max :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p

min :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p

(Read (f p), Read (g p)) => Read ((f :*: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

Methods

readsPrec :: Int -> ReadS ((f :*: g) p)

readList :: ReadS [(f :*: g) p]

readPrec :: ReadPrec ((f :*: g) p)

readListPrec :: ReadPrec [(f :*: g) p]

(Show (f p), Show (g p)) => Show ((f :*: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> (f :*: g) p -> ShowS

show :: (f :*: g) p -> String

showList :: [(f :*: g) p] -> ShowS

Generic ((f :*: g) p)

Defined in GHC.Generics

Associated Types

type Rep ((f :*: g) p) :: Type -> Type

Methods

from :: (f :*: g) p -> Rep ((f :*: g) p) x

to :: Rep ((f :*: g) p) x -> (f :*: g) p

(Semigroup (f p), Semigroup (g p)) => Semigroup ((f :*: g) p)

Since: base-4.12.0.0

Defined in GHC.Generics

Methods

(<>) :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p

sconcat :: NonEmpty ((f :*: g) p) -> (f :*: g) p

stimes :: Integral b => b -> (f :*: g) p -> (f :*: g) p

(Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p)

Since: base-4.12.0.0

Defined in GHC.Generics

Methods

mempty :: (f :*: g) p

mappend :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p

mconcat :: [(f :*: g) p] -> (f :*: g) p

type Rep1 (f :*: g :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

type Rep1 (f :*: g :: k -> Type) = D1 (MetaData ":*:" "GHC.Generics" "base" False) (C1 (MetaCons ":*:" (InfixI RightAssociative 6) False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 f) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 g)))

type SF ((:*:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

type SF ((:*:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type) = NonEmptyF

type MF ((:*:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Tensor

type MF ((:*:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type) = ListF

type I ((:*:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Tensor

type I ((:*:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type) = (Proxy :: Type -> Type)

type C ((:*:) f)

Defined in Data.HFunctor.Interpret

type C ((:*:) f) = (Unconstrained :: (Type -> Type) -> Constraint)

type Rep (f :*: g)

Defined in Data.Functor.Rep

type Rep (f :*: g) = Either (Rep f) (Rep g)

type GRep' (f :*: g)

Defined in Data.Functor.Rep

type GRep' (f :*: g) = Either (GRep' f) (GRep' g)

type Rep ((f :*: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

type Rep ((f :*: g) p) = D1 (MetaData ":*:" "GHC.Generics" "base" False) (C1 (MetaCons ":*:" (InfixI RightAssociative 6) False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f p)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (g p))))

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

outL for :*: actually does not require Functor. This is the more general version.

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

outR for :*: actually does not require Functor. This is the more general version.

data ((f :: k -> Type) :+: (g :: k -> Type)) (p :: k) :: forall k. (k -> Type) -> (k -> Type) -> k -> Type infixr 5

Sums: encode choice between constructors

Constructors

L1 (f p)

R1 (g p)

Instances

HBifunctor ((:+:) :: (k -> Type) -> (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hleft :: (f ~> j) -> (f :+: g) ~> (j :+: g)

hright :: (g ~> k0) -> (f :+: g) ~> (f :+: k0)

hbimap :: (f ~> j) -> (g ~> k0) -> (f :+: g) ~> (j :+: k0)

HFunctor ((:+:) f :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f0 ~> g) -> (f :+: f0) ~> (f :+: g)

HBind ((:+:) f :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

hbind :: (f0 ~> (f :+: g)) -> (f :+: f0) ~> (f :+: g)

hjoin :: (f :+: (f :+: f0)) ~> (f :+: f0)

Inject ((:+:) f :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

inject :: f0 ~> (f :+: f0)

Generic1 (f :+: g :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (f :+: g) :: k -> Type

Methods

from1 :: (f :+: g) a -> Rep1 (f :+: g) a

to1 :: Rep1 (f :+: g) a -> (f :+: g) a

(GSum arity a, GSum arity b) => GSum arity (a :+: b)

Defined in Data.Hashable.Generic.Instances

Methods

hashSum :: HashArgs arity a0 -> Int -> Int -> (a :+: b) a0 -> Int

Semigroupoidal ((:+:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Associated Types

type SF (:+:) :: (Type -> Type) -> Type -> Type

Methods

appendSF :: (SF (:+:) f :+: SF (:+:) f) ~> SF (:+:) f

matchSF :: Functor f => SF (:+:) f ~> (f :+: (f :+: SF (:+:) f))

consSF :: (f :+: SF (:+:) f) ~> SF (:+:) f

toSF :: (f :+: f) ~> SF (:+:) f

biretract :: CS (:+:) f => (f :+: f) ~> f

binterpret :: CS (:+:) h => (f ~> h) -> (g ~> h) -> (f :+: g) ~> h

Associative ((:+:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Methods

associating :: (Functor f, Functor g, Functor h) => (f :+: (g :+: h)) <~> ((f :+: g) :+: h)

Matchable ((:+:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Tensor

Methods

unsplitSF :: (f :+: MF (:+:) f) ~> SF (:+:) f

matchMF :: MF (:+:) f ~> (I (:+:) :+: SF (:+:) f)

Monoidal ((:+:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Tensor

Associated Types

type MF (:+:) :: (Type -> Type) -> Type -> Type

Methods

appendMF :: (MF (:+:) f :+: MF (:+:) f) ~> MF (:+:) f

splitSF :: SF (:+:) f ~> (f :+: MF (:+:) f)

splittingMF :: MF (:+:) f <~> (I (:+:) :+: (f :+: MF (:+:) f))

toMF :: (f :+: f) ~> MF (:+:) f

fromSF :: SF (:+:) f ~> MF (:+:) f

pureT :: CM (:+:) f => I (:+:) ~> f

upgradeC :: CM (:+:) f => proxy f -> (CS (:+:) f -> r) -> r

Tensor ((:+:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Tensor

Associated Types

type I (:+:) :: Type -> Type

Methods

intro1 :: f ~> (f :+: I (:+:))

intro2 :: g ~> (I (:+:) :+: g)

elim1 :: Functor f => (f :+: I (:+:)) ~> f

elim2 :: Functor g => (I (:+:) :+: g) ~> g

Interpret ((:+:) f)

Technically, C 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

Associated Types

type C ((:+:) f) :: (Type -> Type) -> Constraint

Methods

retract :: C ((:+:) f) f0 => (f :+: f0) ~> f0

interpret :: C ((:+:) f) g => (f0 ~> g) -> (f :+: f0) ~> g

(Functor f, Functor g) => Functor (f :+: g)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b

(<$) :: a -> (f :+: g) b -> (f :+: g) a

(Foldable f, Foldable g) => Foldable (f :+: g)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => (f :+: g) m -> m

foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m

foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b

foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b

foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b

foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b

foldr1 :: (a -> a -> a) -> (f :+: g) a -> a

foldl1 :: (a -> a -> a) -> (f :+: g) a -> a

toList :: (f :+: g) a -> [a]

null :: (f :+: g) a -> Bool

length :: (f :+: g) a -> Int

elem :: Eq a => a -> (f :+: g) a -> Bool

maximum :: Ord a => (f :+: g) a -> a

minimum :: Ord a => (f :+: g) a -> a

sum :: Num a => (f :+: g) a -> a

product :: Num a => (f :+: g) a -> a

(Traversable f, Traversable g) => Traversable (f :+: g)

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f0 => (a -> f0 b) -> (f :+: g) a -> f0 ((f :+: g) b)

sequenceA :: Applicative f0 => (f :+: g) (f0 a) -> f0 ((f :+: g) a)

mapM :: Monad m => (a -> m b) -> (f :+: g) a -> m ((f :+: g) b)

sequence :: Monad m => (f :+: g) (m a) -> m ((f :+: g) a)

(Contravariant f, Contravariant g) => Contravariant (f :+: g)

Defined in Data.Functor.Contravariant

Methods

contramap :: (a -> b) -> (f :+: g) b -> (f :+: g) a

(>$) :: b -> (f :+: g) b -> (f :+: g) a

(Foldable1 f, Foldable1 g) => Foldable1 (f :+: g)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => (f :+: g) m -> m

foldMap1 :: Semigroup m => (a -> m) -> (f :+: g) a -> m

toNonEmpty :: (f :+: g) a -> NonEmpty a

(Traversable1 f, Traversable1 g) => Traversable1 (f :+: g)

Defined in Data.Semigroup.Traversable.Class

Methods

traverse1 :: Apply f0 => (a -> f0 b) -> (f :+: g) a -> f0 ((f :+: g) b)

sequence1 :: Apply f0 => (f :+: g) (f0 b) -> f0 ((f :+: g) b)

(SumSize a, SumSize b) => SumSize (a :+: b)

Defined in Data.Hashable.Generic.Instances

Methods

sumSize :: Tagged (a :+: b)

(GSumGet a, GSumGet b) => GSumGet (a :+: b)

Defined in Data.Binary.Generic

Methods

getSum :: (Ord word, Num word, Bits word) => word -> word -> Get ((a :+: b) a0)

(SumSize a, SumSize b) => SumSize (a :+: b)

Defined in Data.Binary.Generic

Methods

sumSize :: Tagged (a :+: b) Word64

(GSumPut a, GSumPut b) => GSumPut (a :+: b)

Defined in Data.Binary.Generic

Methods

putSum :: (Num w, Bits w, Binary w) => w -> w -> (a :+: b) a0 -> Put

(Eq (f p), Eq (g p)) => Eq ((f :+: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

Methods

(==) :: (f :+: g) p -> (f :+: g) p -> Bool

(/=) :: (f :+: g) p -> (f :+: g) p -> Bool

(Typeable f, Typeable g, Data p, Data (f p), Data (g p)) => Data ((f :+: g) p)

Since: base-4.9.0.0

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f :+: g) p -> c ((f :+: g) p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((f :+: g) p)

toConstr :: (f :+: g) p -> Constr

dataTypeOf :: (f :+: g) p -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ((f :+: g) p))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((f :+: g) p))

gmapT :: (forall b. Data b => b -> b) -> (f :+: g) p -> (f :+: g) p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (f :+: g) p -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (f :+: g) p -> r

gmapQ :: (forall d. Data d => d -> u) -> (f :+: g) p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> (f :+: g) p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (f :+: g) p -> m ((f :+: g) p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :+: g) p -> m ((f :+: g) p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :+: g) p -> m ((f :+: g) p)

(Ord (f p), Ord (g p)) => Ord ((f :+: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

Methods

compare :: (f :+: g) p -> (f :+: g) p -> Ordering

(<) :: (f :+: g) p -> (f :+: g) p -> Bool

(<=) :: (f :+: g) p -> (f :+: g) p -> Bool

(>) :: (f :+: g) p -> (f :+: g) p -> Bool

(>=) :: (f :+: g) p -> (f :+: g) p -> Bool

max :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p

min :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p

(Read (f p), Read (g p)) => Read ((f :+: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

Methods

readsPrec :: Int -> ReadS ((f :+: g) p)

readList :: ReadS [(f :+: g) p]

readPrec :: ReadPrec ((f :+: g) p)

readListPrec :: ReadPrec [(f :+: g) p]

(Show (f p), Show (g p)) => Show ((f :+: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> (f :+: g) p -> ShowS

show :: (f :+: g) p -> String

showList :: [(f :+: g) p] -> ShowS

Generic ((f :+: g) p)

Defined in GHC.Generics

Associated Types

type Rep ((f :+: g) p) :: Type -> Type

Methods

from :: (f :+: g) p -> Rep ((f :+: g) p) x

to :: Rep ((f :+: g) p) x -> (f :+: g) p

type Rep1 (f :+: g :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

type Rep1 (f :+: g :: k -> Type) = D1 (MetaData ":+:" "GHC.Generics" "base" False) (C1 (MetaCons "L1" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 f)) :+: C1 (MetaCons "R1" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 g)))

type SF ((:+:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

type SF ((:+:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type) = (Step :: (Type -> Type) -> Type -> Type)

type MF ((:+:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Tensor

type MF ((:+:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type) = (Step :: (Type -> Type) -> Type -> Type)

type I ((:+:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Tensor

type I ((:+:) :: (Type -> Type) -> (Type -> Type) -> Type -> Type) = (V1 :: Type -> Type)

type C ((:+:) f)

Defined in Data.HFunctor.Interpret

type C ((:+:) f) = Plus

type Rep ((f :+: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

type Rep ((f :+: g) p) = D1 (MetaData ":+:" "GHC.Generics" "base" False) (C1 (MetaCons "L1" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f p))) :+: C1 (MetaCons "R1" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (g p))))

data V1 (p :: k) :: forall k. k -> Type

Void: used for datatypes without constructors

Instances

Generic1 (V1 :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 V1 :: k -> Type

Methods

from1 :: V1 a -> Rep1 V1 a

to1 :: Rep1 V1 a -> V1 a

Functor (V1 :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> V1 a -> V1 b

(<$) :: a -> V1 b -> V1 a

Foldable (V1 :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => V1 m -> m

foldMap :: Monoid m => (a -> m) -> V1 a -> m

foldr :: (a -> b -> b) -> b -> V1 a -> b

foldr' :: (a -> b -> b) -> b -> V1 a -> b

foldl :: (b -> a -> b) -> b -> V1 a -> b

foldl' :: (b -> a -> b) -> b -> V1 a -> b

foldr1 :: (a -> a -> a) -> V1 a -> a

foldl1 :: (a -> a -> a) -> V1 a -> a

toList :: V1 a -> [a]

null :: V1 a -> Bool

length :: V1 a -> Int

elem :: Eq a => a -> V1 a -> Bool

maximum :: Ord a => V1 a -> a

minimum :: Ord a => V1 a -> a

sum :: Num a => V1 a -> a

product :: Num a => V1 a -> a

Traversable (V1 :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> V1 a -> f (V1 b)

sequenceA :: Applicative f => V1 (f a) -> f (V1 a)

mapM :: Monad m => (a -> m b) -> V1 a -> m (V1 b)

sequence :: Monad m => V1 (m a) -> m (V1 a)

Contravariant (V1 :: Type -> Type)

Defined in Data.Functor.Contravariant

Methods

contramap :: (a -> b) -> V1 b -> V1 a

(>$) :: b -> V1 b -> V1 a

Foldable1 (V1 :: Type -> Type)

Defined in Data.Semigroup.Foldable.Class

Methods

fold1 :: Semigroup m => V1 m -> m

foldMap1 :: Semigroup m => (a -> m) -> V1 a -> m

toNonEmpty :: V1 a -> NonEmpty a

Apply (V1 :: Type -> Type)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: V1 (a -> b) -> V1 a -> V1 b

(.>) :: V1 a -> V1 b -> V1 b

(<.) :: V1 a -> V1 b -> V1 a

liftF2 :: (a -> b -> c) -> V1 a -> V1 b -> V1 c

Traversable1 (V1 :: Type -> Type)

Defined in Data.Semigroup.Traversable.Class

Methods

traverse1 :: Apply f => (a -> f b) -> V1 a -> f (V1 b)

sequence1 :: Apply f => V1 (f b) -> f (V1 b)

Alt (V1 :: Type -> Type)

Defined in Data.Functor.Alt

Methods

(<!>) :: V1 a -> V1 a -> V1 a

some :: Applicative V1 => V1 a -> V1 [a]

many :: Applicative V1 => V1 a -> V1 [a]

Bind (V1 :: Type -> Type)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: V1 a -> (a -> V1 b) -> V1 b

join :: V1 (V1 a) -> V1 a

Eq (V1 p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(==) :: V1 p -> V1 p -> Bool

(/=) :: V1 p -> V1 p -> Bool

Data p => Data (V1 p)

Since: base-4.9.0.0

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> V1 p -> c (V1 p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (V1 p)

toConstr :: V1 p -> Constr

dataTypeOf :: V1 p -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (V1 p))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V1 p))

gmapT :: (forall b. Data b => b -> b) -> V1 p -> V1 p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V1 p -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V1 p -> r

gmapQ :: (forall d. Data d => d -> u) -> V1 p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> V1 p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> V1 p -> m (V1 p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> V1 p -> m (V1 p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> V1 p -> m (V1 p)

Ord (V1 p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: V1 p -> V1 p -> Ordering

(<) :: V1 p -> V1 p -> Bool

(<=) :: V1 p -> V1 p -> Bool

(>) :: V1 p -> V1 p -> Bool

(>=) :: V1 p -> V1 p -> Bool

max :: V1 p -> V1 p -> V1 p

min :: V1 p -> V1 p -> V1 p

Read (V1 p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

readsPrec :: Int -> ReadS (V1 p)

readList :: ReadS [V1 p]

readPrec :: ReadPrec (V1 p)

readListPrec :: ReadPrec [V1 p]

Show (V1 p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

showsPrec :: Int -> V1 p -> ShowS

show :: V1 p -> String

showList :: [V1 p] -> ShowS

Generic (V1 p)

Defined in GHC.Generics

Associated Types

type Rep (V1 p) :: Type -> Type

Methods

from :: V1 p -> Rep (V1 p) x

to :: Rep (V1 p) x -> V1 p

Semigroup (V1 p)

Since: base-4.12.0.0

Defined in GHC.Generics

Methods

(<>) :: V1 p -> V1 p -> V1 p

sconcat :: NonEmpty (V1 p) -> V1 p

stimes :: Integral b => b -> V1 p -> V1 p

type Rep1 (V1 :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

type Rep1 (V1 :: k -> Type) = D1 (MetaData "V1" "GHC.Generics" "base" False) (V1 :: k -> Type)

type Rep (V1 p)

Since: base-4.9.0.0

Defined in GHC.Generics

type Rep (V1 p) = D1 (MetaData "V1" "GHC.Generics" "base" False) (V1 :: Type -> Type)

data These1 (f :: Type -> Type) (g :: Type -> Type) a

Constructors

This1 (f a)

That1 (g a)

These1 (f a) (g a)

Instances

Semigroupoidal These1

Ideally here SF would be equivalent to MF, just like for :+:. This should be possible if we can write a bijection. This bijection should be possible in theory --- but it has not yet been implemented.

Defined in Data.HBifunctor.Associative

Associated Types

type SF These1 :: (Type -> Type) -> Type -> Type

Methods

appendSF :: These1 (SF These1 f) (SF These1 f) ~> SF These1 f

matchSF :: Functor f => SF These1 f ~> (f :+: These1 f (SF These1 f))

consSF :: These1 f (SF These1 f) ~> SF These1 f

toSF :: These1 f f ~> SF These1 f

biretract :: CS These1 f => These1 f f ~> f

binterpret :: CS These1 h => (f ~> h) -> (g ~> h) -> These1 f g ~> h

Associative These1

Defined in Data.HBifunctor.Associative

Methods

associating :: (Functor f, Functor g, Functor h) => These1 f (These1 g h) <~> These1 (These1 f g) h

Monoidal These1

Defined in Data.HBifunctor.Tensor

Associated Types

type MF These1 :: (Type -> Type) -> Type -> Type

Methods

appendMF :: These1 (MF These1 f) (MF These1 f) ~> MF These1 f

splitSF :: SF These1 f ~> These1 f (MF These1 f)

splittingMF :: MF These1 f <~> (I These1 :+: These1 f (MF These1 f))

toMF :: These1 f f ~> MF These1 f

fromSF :: SF These1 f ~> MF These1 f

pureT :: CM These1 f => I These1 ~> f

upgradeC :: CM These1 f => proxy f -> (CS These1 f -> r) -> r

Tensor These1

Defined in Data.HBifunctor.Tensor

Associated Types

type I These1 :: Type -> Type

Methods

intro1 :: f ~> These1 f (I These1)

intro2 :: g ~> These1 (I These1) g

elim1 :: Functor f => These1 f (I These1) ~> f

elim2 :: Functor g => These1 (I These1) g ~> g

Interpret (These1 f)

Technically, C 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

Associated Types

type C (These1 f) :: (Type -> Type) -> Constraint

Methods

retract :: C (These1 f) f0 => These1 f f0 ~> f0

interpret :: C (These1 f) g => (f0 ~> g) -> These1 f f0 ~> g

Alt f => HBind (These1 f :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor

Methods

hbind :: (f0 ~> These1 f g) -> These1 f f0 ~> These1 f g

hjoin :: These1 f (These1 f f0) ~> These1 f f0

Inject (These1 f :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor

Methods

inject :: f0 ~> These1 f f0

HFunctor (These1 f :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f0 ~> g) -> These1 f f0 ~> These1 f g

HBifunctor These1

Defined in Data.HFunctor.Internal

Methods

hleft :: (f ~> j) -> These1 f g ~> These1 j g

hright :: (g ~> k) -> These1 f g ~> These1 f k

hbimap :: (f ~> j) -> (g ~> k) -> These1 f g ~> These1 j k

Generic1 (These1 f g :: Type -> Type)

Defined in Data.Functor.These

Associated Types

type Rep1 (These1 f g) :: k -> Type

Methods

from1 :: These1 f g a -> Rep1 (These1 f g) a

to1 :: Rep1 (These1 f g) a -> These1 f g a

(Functor f, Functor g) => Functor (These1 f g)

Defined in Data.Functor.These

Methods

fmap :: (a -> b) -> These1 f g a -> These1 f g b

(<$) :: a -> These1 f g b -> These1 f g a

(Foldable f, Foldable g) => Foldable (These1 f g)

Defined in Data.Functor.These

Methods

fold :: Monoid m => These1 f g m -> m

foldMap :: Monoid m => (a -> m) -> These1 f g a -> m

foldr :: (a -> b -> b) -> b -> These1 f g a -> b

foldr' :: (a -> b -> b) -> b -> These1 f g a -> b

foldl :: (b -> a -> b) -> b -> These1 f g a -> b

foldl' :: (b -> a -> b) -> b -> These1 f g a -> b

foldr1 :: (a -> a -> a) -> These1 f g a -> a

foldl1 :: (a -> a -> a) -> These1 f g a -> a

toList :: These1 f g a -> [a]

null :: These1 f g a -> Bool

length :: These1 f g a -> Int

elem :: Eq a => a -> These1 f g a -> Bool

maximum :: Ord a => These1 f g a -> a

minimum :: Ord a => These1 f g a -> a

sum :: Num a => These1 f g a -> a

product :: Num a => These1 f g a -> a

(Traversable f, Traversable g) => Traversable (These1 f g)

Defined in Data.Functor.These

Methods

traverse :: Applicative f0 => (a -> f0 b) -> These1 f g a -> f0 (These1 f g b)

sequenceA :: Applicative f0 => These1 f g (f0 a) -> f0 (These1 f g a)

mapM :: Monad m => (a -> m b) -> These1 f g a -> m (These1 f g b)

sequence :: Monad m => These1 f g (m a) -> m (These1 f g a)

(Arbitrary1 f, Arbitrary1 g) => Arbitrary1 (These1 f g)

Defined in Data.Functor.These

Methods

liftArbitrary :: Gen a -> Gen (These1 f g a)

liftShrink :: (a -> [a]) -> These1 f g a -> [These1 f g a]

(ToJSON1 f, ToJSON1 g) => ToJSON1 (These1 f g)

Defined in Data.Functor.These

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> These1 f g a -> Value

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [These1 f g a] -> Value

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> These1 f g a -> Encoding

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [These1 f g a] -> Encoding

(FromJSON1 f, FromJSON1 g) => FromJSON1 (These1 f g)

Defined in Data.Functor.These

Methods

liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (These1 f g a)

liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [These1 f g a]

(Eq1 f, Eq1 g) => Eq1 (These1 f g)

Defined in Data.Functor.These

Methods

liftEq :: (a -> b -> Bool) -> These1 f g a -> These1 f g b -> Bool

(Ord1 f, Ord1 g) => Ord1 (These1 f g)

Defined in Data.Functor.These

Methods

liftCompare :: (a -> b -> Ordering) -> These1 f g a -> These1 f g b -> Ordering

(Read1 f, Read1 g) => Read1 (These1 f g)

Defined in Data.Functor.These

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (These1 f g a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [These1 f g a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (These1 f g a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [These1 f g a]

(Show1 f, Show1 g) => Show1 (These1 f g)

Defined in Data.Functor.These

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> These1 f g a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [These1 f g a] -> ShowS

(NFData1 f, NFData1 g) => NFData1 (These1 f g)

This instance is available only with deepseq >= 1.4.3.0

Defined in Data.Functor.These

Methods

liftRnf :: (a -> ()) -> These1 f g a -> ()

(Eq1 f, Eq1 g, Eq a) => Eq (These1 f g a)

Defined in Data.Functor.These

Methods

(==) :: These1 f g a -> These1 f g a -> Bool

(/=) :: These1 f g a -> These1 f g a -> Bool

(Typeable f, Typeable g, Typeable a, Data (f a), Data (g a)) => Data (These1 f g a)

Defined in Data.Functor.These

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> These1 f g a -> c (These1 f g a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (These1 f g a)

toConstr :: These1 f g a -> Constr

dataTypeOf :: These1 f g a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (These1 f g a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (These1 f g a))

gmapT :: (forall b. Data b => b -> b) -> These1 f g a -> These1 f g a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> These1 f g a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> These1 f g a -> r

gmapQ :: (forall d. Data d => d -> u) -> These1 f g a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> These1 f g a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> These1 f g a -> m (These1 f g a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> These1 f g a -> m (These1 f g a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> These1 f g a -> m (These1 f g a)

(Ord1 f, Ord1 g, Ord a) => Ord (These1 f g a)

Defined in Data.Functor.These

Methods

compare :: These1 f g a -> These1 f g a -> Ordering

(<) :: These1 f g a -> These1 f g a -> Bool

(<=) :: These1 f g a -> These1 f g a -> Bool

(>) :: These1 f g a -> These1 f g a -> Bool

(>=) :: These1 f g a -> These1 f g a -> Bool

max :: These1 f g a -> These1 f g a -> These1 f g a

min :: These1 f g a -> These1 f g a -> These1 f g a

(Read1 f, Read1 g, Read a) => Read (These1 f g a)

Defined in Data.Functor.These

Methods

readsPrec :: Int -> ReadS (These1 f g a)

readList :: ReadS [These1 f g a]

readPrec :: ReadPrec (These1 f g a)

readListPrec :: ReadPrec [These1 f g a]

(Show1 f, Show1 g, Show a) => Show (These1 f g a)

Defined in Data.Functor.These

Methods

showsPrec :: Int -> These1 f g a -> ShowS

show :: These1 f g a -> String

showList :: [These1 f g a] -> ShowS

Generic (These1 f g a)

Defined in Data.Functor.These

Associated Types

type Rep (These1 f g a) :: Type -> Type

Methods

from :: These1 f g a -> Rep (These1 f g a) x

to :: Rep (These1 f g a) x -> These1 f g a

(Arbitrary1 f, Arbitrary1 g, Arbitrary a) => Arbitrary (These1 f g a)

Defined in Data.Functor.These

Methods

arbitrary :: Gen (These1 f g a)

shrink :: These1 f g a -> [These1 f g a]

(ToJSON1 f, ToJSON1 g, ToJSON a) => ToJSON (These1 f g a)

Defined in Data.Functor.These

Methods

toJSON :: These1 f g a -> Value

toEncoding :: These1 f g a -> Encoding

toJSONList :: [These1 f g a] -> Value

toEncodingList :: [These1 f g a] -> Encoding

(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (These1 f g a)

Defined in Data.Functor.These

Methods

parseJSON :: Value -> Parser (These1 f g a)

parseJSONList :: Value -> Parser [These1 f g a]

(NFData1 f, NFData1 g, NFData a) => NFData (These1 f g a)

This instance is available only with deepseq >= 1.4.3.0

Defined in Data.Functor.These

Methods

rnf :: These1 f g a -> ()

type SF These1

Defined in Data.HBifunctor.Associative

type SF These1 = ComposeT (Flagged :: (Type -> Type) -> Type -> Type) (Steps :: (Type -> Type) -> Type -> Type)

type MF These1

Defined in Data.HBifunctor.Tensor

type MF These1 = (Steps :: (Type -> Type) -> Type -> Type)

type I These1

Defined in Data.HBifunctor.Tensor

type I These1 = (V1 :: Type -> Type)

type C (These1 f)

Defined in Data.HFunctor.Interpret

type C (These1 f) = Plus

type Rep1 (These1 f g :: Type -> Type)

Defined in Data.Functor.These

type Rep1 (These1 f g :: Type -> Type) = D1 (MetaData "These1" "Data.Functor.These" "these-1-37K73wV69xaJpdXmERtoQz" False) (C1 (MetaCons "This1" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 f)) :+: (C1 (MetaCons "That1" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 g)) :+: C1 (MetaCons "These1" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 f) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 g))))

type Rep (These1 f g a)

Defined in Data.Functor.These

type Rep (These1 f g a) = D1 (MetaData "These1" "Data.Functor.These" "these-1-37K73wV69xaJpdXmERtoQz" False) (C1 (MetaCons "This1" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f a))) :+: (C1 (MetaCons "That1" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (g a))) :+: C1 (MetaCons "These1" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f a)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (g a)))))

data Comp f g a where

Functor composition. Comp f g a is equivalent to f (g a), and the Comp pattern synonym is a way of getting the f (g a) in a Comp f g a.

For example, Maybe (IO Bool) is Comp Maybe IO Bool.

This is mostly useful for its typeclass instances: in particular, Functor, Applicative, HBifunctor, and Monoidal.

This is essentially a version of :.: and Compose that allows for an HBifunctor instance.

It is slightly less performant. Using comp . unComp every once in a while will concretize a Comp value (if you have Functor f) and remove some indirection if you have a lot of chained operations.

The "free monoid" over Comp is Free, and the "free semigroup" over Comp is Free1.

Bundled Patterns

pattern Comp :: Functor f => f (g a) -> Comp f g a

Pattern match on and construct a Comp f g a as if it were f (g a).

Instances

Semigroupoidal Comp

Defined in Data.HBifunctor.Associative

Associated Types

type SF Comp :: (Type -> Type) -> Type -> Type

Methods

appendSF :: Comp (SF Comp f) (SF Comp f) ~> SF Comp f

matchSF :: Functor f => SF Comp f ~> (f :+: Comp f (SF Comp f))

consSF :: Comp f (SF Comp f) ~> SF Comp f

toSF :: Comp f f ~> SF Comp f

biretract :: CS Comp f => Comp f f ~> f

binterpret :: CS Comp h => (f ~> h) -> (g ~> h) -> Comp f g ~> h

Associative Comp

Defined in Data.HBifunctor.Associative

Methods

associating :: (Functor f, Functor g, Functor h) => Comp f (Comp g h) <~> Comp (Comp f g) h

Monoidal Comp

Defined in Data.HBifunctor.Tensor

Associated Types

type MF Comp :: (Type -> Type) -> Type -> Type

Methods

appendMF :: Comp (MF Comp f) (MF Comp f) ~> MF Comp f

splitSF :: SF Comp f ~> Comp f (MF Comp f)

splittingMF :: MF Comp f <~> (I Comp :+: Comp f (MF Comp f))

toMF :: Comp f f ~> MF Comp f

fromSF :: SF Comp f ~> MF Comp f

pureT :: CM Comp f => I Comp ~> f

upgradeC :: CM Comp f => proxy f -> (CS Comp f -> r) -> r

Tensor Comp

Defined in Data.HBifunctor.Tensor

Associated Types

type I Comp :: Type -> Type

Methods

intro1 :: f ~> Comp f (I Comp)

intro2 :: g ~> Comp (I Comp) g

elim1 :: Functor f => Comp f (I Comp) ~> f

elim2 :: Functor g => Comp (I Comp) g ~> g

Applicative f => Inject (Comp f :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor

Methods

inject :: f0 ~> Comp f f0

HFunctor (Comp f :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f0 ~> g) -> Comp f f0 ~> Comp f g

HBifunctor Comp

Defined in Data.HFunctor.Internal

Methods

hleft :: (f ~> j) -> Comp f g ~> Comp j g

hright :: (g ~> k) -> Comp f g ~> Comp f k

hbimap :: (f ~> j) -> (g ~> k) -> Comp f g ~> Comp j k

Functor g => Functor (Comp f g)

Defined in Control.Monad.Freer.Church

Methods

fmap :: (a -> b) -> Comp f g a -> Comp f g b

(<$) :: a -> Comp f g b -> Comp f g a

(Applicative f, Applicative g) => Applicative (Comp f g)

Defined in Control.Monad.Freer.Church

Methods

pure :: a -> Comp f g a

(<*>) :: Comp f g (a -> b) -> Comp f g a -> Comp f g b

liftA2 :: (a -> b -> c) -> Comp f g a -> Comp f g b -> Comp f g c

(*>) :: Comp f g a -> Comp f g b -> Comp f g b

(<*) :: Comp f g a -> Comp f g b -> Comp f g a

(Foldable f, Foldable g) => Foldable (Comp f g)

Defined in Control.Monad.Freer.Church

Methods

fold :: Monoid m => Comp f g m -> m

foldMap :: Monoid m => (a -> m) -> Comp f g a -> m

foldr :: (a -> b -> b) -> b -> Comp f g a -> b

foldr' :: (a -> b -> b) -> b -> Comp f g a -> b

foldl :: (b -> a -> b) -> b -> Comp f g a -> b

foldl' :: (b -> a -> b) -> b -> Comp f g a -> b

foldr1 :: (a -> a -> a) -> Comp f g a -> a

foldl1 :: (a -> a -> a) -> Comp f g a -> a

toList :: Comp f g a -> [a]

null :: Comp f g a -> Bool

length :: Comp f g a -> Int

elem :: Eq a => a -> Comp f g a -> Bool

maximum :: Ord a => Comp f g a -> a

minimum :: Ord a => Comp f g a -> a

sum :: Num a => Comp f g a -> a

product :: Num a => Comp f g a -> a

(Traversable f, Traversable g) => Traversable (Comp f g)

Defined in Control.Monad.Freer.Church

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Comp f g a -> f0 (Comp f g b)

sequenceA :: Applicative f0 => Comp f g (f0 a) -> f0 (Comp f g a)

mapM :: Monad m => (a -> m b) -> Comp f g a -> m (Comp f g b)

sequence :: Monad m => Comp f g (m a) -> m (Comp f g a)

(Alternative f, Alternative g) => Alternative (Comp f g)

Defined in Control.Monad.Freer.Church

Methods

empty :: Comp f g a

(<|>) :: Comp f g a -> Comp f g a -> Comp f g a

some :: Comp f g a -> Comp f g [a]

many :: Comp f g a -> Comp f g [a]

(Functor f, Eq1 f, Eq1 g) => Eq1 (Comp f g)

Defined in Control.Monad.Freer.Church

Methods

liftEq :: (a -> b -> Bool) -> Comp f g a -> Comp f g b -> Bool

(Functor f, Ord1 f, Ord1 g) => Ord1 (Comp f g)

Defined in Control.Monad.Freer.Church

Methods

liftCompare :: (a -> b -> Ordering) -> Comp f g a -> Comp f g b -> Ordering

(Functor f, Read1 f, Read1 g) => Read1 (Comp f g)

Defined in Control.Monad.Freer.Church

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Comp f g a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Comp f g a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Comp f g a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Comp f g a]

(Functor f, Show1 f, Show1 g) => Show1 (Comp f g)

Defined in Control.Monad.Freer.Church

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Comp f g a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Comp f g a] -> ShowS

(Functor f, Eq1 f, Eq1 g, Eq a) => Eq (Comp f g a)

Defined in Control.Monad.Freer.Church

Methods

(==) :: Comp f g a -> Comp f g a -> Bool

(/=) :: Comp f g a -> Comp f g a -> Bool

(Functor f, Ord1 f, Ord1 g, Ord a) => Ord (Comp f g a)

Defined in Control.Monad.Freer.Church

Methods

compare :: Comp f g a -> Comp f g a -> Ordering

(<) :: Comp f g a -> Comp f g a -> Bool

(<=) :: Comp f g a -> Comp f g a -> Bool

(>) :: Comp f g a -> Comp f g a -> Bool

(>=) :: Comp f g a -> Comp f g a -> Bool

max :: Comp f g a -> Comp f g a -> Comp f g a

min :: Comp f g a -> Comp f g a -> Comp f g a

(Functor f, Read1 f, Read1 g, Read a) => Read (Comp f g a)

Defined in Control.Monad.Freer.Church

Methods

readsPrec :: Int -> ReadS (Comp f g a)

readList :: ReadS [Comp f g a]

readPrec :: ReadPrec (Comp f g a)

readListPrec :: ReadPrec [Comp f g a]

(Functor f, Show1 f, Show1 g, Show a) => Show (Comp f g a)

Defined in Control.Monad.Freer.Church

Methods

showsPrec :: Int -> Comp f g a -> ShowS

show :: Comp f g a -> String

showList :: [Comp f g a] -> ShowS

type SF Comp

Defined in Data.HBifunctor.Associative

type SF Comp = Free1

type MF Comp

Defined in Data.HBifunctor.Tensor

type MF Comp = Free

type I Comp

Defined in Data.HBifunctor.Tensor

type I Comp = Identity

newtype LeftF f g a

An HBifunctor that ignores its second input. Like a :+: with no R1/right branch.

This is Joker from Data.Bifunctors.Joker, but given a more sensible name for its purpose.

Constructors

LeftF

Fields

• runLeftF :: f a

Instances

HBifunctor (LeftF :: (k2 -> Type) -> (k1 -> Type) -> k2 -> Type)

Defined in Data.HBifunctor

Methods

hleft :: (f ~> j) -> LeftF f g ~> LeftF j g

hright :: (g ~> k) -> LeftF f g ~> LeftF f k

hbimap :: (f ~> j) -> (g ~> k) -> LeftF f g ~> LeftF j k

HFunctor (LeftF f :: (k -> Type) -> k -> Type)

Defined in Data.HBifunctor

Methods

hmap :: (f0 ~> g) -> LeftF f f0 ~> LeftF f g

Semigroupoidal (LeftF :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Associated Types

type SF LeftF :: (Type -> Type) -> Type -> Type

Methods

appendSF :: LeftF (SF LeftF f) (SF LeftF f) ~> SF LeftF f

matchSF :: Functor f => SF LeftF f ~> (f :+: LeftF f (SF LeftF f))

consSF :: LeftF f (SF LeftF f) ~> SF LeftF f

toSF :: LeftF f f ~> SF LeftF f

biretract :: CS LeftF f => LeftF f f ~> f

binterpret :: CS LeftF h => (f ~> h) -> (g ~> h) -> LeftF f g ~> h

Associative (LeftF :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Methods

associating :: (Functor f, Functor g, Functor h) => LeftF f (LeftF g h) <~> LeftF (LeftF f g) h

Functor f => Bifunctor (LeftF f :: Type -> Type -> Type)

Defined in Data.HBifunctor

Methods

bimap :: (a -> b) -> (c -> d) -> LeftF f a c -> LeftF f b d

first :: (a -> b) -> LeftF f a c -> LeftF f b c

second :: (b -> c) -> LeftF f a b -> LeftF f a c

Traversable f => Bitraversable (LeftF f :: Type -> Type -> Type)

Defined in Data.HBifunctor

Methods

bitraverse :: Applicative f0 => (a -> f0 c) -> (b -> f0 d) -> LeftF f a b -> f0 (LeftF f c d)

Foldable f => Bifoldable (LeftF f :: Type -> Type -> Type)

Defined in Data.HBifunctor

Methods

bifold :: Monoid m => LeftF f m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> LeftF f a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> LeftF f a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> LeftF f a b -> c

Applicative f => Biapplicative (LeftF f :: Type -> Type -> Type)

Defined in Data.HBifunctor

Methods

bipure :: a -> b -> LeftF f a b

(<<*>>) :: LeftF f (a -> b) (c -> d) -> LeftF f a c -> LeftF f b d

biliftA2 :: (a -> b -> c) -> (d -> e -> f0) -> LeftF f a d -> LeftF f b e -> LeftF f c f0

(*>>) :: LeftF f a b -> LeftF f c d -> LeftF f c d

(<<*) :: LeftF f a b -> LeftF f c d -> LeftF f a b

Functor f => Functor (LeftF f g)

Defined in Data.HBifunctor

Methods

fmap :: (a -> b) -> LeftF f g a -> LeftF f g b

(<$) :: a -> LeftF f g b -> LeftF f g a

Foldable f => Foldable (LeftF f g)

Defined in Data.HBifunctor

Methods

fold :: Monoid m => LeftF f g m -> m

foldMap :: Monoid m => (a -> m) -> LeftF f g a -> m

foldr :: (a -> b -> b) -> b -> LeftF f g a -> b

foldr' :: (a -> b -> b) -> b -> LeftF f g a -> b

foldl :: (b -> a -> b) -> b -> LeftF f g a -> b

foldl' :: (b -> a -> b) -> b -> LeftF f g a -> b

foldr1 :: (a -> a -> a) -> LeftF f g a -> a

foldl1 :: (a -> a -> a) -> LeftF f g a -> a

toList :: LeftF f g a -> [a]

null :: LeftF f g a -> Bool

length :: LeftF f g a -> Int

elem :: Eq a => a -> LeftF f g a -> Bool

maximum :: Ord a => LeftF f g a -> a

minimum :: Ord a => LeftF f g a -> a

sum :: Num a => LeftF f g a -> a

product :: Num a => LeftF f g a -> a

Traversable f => Traversable (LeftF f g)

Defined in Data.HBifunctor

Methods

traverse :: Applicative f0 => (a -> f0 b) -> LeftF f g a -> f0 (LeftF f g b)

sequenceA :: Applicative f0 => LeftF f g (f0 a) -> f0 (LeftF f g a)

mapM :: Monad m => (a -> m b) -> LeftF f g a -> m (LeftF f g b)

sequence :: Monad m => LeftF f g (m a) -> m (LeftF f g a)

Eq1 f => Eq1 (LeftF f g)

Defined in Data.HBifunctor

Methods

liftEq :: (a -> b -> Bool) -> LeftF f g a -> LeftF f g b -> Bool

Ord1 f => Ord1 (LeftF f g)

Defined in Data.HBifunctor

Methods

liftCompare :: (a -> b -> Ordering) -> LeftF f g a -> LeftF f g b -> Ordering

Read1 f => Read1 (LeftF f g)

Defined in Data.HBifunctor

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (LeftF f g a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [LeftF f g a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (LeftF f g a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [LeftF f g a]

Show1 f => Show1 (LeftF f g)

Defined in Data.HBifunctor

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> LeftF f g a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [LeftF f g a] -> ShowS

Eq (f a) => Eq (LeftF f g a)

Defined in Data.HBifunctor

Methods

(==) :: LeftF f g a -> LeftF f g a -> Bool

(/=) :: LeftF f g a -> LeftF f g a -> Bool

(Typeable g, Typeable a, Typeable f, Typeable k2, Typeable k1, Data (f a)) => Data (LeftF f g a)

Defined in Data.HBifunctor

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> LeftF f g a -> c (LeftF f g a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LeftF f g a)

toConstr :: LeftF f g a -> Constr

dataTypeOf :: LeftF f g a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (LeftF f g a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LeftF f g a))

gmapT :: (forall b. Data b => b -> b) -> LeftF f g a -> LeftF f g a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LeftF f g a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LeftF f g a -> r

gmapQ :: (forall d. Data d => d -> u) -> LeftF f g a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> LeftF f g a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LeftF f g a -> m (LeftF f g a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LeftF f g a -> m (LeftF f g a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LeftF f g a -> m (LeftF f g a)

Ord (f a) => Ord (LeftF f g a)

Defined in Data.HBifunctor

Methods

compare :: LeftF f g a -> LeftF f g a -> Ordering

(<) :: LeftF f g a -> LeftF f g a -> Bool

(<=) :: LeftF f g a -> LeftF f g a -> Bool

(>) :: LeftF f g a -> LeftF f g a -> Bool

(>=) :: LeftF f g a -> LeftF f g a -> Bool

max :: LeftF f g a -> LeftF f g a -> LeftF f g a

min :: LeftF f g a -> LeftF f g a -> LeftF f g a

Read (f a) => Read (LeftF f g a)

Defined in Data.HBifunctor

Methods

readsPrec :: Int -> ReadS (LeftF f g a)

readList :: ReadS [LeftF f g a]

readPrec :: ReadPrec (LeftF f g a)

readListPrec :: ReadPrec [LeftF f g a]

Show (f a) => Show (LeftF f g a)

Defined in Data.HBifunctor

Methods

showsPrec :: Int -> LeftF f g a -> ShowS

show :: LeftF f g a -> String

showList :: [LeftF f g a] -> ShowS

Generic (LeftF f g a)

Defined in Data.HBifunctor

Associated Types

type Rep (LeftF f g a) :: Type -> Type

Methods

from :: LeftF f g a -> Rep (LeftF f g a) x

to :: Rep (LeftF f g a) x -> LeftF f g a

type SF (LeftF :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

type SF (LeftF :: (Type -> Type) -> (Type -> Type) -> Type -> Type) = (Flagged :: (Type -> Type) -> Type -> Type)

type Rep (LeftF f g a)

Defined in Data.HBifunctor

type Rep (LeftF f g a) = D1 (MetaData "LeftF" "Data.HBifunctor" "functor-combinators-0.1.1.1-B2oyFu2GVTM8ySAuzVPoNk" True) (C1 (MetaCons "LeftF" PrefixI True) (S1 (MetaSel (Just "runLeftF") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f a))))

newtype RightF f g a

An HBifunctor that ignores its first input. Like a :+: with no L1/left branch.

In its polykinded form (on f), it is essentially a higher-order version of Tagged.

Constructors

RightF

Fields

• runRightF :: g a

Instances

HBifunctor (RightF :: (k1 -> Type) -> (k2 -> Type) -> k2 -> Type)

Defined in Data.HBifunctor

Methods

hleft :: (f ~> j) -> RightF f g ~> RightF j g

hright :: (g ~> k) -> RightF f g ~> RightF f k

hbimap :: (f ~> j) -> (g ~> k) -> RightF f g ~> RightF j k

HFunctor (RightF f :: (k1 -> Type) -> k1 -> Type)

Defined in Data.HBifunctor

Methods

hmap :: (f0 ~> g) -> RightF f f0 ~> RightF f g

HFunctor (RightF f :: (k -> Type) -> k -> Type)

Defined in Data.HBifunctor

Methods

hmap :: (f0 ~> g) -> RightF f f0 ~> RightF f g

HBind (RightF f :: (k1 -> Type) -> k1 -> Type)

Defined in Data.HBifunctor

Methods

hbind :: (f0 ~> RightF f g) -> RightF f f0 ~> RightF f g

hjoin :: RightF f (RightF f f0) ~> RightF f f0

Inject (RightF f :: (k1 -> Type) -> k1 -> Type)

Defined in Data.HBifunctor

Methods

inject :: f0 ~> RightF f f0

Semigroupoidal (RightF :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Associated Types

type SF RightF :: (Type -> Type) -> Type -> Type

Methods

appendSF :: RightF (SF RightF f) (SF RightF f) ~> SF RightF f

matchSF :: Functor f => SF RightF f ~> (f :+: RightF f (SF RightF f))

consSF :: RightF f (SF RightF f) ~> SF RightF f

toSF :: RightF f f ~> SF RightF f

biretract :: CS RightF f => RightF f f ~> f

binterpret :: CS RightF h => (f ~> h) -> (g ~> h) -> RightF f g ~> h

Associative (RightF :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Methods

associating :: (Functor f, Functor g, Functor h) => RightF f (RightF g h) <~> RightF (RightF f g) h

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

Defined in Data.HBifunctor

Associated Types

type C (RightF f) :: (Type -> Type) -> Constraint

Methods

retract :: C (RightF f) f0 => RightF f f0 ~> f0

interpret :: C (RightF f) g => (f0 ~> g) -> RightF f f0 ~> g

Functor g => Functor (RightF f g)

Defined in Data.HBifunctor

Methods

fmap :: (a -> b) -> RightF f g a -> RightF f g b

(<$) :: a -> RightF f g b -> RightF f g a

Foldable g => Foldable (RightF f g)

Defined in Data.HBifunctor

Methods

fold :: Monoid m => RightF f g m -> m

foldMap :: Monoid m => (a -> m) -> RightF f g a -> m

foldr :: (a -> b -> b) -> b -> RightF f g a -> b

foldr' :: (a -> b -> b) -> b -> RightF f g a -> b

foldl :: (b -> a -> b) -> b -> RightF f g a -> b

foldl' :: (b -> a -> b) -> b -> RightF f g a -> b

foldr1 :: (a -> a -> a) -> RightF f g a -> a

foldl1 :: (a -> a -> a) -> RightF f g a -> a

toList :: RightF f g a -> [a]

null :: RightF f g a -> Bool

length :: RightF f g a -> Int

elem :: Eq a => a -> RightF f g a -> Bool

maximum :: Ord a => RightF f g a -> a

minimum :: Ord a => RightF f g a -> a

sum :: Num a => RightF f g a -> a

product :: Num a => RightF f g a -> a

Traversable g => Traversable (RightF f g)

Defined in Data.HBifunctor

Methods

traverse :: Applicative f0 => (a -> f0 b) -> RightF f g a -> f0 (RightF f g b)

sequenceA :: Applicative f0 => RightF f g (f0 a) -> f0 (RightF f g a)

mapM :: Monad m => (a -> m b) -> RightF f g a -> m (RightF f g b)

sequence :: Monad m => RightF f g (m a) -> m (RightF f g a)

Eq1 g => Eq1 (RightF f g)

Defined in Data.HBifunctor

Methods

liftEq :: (a -> b -> Bool) -> RightF f g a -> RightF f g b -> Bool

Ord1 g => Ord1 (RightF f g)

Defined in Data.HBifunctor

Methods

liftCompare :: (a -> b -> Ordering) -> RightF f g a -> RightF f g b -> Ordering

Read1 g => Read1 (RightF f g)

Defined in Data.HBifunctor

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (RightF f g a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [RightF f g a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (RightF f g a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [RightF f g a]

Show1 g => Show1 (RightF f g)

Defined in Data.HBifunctor

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> RightF f g a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [RightF f g a] -> ShowS

Eq (g a) => Eq (RightF f g a)

Defined in Data.HBifunctor

Methods

(==) :: RightF f g a -> RightF f g a -> Bool

(/=) :: RightF f g a -> RightF f g a -> Bool

(Typeable f, Typeable a, Typeable g, Typeable k1, Typeable k2, Data (g a)) => Data (RightF f g a)

Defined in Data.HBifunctor

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> RightF f g a -> c (RightF f g a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RightF f g a)

toConstr :: RightF f g a -> Constr

dataTypeOf :: RightF f g a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RightF f g a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RightF f g a))

gmapT :: (forall b. Data b => b -> b) -> RightF f g a -> RightF f g a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RightF f g a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RightF f g a -> r

gmapQ :: (forall d. Data d => d -> u) -> RightF f g a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RightF f g a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RightF f g a -> m (RightF f g a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RightF f g a -> m (RightF f g a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RightF f g a -> m (RightF f g a)

Ord (g a) => Ord (RightF f g a)

Defined in Data.HBifunctor

Methods

compare :: RightF f g a -> RightF f g a -> Ordering

(<) :: RightF f g a -> RightF f g a -> Bool

(<=) :: RightF f g a -> RightF f g a -> Bool

(>) :: RightF f g a -> RightF f g a -> Bool

(>=) :: RightF f g a -> RightF f g a -> Bool

max :: RightF f g a -> RightF f g a -> RightF f g a

min :: RightF f g a -> RightF f g a -> RightF f g a

Read (g a) => Read (RightF f g a)

Defined in Data.HBifunctor

Methods

readsPrec :: Int -> ReadS (RightF f g a)

readList :: ReadS [RightF f g a]

readPrec :: ReadPrec (RightF f g a)

readListPrec :: ReadPrec [RightF f g a]

Show (g a) => Show (RightF f g a)

Defined in Data.HBifunctor

Methods

showsPrec :: Int -> RightF f g a -> ShowS

show :: RightF f g a -> String

showList :: [RightF f g a] -> ShowS

Generic (RightF f g a)

Defined in Data.HBifunctor

Associated Types

type Rep (RightF f g a) :: Type -> Type

Methods

from :: RightF f g a -> Rep (RightF f g a) x

to :: Rep (RightF f g a) x -> RightF f g a

type SF (RightF :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

type SF (RightF :: (Type -> Type) -> (Type -> Type) -> Type -> Type) = (Step :: (Type -> Type) -> Type -> Type)

type C (RightF f :: (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor

type C (RightF f :: (Type -> Type) -> Type -> Type) = (Unconstrained :: (Type -> Type) -> Constraint)

type Rep (RightF f g a)

Defined in Data.HBifunctor

type Rep (RightF f g a) = D1 (MetaData "RightF" "Data.HBifunctor" "functor-combinators-0.1.1.1-B2oyFu2GVTM8ySAuzVPoNk" True) (C1 (MetaCons "RightF" PrefixI True) (S1 (MetaSel (Just "runRightF") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (g a))))

Combinator Combinators

data HLift t f a

An "HFunctor combinator" that enhances an HFunctor with the ability to hold a single f a. This is the higher-order analogue of Lift.

You can think of it as a free Inject for any f.

Note that HLift IdentityT is equivalent to EnvT Any.

Constructors

HPure (f a)

HOther (t f a)

Instances

HFunctor t => HFunctor (HLift t :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

hmap :: (f ~> g) -> HLift t f ~> HLift t g

(HBind t, Inject t) => HBind (HLift t :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

hbind :: (f ~> HLift t g) -> HLift t f ~> HLift t g

hjoin :: HLift t (HLift t f) ~> HLift t f

HFunctor t => Inject (HLift t :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

inject :: f ~> HLift t f

Interpret t => Interpret (HLift t)

Never uses inject

Defined in Data.HFunctor.Interpret

Associated Types

type C (HLift t) :: (Type -> Type) -> Constraint

Methods

retract :: C (HLift t) f => HLift t f ~> f

interpret :: C (HLift t) g => (f ~> g) -> HLift t f ~> g

(Functor f, Functor (t f)) => Functor (HLift t f)

Defined in Data.HFunctor

Methods

fmap :: (a -> b) -> HLift t f a -> HLift t f b

(<$) :: a -> HLift t f b -> HLift t f a

(Eq1 (t f), Eq1 f) => Eq1 (HLift t f)

Defined in Data.HFunctor

Methods

liftEq :: (a -> b -> Bool) -> HLift t f a -> HLift t f b -> Bool

(Ord1 (t f), Ord1 f) => Ord1 (HLift t f)

Defined in Data.HFunctor

Methods

liftCompare :: (a -> b -> Ordering) -> HLift t f a -> HLift t f b -> Ordering

(Show1 (t f), Show1 f) => Show1 (HLift t f)

Defined in Data.HFunctor

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> HLift t f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [HLift t f a] -> ShowS

(Eq (f a), Eq (t f a)) => Eq (HLift t f a)

Defined in Data.HFunctor

Methods

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

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

(Ord (f a), Ord (t f a)) => Ord (HLift t f a)

Defined in Data.HFunctor

Methods

compare :: HLift t f a -> HLift t f a -> Ordering

(<) :: HLift t f a -> HLift t f a -> Bool

(<=) :: HLift t f a -> HLift t f a -> Bool

(>) :: HLift t f a -> HLift t f a -> Bool

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

max :: HLift t f a -> HLift t f a -> HLift t f a

min :: HLift t f a -> HLift t f a -> HLift t f a

(Read (f a), Read (t f a)) => Read (HLift t f a)

Defined in Data.HFunctor

Methods

readsPrec :: Int -> ReadS (HLift t f a)

readList :: ReadS [HLift t f a]

readPrec :: ReadPrec (HLift t f a)

readListPrec :: ReadPrec [HLift t f a]

(Show (f a), Show (t f a)) => Show (HLift t f a)

Defined in Data.HFunctor

Methods

showsPrec :: Int -> HLift t f a -> ShowS

show :: HLift t f a -> String

showList :: [HLift t f a] -> ShowS

type C (HLift t)

Defined in Data.HFunctor.Interpret

type C (HLift t) = C t

data HFree t f a

An "HFunctor combinator" that turns an HFunctor into potentially infinite nestings of that HFunctor.

An HFree t f a is either f a, t f a, t (t f) a, t (t (t f)) a, etc.

This effectively turns t into a tree with t branches.

One particularly useful usage is with MapF. For example if you had a data type representing a command line command parser:

data Command a

You could represent "many possible named commands" using

type Commands = MapF String Command

And you can represent multiple nested named commands using:

type NestedCommands = HFree (MapF String)

This has an Interpret instance, but it can be more useful to use via direct pattern matching, or through

foldHFree
    :: HBifunctor t
    => f ~> g
    -> t g ~> g
    -> HFree t f ~> g

which requires no extra constriant on g, and lets you consider each branch separately.

This can be considered the higher-oder analogue of Free; it is the free HBind for any HFunctor t.

Note that HFree IdentityT is equivalent to Step.

Constructors

HReturn (f a)

HJoin (t (HFree t f) a)

Instances

HFunctor t => HFunctor (HFree t :: (k -> Type) -> k -> Type)

Defined in Data.HFunctor

Methods

hmap :: (f ~> g) -> HFree t f ~> HFree t g

HFunctor t => HBind (HFree t :: (k -> Type) -> k -> Type)

HFree is the "free HBind" for any HFunctor

Defined in Data.HFunctor

Methods

hbind :: (f ~> HFree t g) -> HFree t f ~> HFree t g

hjoin :: HFree t (HFree t f) ~> HFree t f

HFunctor t => Inject (HFree t :: (k -> Type) -> k -> Type)

HFree is the "free HBind and Inject" for any HFunctor

Defined in Data.HFunctor

Methods

inject :: f ~> HFree t f

Interpret t => Interpret (HFree t)

Never uses inject

Defined in Data.HFunctor.Interpret

Associated Types

type C (HFree t) :: (Type -> Type) -> Constraint

Methods

retract :: C (HFree t) f => HFree t f ~> f

interpret :: C (HFree t) g => (f ~> g) -> HFree t f ~> g

(Functor f, Functor (t (HFree t f))) => Functor (HFree t f)

Defined in Data.HFunctor

Methods

fmap :: (a -> b) -> HFree t f a -> HFree t f b

(<$) :: a -> HFree t f b -> HFree t f a

(Show1 (t (HFree t f)), Show1 f) => Show1 (HFree t f)

Defined in Data.HFunctor

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> HFree t f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [HFree t f a] -> ShowS

(Show1 (t (HFree t f)), Show1 f, Show a) => Show (HFree t f a)

Defined in Data.HFunctor

Methods

showsPrec :: Int -> HFree t f a -> ShowS

show :: HFree t f a -> String

showList :: [HFree t f a] -> ShowS

type C (HFree t)

Defined in Data.HFunctor.Interpret

type C (HFree t) = C t

Util

Natural Transformations

generalize :: Applicative f => Identity ~> f

Turn Identity into any Applicative f. Can be useful as an argument to hmap, hbimap, or interpret.

It is a more general form of generalize from mmorph.

absorb :: f ~> Proxy

Natural transformation from any functor f into Proxy. Can be useful for "zeroing out" a functor with hmap or hbimap or interpret.