From bf038b00e6a84af60bc32f1a9d0f4b73a017669c Mon Sep 17 00:00:00 2001
From: Edward Kmett <ekmett@gmail.com>
Date: Wed, 9 Nov 2011 00:36:12 -0500
Subject: [PATCH] streamlined MonadSpec

---
 .gitignore                              |  2 ++
 CHANGELOG.markdown                      |  4 +++
 Control/Concurrent/Speculation/Class.hs | 37 +++++++++++++------------
 speculation.cabal                       |  2 +-
 4 files changed, 26 insertions(+), 19 deletions(-)

diff --git a/.gitignore b/.gitignore
index 9645a0f..a9306df 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,4 @@
 dist
 .hpc
+*.swo
+*.swp
diff --git a/CHANGELOG.markdown b/CHANGELOG.markdown
index 13b3cc3..d2c9591 100644
--- a/CHANGELOG.markdown
+++ b/CHANGELOG.markdown
@@ -1,3 +1,7 @@
+/1.4/
+
+ * Simplified MonadSpec
+
 /1.3/
 
  * Removed old benchmark/test framework.
diff --git a/Control/Concurrent/Speculation/Class.hs b/Control/Concurrent/Speculation/Class.hs
index f8f0816..cc3d2a2 100644
--- a/Control/Concurrent/Speculation/Class.hs
+++ b/Control/Concurrent/Speculation/Class.hs
@@ -17,36 +17,37 @@ module Control.Concurrent.Speculation.Class where
 
 import Control.Monad.Trans.Cont
 import Control.Concurrent.Speculation
+import Data.Function (on)
 
 class MonadSpec m where
-  -- | When a is unevaluated, @'spec' g a@ evaluates the current continuation 
-  -- with @g@ while testing if @g@ '==' @a@, if they differ, it re-evalutes the
-  -- continuation with @a@. If @a@ was already evaluated, the continuation is
-  -- just directly applied to @a@ instead.
-  specM :: Eq a => a -> a -> m a
-
-  -- | As per 'spec', without the check for whether or not the second argument
-  -- is already evaluated.
-  specM' :: Eq a => a -> a -> m a
-
   -- | @spec@ with a user supplied comparison function
   specByM :: (a -> a -> Bool) -> a -> a -> m a
 
   -- | @spec'@ with a user supplied comparison function
   specByM' :: (a -> a -> Bool) -> a -> a -> m a
 
-  -- | @spec'@ with a user supplied comparison function
-  specOnM :: Eq c => (a -> c) -> a -> a -> m a
+-- | When a is unevaluated, @'spec' g a@ evaluates the current continuation 
+-- with @g@ while testing if @g@ '==' @a@, if they differ, it re-evalutes the
+-- continuation with @a@. If @a@ was already evaluated, the continuation is
+-- just directly applied to @a@ instead.
+specM :: (MonadSpec m, Eq a) => a -> a -> m a
+specM = specByM (==)
 
-  -- | @spec'@ with a user supplied comparison function
-  specOnM' :: Eq c => (a -> c) -> a -> a -> m a
+-- | As per 'spec', without the check for whether or not the second argument
+-- is already evaluated.
+specM' :: (MonadSpec m, Eq a) => a -> a -> m a
+specM' = specByM' (==)
+
+-- | @spec'@ with a user supplied comparison function
+specOnM :: (MonadSpec m, Eq c) => (a -> c) -> a -> a -> m a
+specOnM = specByM . on (==)
+
+-- | @spec'@ with a user supplied comparison function
+specOnM' :: (MonadSpec m, Eq c) => (a -> c) -> a -> a -> m a
+specOnM' = specByM . on (==)
 
 -- * Basic speculation
 
 instance Monad m => MonadSpec (ContT r m) where
-  specM g a = ContT $ \k -> spec g k a
-  specM' g a = ContT $ \k -> spec' g k a
   specByM f g a = ContT $ \k -> specBy f g k a
   specByM' f g a = ContT $ \k -> specBy' f g k a
-  specOnM f g a = ContT $ \k -> specOn f g k a
-  specOnM' f g a = ContT $ \k -> specOn' f g k a
diff --git a/speculation.cabal b/speculation.cabal
index fd7aeb1..0e660ee 100644
--- a/speculation.cabal
+++ b/speculation.cabal
@@ -1,5 +1,5 @@
 name:           speculation
-version:        1.3
+version:        1.4
 license:        BSD3
 license-file:   LICENSE
 author:         Edward A. Kmett