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

Data.Functor.Apply.Free

Description

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.

Synopsis

data Ap1 :: (Type -> Type) -> Type -> Type where
- Ap1 :: f a -> Ap f (a -> b) -> Ap1 f b
- pattern DayAp1 :: Day f (Ap f) a -> Ap1 f a
toAp :: Ap1 f ~> Ap f
fromAp :: Ap f ~> (Identity :+: Ap1 f)
liftAp1 :: f ~> Ap1 f
retractAp1 :: Apply f => Ap1 f ~> f
runAp1 :: Apply g => (f ~> g) -> Ap1 f ~> g

Documentation

data Ap1 :: (Type -> Type) -> Type -> Type where Source #

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

Instances details

HBind Ap1 Source #
Instance details Defined in Data.Functor.Apply.Free Methods hbind :: forall (f :: k -> Type) (g :: k -> Type). (f ~> Ap1 g) -> Ap1 f ~> Ap1 g Source # hjoin :: forall (f :: k -> Type). Ap1 (Ap1 f) ~> Ap1 f Source #
Inject Ap1 Source #
Instance details Defined in Data.Functor.Apply.Free Methods inject :: forall (f :: k -> Type). f ~> Ap1 f Source #
FreeOf Apply Ap1 Source #
Instance details Defined in Data.HFunctor.Final Associated Types type FreeFunctorBy Ap1 :: (Type -> Type) -> Constraint Source # Methods fromFree :: forall (f :: Type -> Type). Ap1 f ~> Final Apply f Source # toFree :: forall (f :: Type -> Type). FreeFunctorBy Ap1 f => Final Apply f ~> Ap1 f Source #
HTraversable Ap1 Source #
Instance details 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) Source #
HTraversable1 Ap1 Source #
Instance details 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) Source #
HFunctor Ap1 Source #
Instance details Defined in Data.Functor.Apply.Free Methods hmap :: forall (f :: k -> Type) (g :: k -> Type). (f ~> g) -> Ap1 f ~> Ap1 g Source #
Apply f => Interpret Ap1 (f :: Type -> Type) Source #
Instance details Defined in Data.Functor.Apply.Free Methods retract :: Ap1 f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Ap1 g ~> f Source #
Functor (Ap1 f) Source #
Instance details 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) Source #	Since: 0.3.0.0
Instance details Defined in Data.Functor.Apply.Free Methods invmap :: (a -> b) -> (b -> a) -> Ap1 f a -> Ap1 f b #
Apply (Ap1 f) Source #
Instance details 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 Source #
Instance details Defined in Data.HFunctor.Final type FreeFunctorBy Ap1 = Unconstrained :: (Type -> Type) -> Constraint

toAp :: Ap1 f ~> Ap f Source #

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) Source #

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

liftAp1 :: f ~> Ap1 f Source #

Embed an f into Ap1.

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

Extract the f out of the Ap1.

retractAp1 . liftAp1 == id

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

Interpret an Ap f into some Apply context g.