Changeset 12775

Timestamp:

03.11.2009 15:03:01 (3 weeks ago)

Author:

maeder

Message:

hlinted

Files:

• trunk/Common/Lib/Rel.hs (modified) (9 diffs)

trunk/Common/Lib/Rel.hs

@@ -128 +128 @@
 -- | make relation irreflexive
 irreflex :: Ord a => Rel a -> Rel a
-irreflex (Rel m) = Rel $ rmNull $ Map.mapWithKey (Set.delete) m
+irreflex (Rel m) = Rel $ rmNull $ Map.mapWithKey Set.delete m
 
 -- | compute strongly connected components for a transitively closed relation
@@ -146 +146 @@
 
 setToMap :: Ord a => Set.Set a -> Map.Map a a
-setToMap s = Map.fromDistinctAscList $
-             List.map (\ a -> (a, a)) $ Set.toList s
+setToMap = Map.fromDistinctAscList . List.map (\ a -> (a, a)) . Set.toList
 
 {- | transitive reduction (minimal relation with the same transitive closure)
@@ -188 +187 @@
 map :: (Ord a, Ord b) => (a -> b) -> Rel a -> Rel b
 map f (Rel m) = Rel $ Map.foldWithKey
-    ( \ a v -> Map.insertWith Set.union (f a) $ Set.map f v) Map.empty m
+    ( \ a -> Map.insertWith Set.union (f a) . Set.map f) Map.empty m
 
 -- | Restriction of a relation under a set
@@ -204 +203 @@
 -- | convert a set of ordered pairs to a relation
 fromSet :: (Ord a) => Set.Set (a, a) -> Rel a
-fromSet s = fromAscList $ Set.toList s
+fromSet = fromAscList . Set.toList
 
 -- | convert a sorted list of ordered pairs to a relation
@@ -223 +222 @@
    between 1 and the second value that is output. -}
 toPrecMap :: Ord a =>  Rel a -> (Map.Map a Int, Int)
-toPrecMap r = foldl ( \ (m1, c) s -> let n = c + 1 in
+toPrecMap = foldl ( \ (m1, c) s -> let n = c + 1 in
                     (Set.fold ( \ i -> Map.insert i n) m1 s, n))
-                 (Map.empty, 0) $ topSort r
+                 (Map.empty, 0) . topSort
 
 topSortDAG :: Ord a => Rel a -> [Set.Set a]
@@ -254 +253 @@
     else let Rel im = irreflex r
              mr = elemsSet im Set.\\ Map.keysSet im
-         in if Set.null mr then Map.keysSet $ Map.filterWithKey (\ k v ->
-                                           Set.singleton k == v) m
+         in if Set.null mr then Map.keysSet $ Map.filterWithKey
+                ((==) . Set.singleton) m
             else mr
 
@@ -287 +286 @@
     let (a, b) = Set.deleteFindMin c
         (m, d) = Set.deleteFindMax c
-    in insert m a $ foldr ( \ (x, y) -> insert x y) (delete a a r) $
+    in insert m a $ foldr (uncurry insert) (delete a a r) $
        zip (Set.toList d) (Set.toList b)
 
@@ -296 +295 @@
 haveCommonLeftElem :: (Ord a) => a -> a -> Rel a -> Bool
 haveCommonLeftElem t1 t2 =
-    Map.fold(\ e rs -> rs || (t1 `Set.member` e &&
-                              t2 `Set.member` e)) False . toMap
+    Map.fold(\ e -> (|| Set.member t1 e && Set.member t2 e)) False . toMap
 
 -- | partitions a set into a list of disjoint non-empty subsets
@@ -327 +325 @@
     where iso x y = member x y rel && member y x rel
           check s = Set.null s ||
-                  Set.fold (\y rs -> rs &&
-                                     not (haveCommonLeftElem x y rel)) True s'
+                  Set.fold (\ y ->
+                            (&& not (haveCommonLeftElem x y rel))) True s'
                   && check s'
               where (x, s') = Set.deleteFindMin s