diff --git a/Control/Monad/Co.hs b/Control/Monad/Co.hs
--- a/Control/Monad/Co.hs
+++ b/Control/Monad/Co.hs
@@ -18,8 +18,8 @@
 -- http://comonad.com/reader/2011/monads-from-comonads/
 --
 ----------------------------------------------------------------------------
-module Control.Monad.Co 
-  ( 
+module Control.Monad.Co
+  (
   -- * Monads from Comonads
     Co, co, runCo
   -- * Monad Transformers from Comonads
@@ -44,7 +44,13 @@
 import Control.Monad.Writer.Class as Writer
 import Control.Monad.Identity
 import Data.Functor.Bind
+import Control.Concurrent.Speculation
+import Control.Concurrent.Speculation.Class
 
+instance Comonad w => MonadSpec (CoT w m) where
+  specByM f g a = CoT (\k -> specBy f g (extract k) a)
+  specByM' f g a = CoT (\k -> specBy' f g (extract k) a)
+
 type Co w = CoT w Identity
 
 co :: Functor w => (forall r. w (a -> r) -> r) -> Co w a
@@ -67,7 +73,7 @@
 instance Comonad w => Applicative (CoT w m) where
   pure a = CoT (`extract` a)
   mf <*> ma = mf >>= \f -> fmap f ma
-  
+
 instance Comonad w => Monad (CoT w m) where
   return a = CoT (`extract` a)
   CoT k >>= f = CoT (k . extend (\wa a -> runCoT (f a) wa))
@@ -82,10 +88,10 @@
 liftCoT0 f = CoT (extract <*> f)
 
 lowerCoT0 :: (Functor w, Monad m) => CoT w m s -> w a -> m s
-lowerCoT0 m = runCoT m . (return <$) 
+lowerCoT0 m = runCoT m . (return <$)
 
 lowerCo0 :: Functor w => Co w s -> w a -> s
-lowerCo0 m = runIdentity . runCoT m . (return <$) 
+lowerCo0 m = runIdentity . runCoT m . (return <$)
 
 liftCoT1 :: (forall a. w a -> a) -> CoT w m ()
 liftCoT1 f = CoT (`f` ())
@@ -124,7 +130,7 @@
 
 instance (Comonad w, MonadWriter e m) => MonadWriter e (CoT w m) where
   tell = lift . tell
-  pass m = CoT (pass . runCoT m . fmap aug) where 
+  pass m = CoT (pass . runCoT m . fmap aug) where
     aug f (a,e) = liftM (\r -> (r,e)) (f a)
   listen = error "Control.Monad.Co.listen: TODO"
 
diff --git a/Control/Monad/Codensity.hs b/Control/Monad/Codensity.hs
--- a/Control/Monad/Codensity.hs
+++ b/Control/Monad/Codensity.hs
@@ -28,8 +28,14 @@
 import Data.Functor.Apply
 import Control.Monad.Trans.Class
 import Control.Monad.IO.Class
+import Control.Concurrent.Speculation
+import Control.Concurrent.Speculation.Class
 
 newtype Codensity m a = Codensity { runCodensity :: forall b. (a -> m b) -> m b }
+
+instance MonadSpec (Codensity m) where
+  specByM f g a = Codensity $ \k -> specBy f g k a
+  specByM' f g a = Codensity $ \k -> specBy' f g k a
 
 instance Functor (Codensity k) where
   fmap f (Codensity m) = Codensity (\k -> m (k . f))
diff --git a/Control/Monad/Free/Church.hs b/Control/Monad/Free/Church.hs
--- a/Control/Monad/Free/Church.hs
+++ b/Control/Monad/Free/Church.hs
@@ -31,6 +31,12 @@
 import Control.Monad.Cont.Class
 import Control.Monad.Trans.Class
 import Control.Monad.State.Class
+import Control.Concurrent.Speculation
+import Control.Concurrent.Speculation.Class
+
+instance MonadSpec (F f) where
+  specByM f g a = F (\k _ -> specBy f g k a)
+  specByM' f g a = F (\k _ -> specBy' f g k a)
 
 newtype F f a = F { runF :: forall r. (a -> r) -> (f r -> r) -> r }
 
diff --git a/kan-extensions.cabal b/kan-extensions.cabal
--- a/kan-extensions.cabal
+++ b/kan-extensions.cabal
@@ -1,6 +1,6 @@
 name:          kan-extensions
 category:      Data Structures, Monads, Comonads, Functors
-version:       2.0.2
+version:       2.1
 license:       BSD3
 cabal-version: >= 1.6
 license-file:  LICENSE
@@ -22,13 +22,13 @@
     CPP
     MultiParamTypeClasses
     GADTs
-    Rank2Types, 
+    Rank2Types,
     FlexibleInstances
     FlexibleContexts
     UndecidableInstances
     TypeFamilies
 
-  build-depends: 
+  build-depends:
     array                  >= 0.3.0.2 && < 0.4,
     base                   >= 4       && < 5,
     comonad                >= 1.1.1.1 && < 1.2,
@@ -42,8 +42,9 @@
     comonads-fd            >= 2.0     && < 2.1,
     keys                   >= 2.1     && < 2.2,
     free                   >= 2.0     && < 2.1,
-    adjunctions            >= 2.0     && < 2.1,
-    representable-functors >= 2.0     && < 2.1
+    adjunctions            >= 2.0.4   && < 2.1,
+    representable-functors >= 2.1     && < 2.2,
+    speculation            >= 1.4     && < 1.5
 
   exposed-modules:
     Control.Comonad.Density