Control.Functor.Constrained

Documentation

module Control.Category.Constrained

Functors

class (Category r, Category t, Object t (f (UnitObject r))) => Functor f r t | f r -> t, f t -> r where

Minimal complete definition

fmap

Methods

fmap :: (Object r a, Object t (f a), Object r b, Object t (f b)) => r a b -> t (f a) (f b)

Instances

Functor [] (Coercion *) (Coercion *)

Methods

fmap :: (Object (Coercion *) a, Object (Coercion *) [a], Object (Coercion *) b, Object (Coercion *) [b]) => Coercion * a b -> Coercion * [a] [b]

Functor [] (Discrete *) (Discrete *)

Methods

fmap :: (Object (Discrete *) a, Object (Discrete *) [a], Object (Discrete *) b, Object (Discrete *) [b]) => Discrete * a b -> Discrete * [a] [b]

Functor Maybe (Coercion *) (Coercion *)

Methods

fmap :: (Object (Coercion *) a, Object (Coercion *) (Maybe a), Object (Coercion *) b, Object (Coercion *) (Maybe b)) => Coercion * a b -> Coercion * (Maybe a) (Maybe b)

Functor Maybe (Discrete *) (Discrete *)

Methods

fmap :: (Object (Discrete *) a, Object (Discrete *) (Maybe a), Object (Discrete *) b, Object (Discrete *) (Maybe b)) => Discrete * a b -> Discrete * (Maybe a) (Maybe b)

Functor IO (Coercion *) (Coercion *)

Methods

fmap :: (Object (Coercion *) a, Object (Coercion *) (IO a), Object (Coercion *) b, Object (Coercion *) (IO b)) => Coercion * a b -> Coercion * (IO a) (IO b)

Functor IO (Discrete *) (Discrete *)

Methods

fmap :: (Object (Discrete *) a, Object (Discrete *) (IO a), Object (Discrete *) b, Object (Discrete *) (IO b)) => Discrete * a b -> Discrete * (IO a) (IO b)

Functor Complex (Coercion *) (Coercion *)

Methods

fmap :: (Object (Coercion *) a, Object (Coercion *) (Complex a), Object (Coercion *) b, Object (Coercion *) (Complex b)) => Coercion * a b -> Coercion * (Complex a) (Complex b)

Functor Complex (Discrete *) (Discrete *)

Methods

fmap :: (Object (Discrete *) a, Object (Discrete *) (Complex a), Object (Discrete *) b, Object (Discrete *) (Complex b)) => Discrete * a b -> Discrete * (Complex a) (Complex b)

(Functor [] k k, o [UnitObject k]) => Functor [] (ConstrainedCategory k o) (ConstrainedCategory k o)

Methods

fmap :: (Object (ConstrainedCategory k o) a, Object (ConstrainedCategory k o) [a], Object (ConstrainedCategory k o) b, Object (ConstrainedCategory k o) [b]) => ConstrainedCategory k o a b -> ConstrainedCategory k o [a] [b]

Functor f => Functor f ((->) LiftedRep LiftedRep) ((->) LiftedRep LiftedRep)

Methods

fmap :: (Object (LiftedRep -> LiftedRep) a, Object (LiftedRep -> LiftedRep) (f a), Object (LiftedRep -> LiftedRep) b, Object (LiftedRep -> LiftedRep) (f b)) => (LiftedRep -> LiftedRep) a b -> (LiftedRep -> LiftedRep) (f a) (f b)

Functor (Either a) (Discrete *) (Discrete *)

Methods

fmap :: (Object (Discrete *) a, Object (Discrete *) (Either a a), Object (Discrete *) b, Object (Discrete *) (Either a b)) => Discrete * a b -> Discrete * (Either a a) (Either a b)

Functor (Either a) (Coercion *) (Coercion *)

Methods

fmap :: (Object (Coercion *) a, Object (Coercion *) (Either a a), Object (Coercion *) b, Object (Coercion *) (Either a b)) => Coercion * a b -> Coercion * (Either a a) (Either a b)

Functor ((,) a) (Discrete *) (Discrete *)

Methods

fmap :: (Object (Discrete *) a, Object (Discrete *) (a, a), Object (Discrete *) b, Object (Discrete *) (a, b)) => Discrete * a b -> Discrete * (a, a) (a, b)

Functor ((,) a) (Coercion *) (Coercion *)

Methods

fmap :: (Object (Coercion *) a, Object (Coercion *) (a, a), Object (Coercion *) b, Object (Coercion *) (a, b)) => Coercion * a b -> Coercion * (a, a) (a, b)

Functor ((->) LiftedRep LiftedRep a) (Discrete *) (Discrete *)

Methods

fmap :: (Object (Discrete *) a, Object (Discrete *) ((LiftedRep -> LiftedRep) a a), Object (Discrete *) b, Object (Discrete *) ((LiftedRep -> LiftedRep) a b)) => Discrete * a b -> Discrete * ((LiftedRep -> LiftedRep) a a) ((LiftedRep -> LiftedRep) a b)

Functor ((->) LiftedRep LiftedRep a) (Coercion *) (Coercion *)

Methods

fmap :: (Object (Coercion *) a, Object (Coercion *) ((LiftedRep -> LiftedRep) a a), Object (Coercion *) b, Object (Coercion *) ((LiftedRep -> LiftedRep) a b)) => Coercion * a b -> Coercion * ((LiftedRep -> LiftedRep) a a) ((LiftedRep -> LiftedRep) a b)

(<$>) :: (Functor f r (->), Object r a, Object r b) => r a b -> f a -> f b infixl 4

constrainedFmap :: (Category r, Category t, o a, o b, o (f a), o (f b)) => (r a b -> t (f a) (f b)) -> ConstrainedCategory r o a b -> ConstrainedCategory t o (f a) (f b)

[Co]product mapping

class (CoCartesian r, Cartesian t, Functor f r t, Object t (f (ZeroObject r))) => SumToProduct f r t where

It is fairly common for functors (typically, container-like) to map Either to tuples in a natural way, thus "separating the variants". This is related to Foldable (with list and tuple monoids), but rather more effective.

Minimal complete definition

sum2product, mapEither, filter

Methods

sum2product :: (ObjectSum r a b, ObjectPair t (f a) (f b)) => t (f (a + b)) (f a, f b)

  sum2product ≡ mapEither id
  

mapEither :: (Object r a, ObjectSum r b c, Object t (f a), ObjectPair t (f b) (f c)) => r a (b + c) -> t (f a) (f b, f c)

  mapEither f ≡ sum2product . fmap f
  

filter :: (Object r a, Object r Bool, Object t (f a)) => r a Bool -> t (f a) (f a)

Instances

SumToProduct [] ((->) LiftedRep LiftedRep) ((->) LiftedRep LiftedRep)

Methods

sum2product :: (ObjectSum (LiftedRep -> LiftedRep) a b, ObjectPair (LiftedRep -> LiftedRep) [a] [b]) => (LiftedRep -> LiftedRep) [a + b] ([a], [b])

mapEither :: (Object (LiftedRep -> LiftedRep) a, ObjectSum (LiftedRep -> LiftedRep) b c, Object (LiftedRep -> LiftedRep) [a], ObjectPair (LiftedRep -> LiftedRep) [b] [c]) => (LiftedRep -> LiftedRep) a (b + c) -> (LiftedRep -> LiftedRep) [a] ([b], [c])

filter :: (Object (LiftedRep -> LiftedRep) a, Object (LiftedRep -> LiftedRep) Bool, Object (LiftedRep -> LiftedRep) [a]) => (LiftedRep -> LiftedRep) a Bool -> (LiftedRep -> LiftedRep) [a] [a]

(o (), o [()], o Void, o [Void]) => SumToProduct [] (ConstrainedCategory ((->) LiftedRep LiftedRep) o) (ConstrainedCategory ((->) LiftedRep LiftedRep) o)

Methods

sum2product :: (ObjectSum (ConstrainedCategory (LiftedRep -> LiftedRep) o) a b, ObjectPair (ConstrainedCategory (LiftedRep -> LiftedRep) o) [a] [b]) => ConstrainedCategory (LiftedRep -> LiftedRep) o [a + b] ([a], [b])

mapEither :: (Object (ConstrainedCategory (LiftedRep -> LiftedRep) o) a, ObjectSum (ConstrainedCategory (LiftedRep -> LiftedRep) o) b c, Object (ConstrainedCategory (LiftedRep -> LiftedRep) o) [a], ObjectPair (ConstrainedCategory (LiftedRep -> LiftedRep) o) [b] [c]) => ConstrainedCategory (LiftedRep -> LiftedRep) o a (b + c) -> ConstrainedCategory (LiftedRep -> LiftedRep) o [a] ([b], [c])

filter :: (Object (ConstrainedCategory (LiftedRep -> LiftedRep) o) a, Object (ConstrainedCategory (LiftedRep -> LiftedRep) o) Bool, Object (ConstrainedCategory (LiftedRep -> LiftedRep) o) [a]) => ConstrainedCategory (LiftedRep -> LiftedRep) o a Bool -> ConstrainedCategory (LiftedRep -> LiftedRep) o [a] [a]