Safe Haskell	None
Language	Haskell2010
Extensions	Cpp MonoLocalBinds ScopedTypeVariables TypeFamilies GADTs GADTSyntax PolyKinds InstanceSigs TypeSynonymInstances FlexibleInstances KindSignatures RankNTypes ExplicitNamespaces ExplicitForAll

Control.Arrow.Free

Contents

Free arrow
Free arrow (CPS style)
Free interface re-exports

Synopsis

data Arr f a b where
- Id :: Arr f a a
- Arr :: (b -> c) -> Arr f a b -> Arr f a c
- Prod :: Arr f a b -> Arr f a c -> Arr f a (b, c)
arrArr :: (b -> c) -> Arr f b c
mapArr :: f b c -> Arr f a b -> Arr f a c
foldArr :: forall f arr a b. Arrow arr => (forall x y. f x y -> arr x y) -> Arr f a b -> arr a b
newtype A f a b = A {
- runA :: forall r. Arrow r => (forall x y. f x y -> r x y) -> r a b
}
fromA :: A f a b -> Arr f a b
toA :: Arr f a b -> A f a b
class FreeAlgebra2 (m :: (k -> k -> Type) -> k -> k -> Type) where
- liftFree2 :: AlgebraType0 m f => f a b -> m f a b
- foldNatFree2 :: (AlgebraType m d, AlgebraType0 m f) => (forall (x :: k) (y :: k). f x y -> d x y) -> m f a b -> d a b
- codom2 :: AlgebraType0 m f => Proof (AlgebraType m (m f)) (m f)
- forget2 :: AlgebraType m f => Proof (AlgebraType0 m f) (m f)
wrapFree2 :: (AlgebraType0 m f, FreeAlgebra2 m, Monad (m f a)) => f a (m f a b) -> m f a b
foldFree2 :: (FreeAlgebra2 m, AlgebraType m f) => m f a b -> f a b
hoistFree2 :: (FreeAlgebra2 m, AlgebraType0 m g, AlgebraType0 m f) => (forall (x :: k) (y :: k). f x y -> g x y) -> m f a b -> m g a b
joinFree2 :: (FreeAlgebra2 m, AlgebraType0 m f) => m (m f) a b -> m f a b
bindFree2 :: (FreeAlgebra2 m, AlgebraType0 m g, AlgebraType0 m f) => m f a b -> (forall (x :: k) (y :: k). f x y -> m g x y) -> m g a b

Free arrow

data Arr f a b where Source #

Constructors

Id :: Arr f a a
Arr :: (b -> c) -> Arr f a b -> Arr f a c
Prod :: Arr f a b -> Arr f a c -> Arr f a (b, c)

Instances

Arrow (Arr f) Source #
Instance details Defined in Control.Arrow.Free Methods arr :: (b -> c) -> Arr f b c # first :: Arr f b c -> Arr f (b, d) (c, d) # second :: Arr f b c -> Arr f (d, b) (d, c) # (***) :: Arr f b c -> Arr f b' c' -> Arr f (b, b') (c, c') # (&&&) :: Arr f b c -> Arr f b c' -> Arr f b (c, c') #
FreeAlgebra2 Arr Source #
Instance details Defined in Control.Arrow.Free Methods liftFree2 :: AlgebraType0 Arr f => f a b -> Arr f a b # foldNatFree2 :: (AlgebraType Arr d, AlgebraType0 Arr f) => (forall (x :: k) (y :: k). f x y -> d x y) -> Arr f a b -> d a b # codom2 :: AlgebraType0 Arr f => Proof (AlgebraType Arr (Arr f)) (Arr f) # forget2 :: AlgebraType Arr f => Proof (AlgebraType0 Arr f) (Arr f) #
Category (Arr f :: Type -> Type -> Type) Source #
Instance details Defined in Control.Arrow.Free Methods id :: Arr f a a # (.) :: Arr f b c -> Arr f a b -> Arr f a c #
Semigroup (Arr f o o) Source #
Instance details Defined in Control.Arrow.Free Methods (<>) :: Arr f o o -> Arr f o o -> Arr f o o # sconcat :: NonEmpty (Arr f o o) -> Arr f o o # stimes :: Integral b => b -> Arr f o o -> Arr f o o #
Monoid (Arr f o o) Source #
Instance details Defined in Control.Arrow.Free Methods mempty :: Arr f o o # mappend :: Arr f o o -> Arr f o o -> Arr f o o # mconcat :: [Arr f o o] -> Arr f o o #
type AlgebraType0 Arr (f :: l) Source #
Instance details Defined in Control.Arrow.Free type AlgebraType0 Arr (f :: l) = ()
type AlgebraType Arr (c :: Type -> Type -> Type) Source #
Instance details Defined in Control.Arrow.Free type AlgebraType Arr (c :: Type -> Type -> Type) = Arrow c

arrArr :: (b -> c) -> Arr f b c Source #

mapArr :: f b c -> Arr f a b -> Arr f a c Source #

foldArr :: forall f arr a b. Arrow arr => (forall x y. f x y -> arr x y) -> Arr f a b -> arr a b Source #

Free arrow (CPS style)

newtype A f a b Source #

Free arrow using CPS sytle.

Constructors

A
Fields runA :: forall r. Arrow r => (forall x y. f x y -> r x y) -> r a b

Instances

Arrow (A f) Source #
Instance details Defined in Control.Arrow.Free Methods arr :: (b -> c) -> A f b c # first :: A f b c -> A f (b, d) (c, d) # second :: A f b c -> A f (d, b) (d, c) # (***) :: A f b c -> A f b' c' -> A f (b, b') (c, c') # (&&&) :: A f b c -> A f b c' -> A f b (c, c') #
FreeAlgebra2 A Source #
Instance details Defined in Control.Arrow.Free Methods liftFree2 :: AlgebraType0 A f => f a b -> A f a b # foldNatFree2 :: (AlgebraType A d, AlgebraType0 A f) => (forall (x :: k) (y :: k). f x y -> d x y) -> A f a b -> d a b # codom2 :: AlgebraType0 A f => Proof (AlgebraType A (A f)) (A f) # forget2 :: AlgebraType A f => Proof (AlgebraType0 A f) (A f) #
Category (A f :: Type -> Type -> Type) Source #
Instance details Defined in Control.Arrow.Free Methods id :: A f a a # (.) :: A f b c -> A f a b -> A f a c #
Semigroup (A f o o) Source #
Instance details Defined in Control.Arrow.Free Methods (<>) :: A f o o -> A f o o -> A f o o # sconcat :: NonEmpty (A f o o) -> A f o o # stimes :: Integral b => b -> A f o o -> A f o o #
Monoid (A f o o) Source #
Instance details Defined in Control.Arrow.Free Methods mempty :: A f o o # mappend :: A f o o -> A f o o -> A f o o # mconcat :: [A f o o] -> A f o o #
type AlgebraType0 A (f :: l) Source #
Instance details Defined in Control.Arrow.Free type AlgebraType0 A (f :: l) = ()
type AlgebraType A (c :: Type -> Type -> Type) Source #
Instance details Defined in Control.Arrow.Free type AlgebraType A (c :: Type -> Type -> Type) = Arrow c

fromA :: A f a b -> Arr f a b Source #

Inverse of fromA, which also is a specialisatin of hoistFreeH2.

toA :: Arr f a b -> A f a b Source #

Isomorphism from Arr to A, which is a specialisation of hoistFreeH2.

Free interface re-exports

class FreeAlgebra2 (m :: (k -> k -> Type) -> k -> k -> Type) where #

Free algebra class similar to FreeAlgebra1 and FreeAlgebra, but for types of kind k -> k -> Type.

Minimal complete definition

liftFree2, foldNatFree2

Methods

liftFree2 :: AlgebraType0 m f => f a b -> m f a b #

Lift a graph f satsifying the constraint AlgebraType0 to a free its object m f.

foldNatFree2 :: (AlgebraType m d, AlgebraType0 m f) => (forall (x :: k) (y :: k). f x y -> d x y) -> m f a b -> d a b #

This represents the theorem that m f is indeed free object (as in propositions as types). The types of kind k -> k -> Type form a category, where an arrow from f :: k -> k -> Type to d :: k -> k -> Type is represented by type forall x y. f x y -> d x y. foldNatFree2 states that whenever we have such a morphism and d satisfies the constraint AlgebraType m d then we can construct a morphism from m f to d.

foldNatFree2 nat (liftFree2 tr) = nat tr

foldNatFree2 nat . foldNatFree2 nat' = foldNatFree2 (foldNatFree2 nat . nat')

codom2 :: AlgebraType0 m f => Proof (AlgebraType m (m f)) (m f) #

A proof that for each f satisfying AlgebraType0 m f, m f satisfies AlgebraType m (m f) constrant. This means that m is a well defined functor from the full sub-category of types of kind k -> k -> Type which satisfy the AlgebraType0 m constraint to the full subcategory of types of the same kind which satifsfy the constraint AlgebraType m.

forget2 :: AlgebraType m f => Proof (AlgebraType0 m f) (m f) #

A proof that each type f :: k -> k -> Type satisfying the Algebra m f constraint also satisfies AlgebraType0 m f. This states that there is a well defined forgetful functor from the category of types of kind k -> k -> Type which satisfy the AlgebraType m to the category of types of the same kind which satisfy the AlgebraType0 m constraint.

Instances

FreeAlgebra2 (ListTr :: (k -> k -> Type) -> k -> k -> Type) Source #
Instance details Defined in Control.Category.Free.Internal Methods liftFree2 :: AlgebraType0 ListTr f => f a b -> ListTr f a b # foldNatFree2 :: (AlgebraType ListTr d, AlgebraType0 ListTr f) => (forall (x :: k0) (y :: k0). f x y -> d x y) -> ListTr f a b -> d a b # codom2 :: AlgebraType0 ListTr f => Proof (AlgebraType ListTr (ListTr f)) (ListTr f) # forget2 :: AlgebraType ListTr f => Proof (AlgebraType0 ListTr f) (ListTr f) #
FreeAlgebra2 (Queue :: (k -> k -> Type) -> k -> k -> Type) Source #
Instance details Defined in Control.Category.Free.Internal Methods liftFree2 :: AlgebraType0 Queue f => f a b -> Queue f a b # foldNatFree2 :: (AlgebraType Queue d, AlgebraType0 Queue f) => (forall (x :: k0) (y :: k0). f x y -> d x y) -> Queue f a b -> d a b # codom2 :: AlgebraType0 Queue f => Proof (AlgebraType Queue (Queue f)) (Queue f) # forget2 :: AlgebraType Queue f => Proof (AlgebraType0 Queue f) (Queue f) #
FreeAlgebra2 (C :: (k -> k -> Type) -> k -> k -> Type) Source #
Instance details Defined in Control.Category.Free Methods liftFree2 :: AlgebraType0 C f => f a b -> C f a b # foldNatFree2 :: (AlgebraType C d, AlgebraType0 C f) => (forall (x :: k0) (y :: k0). f x y -> d x y) -> C f a b -> d a b # codom2 :: AlgebraType0 C f => Proof (AlgebraType C (C f)) (C f) # forget2 :: AlgebraType C f => Proof (AlgebraType0 C f) (C f) #
Monad m => FreeAlgebra2 (EffCat m :: (k -> k -> Type) -> k -> k -> Type) Source #
Instance details Defined in Control.Category.FreeEffect Methods liftFree2 :: AlgebraType0 (EffCat m) f => f a b -> EffCat m f a b # foldNatFree2 :: (AlgebraType (EffCat m) d, AlgebraType0 (EffCat m) f) => (forall (x :: k0) (y :: k0). f x y -> d x y) -> EffCat m f a b -> d a b # codom2 :: AlgebraType0 (EffCat m) f => Proof (AlgebraType (EffCat m) (EffCat m f)) (EffCat m f) # forget2 :: AlgebraType (EffCat m) f => Proof (AlgebraType0 (EffCat m) f) (EffCat m f) #
FreeAlgebra2 A Source #
Instance details Defined in Control.Arrow.Free Methods liftFree2 :: AlgebraType0 A f => f a b -> A f a b # foldNatFree2 :: (AlgebraType A d, AlgebraType0 A f) => (forall (x :: k) (y :: k). f x y -> d x y) -> A f a b -> d a b # codom2 :: AlgebraType0 A f => Proof (AlgebraType A (A f)) (A f) # forget2 :: AlgebraType A f => Proof (AlgebraType0 A f) (A f) #
FreeAlgebra2 Arr Source #
Instance details Defined in Control.Arrow.Free Methods liftFree2 :: AlgebraType0 Arr f => f a b -> Arr f a b # foldNatFree2 :: (AlgebraType Arr d, AlgebraType0 Arr f) => (forall (x :: k) (y :: k). f x y -> d x y) -> Arr f a b -> d a b # codom2 :: AlgebraType0 Arr f => Proof (AlgebraType Arr (Arr f)) (Arr f) # forget2 :: AlgebraType Arr f => Proof (AlgebraType0 Arr f) (Arr f) #

wrapFree2 :: (AlgebraType0 m f, FreeAlgebra2 m, Monad (m f a)) => f a (m f a b) -> m f a b #

Version of wrap from free package but for graphs.

foldFree2 :: (FreeAlgebra2 m, AlgebraType m f) => m f a b -> f a b #

Like foldFree or foldFree1 but for graphs.

A lawful instance will satisfy:

 foldFree2 . liftFree2 == id :: f a b -> f a b

It is the unit of adjuction defined by FreeAlgebra1 class.

hoistFree2 :: (FreeAlgebra2 m, AlgebraType0 m g, AlgebraType0 m f) => (forall (x :: k) (y :: k). f x y -> g x y) -> m f a b -> m g a b #

Hoist the underlying graph in the free structure. This is a higher version of a functor (analogous to fmapFree, which defined functor instance for FreeAlgebra instances) and it satisfies the functor laws:

hoistFree2 id = id

hoistFree2 f . hoistFree2 g = hoistFree2 (f . g)

joinFree2 :: (FreeAlgebra2 m, AlgebraType0 m f) => m (m f) a b -> m f a b #

FreeAlgebra2 mis a monad on some subcategory of graphs (types of kindk -> k -> Type@), joinFree it is the join of this monad.

foldNatFree2 nat . joinFree2 = foldNatFree2 (foldNatFree2 nat)

This property is analogous to foldMap f . concat = foldMap (foldMap f),

bindFree2 :: (FreeAlgebra2 m, AlgebraType0 m g, AlgebraType0 m f) => m f a b -> (forall (x :: k) (y :: k). f x y -> m g x y) -> m g a b #

bind of the monad defined by m on the subcategory of graphs (types of kind k -> k -> Type).

foldNatFree2 nat (bindFree mf nat') = foldNatFree2 (foldNatFree2 nat . nat') mf