constrained-categories 0.2.0.0 → 0.2.1.0

raw patch · 8 files changed

+55/−18 lines, 8 filesdep ~basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: base

API changes (from Hackage documentation)

Files

• Control/Applicative/Constrained.hs +1/−1
• Control/Arrow/Constrained.hs +3/−3
• Control/Category/Constrained/Prelude.hs +1/−1
• Control/Functor/Constrained.hs +1/−1
• Control/Monad/Constrained.hs +13/−2
• Data/Foldable/Constrained.hs +19/−1
• Data/Traversable/Constrained.hs +16/−8
• constrained-categories.cabal +1/−1

@@ -28,7 +28,7 @@ import Control.Functor.Constrained import Control.Arrow.Constrained -import Prelude hiding (id, const, (.), ($), Functor(..), curry, uncurry)+import Prelude hiding (id, const, (.), ($), Functor(..), Applicative(..), curry, uncurry) import qualified Control.Category.Hask as Hask  

@@ -104,9 +104,9 @@   --- | Unlike 'first', 'second', '***' and 'arr', '&&&' has an intrinsic notion---   of \"direction\": it is basically equivalent to precomposing the result---   of '***' with a @b -> (b,b)@, but that is in general only available+-- | Unlike 'first', 'second', '***' and 'arr', the fanout operation '&&&' has an+--   intrinsic notion of \"direction\": it is basically equivalent to precomposing+--   the result of '***' with a @b -> (b,b)@, but that is only available --   for arrows that generalise ordinary functions, in their native direction. --   (@(b,b) ->b@ is specific to semigroups.) It is for this reason the only constituent --   class of 'Arrow' that actually has \"arrow\" in its name.

@@ -20,7 +20,7 @@          ) where  import Prelude hiding ( id, const, fst, snd, (.), ($), curry, uncurry-                      , Functor(..), Monad(..), (=<<), filter+                      , Functor(..), (<$>), Applicative(..), (<*>), Monad(..), (=<<), filter                       , mapM, mapM_, sequence, sequence_ )  import Control.Category.Constrained hiding (ConstrainedMorphism)

@@ -27,7 +27,7 @@  import Control.Category.Constrained -import Prelude hiding (id, (.), Functor(..), filter)+import Prelude hiding (id, (.), Functor(..), filter, (<$>)) import qualified Prelude  import Data.Void

@@ -28,6 +28,7 @@                                 , mapM, mapM_, forM, forM_, sequence, sequence_                                 , guard, when, unless                                 , forever, void+                                , filterM                                 ) where  @@ -38,8 +39,8 @@  import Prelude hiding (      id, const, fst, snd, (.), ($)-   , Functor(..), Monad(..), (=<<)-   , uncurry, curry+   , Functor(..), Applicative(..), Monad(..), (=<<)+   , uncurry, curry, filter    , mapM, mapM_, sequence, sequence_    ) import qualified Control.Category.Hask as Hask@@ -256,6 +257,16 @@         ) => Bool -> m u `k` m u unless False = id unless True = pure . terminal+++filterM :: ( PreArrow k, Monad m k, SumToProduct c k k, EndoTraversable c k+           , ObjectPair k Bool a, Object k (c a), Object k (m (c a))+           , ObjectPair k (Bool, a) (c (Bool, a))+           , ObjectPair k (m Bool) (m a)+           , ObjectPair k (m (Bool, a)) (m (c (Bool, a)))+           , PointObject k (c (Bool, a))+           ) => a `k` m Bool -> c a `k` m (c a)+filterM pg = fmap (fmap snd <<< filter fst) <<< mapM (fzip <<< pg &&& pure)       

@@ -33,10 +33,12 @@    , Functor(..)    , uncurry, curry    , mapM_, sequence_, concatMap+   , Foldable(..)    ) import Data.Monoid  import qualified Control.Category.Hask as Hask+import qualified Data.Foldable as Hask import qualified Control.Arrow as A  import Control.Arrow.Constrained@@ -44,9 +46,25 @@   +-- | Foldable class, generalised to use arrows in categories other than 'Hask.->'. This changes the interface+--   somewhat &#x2013; in particular, 'Hask.foldr' relies on currying and hence can't really be expressed in+--   a category without exponential objects; however the monoidal folds come out quite nicely. (Of course,+--   it's debatable how much sense the Hask-'Monoid' class even makes in other categories.)+--   +--   Unlike with the 'Functor' classes, there is no derived instance @'Hask.Foldable' f => 'Foldable' f (->) (->)@:+--   in this case, it would prevent some genarality.+--   See below for how to define such an instance manually. class (Functor t k l) => Foldable t k l where+  -- |+  -- @+  -- 'ffoldl' &#x2261; 'uncurry' . 'Hask.foldl' . 'curry'+  -- @   ffoldl :: ( ObjectPair k a b, ObjectPair l a (t b)             ) => k (a,b) a -> l (a,t b) a+  -- |+  -- @+  -- 'foldMap' &#x2261; 'Hask.foldMap'+  -- @   foldMap :: ( Object k a, Object l (t a), Monoid m, Object k m, Object l m )                => (a `k` m) -> t a `l` m @@ -87,7 +105,7 @@ instance Foldable [] (->) (->) where   foldMap _ [] = mempty   foldMap f (x:xs) = f x <> foldMap f xs-  ffoldl f = uncurry $ foldl (curry f)+  ffoldl f = uncurry $ Hask.foldl (curry f)  instance Foldable Maybe (->) (->) where   foldMap f Nothing = mempty

@@ -17,7 +17,8 @@ module Data.Traversable.Constrained            ( module Control.Applicative.Constrained             , Traversable(..)-           , sequence, mapM, forM+           , sequence, forM+           , EndoTraversable            ) where  @@ -29,6 +30,8 @@    , Functor(..)    , uncurry, curry    , mapM, mapM_, sequence+   , Traversable(..)+   , Applicative(..)    ) import qualified Control.Category.Hask as Hask import qualified Control.Arrow as A@@ -46,7 +49,15 @@               , ObjectPair k b (t b), ObjectPair l (f b) (f (t b))                , ObjectPoint k (t b)               ) => a `l` f b -> s a `l` f (t b)+  +  -- | 'traverse', restricted to endofunctors. May be more efficient to implement.+  mapM :: ( k~l, s~t, Applicative m k k+          , Object k a, Object k (t a), ObjectPair k b (t b), ObjectPair k (m b) (m (t b))+          , ObjectPoint k (t b)+          ) => a `k` m b -> t a `k` m (t b)+  mapM = traverse + sequence :: ( Traversable t t k k, Monoidal f k k             , ObjectPair k a (t a), ObjectPair k (f a) (f (t a))             , Object k (t (f a))@@ -72,13 +83,6 @@ --   fmap (Stupid (ConstrainedMorphism f)) (Stupid a) = Stupid (f a) --  --- | 'traverse', restricted to endofunctors.-mapM :: ( Traversable t t k k, Monoidal m k k-        , Object k a, Object k (t a), ObjectPair k b (t b), ObjectPair k (m b) (m (t b))-        , ObjectPoint k (t b)-        ) => a `k` m b -> t a `k` m (t b)-mapM = traverse- -- | Flipped version of 'traverse' / 'mapM'. forM :: forall s t k m a b l .          ( Traversable s t k l, Monoidal m k l, Function l@@ -87,5 +91,9 @@         , ObjectPoint k (t b)         ) => s a -> (a `l` m b) -> m (t b) forM v f = traverse f $ v+++-- | A traversable that can be used with 'mapM'.+type EndoTraversable t k = Traversable t t k k  

@@ -1,5 +1,5 @@ Name:                constrained-categories-Version:             0.2.0.0+Version:             0.2.1.0 Category:            control Synopsis:            Constrained clones of the category-theory type classes, using ConstraintKinds. Description:         Haskell has, and makes great use of, powerful facilities from category