diff --git a/Control/Comonad.hs b/Control/Comonad.hs
--- a/Control/Comonad.hs
+++ b/Control/Comonad.hs
@@ -14,16 +14,12 @@
   -- * Comonads
   -- $definition
     Comonad(..)
-  , (=>>)     -- :: Comonad w => w a -> (w a -> b) -> w b
-  , (<<=)     -- :: Comonad w => (w a -> b) -> w a -> w b
   , liftW     -- :: Comonad w => (a -> b) -> w a -> w b
   , wfix      -- :: Comonad w => w (w a -> a) -> a
 
   -- * Cokleisli Arrows
   , Cokleisli(..)
-  -- ** Cokleisli composition
-  , (=>=)     -- :: Comonad w => (w a -> b) -> (w b -> c) -> w a -> c
-  , (=<=)     -- :: Comonad w => (w b -> c) -> (w a -> b) -> w a -> c
+  , module Data.Functor.Extend
   ) where
 
 import Prelude hiding (id, (.))
@@ -32,29 +28,18 @@
 import Control.Category
 import Control.Monad.Trans.Identity
 import Data.Functor.Identity
+import Data.Functor.Extend
 import Data.Monoid
 import Data.Typeable
-
-infixl 1 =>> 
-infixr 1 <<=, =<=, =>= 
+import Data.Semigroup
 
 {- | $definition -}
 
-class Functor w => Comonad w where
+class Extend w => Comonad w where
   -- | 
   -- > extract . fmap f = f . extract
   extract   :: w a -> a
-  -- | 
-  -- > duplicate = extend id
-  -- > fmap (fmap f) . duplicate = duplicate . fmap f
-  duplicate :: w a -> w (w a)
-  -- |
-  -- > extend f  = fmap f . duplicate
-  extend    :: (w a -> b) -> w a -> w b
 
-  extend f = fmap f . duplicate
-  duplicate = extend id
-
 -- | A suitable default definition for 'fmap' for a 'Comonad'. 
 -- Promotes a function to a comonad.
 --
@@ -63,26 +48,6 @@
 liftW f = extend (f . extract)
 {-# INLINE liftW #-}
 
--- | 'extend' with the arguments swapped. Dual to '>>=' for a 'Monad'.
-(=>>) :: Comonad w => w a -> (w a -> b) -> w b
-(=>>) = flip extend
-{-# INLINE (=>>) #-}
-
--- | 'extend' in operator form 
-(<<=) :: Comonad w => (w a -> b) -> w a -> w b
-(<<=) = extend
-{-# INLINE (<<=) #-}
-
--- | Right-to-left Cokleisli composition 
-(=<=) :: Comonad w => (w b -> c) -> (w a -> b) -> w a -> c
-f =<= g = f . extend g
-{-# INLINE (=<=) #-}
-
--- | Left-to-right Cokleisli composition
-(=>=) :: Comonad w => (w a -> b) -> (w b -> c) -> w a -> c
-f =>= g = g . extend f 
-{-# INLINE (=>=) #-}
-
 -- | Comonadic fixed point
 wfix :: Comonad w => w (w a -> a) -> a
 wfix w = extract w (extend wfix w)
@@ -99,11 +64,9 @@
 
 instance Comonad ((,)e) where
   extract = snd
-  duplicate ~(e,a) = (e,(e,a))
 
-instance Monoid m => Comonad ((->)m) where
+instance (Semigroup m, Monoid m) => Comonad ((->)m) where
   extract f = f mempty
-  duplicate f m = f . mappend m
 
 -- * Comonads for types from 'transformers'.
 --
@@ -112,14 +75,11 @@
 -- TODO: Petition to move Data.Functor.Identity into base
 instance Comonad Identity where
   extract = runIdentity
-  extend f = Identity . f 
-  duplicate = Identity
 
 -- Provided to avoid an orphan instance. Not proposed to standardize. 
 -- If Comonad moved to base, consider moving instance into transformers?
 instance Comonad w => Comonad (IdentityT w) where
   extract = extract . runIdentityT
-  extend f (IdentityT m) = IdentityT (extend (f . IdentityT) m)
 
 -- | The 'Cokleisli' 'Arrow's of a given 'Comonad'
 newtype Cokleisli w a b = Cokleisli { runCokleisli :: w a -> b }
@@ -163,7 +123,6 @@
   return = Cokleisli . const
   Cokleisli k >>= f = Cokleisli $ \w -> runCokleisli (f (k w)) w
 
-
 {- $definition
 
 There are two ways to define a comonad:
@@ -207,4 +166,3 @@
 the definition of 'liftW' respectively.
 
 -}
-
diff --git a/Data/Functor/Extend.hs b/Data/Functor/Extend.hs
new file mode 100644
--- /dev/null
+++ b/Data/Functor/Extend.hs
@@ -0,0 +1,134 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Functor.Extend
+-- Copyright   :  (C) 2011 Edward Kmett
+-- License     :  BSD-style (see the file LICENSE)
+--
+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
+-- Stability   :  provisional
+-- Portability :  portable
+--
+----------------------------------------------------------------------------
+module Data.Functor.Extend
+  ( -- * $definition
+    Extend(..)
+  , (=>>)     -- :: Extend w => w a -> (w a -> b) -> w b
+  , (<<=)     -- :: Extend w => (w a -> b) -> w a -> w b
+  , (=>=)     -- :: Extend w => (w a -> b) -> (w b -> c) -> w a -> c
+  , (=<=)     -- :: Extend w => (w b -> c) -> (w a -> b) -> w a -> c
+  ) where
+
+import Prelude hiding (id, (.))
+import Control.Category
+import Control.Monad.Trans.Identity
+import Data.Functor.Identity
+import Data.Semigroup
+import Data.List (tails)
+
+infixl 1 =>> 
+infixr 1 <<=, =<=, =>= 
+
+class Functor w => Extend w where
+  -- | 
+  -- > duplicate = extend id
+  -- > fmap (fmap f) . duplicate = duplicate . fmap f
+  duplicate :: w a -> w (w a)
+  -- |
+  -- > extend f  = fmap f . duplicate
+  extend    :: (w a -> b) -> w a -> w b
+
+  extend f = fmap f . duplicate
+  duplicate = extend id
+
+-- | 'extend' with the arguments swapped. Dual to '>>=' for a 'Monad'.
+(=>>) :: Extend w => w a -> (w a -> b) -> w b
+(=>>) = flip extend
+{-# INLINE (=>>) #-}
+
+-- | 'extend' in operator form 
+(<<=) :: Extend w => (w a -> b) -> w a -> w b
+(<<=) = extend
+{-# INLINE (<<=) #-}
+
+-- | Right-to-left Cokleisli composition 
+(=<=) :: Extend w => (w b -> c) -> (w a -> b) -> w a -> c
+f =<= g = f . extend g
+{-# INLINE (=<=) #-}
+
+-- | Left-to-right Cokleisli composition
+(=>=) :: Extend w => (w a -> b) -> (w b -> c) -> w a -> c
+f =>= g = g . extend f 
+{-# INLINE (=>=) #-}
+
+-- * Extends for Prelude types:
+--
+-- Instances: While Data.Functor.Extend.Instances would be symmetric
+-- to the definition of Control.Monad.Instances in base, the reason
+-- the latter exists is because of Haskell 98 specifying the types
+-- @'Either' a@, @((,)m)@ and @((->)e)@ and the class Monad without
+-- having the foresight to require or allow instances between them.
+--
+-- Here Haskell 98 says nothing about Extend, so we can include the
+-- instances directly avoiding the wart of orphan instances.
+
+instance Extend [] where
+  duplicate = tails
+
+instance Extend Maybe where
+  duplicate Nothing = Nothing
+  duplicate j = Just j
+
+instance Extend (Either a) where
+  duplicate (Left a) = Left a
+  duplicate r = Right r
+
+instance Extend ((,)e) where
+  duplicate p = (fst p, p)
+
+instance Semigroup m => Extend ((->)m) where
+  duplicate f m = f . (<>) m
+
+-- I can't fix the world
+-- instance (Monoid m, Extend n) => Extend (ReaderT m n) 
+--   duplicate f m = f . mappend m
+
+-- * Extends for types from 'transformers'.
+--
+-- This isn't really a transformer, so i have no compunction about including the instance here.
+--
+-- TODO: Petition to move Data.Functor.Identity into base
+instance Extend Identity where
+  duplicate = Identity
+
+-- Provided to avoid an orphan instance. Not proposed to standardize. 
+-- If Extend moved to base, consider moving instance into transformers?
+instance Extend w => Extend (IdentityT w) where
+  extend f (IdentityT m) = IdentityT (extend (f . IdentityT) m)
+
+{- $definition
+
+There are two ways to define an 'Extend' instance:
+
+I. Provide definitions for 'extend'
+satisfying this law:
+
+> extend f . extend g = extend (f . extend g)
+
+II. Alternately, you may choose to provide definitions for 'duplicate' 
+satisfying this laws:
+
+> duplicate . duplicate    = fmap duplicate . duplicate
+
+These are both equivalent to the statement that (=>=) is associative
+
+> (f =>= g) =>= h = f =>= (g =>= h)
+
+You may of course, choose to define both 'duplicate' /and/ 'extend'. 
+In that case you must also satisfy these laws:
+
+> extend f  = fmap f . duplicate
+> duplicate = extend id
+
+These are the default definitions of 'extend' and 'duplicate'.
+
+-}
diff --git a/comonad.cabal b/comonad.cabal
--- a/comonad.cabal
+++ b/comonad.cabal
@@ -1,6 +1,6 @@
 name:          comonad
 category:      Control, Comonads
-version:       0.7.0
+version:       0.9.0
 license:       BSD3
 cabal-version: >= 1.6
 license-file:  LICENSE
@@ -20,9 +20,11 @@
 library
   build-depends: 
     base >= 4 && < 4.4,
-    transformers >= 0.2.0 && < 0.3
+    transformers >= 0.2.0 && < 0.3,
+    semigroups >= 0.3.4 && < 0.5
 
   exposed-modules:
     Control.Comonad
+    Data.Functor.Extend
 
   ghc-options: -Wall