[ Re #71 ] DFAMin: add type signatures

To increase documentation and readability, I added type signatures also
to some local definitions.

Needs language extension ScopedTypeVariables.

Author: andreasabel

src/DFAMin.hs

@@ -1,5 +1,8 @@
 {-# OPTIONS_GHC -fno-warn-name-shadowing #-}
-{-# LANGUAGE PatternGuards #-}
+
+{-# LANGUAGE PatternGuards       #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+
 module DFAMin (minimizeDFA) where
 
 import AbsSyn
@@ -31,19 +34,22 @@ import Data.List as List
 --      end;
 -- end;
 
-minimizeDFA :: Ord a => DFA Int a -> DFA Int a
+minimizeDFA :: forall a. Ord a => DFA Int a -> DFA Int a
 minimizeDFA  dfa@DFA { dfa_start_states = starts,
                        dfa_states       = statemap
                      }
   = DFA { dfa_start_states = starts,
           dfa_states       = Map.fromList states }
   where
+      equiv_classes   :: [EquivalenceClass]
       equiv_classes   = groupEquivStates dfa
 
+      numbered_states :: [(Int, EquivalenceClass)]
       numbered_states = number (length starts) equiv_classes
 
       -- assign each state in the minimized DFA a number, making
       -- sure that we assign the numbers [0..] to the start states.
+      number :: Int -> [EquivalenceClass] -> [(Int, EquivalenceClass)]
       number _ [] = []
       number n (ss:sss) =
         case filter (`IS.member` ss) starts of
@@ -53,6 +59,7 @@ minimizeDFA  dfa@DFA { dfa_start_states = starts,
           -- to multiple starts states, we just have to duplicate
           -- that state.
 
+      states :: [(Int, State Int a)]
       states = [
                 let old_states = map (lookup statemap) (IS.toList equiv)
                     accs = map fix_acc (state_acc (head old_states))
@@ -64,35 +71,44 @@ minimizeDFA  dfa@DFA { dfa_start_states = starts,
                | (n, equiv) <- numbered_states
                ]
 
+      fix_acc :: Accept a -> Accept a
       fix_acc acc = acc { accRightCtx = fix_rctxt (accRightCtx acc) }
 
+      fix_rctxt :: RightContext SNum -> RightContext SNum
       fix_rctxt (RightContextRExp s) = RightContextRExp (get_new s)
       fix_rctxt other = other
 
+      lookup :: Ord k => Map k v -> k -> v
       lookup m k = Map.findWithDefault (error "minimizeDFA") k m
+
+      get_new :: Int -> Int
       get_new = lookup old_to_new
 
       old_to_new :: Map Int Int
       old_to_new = Map.fromList [ (s,n) | (n,ss) <- numbered_states,
                                           s <- IS.toList ss ]
 
+type EquivalenceClass = IntSet
 
-groupEquivStates :: (Ord a) => DFA Int a -> [IntSet]
+groupEquivStates :: forall a. Ord a => DFA Int a -> [EquivalenceClass]
 groupEquivStates DFA { dfa_states = statemap }
   = go init_p init_q
   where
+    accepting, nonaccepting :: Map Int (State Int a)
     (accepting, nonaccepting) = Map.partition acc statemap
        where acc (State as _) = not (List.null as)
 
+    nonaccepting_states :: EquivalenceClass
     nonaccepting_states = IS.fromList (Map.keys nonaccepting)
 
     -- group the accepting states into equivalence classes
+    accept_map :: Map [Accept a] [Int]
     accept_map = {-# SCC "accept_map" #-}
       foldl' (\m (n,s) -> Map.insertWith (++) (state_acc s) [n] m)
              Map.empty
              (Map.toList accepting)
 
-    -- accept_groups :: Ord s => [Set s]
+    accept_groups :: [EquivalenceClass]
     accept_groups = map IS.fromList (Map.elems accept_map)
 
     init_p = nonaccepting_states : accept_groups
@@ -118,6 +134,7 @@ groupEquivStates DFA { dfa_states = statemap }
               | s <- IS.toList a ]
 
     -- The outer loop: recurse on each set in Q
+    go ::  [EquivalenceClass] -> [EquivalenceClass] -> [EquivalenceClass]
     go p [] = p
     go p (a:q) = go1 0 p q
      where
@@ -145,6 +162,3 @@ groupEquivStates DFA { dfa_states = statemap }
                              replaceyin (z:zs)
                                 | z == y    = i : d : zs
                                 | otherwise = z : replaceyin zs
-
-
-