Copyright	(c) Justin Le 2019
License	BSD3
Maintainer	[email protected]
Stability	experimental
Portability	non-portable
Safe Haskell	None
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 (a :: Type -> Type) b where
- Ap1 :: forall (a :: Type -> Type) a1 b. a a1 -> Ap a (a1 -> b) -> Ap1 a b
- pattern DayAp1 :: Day f (Ap f) a -> Ap1 f a
toAp :: forall (f :: Type -> Type) x. Ap1 f x -> Ap f x
fromAp :: forall (f :: Type -> Type) x. Ap f x -> (Identity :+: Ap1 f) x
liftAp1 :: f x -> Ap1 f x
retractAp1 :: forall (f :: Type -> Type). Apply f => Ap1 f ~> f
runAp1 :: forall (g :: Type -> Type) (f :: Type -> Type). Apply g => (f ~> g) -> Ap1 f ~> g

Documentation

data Ap1 (a :: Type -> Type) b 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 :: forall (a :: Type -> Type) a1 b. a a1 -> Ap a (a1 -> b) -> Ap1 a 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 :: Type -> Type) (g :: Type -> Type). (f ~> Ap1 g) -> Ap1 f ~> Ap1 g Source #

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

Inject Ap1 Source #

Instance details

Defined in Data.Functor.Apply.Free

Methods

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

FreeOf Apply Ap1 Source #

Instance details

Defined in Data.HFunctor.Final

Associated Types

type FreeFunctorBy Ap1
Instance details Defined in Data.HFunctor.Final type FreeFunctorBy Ap1 = Unconstrained :: (Type -> Type) -> Constraint

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 :: Applicative h => (forall x. 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 :: Apply h => (forall x. 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 :: Type -> Type) (g :: Type -> 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 :: Type -> 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 :: forall (f :: Type -> Type) x. Ap1 f x -> Ap f x Source #

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

fromAp :: forall (f :: Type -> Type) x. Ap f x -> (Identity :+: Ap1 f) x Source #

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

liftAp1 :: f x -> Ap1 f x Source #

Embed an f into Ap1.

retractAp1 :: forall (f :: Type -> Type). Apply f => Ap1 f ~> f Source #

Extract the f out of the Ap1.

retractAp1 . liftAp1 == id

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

Interpret an Ap f into some Apply context g.