[Fencommits] fenfire-hs: slim down the previous record by removing the Accessor abstraction -- we don't currently need it and while it's an interesting and possibly useful abstraction, the code is less scary and repetitive without it :-)

[Benja Fallenstein]

Tue Apr  3 23:30:40 EEST 2007  Benja Fallenstein <benja.fallenstein at gmail.com>
  * slim down the previous record by removing the Accessor abstraction -- we don't currently need it and while it's an interesting and possibly useful abstraction, the code is less scary and repetitive without it :-)
diff -rN -u old-fenfire-hs/Fenfire/Cache.hs new-fenfire-hs/Fenfire/Cache.hs
--- old-fenfire-hs/Fenfire/Cache.hs	2007-04-03 23:31:08.000000000 +0300
+++ new-fenfire-hs/Fenfire/Cache.hs	2007-04-03 23:31:08.000000000 +0300
@@ -20,7 +20,7 @@
 -- Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 -- MA  02111-1307  USA
 
-import Fenfire.Utils hiding (access)
+import Fenfire.Utils
 
 import Data.Bits
 import Data.HashTable (HashTable)
diff -rN -u old-fenfire-hs/Fenfire/Utils.hs new-fenfire-hs/Fenfire/Utils.hs
--- old-fenfire-hs/Fenfire/Utils.hs	2007-04-03 23:31:08.000000000 +0300
+++ new-fenfire-hs/Fenfire/Utils.hs	2007-04-03 23:31:08.000000000 +0300
@@ -46,46 +46,26 @@
 
 
 type Changer inner outer = Endo inner -> Endo outer
-data Accessor inner outer = Accessor { access :: outer -> inner,
-                                       change :: Changer inner outer }
-                                       
-write :: Accessor inner outer -> inner -> Endo outer
-write acc x = change acc (const x)
 
-gets' :: MonadState outer m => Accessor inner outer -> m inner
-gets' = gets . access
+sets :: Changer inner outer -> inner -> Endo outer
+sets chg x = chg (const x)
 
 puts :: MonadState outer m => Changer inner outer -> inner -> m ()
-puts chg x = modify (chg $ const x)
-
-puts' :: MonadState outer m => Accessor inner outer -> inner -> m ()
-puts' = puts . change
+puts chg x = modify (sets chg x)
 
 modifies :: MonadState outer m => Changer inner outer -> Endo inner -> m ()
 modifies chg f = modify (chg f)
 
-modifies' :: MonadState outer m => Accessor inner outer -> Endo inner -> m ()
-modifies' = modifies . change
-
 type ChangerM m inner outer = EndoM m inner -> EndoM m outer
-data AccessorM m inner outer = AccessorM { maccess :: outer -> m inner,
-                                           mchange :: ChangerM m inner outer }
                                        
-mwrite :: MonadState outer m =>
-          AccessorM m inner outer -> inner -> EndoM m outer
-mwrite acc x = mchange acc (const $ return x)
+msets :: MonadState outer m => ChangerM m inner outer -> inner -> EndoM m outer
+msets chg x = chg (const $ return x)
 
 mgets :: MonadState outer m => (outer -> m inner) -> m inner
 mgets f = get >>= f
 
-mgets' :: MonadState outer m => AccessorM m inner outer -> m inner
-mgets' = mgets . maccess
-
 mputs :: MonadState outer m => ChangerM m inner outer -> inner -> m ()
-mputs chg x = mmodify (chg $ const $ return x)
-
-mputs' :: MonadState outer m => AccessorM m inner outer -> inner -> m ()
-mputs' = mputs . mchange
+mputs chg x = mmodify (msets chg x)
 
 mmodify :: MonadState state m => EndoM m state -> m ()
 mmodify f = get >>= f >>= put
@@ -94,11 +74,6 @@
              ChangerM m inner outer -> EndoM m inner -> m ()
 mmodifies chg f = mmodify (chg f)
 
-mmodifies' :: MonadState outer m => 
-              AccessorM m inner outer -> EndoM m inner -> m ()
-mmodifies' = mmodifies . mchange
-                                       
-
 
 
 type Time     = Double -- seconds since the epoch
diff -rN -u old-fenfire-hs/Fenfire.fhs new-fenfire-hs/Fenfire.fhs
--- old-fenfire-hs/Fenfire.fhs	2007-04-03 23:31:08.000000000 +0300
+++ new-fenfire-hs/Fenfire.fhs	2007-04-03 23:31:08.000000000 +0300
@@ -167,8 +167,8 @@
     
 findChange :: (?vs :: ViewSettings, ?graph :: Graph) =>
               Rotation -> Int -> Maybe Rotation
-findChange rot@(Rotation n r) dir = fmap (Rotation n . (r+)) change_ where
-    change_ = listToMaybe $ List.sortBy (\x y -> abs x `compare` abs y)
+findChange rot@(Rotation n r) dir = fmap (Rotation n . (r+)) change where
+    change = listToMaybe $ List.sortBy (\x y -> abs x `compare` abs y)
                   $ catMaybes [findChange' Neg, findChange' Pos]
     findChange' dir' = fmap (subtract r) r' where
         len = length $ conns n dir'