Control.Arrow.Mix.Category

Documentation

type Along f input output i o = f (i, input) (o, output)

Sometimes we need to refine our morphism a bit; therefore, we use Along f i o instead of just f.

type :~> f g = forall i o. f i o -> g i o

Arrow morphism

type :~~> f g = forall i o. (i -> o) -> f i o -> g i o

Refined arrow morphism

class AlMonad m where

Something like a monad - but for arrows

Methods

alRet :: Arrow b => b :~> m b

alLift :: (Arrow b, Arrow c) => (Along b i1 o1 :~~> Along (m c) i2 o2) -> m b i1 o1 -> m c i2 o2

Instances

AlMonad f => AlMonad (:$~ f)

Arrow a => AlMonad (:+ a)

Arrow a => AlMonad (Mix a)

(~>>=) :: (AlMonad m, Arrow b, Arrow c) => m b i1 o1 -> (Along b i1 o1 :~> Along (m c) i2 o2) -> m c i2 o2

Most of time we don't need refined morphisms. That's why we would want a simpler combinator.

class AlFunctor f where

Something like a functor - again, for arrows

Methods

alMap :: (Arrow b, Arrow c) => (Along b i1 o1 :~> Along c i2 o2) -> f b i1 o1 -> f c i2 o2

Instances

AlMonad m => AlFunctor (:$~ m)

Arrow a => AlFunctor (:+ a)

type OhNo a b = b

Just a trick to avoid specifying rank explicitly

newtype (f :$~ a) input output

Declarations like instance Monad m => Functor m don't work well in Haskell. That's why we need a newtype.

Constructors

Apply

Fields

runApply :: a input output `OhNo` f a input output

Instances

AlMonad m => AlFunctor (:$~ m)

AlMonad f => AlMonad (:$~ f)

(AlMonad m, Arrow a) => Arrow (:$~ m a)

(AlMonad m, ArrowChoice a) => ArrowChoice (:$~ m a)

(AlMonad m, ArrowLoop a) => ArrowLoop (:$~ m a)

(AlMonad m, Arrow a) => Category (:$~ m a)