diff --git a/extensible-effects.cabal b/extensible-effects.cabal
--- a/extensible-effects.cabal
+++ b/extensible-effects.cabal
@@ -6,7 +6,7 @@
 -- PVP summary:      +-+------- breaking API changes
 --                   | | +----- non-breaking API additions
 --                   | | | +--- code changes with no API change
-version:             1.11.0.0
+version:             1.11.0.1
 
 -- A short (one-line) description of the package.
 synopsis:            An Alternative to Monad Transformers
@@ -65,6 +65,7 @@
                        Control.Eff.Choose
                        Control.Eff.Coroutine
                        Control.Eff.Cut
+                       Control.Eff.Example
                        Control.Eff.Exception
                        Control.Eff.Fresh
                        Control.Eff.Lift
diff --git a/src/Control/Eff.hs b/src/Control/Eff.hs
--- a/src/Control/Eff.hs
+++ b/src/Control/Eff.hs
@@ -18,50 +18,8 @@
 -- as described in <http://okmij.org/ftp/Haskell/extensible/exteff.pdf>.
 --
 -- Extensible Effects are implemented as typeclass constraints on an Eff[ect] datatype.
--- A contrived example is:
---
--- > {-# LANGUAGE FlexibleContexts #-}
--- > import Control.Eff
--- > import Control.Eff.Lift
--- > import Control.Eff.State
--- > import Control.Monad (void)
--- > import Data.Typeable
--- >
--- > -- Write the elements of a list of numbers, in order.
--- > writeAll :: (Typeable a, Member (Writer a) e)
--- >          => [a]
--- >          -> Eff e ()
--- > writeAll = mapM_ putWriter
--- >
--- > -- Add a list of numbers to the current state.
--- > sumAll :: (Typeable a, Num a, Member (State a) e)
--- >        => [a]
--- >        -> Eff e ()
--- > sumAll = mapM_ (onState . (+))
--- >
--- > -- Write a list of numbers and add them to the current state.
--- > writeAndAdd :: (Member (Writer Integer) e, Member (State Integer) e)
--- >             => [Integer]
--- >             -> Eff e ()
--- > writeAndAdd l = do
--- >     writeAll l
--- >     sumAll l
--- >
--- > -- Sum a list of numbers.
--- > sumEff :: (Num a, Typeable a) => [a] -> a
--- > sumEff l = let (s, ()) = run $ runState 0 $ sumAll l
--- >            in s
--- >
--- > -- Safely get the last element of a list.
--- > -- Nothing for empty lists; Just the last element otherwise.
--- > lastEff :: Typeable a => [a] -> Maybe a
--- > lastEff l = let (a, ()) = run $ runWriter $ writeAll l
--- >             in a
--- >
--- > -- Get the last element and sum of a list
--- > lastAndSum :: (Typeable a, Num a) => [a] -> (Maybe a, a)
--- > lastAndSum l = let (lst, (total, ())) = run $ runWriter $ runState 0 $ writeAndAdd l
--- >                in (lst, total)
+-- A contrived example can be found under "Control.Eff.Example". To run the
+-- effects, consult the tests.
 module Control.Eff(
                     Eff
                   , module Reflection
diff --git a/src/Control/Eff/Example.hs b/src/Control/Eff/Example.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Eff/Example.hs
@@ -0,0 +1,46 @@
+{-# LANGUAGE FlexibleContexts #-}
+
+-- | Example usage of "Control.Eff"
+module Control.Eff.Example where
+
+import Control.Eff
+import Control.Eff.State.Lazy
+import Control.Eff.Writer.Lazy
+import Data.Typeable
+
+-- | Write the elements of a list of numbers, in order.
+writeAll :: (Typeable a, Member (Writer a) e)
+         => [a]
+         -> Eff e ()
+writeAll = mapM_ tell
+
+-- | Add a list of numbers to the current state.
+sumAll :: (Typeable a, Num a, Member (State a) e)
+       => [a]
+       -> Eff e ()
+sumAll = mapM_ (modify . (+))
+
+-- | Write a list of numbers and add them to the current state.
+writeAndAdd :: (Member (Writer a) e, Member (State a) e, Num a, Typeable a)
+            => [a]
+            -> Eff e ()
+writeAndAdd l = do
+    writeAll l
+    sumAll l
+
+-- | Sum a list of numbers.
+sumEff :: (Num a, Typeable a) => [a] -> a
+sumEff l = let (s, ()) = run $ runState 0 $ sumAll l
+           in s
+
+-- | Safely get the last element of a list.
+-- Nothing for empty lists; Just the last element otherwise.
+lastEff :: Typeable a => [a] -> Maybe a
+lastEff l = let (a, ()) = run $ runLastWriter $ writeAll l
+            in a
+
+
+-- | Get the last element and sum of a list
+lastAndSum :: (Typeable a, Num a) => [a] -> (Maybe a, a)
+lastAndSum l = let (lst, (total, ())) = run $ runLastWriter $ runState 0 $ writeAndAdd l
+               in (lst, total)
diff --git a/src/Control/Eff/Operational.hs b/src/Control/Eff/Operational.hs
--- a/src/Control/Eff/Operational.hs
+++ b/src/Control/Eff/Operational.hs
@@ -61,7 +61,7 @@
 
 -- $usage
 --
--- See 'Control.Eff.Operational.Example' for an example of defining data using
+-- See "Control.Eff.Operational.Example" for an example of defining data using
 -- GADTs and implementing interpreters from the data to effects.
 --
 -- To use the interpreter, see below or consult the tests.
diff --git a/test/Test.hs b/test/Test.hs
--- a/test/Test.hs
+++ b/test/Test.hs
@@ -15,6 +15,7 @@
 import Test.QuickCheck
 
 import Control.Eff
+import Control.Eff.Example as Eg
 import Control.Eff.Exception
 import Control.Eff.Lift
 import Control.Eff.Operational as Op
@@ -62,30 +63,13 @@
 
 prop_Documentation_example :: [Integer] -> Property
 prop_Documentation_example l = let
-  (total1, ()) = run $ LazyS.runState 0 $ sumAll l
-  (last1, ()) = run $ LazyW.runLastWriter $ writeAll l
-  (total2, (last2, ())) = run $ LazyS.runState 0 $ LazyW.runLastWriter $ writeAndAdd l
-  (last3, (total3, ())) = run $ LazyW.runLastWriter $ LazyS.runState 0 $ writeAndAdd l
+  (total1, ()) = run $ LazyS.runState 0 $ Eg.sumAll l
+  (last1, ()) = run $ LazyW.runLastWriter $ Eg.writeAll l
+  (total2, (last2, ())) = run $ LazyS.runState 0 $ LazyW.runLastWriter $ Eg.writeAndAdd l
+  (last3, (total3, ())) = run $ LazyW.runLastWriter $ LazyS.runState 0 $ Eg.writeAndAdd l
   in
    allEqual [safeLast l, last1, last2, last3]
    .&&. allEqual [sum l, total1, total2, total3]
-  where
-    writeAll :: (Typeable a, Member (LazyW.Writer a) e)
-             => [a]
-             -> Eff e ()
-    writeAll = mapM_ LazyW.tell
-
-    sumAll :: (Typeable a, Num a, Member (LazyS.State a) e)
-           => [a]
-           -> Eff e ()
-    sumAll = mapM_ (LazyS.modify . (+))
-
-    writeAndAdd :: (Member (LazyW.Writer Integer) e, Member (LazyS.State Integer) e)
-                => [Integer]
-                -> Eff e ()
-    writeAndAdd lst = do
-        writeAll lst
-        sumAll lst
 
 -- }}}