diff --git a/Control/Parallel/Strategies.hs b/Control/Parallel/Strategies.hs
--- a/Control/Parallel/Strategies.hs
+++ b/Control/Parallel/Strategies.hs
@@ -824,9 +824,5 @@
   * An exception to the type driven naming scheme are 'evalBuffer' and
      'parBuffer', which are not named after their type constructor (lists)
      but after their function (rolling buffer of fixed size).
-
-  * A strategy combinator that is not as compositional as its type
-    suggests is suffixed with @'@.
-    Examples: 'evalFunctor'', 'parBuffer''.
 -}
 
diff --git a/Control/Seq.hs b/Control/Seq.hs
--- a/Control/Seq.hs
+++ b/Control/Seq.hs
@@ -26,9 +26,6 @@
        , using            -- :: a -> Strategy a -> a
        , withStrategy     -- :: Strategy a -> a -> a
 
-         -- * Composition of sequential strategies
-       , dot              -- :: Strategy a -> Strategy a -> Strategy a
-
          -- * Basic sequential strategies
        , r0               -- :: Strategy a
        , rseq
@@ -46,6 +43,10 @@
        , seqArrayBounds   -- :: Ix i => Strategy i -> Strategy (Array i a)
 
          -- * Sequential strategies for tuples
+
+         -- | Evaluate the components of a tuple according to the given strategies.
+         -- No guarantee is given as to the order of evaluation.
+
        , seqTuple2        -- :: Strategy a -> ... -> Strategy (a,...)
        , seqTuple3
        , seqTuple4
@@ -65,7 +66,6 @@
 import Data.Array (Array)
 import qualified Data.Array (bounds, elems)
 
-infixr 9 `dot`     -- same as function composition (.)
 infixl 0 `using`   -- lowest precedence and associate to the left
 
 -- --------------------------------------------------------------------------
@@ -85,25 +85,6 @@
 withStrategy :: Strategy a -> a -> a
 withStrategy = flip using
 
--- | Compose two strategies sequentially.
--- This is the analogue to function composition on strategies.
--- (Probably not very useful; provided because "Control.Parallel.Strategies"
--- provides the same function.)
---
--- > strat2 `dot` strat1 == strat2 . withStrategy strat1
---
-dot :: Strategy a -> Strategy a -> Strategy a
-(strat2 `dot` strat1) x = strat1 x `seq` strat2 x
-                          
--- More reasons for removing dot:
--- * It is inefficient: Traverses 'x' twice.
--- * It does not satisfy the property that 'Strategies.dot' has; there is 
---   a counter-example to the equation
---   > strat2 `dot` strat1 == strat2 . withStrategy strat1
---   Try strat2 = r0 and strat1 = rseq and apply to 'undefined';
---   the LHS will diverge while the RHS will evaluate to '()'.
-
-
 -- --------------------------------------------------------------------------
 -- Basic sequential strategies
 
@@ -176,8 +157,6 @@
 -- --------------------------------------------------------------------------
 -- Sequential strategies for tuples
 
--- | Evaluate the components of a tuple according to the given strategies.
--- No guarantee is given as to the order of evaluation.
 seqTuple2 :: Strategy a -> Strategy b -> Strategy (a,b)
 seqTuple2 strat1 strat2 (x1,x2) =
   strat1 x1 `seq` strat2 x2
diff --git a/parallel.cabal b/parallel.cabal
--- a/parallel.cabal
+++ b/parallel.cabal
@@ -1,5 +1,5 @@
 name:		parallel
-version:	3.0.0.0
+version:	3.1.0.0
 license:	BSD3
 license-file:	LICENSE
 maintainer:	libraries@haskell.org