functor-combinators-0.3.6.0: Tools for functor combinator-based program design

Description

The church-encoded Freer Monad. Basically provides the free monad in a way that is compatible with HFunctor and Interpret. We also have the "semigroup" version Free1, which is the free Bind.

The module also provides a version of :.: (or Compose), Comp, in a way that is compatible with HBifunctor and the related typeclasses.

Synopsis

# Free

newtype Free f a Source #

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.

Constructors

 Free FieldsrunFree :: forall r. (a -> r) -> (forall s. f s -> (s -> r) -> r) -> r

#### Instances

Instances details
 Source # Instance detailsDefined in Data.HFunctor.Final Associated Typestype FreeFunctorBy Free :: (Type -> Type) -> Constraint Source # MethodsfromFree :: forall (f :: Type -> Type). Free f ~> Final Monad f Source #toFree :: forall (f :: Type -> Type). FreeFunctorBy Free f => Final Monad f ~> Free f Source # MonadFree f (Free f) Source # Instance detailsDefined in Control.Monad.Freer.Church Methodswrap :: f (Free f a) -> Free f a # Monad (Free f) Source # Instance detailsDefined 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 # Functor (Free f) Source # Instance detailsDefined in Control.Monad.Freer.Church Methodsfmap :: (a -> b) -> Free f a -> Free f b #(<$) :: a -> Free f b -> Free f a # Source # Instance detailsDefined in Control.Monad.Freer.Church Methodspure :: 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) Source # Instance detailsDefined in Control.Monad.Freer.Church Methodsfold :: Monoid m => Free f m -> m #foldMap :: Monoid m => (a -> m) -> Free f a -> 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) Source # Instance detailsDefined in Control.Monad.Freer.Church Methodstraverse :: 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) Source # Instance detailsDefined in Control.Monad.Freer.Church MethodsliftEq :: (a -> b -> Bool) -> Free f a -> Free f b -> Bool # (Functor f, Ord1 f) => Ord1 (Free f) Source # Instance detailsDefined in Control.Monad.Freer.Church MethodsliftCompare :: (a -> b -> Ordering) -> Free f a -> Free f b -> Ordering # (Functor f, Read1 f) => Read1 (Free f) Source # Instance detailsDefined in Control.Monad.Freer.Church MethodsliftReadsPrec :: (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) Source # Instance detailsDefined in Control.Monad.Freer.Church MethodsliftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Free f a -> ShowS #liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Free f a] -> ShowS # Apply (Free f) Source # Instance detailsDefined 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) Source # Instance detailsDefined in Control.Monad.Freer.Church Methodspoint :: a -> Free f a # Bind (Free f) Source # Instance detailsDefined 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 # Source # Instance detailsDefined in Data.HFunctor Methodshbind :: forall (f :: k -> Type) (g :: k -> Type). (f ~> Free g) -> Free f ~> Free g Source #hjoin :: forall (f :: k -> Type). Free (Free f) ~> Free f Source # Source # Instance detailsDefined in Data.HFunctor Methodsinject :: forall (f :: k -> Type). f ~> Free f Source # Monad f => Interpret Free (f :: Type -> Type) Source # A free Monad Instance detailsDefined in Data.HFunctor.Interpret Methodsinterpret :: forall (g :: k -> Type). (g ~> f) -> Free g ~> f Source # Source # Instance detailsDefined in Data.HFunctor.Internal Methodshmap :: forall (f :: k -> Type) (g :: k -> Type). (f ~> g) -> Free f ~> Free g Source # (Functor f, Eq1 f, Eq a) => Eq (Free f a) Source # Instance detailsDefined 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) Source # Instance detailsDefined in Control.Monad.Freer.Church Methodscompare :: 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) Source # Read in terms of pure and wrap. Instance detailsDefined in Control.Monad.Freer.Church MethodsreadsPrec :: 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) Source # Show in terms of pure and wrap. Instance detailsDefined in Control.Monad.Freer.Church MethodsshowsPrec :: Int -> Free f a -> ShowS #show :: Free f a -> String #showList :: [Free f a] -> ShowS # Source # Instance detailsDefined in Data.HFunctor.Final type FreeFunctorBy Free = Unconstrained :: (Type -> Type) -> Constraint reFree :: (MonadFree f m, Functor f) => Free f a -> m a Source # Convert a Free f into any instance of MonadFree f. ## Interpretation Lift an f into Free f, so you can use it as a Monad. This is inject. interpretFree :: Monad g => (f ~> g) -> Free f ~> g Source # Interpret a Free f into a context g, provided that g has a Monad instance. This is interpret. retractFree :: Monad f => Free f ~> f Source # Extract the fs back "out" of a Free f, utilizing its Monad instance. This is retract. hoistFree :: (f ~> g) -> Free f ~> Free g Source # Swap out the underlying functor over a Free. This preserves all of the structure of the Free. ## Folding Arguments  :: Functor f => (a -> r) handle pure -> (f r -> r) handle wrap -> Free f a -> r Recursively fold down a Free by handling the pure case and the nested/wrapped case. This is a catamorphism. This requires Functor f; see foldFree' and foldFreeC for a version that doesn't require Functor f. foldFree' :: (a -> r) -> (forall s. f s -> (s -> r) -> r) -> Free f a -> r Source # A version of foldFree that doesn't require Functor f, by taking a RankN folding function. This is essentially a flipped runFree. Arguments  :: (a -> r) handle pure -> (Coyoneda f r -> r) handle wrap -> Free f a -> r A version of foldFree that doesn't require Functor f, by folding over a Coyoneda instead. # Free1 newtype Free1 f a Source # 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. Constructors  Free1 FieldsrunFree1 :: forall r. (forall s. f s -> (s -> a) -> r) -> (forall s. f s -> (s -> r) -> r) -> r Bundled Patterns  pattern DoneF1 :: Functor f => f a -> Free1 f a Constructor matching on the case that a Free1 f consists of just a single un-nested f. Used as a part of the Show and Read instances. pattern MoreF1 :: Functor f => f (Free1 f a) -> Free1 f a Constructor matching on the case that a Free1 f is a nested f (Free1 f a). Used as a part of the Show and Read instances.As a constructor, this is equivalent to wrap. #### Instances Instances details  Source # Instance detailsDefined in Data.HFunctor.Final Associated Typestype FreeFunctorBy Free1 :: (Type -> Type) -> Constraint Source # MethodsfromFree :: forall (f :: Type -> Type). Free1 f ~> Final Bind f Source #toFree :: forall (f :: Type -> Type). FreeFunctorBy Free1 f => Final Bind f ~> Free1 f Source # Functor (Free1 f) Source # Instance detailsDefined in Control.Monad.Freer.Church Methodsfmap :: (a -> b) -> Free1 f a -> Free1 f b #(<$) :: a -> Free1 f b -> Free1 f a # Foldable f => Foldable (Free1 f) Source # Instance detailsDefined in Control.Monad.Freer.Church Methodsfold :: Monoid m => Free1 f m -> m #foldMap :: Monoid m => (a -> m) -> Free1 f a -> 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) Source # Instance detailsDefined in Control.Monad.Freer.Church Methodstraverse :: 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) Source # Instance detailsDefined in Control.Monad.Freer.Church MethodsliftEq :: (a -> b -> Bool) -> Free1 f a -> Free1 f b -> Bool # (Functor f, Ord1 f) => Ord1 (Free1 f) Source # Instance detailsDefined in Control.Monad.Freer.Church MethodsliftCompare :: (a -> b -> Ordering) -> Free1 f a -> Free1 f b -> Ordering # (Functor f, Read1 f) => Read1 (Free1 f) Source # Instance detailsDefined in Control.Monad.Freer.Church MethodsliftReadsPrec :: (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) Source # Instance detailsDefined in Control.Monad.Freer.Church MethodsliftShowsPrec :: (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) Source # Instance detailsDefined in Control.Monad.Freer.Church Methodsfold1 :: Semigroup m => Free1 f m -> m #foldMap1 :: Semigroup m => (a -> m) -> Free1 f a -> m #toNonEmpty :: Free1 f a -> NonEmpty a # Apply (Free1 f) Source # Instance detailsDefined 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 # Source # Instance detailsDefined in Control.Monad.Freer.Church Methodstraverse1 :: 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) Source # Instance detailsDefined 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 # Source # Instance detailsDefined in Data.HFunctor Methodshbind :: forall (f :: k -> Type) (g :: k -> Type). (f ~> Free1 g) -> Free1 f ~> Free1 g Source #hjoin :: forall (f :: k -> Type). Free1 (Free1 f) ~> Free1 f Source # Source # Instance detailsDefined in Data.HFunctor Methodsinject :: forall (f :: k -> Type). f ~> Free1 f Source # Bind f => Interpret Free1 (f :: Type -> Type) Source # A free Bind Instance detailsDefined in Data.HFunctor.Interpret Methodsinterpret :: forall (g :: k -> Type). (g ~> f) -> Free1 g ~> f Source # Source # Instance detailsDefined in Data.HFunctor.Internal Methodshmap :: forall (f :: k -> Type) (g :: k -> Type). (f ~> g) -> Free1 f ~> Free1 g Source # (Functor f, Eq1 f, Eq a) => Eq (Free1 f a) Source # Instance detailsDefined 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) Source # Instance detailsDefined in Control.Monad.Freer.Church Methodscompare :: 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) Source # Read in terms of DoneF1 and MoreF1. Instance detailsDefined in Control.Monad.Freer.Church MethodsreadsPrec :: 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) Source # Show in terms of DoneF1 and MoreF1. Instance detailsDefined in Control.Monad.Freer.Church MethodsshowsPrec :: Int -> Free1 f a -> ShowS #show :: Free1 f a -> String #showList :: [Free1 f a] -> ShowS # Source # Instance detailsDefined in Data.HFunctor.Final type FreeFunctorBy Free1 = Unconstrained :: (Type -> Type) -> Constraint

reFree1 :: (MonadFree f m, Functor f) => Free1 f a -> m a Source #

Convert a Free1 f into any instance of MonadFree f.

Free1 f is a special subset of Free f that consists of at least one nested f. This converts it back into the "bigger" type.

See free1Comp for a version that preserves the "one nested layer" property.

## Interpretation

Inject an f into a Free1 f

interpretFree1 :: Bind g => (f ~> g) -> Free1 f ~> g Source #

Interpret the Free1 f in some context g, provided that g has a Bind instance. Since we always have at least one f, we will always have at least one g, so we do not need a full Monad constraint.

retractFree1 :: Bind f => Free1 f ~> f Source #

Retract the f out of a Free1 f, as long as the f implements Bind. Since we always have at least one f, we do not need a full Monad constraint.

hoistFree1 :: (f ~> g) -> Free1 f ~> Free1 g Source #

Map the underlying functor under a Free1.

## Conversion

free1Comp :: Free1 f ~> Comp f (Free f) Source #

Because a Free1 f is just a Free f with at least one nested layer of f, this function converts it back into the one-nested-f format.

matchFree1 :: forall f. Functor f => Free1 f ~> (f :+: Comp f (Free1 f)) Source #

A Free1 f is either a single un-nested f, or a f nested with another Free1 f. This decides which is the case.

## Folding

Arguments

 :: Functor f => (f a -> r) handle DoneF1. -> (f r -> r) handle MoreF1. -> Free1 f a -> r

Recursively fold down a Free1 by handling the single f case and the nested/wrapped case.

This is a catamorphism.

This requires Functor f; see foldFree' and foldFreeC for a version that doesn't require Functor f.

foldFree1' :: (forall s. f s -> (s -> a) -> r) -> (forall s. f s -> (s -> r) -> r) -> Free1 f a -> r Source #

A version of foldFree1 that doesn't require Functor f, by taking a RankN folding function. This is essentially a flipped runFree.

foldFree1C :: (Coyoneda f a -> r) -> (Coyoneda f r -> r) -> Free1 f a -> r Source #

A version of foldFree1 that doesn't require Functor f, by folding over a Coyoneda instead.

# Comp

data Comp f g a Source #

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.

Constructors

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

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

Instances details
 HFunctor (Comp f :: (k -> Type) -> k -> Type) Source # Instance detailsDefined in Data.HFunctor.Internal Methodshmap :: forall (f0 :: k0 -> Type) (g :: k0 -> Type). (f0 ~> g) -> Comp f f0 ~> Comp f g Source # Applicative f => Inject (Comp f :: (Type -> Type) -> Type -> Type) Source # Instance detailsDefined in Data.HFunctor Methodsinject :: forall (f0 :: k -> Type). f0 ~> Comp f f0 Source # Associative (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Source # Instance detailsDefined in Data.HBifunctor.Associative Associated Typestype NonEmptyBy Comp :: (Type -> Type) -> Type -> Type Source #type FunctorBy Comp :: (Type -> Type) -> Constraint Source # Methodsassociating :: forall (f :: Type -> Type) (g :: Type -> Type) (h :: Type -> Type). (FunctorBy Comp f, FunctorBy Comp g, FunctorBy Comp h) => Comp f (Comp g h) <~> Comp (Comp f g) h Source #appendNE :: forall (f :: Type -> Type). Comp (NonEmptyBy Comp f) (NonEmptyBy Comp f) ~> NonEmptyBy Comp f Source #matchNE :: forall (f :: Type -> Type). FunctorBy Comp f => NonEmptyBy Comp f ~> (f :+: Comp f (NonEmptyBy Comp f)) Source #consNE :: forall (f :: Type -> Type). Comp f (NonEmptyBy Comp f) ~> NonEmptyBy Comp f Source #toNonEmptyBy :: forall (f :: Type -> Type). Comp f f ~> NonEmptyBy Comp f Source # Bind f => SemigroupIn (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) f Source # Instances of Bind are semigroups in the semigroupoidal category on Comp. Instance detailsDefined in Data.HBifunctor.Associative Methodsbiretract :: Comp f f ~> f Source #binterpret :: forall (g :: Type -> Type) (h :: Type -> Type). (g ~> f) -> (h ~> f) -> Comp g h ~> f Source # Tensor (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Identity Source # Instance detailsDefined in Data.HBifunctor.Tensor Associated Typestype ListBy Comp :: (Type -> Type) -> Type -> Type Source # Methodsintro1 :: forall (f :: Type -> Type). f ~> Comp f Identity Source #intro2 :: forall (g :: Type -> Type). g ~> Comp Identity g Source #elim1 :: forall (f :: Type -> Type). FunctorBy Comp f => Comp f Identity ~> f Source #elim2 :: forall (g :: Type -> Type). FunctorBy Comp g => Comp Identity g ~> g Source #appendLB :: forall (f :: Type -> Type). Comp (ListBy Comp f) (ListBy Comp f) ~> ListBy Comp f Source #splitNE :: forall (f :: Type -> Type). NonEmptyBy Comp f ~> Comp f (ListBy Comp f) Source #splittingLB :: forall (f :: Type -> Type). ListBy Comp f <~> (Identity :+: Comp f (ListBy Comp f)) Source #toListBy :: forall (f :: Type -> Type). Comp f f ~> ListBy Comp f Source #fromNE :: forall (f :: Type -> Type). NonEmptyBy Comp f ~> ListBy Comp f Source # (Bind f, Monad f) => MonoidIn (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Identity f Source # Instances of Monad are monoids in the monoidal category on Comp.This instance is the "proof" that "monads are the monoids in the category of endofunctors (enriched with Comp)"Note that because of typeclass constraints, this requires Bind as well as Monad. But, you can get a "local" instance of Apply for any Monad using unsafeBind. Instance detailsDefined in Data.HBifunctor.Tensor Methods HBifunctor (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Source # Instance detailsDefined in Data.HFunctor.Internal Methodshleft :: forall (f :: k -> Type) (j :: k -> Type) (g :: k -> Type). (f ~> j) -> Comp f g ~> Comp j g Source #hright :: forall (g :: k -> Type) (l :: k -> Type) (f :: k -> Type). (g ~> l) -> Comp f g ~> Comp f l Source #hbimap :: forall (f :: k -> Type) (j :: k -> Type) (g :: k -> Type) (l :: k -> Type). (f ~> j) -> (g ~> l) -> Comp f g ~> Comp j l Source # Functor g => Functor (Comp f g) Source # Instance detailsDefined in Control.Monad.Freer.Church Methodsfmap :: (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) Source # Instance detailsDefined in Control.Monad.Freer.Church Methodspure :: 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) Source # Instance detailsDefined in Control.Monad.Freer.Church Methodsfold :: Monoid m => Comp f g m -> m #foldMap :: Monoid m => (a -> m) -> Comp f g a -> 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) Source # Instance detailsDefined in Control.Monad.Freer.Church Methodstraverse :: 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) Source # Instance detailsDefined in Control.Monad.Freer.Church Methodsempty :: 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) Source # Instance detailsDefined in Control.Monad.Freer.Church MethodsliftEq :: (a -> b -> Bool) -> Comp f g a -> Comp f g b -> Bool # (Functor f, Ord1 f, Ord1 g) => Ord1 (Comp f g) Source # Instance detailsDefined in Control.Monad.Freer.Church MethodsliftCompare :: (a -> b -> Ordering) -> Comp f g a -> Comp f g b -> Ordering # (Functor f, Read1 f, Read1 g) => Read1 (Comp f g) Source # Instance detailsDefined in Control.Monad.Freer.Church MethodsliftReadsPrec :: (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) Source # Instance detailsDefined in Control.Monad.Freer.Church MethodsliftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Comp f g a -> ShowS #liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Comp f g a] -> ShowS # (Apply f, Apply g) => Apply (Comp f g) Source # Since: 0.3.6.0 Instance detailsDefined in Control.Monad.Freer.Church Methods(<.>) :: Comp f g (a -> b) -> Comp f g a -> Comp f g b #(.>) :: Comp f g a -> Comp f g b -> Comp f g b #(<.) :: Comp f g a -> Comp f g b -> Comp f g a #liftF2 :: (a -> b -> c) -> Comp f g a -> Comp f g b -> Comp f g c # Functor f => Apply (Chain1 (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) f) Source # Instance detailsDefined in Data.HFunctor.Chain Methods(<.>) :: Chain1 Comp f (a -> b) -> Chain1 Comp f a -> Chain1 Comp f b #(.>) :: Chain1 Comp f a -> Chain1 Comp f b -> Chain1 Comp f b #(<.) :: Chain1 Comp f a -> Chain1 Comp f b -> Chain1 Comp f a #liftF2 :: (a -> b -> c) -> Chain1 Comp f a -> Chain1 Comp f b -> Chain1 Comp f c # (Plus f, Plus g) => Plus (Comp f g) Source # Since: 0.3.6.0 Instance detailsDefined in Control.Monad.Freer.Church Methodszero :: Comp f g a # (Alt f, Alt g) => Alt (Comp f g) Source # Since: 0.3.6.0 Instance detailsDefined in Control.Monad.Freer.Church Methods() :: Comp f g a -> Comp f g a -> Comp f g a #some :: Applicative (Comp f g) => Comp f g a -> Comp f g [a] #many :: Applicative (Comp f g) => Comp f g a -> Comp f g [a] # Functor f => Bind (Chain1 (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) f) Source # Chain1 Comp is the free "semigroup in the semigroupoidal category of endofunctors enriched by Comp" --- aka, the free Bind. Instance detailsDefined in Data.HFunctor.Chain Methods(>>-) :: Chain1 Comp f a -> (a -> Chain1 Comp f b) -> Chain1 Comp f b #join :: Chain1 Comp f (Chain1 Comp f a) -> Chain1 Comp f a # (Functor f, Eq1 f, Eq1 g, Eq a) => Eq (Comp f g a) Source # Instance detailsDefined 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) Source # Instance detailsDefined in Control.Monad.Freer.Church Methodscompare :: 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) Source # Instance detailsDefined in Control.Monad.Freer.Church MethodsreadsPrec :: 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) Source # Instance detailsDefined in Control.Monad.Freer.Church MethodsshowsPrec :: Int -> Comp f g a -> ShowS #show :: Comp f g a -> String #showList :: [Comp f g a] -> ShowS # Monad (Chain (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Identity f) Source # Chain Comp Identity is the free "monoid in the monoidal category of endofunctors enriched by Comp" --- aka, the free Monad. Instance detailsDefined in Data.HFunctor.Chain Methods(>>=) :: Chain Comp Identity f a -> (a -> Chain Comp Identity f b) -> Chain Comp Identity f b #(>>) :: Chain Comp Identity f a -> Chain Comp Identity f b -> Chain Comp Identity f b #return :: a -> Chain Comp Identity f a # Applicative (Chain (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Identity f) Source # Instance detailsDefined in Data.HFunctor.Chain Methodspure :: a -> Chain Comp Identity f a #(<*>) :: Chain Comp Identity f (a -> b) -> Chain Comp Identity f a -> Chain Comp Identity f b #liftA2 :: (a -> b -> c) -> Chain Comp Identity f a -> Chain Comp Identity f b -> Chain Comp Identity f c #(*>) :: Chain Comp Identity f a -> Chain Comp Identity f b -> Chain Comp Identity f b #(<*) :: Chain Comp Identity f a -> Chain Comp Identity f b -> Chain Comp Identity f a # Apply (Chain (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Identity f) Source # Instance detailsDefined in Data.HFunctor.Chain Methods(<.>) :: Chain Comp Identity f (a -> b) -> Chain Comp Identity f a -> Chain Comp Identity f b #(.>) :: Chain Comp Identity f a -> Chain Comp Identity f b -> Chain Comp Identity f b #(<.) :: Chain Comp Identity f a -> Chain Comp Identity f b -> Chain Comp Identity f a #liftF2 :: (a -> b -> c) -> Chain Comp Identity f a -> Chain Comp Identity f b -> Chain Comp Identity f c # Bind (Chain (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Identity f) Source # Instance detailsDefined in Data.HFunctor.Chain Methods(>>-) :: Chain Comp Identity f a -> (a -> Chain Comp Identity f b) -> Chain Comp Identity f b #join :: Chain Comp Identity f (Chain Comp Identity f a) -> Chain Comp Identity f a # type NonEmptyBy (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Source # Instance detailsDefined in Data.HBifunctor.Associative type NonEmptyBy (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) = Free1 type FunctorBy (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Source # Instance detailsDefined in Data.HBifunctor.Associative type FunctorBy (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) = Functor type ListBy (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Source # Instance detailsDefined in Data.HBifunctor.Tensor type ListBy (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) = Free

comp :: f (g a) -> Comp f g a Source #

"Smart constructor" for Comp that doesn't require Functor f.