cleaning up, minimizing Utils

Author: atzedijkstra

chr-data/src/CHR/Data/Lookup/Scoped.hs

@@ -185,6 +185,8 @@ instance (Scoped scps, Lookup lkup k (ScopedItem v)) => Lookup (ScpsLkup lkup sc
   -- first a quick test, then the more expensive
   null l@(ScpsLkup lkup scps) = null lkup || List.null (toList l)
 
+  size l@(ScpsLkup lkup _) = size lkup
+  
   {-
   -- should restrict to items which are nested inside current scope
   findMin (ScpsLkup lkup scps) = second _scopeditemVal $ findMin lkup

chr-data/src/CHR/Utils.hs

@@ -6,6 +6,7 @@
 
 module CHR.Utils
   ( 
+  {-
     -- * Set
     unionMapSet
 
@@ -18,18 +19,24 @@ module CHR.Utils
     -- * List
   , hdAndTl', hdAndTl
   , maybeNull
-  , maybeHd
+  -}
+    maybeHd
+  {-
   , wordsBy
   , initlast, initlast2
   , last'
   , firstNotEmpty
   , listSaturate, listSaturateWith
   , spanOnRest
   , filterMb
+  -}
   , splitPlaces
   , combineToDistinguishedEltsBy
+  {-
   , partitionOnSplit
+  -}
   , zipWithN
+  {-
   
     -- * Tuple
   , tup123to1, tup123to2
@@ -82,19 +89,26 @@ module CHR.Utils
   , showUnprefixed
   
     -- * Ordering
+    -}
   , orderingLexic
+  {-
   , orderingLexicList
   
     -- * Misc
+  -}
   , panic
-  
+  {-
   , isSortedByOn
   , sortOnLazy
   , sortOn
+  -}
   , sortByOn
+  {-
   , groupOn
   , groupByOn
+  -}
   , groupSortOn
+  {-
   , groupSortByOn
   , nubOn
   
@@ -115,6 +129,7 @@ module CHR.Utils
     -- * Monad
   , firstMaybeM
   , breakM
+  -}
   )
   where
 
@@ -128,6 +143,8 @@ import qualified Data.Set as Set
 import qualified Data.Map as Map
 -- import qualified Data.Graph as Graph
 
+{-
+
 -------------------------------------------------------------------------
 -- Set
 -------------------------------------------------------------------------
@@ -147,11 +164,13 @@ inverseMap mk = Map.fromList . map (uncurry mk) . Map.toList
 -- | Show keys of map using a separator
 showStringMapKeys :: Map.Map String x -> String -> String
 showStringMapKeys m sep = concat $ intersperse sep $ Map.keys m
+-}
 
 -------------------------------------------------------------------------
 -- List
 -------------------------------------------------------------------------
 
+{-
 -- | Get head and tail, with default if empty list
 hdAndTl' :: a -> [a] -> (a,[a])
 hdAndTl' _ (a:as) = (a,as)
@@ -161,6 +180,7 @@ hdAndTl' n []     = (n,[])
 hdAndTl :: [a] -> (a,[a])
 hdAndTl = hdAndTl' (panic "hdAndTl")
 {-# INLINE hdAndTl  #-}
+-}
 
 maybeNull :: r -> ([a] -> r) -> [a] -> r
 maybeNull n f l = if null l then n else f l
@@ -170,6 +190,7 @@ maybeHd :: r -> (a -> r) -> [a] -> r
 maybeHd n f = maybeNull n (f . head)
 {-# INLINE maybeHd  #-}
 
+{-
 -- | Split up in words by predicate
 wordsBy :: (a -> Bool) -> [a] -> [[a]]
 wordsBy p l
@@ -236,6 +257,8 @@ filterMb :: (a -> Maybe b) -> [a] -> [b]
 filterMb p = catMaybes . map p
 {-# INLINE filterMb #-}
 
+-}
+
 -- | Split at index places (inspired by/from split package). Places should be increasing, starting with an index >= 0.
 -- The number of sublists returned is one higher than the number of places.
 -- 
@@ -279,6 +302,8 @@ zipWithN :: ([x] -> y) -> [[x]] -> [y]
 zipWithN f l | any null l = []
              | otherwise  = f (map head l) : zipWithN f (map tail l)
 
+{-
+
 -------------------------------------------------------------------------
 -- Tupling, untupling
 -------------------------------------------------------------------------
@@ -353,6 +378,7 @@ fth  = fth4
 {-# INLINE fth4 #-}
 {-# INLINE fth  #-}
 
+
 -------------------------------------------------------------------------
 -- String
 -------------------------------------------------------------------------
@@ -434,6 +460,9 @@ splitForQualified s
                   (nq,(_:ns)) -> nq ++ [concatMap ("."++) ns]
                   _ -> ws'
 
+-}
+
+
 -------------------------------------------------------------------------
 -- Misc
 -------------------------------------------------------------------------
@@ -445,6 +474,8 @@ panic m = error ("panic: " ++ m)
 -- group/sort/nub combi's
 -------------------------------------------------------------------------
 
+{-
+
 isSortedByOn :: (b -> b -> Ordering) -> (a -> b) -> [a] -> Bool
 isSortedByOn cmp sel l
   = isSrt l
@@ -457,6 +488,8 @@ sortOnLazy :: Ord b => (a -> b) -> [a] -> [a]
 sortOnLazy = sortByOn compare
 {-# INLINE sortOnLazy #-}
 
+-}
+
 #if __GLASGOW_HASKELL__ >= 710
 #else
 -- | The original Data.List.sortOn.
@@ -466,6 +499,7 @@ sortOn = sortOnLazy
 {-# INLINE sortOn #-}
 #endif
 
+
 sortByOn :: (b -> b -> Ordering) -> (a -> b) -> [a] -> [a]
 sortByOn cmp sel = sortBy (cmp `on` sel) -- (\e1 e2 -> sel e1 `cmp` sel e2)
 
@@ -475,6 +509,7 @@ groupOn sel = groupBy ((==) `on` sel) -- (\e1 e2 -> sel e1 == sel e2)
 groupSortOn :: Ord b => (a -> b) -> [a] -> [[a]]
 groupSortOn sel = groupOn sel . sortOn sel
 
+{-
 groupByOn :: (b -> b -> Bool) -> (a -> b) -> [a] -> [[a]]
 groupByOn eq sel = groupBy (eq `on` sel) -- (\e1 e2 -> sel e1 `eq` sel e2)
 
@@ -499,6 +534,7 @@ partitionOnSplit split adapt pred xs = foldr sel ([],[]) xs
   where sel x ~(ts,fs) | pred x'   = ((adapt x',y):ts,   fs)
                        | otherwise = (             ts, y:fs)
           where (x',y) = split x
+-}
 
 {-
 partition               :: (a -> Bool) -> [a] -> ([a],[a])
@@ -510,6 +546,7 @@ select p x ~(ts,fs) | p x       = (x:ts,fs)
                     | otherwise = (ts, x:fs)
 -}
 
+{-
 -------------------------------------------------------------------------
 -- Partitioning with rebuild
 -------------------------------------------------------------------------
@@ -522,6 +559,8 @@ partitionAndRebuild f (v:vs)
   where (vs1,vs2,mk) = partitionAndRebuild f vs
 partitionAndRebuild _ [] = ([], [], \_ _ -> [])
 
+-}
+
 -------------------------------------------------------------------------
 -- Ordering
 -------------------------------------------------------------------------
@@ -536,10 +575,13 @@ orderingLexic :: Ordering -> Ordering -> Ordering
 orderingLexic o1 o2 = if o1 == EQ then o2 else o1
 {-# INLINE orderingLexic #-}
 
+{-
+
 -------------------------------------------------------------------------
 -- Maybe
 -------------------------------------------------------------------------
 
+
 panicJust :: String -> Maybe a -> a
 panicJust m = maybe (panic m) id
 {-# INLINE panicJust #-}
@@ -569,6 +611,8 @@ maybeOr n fa fb ma mb
                   Just b -> fb b
                   _      -> n
 
+-}
+
 -------------------------------------------------------------------------
 -- Strongly Connected Components
 -------------------------------------------------------------------------
@@ -578,6 +622,7 @@ scc :: Ord n => [(n,[n])] -> [[n]]
 scc = map Graph.flattenSCC . Graph.stronglyConnComp . map (\(n,ns) -> (n, n, ns))
 -}
 
+{-
 -------------------------------------------------------------------------
 -- Map
 -------------------------------------------------------------------------
@@ -609,3 +654,7 @@ breakM :: Monad m => (a -> Bool) -> [m a] -> m ([a], Maybe (a,[m a]))
 breakM p l = br [] l >>= \(acc,res) -> return (reverse acc, res)
   where br acc []     = return (acc, Nothing)
         br acc (m:ms) = m >>= \x -> if p x then return (acc, Just (x, ms)) else br (x:acc) ms
+
+-}
+
+