hunk ./ch2/Algorithms.hs 4
-import DataSet
-import Data.Map (Map, (!))
-import qualified Data.Map as M
+import Prelude hiding (null, lookup)
+import DataSet (empty, DataSet (..), mapWithKey, transform, fromList, (!), lookup, MetricPrime, unionWith, intersectionWith, null, size, toList, delete, Metric, handleLookups)
+import qualified DataSet as D
+import Data.Map (Map)
hunk ./ch2/Algorithms.hs 27
+
hunk ./ch2/Algorithms.hs 35
-euclidean' m m' = if M.null m'' 
+euclidean' m m' = if null m'' 
hunk ./ch2/Algorithms.hs 38
-    where m'' = M.intersectionWith diff m m'
+    where m'' = intersectionWith diff m m'
hunk ./ch2/Algorithms.hs 44
-pearson' p p' = if M.null p'' || (den == 0) 
+pearson' p p' = if null p'' || (den == 0) 
hunk ./ch2/Algorithms.hs 47
- where p'' = M.intersectionWith (\a b->(a,b)) p p'
-       n = fromIntegral $ M.size p''
+ where p'' = intersectionWith (\a b->(a,b)) p p'
+       n = fromIntegral $ size p''
hunk ./ch2/Algorithms.hs 50
-       (sum1Sq,sum2Sq) = F.foldr (pair3 (+)) (0,0) $ M.map (pair (^2)) p''
-       pSum = F.foldr (+) 0 $ M.map ( \(a,b)->a*b ) p''
+       (sum1Sq,sum2Sq) = F.foldr (pair3 (+)) (0,0) $ D.map (pair (^2)) p''
+       pSum = F.foldr (+) 0 $ D.map ( \(a,b)->a*b ) p''
hunk ./ch2/Algorithms.hs 71
-    case M.lookup key set of
+    case lookup key set of
hunk ./ch2/Algorithms.hs 74
-                filter ((/= Nothing) . snd) . M.toList . 
-                fmap (metric m) $ M.delete key set
+                filter ((/= Nothing) . snd) . toList . 
+                fmap (metric m) $ delete key set
hunk ./ch2/Algorithms.hs 80
-     case M.lookup key set of
+     case lookup key set of
hunk ./ch2/Algorithms.hs 82
-       Just m -> M.toList . fmap (\(a,b) -> a*b) . items $ m
-  where set' = M.delete key $ set
+       Just m -> toList . fmap (\(a,b) -> a*b) . items $ m
+  where set' = delete key $ set
hunk ./ch2/Algorithms.hs 85
-        weighted m = M.mapWithKey (\k m' -> fmap 
+        weighted m = mapWithKey (\k m' -> fmap 
hunk ./ch2/Algorithms.hs 88
-        items m = F.foldr (M.unionWith (pair3 (+))) M.empty . weighted $ m
+        items m = F.foldr (unionWith (pair3 (+))) empty . weighted $ m
hunk ./ch2/Algorithms.hs 94
-calculateSimilarItems n d = DataSet . fmap M.fromList $ items'
+calculateSimilarItems n d = DataSet . fmap fromList $ items'
hunk ./ch2/Algorithms.hs 96
-        items' = M.mapWithKey (\key _ -> take n $ 
+        items' = mapWithKey (\key _ -> take n $ 
hunk ./ch2/DataSet.hs 3
-module DataSet (DataSet (..), Metric, handleLookups, MetricPrime, transform, fromLists)
+module DataSet (DataSet (..), Metric, handleLookups, MetricPrime, transform, fromLists,(!),null,intersectionWith,size,map,lookup,toList,delete,lookup,mapWithKey,unionWith,fromList,empty)
hunk ./ch2/DataSet.hs 6
+import Prelude hiding (map,null,lookup)
hunk ./ch2/DataSet.hs 65
+
+null :: Map a b -> Bool
+null = M.null
+
+intersectionWith :: Ord a => (b -> c -> d) -> Map a b -> Map a c -> Map a d
+intersectionWith = M.intersectionWith
+
+size :: Map a b -> Int
+size = M.size
+ 
+map = M.map
+
+lookup :: (Monad m, Ord a) => a -> Map a b -> m b
+lookup = M.lookup
+
+toList = M.toList
+
+delete :: Ord a => a -> Map a b -> Map a b
+delete = M.delete
+
+mapWithKey = M.mapWithKey
+
+fromList :: Ord a => [(a, b)] -> Map a b
+fromList = M.fromList
+
+unionWith :: Ord a => (b -> b -> b) -> Map a b -> Map a b -> Map a b
+unionWith = M.unionWith
+
+empty = M.empty
hunk ./ch2/TestDataSet.hs 5
-import DataSet
+import DataSet hiding (map)
hunk ./ch2/TestDataSet.hs 89
+
+tests = TestList [TestLabel "test1" test1,
+                  TestLabel "test2" test2,
+                  TestLabel "test3" test3,
+                  TestLabel "test4" test4,
+                  TestLabel "test5" test5]