From 7b34f4f43a0f0069bb3ff97f554ed593c5cd800c Mon Sep 17 00:00:00 2001
From: erkok <unknown>
Date: Tue, 1 Oct 2002 15:58:12 +0000
Subject: [PATCH] [project @ 2002-10-01 15:58:11 by erkok] Merge Fix.hs with
 MonadRec.hs, and remove the latter.

As agreed, the class is now called "MonadFix", and the
library is called "Control.Monad.Fix".

Note: The old Control.Monad.Fix used to export the function

      fix :: (a -> a) -> a

I retained that behavior, but I don't think it should export it.
---
 Control/Monad/Fix.hs      |   33 +++++++++++++++++++-----
 Control/Monad/MonadRec.hs |   63 ---------------------------------------------
 2 files changed, 26 insertions(+), 70 deletions(-)
 delete mode 100644 Control/Monad/MonadRec.hs

diff --git a/Control/Monad/Fix.hs b/Control/Monad/Fix.hs
index 8327212..c465511 100644
--- a/Control/Monad/Fix.hs
+++ b/Control/Monad/Fix.hs
@@ -2,7 +2,7 @@
 -- |
 -- Module      :  Control.Monad.Fix
 -- Copyright   :  (c) Andy Gill 2001,
---		  (c) Oregon Graduate Institute of Science and Technology, 2001
+--		  (c) Oregon Graduate Institute of Science and Technology, 2002
 -- License     :  BSD-style (see the file libraries/base/LICENSE)
 -- 
 -- Maintainer  :  libraries@haskell.org
@@ -16,6 +16,9 @@
 --	      Higher-Order Polymorphism/, 
 --	    Mark P Jones (<http://www.cse.ogi.edu/~mpj>)
 --		  Advanced School of Functional Programming, 1995.
+--
+-- Oct. 1st, 2002: Added instances for Lazy ST, ST, and List monads
+--           
 -----------------------------------------------------------------------------
 
 module Control.Monad.Fix (
@@ -26,6 +29,8 @@ module Control.Monad.Fix (
   ) where
 
 import Prelude
+import qualified Control.Monad.ST.Lazy as LazyST
+import qualified Control.Monad.ST as ST
 import System.IO
 
 fix :: (a -> a) -> a
@@ -34,13 +39,27 @@ fix f = let x = f x in x
 class (Monad m) => MonadFix m where
 	mfix :: (a -> m a) -> m a
 
+-- Instances of MonadFix
+
+-- Maybe:
 instance MonadFix Maybe where
-	mfix f = let
-		a = f $ case a of
-			Just x -> x
-			_      -> error "empty mfix argument"
-		in a
+    mfix f = let a = f (unJust a) in a
+             where unJust (Just x) = x
+
+-- List:
+instance MonadFix [] where
+    mfix f = case fix (f . head) of
+               []    -> []
+               (x:_) -> x : mfix (tail . f)
 
+-- IO:
 instance MonadFix IO where
-	mfix = fixIO
+    mfix = fixIO 
 
+-- Lazy State:
+instance MonadFix (LazyST.ST s) where
+    mfix = LazyST.fixST
+    
+-- Strict State:
+instance MonadFix (ST.ST s) where
+    mfix = ST.fixST
diff --git a/Control/Monad/MonadRec.hs b/Control/Monad/MonadRec.hs
deleted file mode 100644
index 00a8c26..0000000
--- a/Control/Monad/MonadRec.hs
+++ /dev/null
@@ -1,63 +0,0 @@
------------------------------------------------------------------------------
--- |
--- Module      :  Control.Monad.MonadRec
--- Copyright   :  (c) Oregon Graduate Institute of Science and Technology, 2002
--- License     :  BSD-style (see the file libraries/base/LICENSE)
---
--- Maintainer  :  libraries@haskell.org, erkok@cse.ogi.edu
--- Stability   :  experimental
--- Portability :  portable 
---
--- Declaration of the MonadRec class, and instances for
--- maybe, list, IO, strict state, and lazy state monads
---
--- Note	: There's a clear overlap with the Control.Monad.Fix
---        module, as they basically define the same structure
---        with different names. The "MonadRec" name is kept
---        here basically for compatibility with the current Hugs
---        implementation. (Note that this duplication also exist 
---        in the current Hugs release as well.)
---
------------------------------------------------------------------------------
-
-module Control.Monad.MonadRec (
-	MonadRec(mfix)
-  ) where
-    
-import Prelude 
-import qualified Control.Monad.ST.Lazy as LazyST
-import qualified Control.Monad.ST as ST
-import System.IO
-
-fix :: (a -> a) -> a
-fix f = let a = f a in a
-
--- The MonadRec class definition
-
-class Monad m => MonadRec m where
-    mfix :: (a -> m a) -> m a 
-
--- Instances of MonadRec
-
--- Maybe:
-instance MonadRec Maybe where
-    mfix f = let a = f (unJust a) in a
-             where unJust (Just x) = x
-
--- List:
-instance MonadRec [] where
-    mfix f = case fix (f . head) of
-               []    -> []
-               (x:_) -> x : mfix (tail . f)
-
--- IO:
-instance MonadRec IO where
-    mfix = fixIO 
-
--- Lazy State:
-instance MonadRec (LazyST.ST s) where
-    mfix = LazyST.fixST
-    
--- Strict State:
-instance MonadRec (ST.ST s) where
-    mfix = ST.fixST
-- 
1.7.10.4