linted files

ExtractRules.hs

@@ -9,15 +9,13 @@ import Data.Map(Map)
 extractRules :: Confidence -> [ItemSet] -> [ItemSet] -> [Rule]
 extractRules threshold table patterns = filter (\x -> threshold <= confidence table x) rules where
     rules = Map.foldrWithKey (\k v old -> ruleFromSubset v k : old) [] subsets
-    subsets = foldr (\x old -> insertMultiple (filteredPowerset x) x old) Map.empty patterns
+    subsets = foldr (\x -> insertMultiple (filteredPowerset x) x) Map.empty patterns
     filteredPowerset (ItemSet set) = map (ItemSet . Set.fromList) $
         filter (\val -> val /= Set.toList set && val /= []) $ powerset $ Set.toList set
 
 ruleFromSubset :: ItemSet -> ItemSet -> Rule
 ruleFromSubset set subset = Rule subset (difference set subset)
 
-
-
 insertMultiple :: Ord k => [k] -> a -> Map k a -> Map k a
 insertMultiple keys value m = foldr (\x old -> Map.insert x value old) m keys
 

FrequentPatterns.hs

@@ -11,7 +11,8 @@ semiUnion :: ItemSet -> ItemSet -> ItemSet
 semiUnion (ItemSet set1) (ItemSet set2) = ItemSet $
     if max1 <= max2 && Set.delete max1 set1 == Set.delete max2 set2
     then set1 `Set.union` set2
-    else Set.empty where
+    else Set.empty
+        where
         max1 = Set.findMax set1
         max2 = Set.findMax set2
 
@@ -24,18 +25,21 @@ semiUnion (ItemSet set1) (ItemSet set2) = ItemSet $
 -- generate the next level in a bottom-up route
 generateNextLevel :: [ItemSet] -> [ItemSet]
 generateNextLevel level = trace ("Computing level " ++ show (isSize (head level))) $
-    foldr (\value old -> generate value ++ old) [] level where
+    foldr (\value old -> generate value ++ old) [] level
+        where
         generate value = takeWhile (/= empty) $
             parMap rpar (semiUnion value) (tail $ List.dropWhile (/= value) level) -- FIXME: this could be a better strategy
         isSize (ItemSet set) = Set.size set
 
 singletons :: [ItemSet] -> [Item]
-singletons table = Set.toList $ foldr union (Set.fromList []) table where
+singletons table = Set.toList $ foldr union (Set.fromList []) table
+    where
 	union (ItemSet row) old = old `Set.union` row
 
 frequentPatterns :: Frequency -> [ItemSet] -> [[ItemSet]]
 frequentPatterns thresh table = until (\x -> [] == head x)
-    (\x -> filterByFrequency (generateNextLevel (head x)) : x) [firstLevel] where
+    (\x -> filterByFrequency (generateNextLevel (head x)) : x) [firstLevel]
+        where
         firstLevel = filterByFrequency $ map (\x -> ItemSet $ Set.fromList [x]) $
             trace "Generated Singletons" (singletons table)
         filterByFrequency = filter (\x -> frequency table x >= thresh)

phase1.hs

@@ -21,8 +21,8 @@ main = do
             let output = formatToCSV table freqPats
             putStrLn output
             when (length args > 2) $
-                writeFile (args !! 2) $ output
+                writeFile (args !! 2) output
 
 formatToCSV :: [ItemSet] -> [ItemSet] -> String
-formatToCSV table frequents = foldr (\x old -> old ++ formatRow x ++ "\n") "" frequents where
+formatToCSV table = foldr (\x old -> old ++ formatRow x ++ "\n") "" where
     formatRow (ItemSet set) = init $ Set.foldr (\x old -> old ++ show x ++ ",") (show (count table (ItemSet set)) ++",") set

phase2.hs

@@ -21,10 +21,10 @@ main = do
                     --putStrLn output
                     print $ zip rules (map (lift table) rules)
                     when (length args > 3) $
-                        writeFile (args !! 3) $ output
+                        writeFile (args !! 3) output
                     where
-                        freqPats = map (ItemSet. Set.fromList .map Item) (map tail freqFileContent)
+                    freqPats = map ((ItemSet. Set.fromList .map Item) . tail) freqFileContent
-                        table = map (ItemSet. Set.fromList .map Item) tableFileContent
+                    table = map (ItemSet. Set.fromList .map Item) tableFileContent
-                        rules = extractRules threshold table freqPats
+                    rules = extractRules threshold table freqPats
-                        output = init $ foldr (\x old -> old++x++"\n") "" $ map show rules
+                    output = init $ foldr ((\x old -> old++x++"\n").show) "" rules