diff --git a/Control/Arrow/Constrained.hs b/Control/Arrow/Constrained.hs
--- a/Control/Arrow/Constrained.hs
+++ b/Control/Arrow/Constrained.hs
@@ -59,6 +59,8 @@
     -- * Misc utility
     -- ** Conditionals
     , choose, ifThenElse
+    -- ** Coercions
+    , follow, flout, pretend, swallow, pretendLike, swallowLike
     ) where
 
 import Prelude hiding (id, const, fst, snd, (.), ($), Functor(..), Monad(..), (=<<))
@@ -69,6 +71,9 @@
 import Data.Tagged
 import Data.Void
 
+import Data.Coerce
+import Data.Type.Coercion
+
 import qualified Control.Arrow as Arr
 
 infixr 1 >>>, <<<
@@ -245,8 +250,11 @@
 instance (Function f) => EnhancedCat (->) (ConstrainedCategory f o) where
   arr (ConstrainedMorphism q) = arr q
 
+instance EnhancedCat (->) Coercion where
+  arr = coerceWith
 
 
+
 type Arrow a k = (WellPointed a, EnhancedCat a k)
 type ArrowChoice a k = (WellPointed a, PreArrChoice a, EnhancedCat a k)
 
@@ -427,3 +435,44 @@
        => x -> GenericAgent k a x
 genericPoint x = GenericAgent $ const x
 
+
+
+-- | Imitate a type change in a different category. This is usually possible
+--   for type changes that are no-ops at runtime, in particular for newtype wrappers.
+follow :: (EnhancedCat k Coercion, Coercible a b, Object k a, Object k b)
+                 => p a b -> k a b
+follow _ = arr Coercion
+
+-- | The opposite of 'follow'.
+flout :: (EnhancedCat k Coercion, Coercible b a, Object k a, Object k b)
+                 => p a b -> k b a
+flout _ = arr Coercion
+
+-- | Wrap an endomorphism in inverse coercions, to have it work on any type
+--   that's representationally equivalent to the one in the morphism's signature.
+--   This is a specialised version of 'pretendLike'.
+pretend :: (EnhancedCat k Coercion, Object k a, Object k b)
+                  => Coercion a b -> k a a -> k b b
+pretend crc f = arr crc . f . arr (sym crc)
+
+-- | Equivalent to @'pretend' . 'sym'@.
+swallow :: (EnhancedCat k Coercion, Object k a, Object k b)
+                  => Coercion b a -> k a a -> k b b
+swallow crc f = arr (sym crc) . f . arr crc
+
+-- | This works much like <http://hackage.haskell.org/package/newtype-0.2/docs/Control-Newtype.html#v:over over>:
+--   wrap a morphism in any coercions required so the result types match.
+--   This will often be too polymorphic for the type checker; consider using the
+--   more explicit 'follow' and 'flout'.
+pretendLike :: ( EnhancedCat k Coercion, Coercible b a, Coercible c d
+               , Object k a, Object k b, Object k c, Object k d )
+                   => p c d -> k a c -> k b d
+pretendLike _ f = arr Coercion . f . arr Coercion
+
+
+-- | Generalised coercion analogue of
+--   <http://hackage.haskell.org/package/newtype-0.2/docs/Control-Newtype.html#v:under under>.
+swallowLike :: ( EnhancedCat k Coercion, Coercible b a, Coercible c d
+               , Object k a, Object k b, Object k c, Object k d )
+                   => p b a -> k a c -> k b d
+swallowLike _ f = arr Coercion . f . arr Coercion
diff --git a/Control/Category/Constrained.hs b/Control/Category/Constrained.hs
--- a/Control/Category/Constrained.hs
+++ b/Control/Category/Constrained.hs
@@ -45,6 +45,8 @@
 import Data.Tagged
 import Data.Monoid
 import Data.Void
+import Data.Type.Coercion
+import qualified Control.Category as Hask
 
 -- | In mathematics, a category is defined as a class of /objects/, plus a class of
 --   /morphisms/ between those objects. In Haskell, one traditionally works in
@@ -399,4 +401,6 @@
   ($~) = ($)
 
 
-
+instance Category Coercion where
+  id = Hask.id
+  (.) = (Hask..)
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
@@ -21,7 +21,9 @@
 
 import Prelude hiding ( id, const, fst, snd, (.), ($), curry, uncurry
                       , Functor(..), (<$>), Applicative(..), (<*>), Monad(..), (=<<), filter
-                      , mapM, mapM_, sequence, sequence_ )
+                      , mapM, mapM_, sequence, sequence_
+                      , Foldable, foldMap, fold, traverse_, concatMap
+                      , Traversable, traverse )
 
 import Control.Category.Constrained hiding (ConstrainedMorphism)
 import Control.Functor.Constrained
@@ -29,4 +31,8 @@
 import Control.Monad.Constrained hiding 
          (MonadPlus(..), MonadZero(..), (>=>), (<=<), guard, forever, void)
 import Control.Arrow.Constrained (Function, ($), ifThenElse, fst, snd, const)
+import Control.Applicative.Constrained
+
+import Data.Foldable.Constrained (Foldable, foldMap, fold, traverse_, concatMap)
+import Data.Traversable.Constrained (Traversable, traverse)
 
diff --git a/Control/Functor/Constrained.hs b/Control/Functor/Constrained.hs
--- a/Control/Functor/Constrained.hs
+++ b/Control/Functor/Constrained.hs
@@ -32,6 +32,9 @@
 
 import Data.Void
 
+import Data.Type.Coercion
+import Data.Complex
+
 class ( Category r, Category t, Object t (f (UnitObject r)) )
            => Functor f r t | f r -> t, f t -> r where
   fmap :: (Object r a, Object t (f a), Object r b, Object t (f b))
@@ -95,4 +98,11 @@
   filter (ConstrainedMorphism f) = ConstrainedMorphism $ filter f
 
   
+instance Functor [] Coercion Coercion where fmap Coercion = Coercion
+instance Functor Maybe Coercion Coercion where fmap Coercion = Coercion
+instance Functor (Either a) Coercion Coercion where fmap Coercion = Coercion
+instance Functor ((->) a) Coercion Coercion where fmap Coercion = Coercion
+instance Functor ((,) a) Coercion Coercion where fmap Coercion = Coercion
+instance Functor IO Coercion Coercion where fmap Coercion = Coercion
+instance Functor Complex Coercion Coercion where fmap Coercion = Coercion
 
diff --git a/Control/Monad/Constrained.hs b/Control/Monad/Constrained.hs
--- a/Control/Monad/Constrained.hs
+++ b/Control/Monad/Constrained.hs
@@ -264,7 +264,7 @@
            , 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))
+           , TraversalObject 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/Traversable/Constrained.hs b/Data/Traversable/Constrained.hs
--- a/Data/Traversable/Constrained.hs
+++ b/Data/Traversable/Constrained.hs
@@ -17,8 +17,9 @@
 module Data.Traversable.Constrained
            ( module Control.Applicative.Constrained 
            , Traversable(..)
-           , sequence, forM
+           , forM
            , EndoTraversable
+           , haskTraverse
            ) where
 
 
@@ -36,37 +37,44 @@
 import qualified Control.Category.Hask as Hask
 import qualified Control.Arrow as A
 
+import qualified Data.Traversable as Hask
+
 import Control.Arrow.Constrained
 
 import Data.Monoid
 
+import GHC.Exts (Constraint)
 
 
 
 class (Category k, Category l, Functor s l l, Functor t k k) 
       => Traversable s t k l | s k l -> t, t k l -> s, s t k -> l, s t l -> k where
+  type TraversalObject k t b :: Constraint
+  type TraversalObject k t b = ()
+  
   traverse :: ( Monoidal f k l, Object l a, Object l (s a)
               , ObjectPair k b (t b), ObjectPair l (f b) (f (t b)) 
-              , ObjectPoint k (t b)
+              , TraversalObject 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)
+          , TraversalObject 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))
-            , ObjectPoint k (t a)
-            ) => t (f a) `k` f (t a)
-sequence = traverse id
+  sequence :: ( k~l, s~t, Monoidal f k k
+              , ObjectPair k a (t a), ObjectPair k (f a) (f (t a))
+              , Object k (t (f a))
+              , TraversalObject k t a
+              ) => t (f a) `k` f (t a)
+  sequence = traverse id
 
 instance (Arrow k (->), WellPointed k, Function k, Functor [] k k) 
              => Traversable [] [] k k where
+  type TraversalObject k [] b = PointObject k [b]
   traverse f = arr mM
    where mM [] = constPure [] `inCategoryOf` f $ mempty
          mM (x:xs) = fzipWith (arr $ uncurry(:)) `inCategoryOf` f 
@@ -74,6 +82,7 @@
 
 instance (Arrow k (->), WellPointed k, Function k, Functor Maybe k k)
             => Traversable Maybe Maybe k k where
+  type TraversalObject k Maybe b = PointObject k (Maybe b)
   traverse f = arr mM 
    where mM Nothing = constPure Nothing `inCategoryOf` f $ mempty
          mM (Just x) = fmap (arr Just) . f $ x
@@ -88,7 +97,7 @@
         ( Traversable s t k l, Monoidal m k l, Function l
         , Object k b, Object k (t b), ObjectPair k b (t b)
         , Object l a, Object l (s a), ObjectPair l (m b) (m (t b))
-        , ObjectPoint k (t b)
+        , TraversalObject k t b
         ) => s a -> (a `l` m b) -> m (t b)
 forM v f = traverse f $ v
 
@@ -96,4 +105,21 @@
 -- | A traversable that can be used with 'mapM'.
 type EndoTraversable t k = Traversable t t k k
 
+
+newtype HaskWrapApplicative f x = HaskWrapApplicative { getHWAppl :: f x }
+
+instance (Functor f (->) (->)) => Hask.Functor (HaskWrapApplicative f) where
+  fmap f (HaskWrapApplicative c) = HaskWrapApplicative $ fmap f c
+instance (Monoidal f (->) (->)) => Hask.Applicative (HaskWrapApplicative f) where
+  pure x = HaskWrapApplicative $ (fmap (const x) . pureUnit) ()
+  HaskWrapApplicative fs <*> HaskWrapApplicative xs
+       = HaskWrapApplicative $ fzipWith (uncurry ($)) (fs, xs)
+
+-- | Use this if you want to “derive” a constrained traversable instance from a
+--   given 'Hask.Traversable' one. (You will not be able to simply set
+--   @'traverse' = 'Hask.traverse'@, because the latter requires the Prelude version
+--   of 'Hask.Applicative', which can not be inferred from the constrained `Monoidal`.
+haskTraverse :: (Hask.Traversable t, Monoidal f (->) (->))
+      => (a -> f b) -> t a -> f (t b)
+haskTraverse f = getHWAppl . Hask.traverse (HaskWrapApplicative . f) 
 
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.5.1
+Version:             0.3.0.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
@@ -31,6 +31,8 @@
 Homepage:            https://github.com/leftaroundabout/constrained-categories
 Build-Type:          Simple
 Cabal-Version:       >=1.10
+Tested-With:         GHC == 7.8.4, GHC == 7.10.2, GHC == 8.0.2
+                                
 
 source-repository head
   type: git
@@ -38,7 +40,7 @@
 
 Library
   Default-Language:   Haskell2010
-  Build-Depends:      base>=4.6 && <5
+  Build-Depends:      base>=4.7 && <5
                       , tagged
                       , void
   Default-Extensions: ConstraintKinds