diff --git a/Control/Applicative/Constrained.hs b/Control/Applicative/Constrained.hs
--- a/Control/Applicative/Constrained.hs
+++ b/Control/Applicative/Constrained.hs
@@ -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
 
 
diff --git a/Control/Arrow/Constrained.hs b/Control/Arrow/Constrained.hs
--- a/Control/Arrow/Constrained.hs
+++ b/Control/Arrow/Constrained.hs
@@ -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.
diff --git a/Control/Category/Constrained/Prelude.hs b/Control/Category/Constrained/Prelude.hs
--- a/Control/Category/Constrained/Prelude.hs
+++ b/Control/Category/Constrained/Prelude.hs
@@ -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)
diff --git a/Control/Functor/Constrained.hs b/Control/Functor/Constrained.hs
--- a/Control/Functor/Constrained.hs
+++ b/Control/Functor/Constrained.hs
@@ -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
diff --git a/Control/Monad/Constrained.hs b/Control/Monad/Constrained.hs
--- a/Control/Monad/Constrained.hs
+++ b/Control/Monad/Constrained.hs
@@ -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)
     
 
 
diff --git a/Data/Foldable/Constrained.hs b/Data/Foldable/Constrained.hs
--- a/Data/Foldable/Constrained.hs
+++ b/Data/Foldable/Constrained.hs
@@ -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
diff --git a/Data/Traversable/Constrained.hs b/Data/Traversable/Constrained.hs
--- a/Data/Traversable/Constrained.hs
+++ b/Data/Traversable/Constrained.hs
@@ -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
 
 
diff --git a/constrained-categories.cabal b/constrained-categories.cabal
--- a/constrained-categories.cabal
+++ b/constrained-categories.cabal
@@ -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