Data.Functor.Apply.Free

The free Apply. Provides Ap1 and various utility methods. See Ap1 for more details.

Ideally Ap1 would be in the free package. However, it is defined here for now.

Documentation

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

HBind Ap1

Defined in Data.Functor.Apply.Free

Methods

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

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

Inject Ap1

Defined in Data.Functor.Apply.Free

Methods

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

FreeOf Apply Ap1

Defined in Data.HFunctor.Final

Associated Types

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

Methods

fromFree :: forall (f :: Type -> Type). Ap1 f ~> Final Apply f

toFree :: forall (f :: Type -> Type). FreeFunctorBy Ap1 f => Final Apply f ~> Ap1 f

HTraversable Ap1

Defined in Data.Functor.Apply.Free

Methods

htraverse :: forall h f g (a :: k1). Applicative h => (forall (x :: k). f x -> h (g x)) -> Ap1 f a -> h (Ap1 g a)

HTraversable1 Ap1

Defined in Data.Functor.Apply.Free

Methods

htraverse1 :: forall h f g (a :: k1). Apply h => (forall (x :: k). f x -> h (g x)) -> Ap1 f a -> h (Ap1 g a)

HFunctor Ap1

Defined in Data.Functor.Apply.Free

Methods

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

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

Defined in Data.Functor.Apply.Free

Methods

retract :: Ap1 f ~> f

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

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

Invariant (Ap1 f)

Since: 0.3.0.0

Defined in Data.Functor.Apply.Free

Methods

invmap :: (a -> b) -> (b -> a) -> Ap1 f a -> Ap1 f b

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 FreeFunctorBy Ap1

Defined in Data.HFunctor.Final

type FreeFunctorBy Ap1 = Unconstrained :: (Type -> Type) -> Constraint

toAp :: Ap1 f ~> Ap f

An Ap1 is a "non-empty" Ap; this function "forgets" the non-empty property and turns it back into a normal Ap.

fromAp :: Ap f ~> (Identity :+: Ap1 f)

Convert an Ap into an Ap1 if possible. If the Ap was "empty", return the Pure value instead.

liftAp1 :: f ~> Ap1 f

Embed an f into Ap1.

retractAp1 :: Apply f => Ap1 f ~> f

Extract the f out of the Ap1.

retractAp1 . liftAp1 == id

runAp1 :: Apply g => (f ~> g) -> Ap1 f ~> g

Interpret an Ap f into some Apply context g.