remove restrictKeys in favour of filter

Author: nicuveo

src/DFAMin.hs

@@ -1,20 +1,16 @@
-{-# LANGUAGE CPP #-}
-
 module DFAMin (minimizeDFA) where
 
 import AbsSyn
 
-import Control.Monad (guard)
+import Control.Monad  (guard)
 import Data.Bifunctor (second)
--- import Data.Foldable (fold)
-import Data.IntMap   (IntMap)
-import Data.IntSet   (IntSet)
--- import Data.Map      (Map)
+import Data.IntMap    (IntMap)
+import Data.IntSet    (IntSet)
 
-import qualified Data.IntMap   as IntMap
-import qualified Data.IntSet   as IntSet
-import qualified Data.List     as List
-import qualified Data.Map      as Map
+import qualified Data.IntMap as IntMap
+import qualified Data.IntSet as IntSet
+import qualified Data.List   as List
+import qualified Data.Map    as Map
 
 {- Note [Hopcroft's Algorithm]
 
@@ -203,20 +199,6 @@ generateReverseTransitionCache dfa = IntMap.elems $
     pure (token, IntMap.singleton targetState (IntSet.singleton sourceState))
 
 
--- -- | Given an IntMap and an IntSet, restrict the IntMap to the keys that are
--- -- within the IntSet.
--- --
--- -- This function is a simple wrapper around 'IntMap.restrictKeys', provided for
--- -- compatibility with older versions of @containers@.
--- restrictKeys :: forall a. IntMap a -> IntSet -> IntMap a
--- restrictKeys m s =
--- #if MIN_VERSION_containers(0,6,0)
---     IntMap.restrictKeys m s
--- #else
---     IntMap.filterWithKey (\k _ -> k `IntSet.member` s) m
--- #endif
-
-
 -- | Given two sets X and Y, compute their intersection and difference.
 -- Only returns both if both are non-empty, otherwise return neither.
 refine
@@ -246,12 +228,11 @@ groupEquivalentStates dfa = outerLoop ([], initialSubsets dfa)
     outerLoop :: ([EquivalenceClass], [EquivalenceClass]) -> [EquivalenceClass]
     outerLoop (r,  []) = r
     outerLoop (r, a:w) = outerLoop $ List.foldl' refineWithX (a:r,w) $ do
-      allPreviousStates  :: IntMap EquivalenceClass <- reverseTransitionCache
-      -- let x = fold $ restrictKeys allPreviousStates a
-      -- Is 'restrictKeys' here really better than the following simpler filter?
-      -- The given asymptotics does look better, but aren't there overheads to create a balanced 'IntMap'
-      -- just to destroy it immediately with a 'fold'?
-      let x = IntSet.unions $ map (\ (tgt, srcs) -> if tgt `IntSet.member` a then srcs else IntSet.empty) $ IntMap.toList allPreviousStates
+      allPreviousStates <- reverseTransitionCache
+      let x = IntSet.unions $ do
+            (target, sources) <- IntMap.toList allPreviousStates
+            guard $ target `IntSet.member` a
+            pure sources
       guard $ not $ IntSet.null x
       pure x