1 files changed, 1 insertions, 64 deletions

diff --git a/lib/CommandLine.hs b/lib/CommandLine.hs
index 4897b21..6bd42ea 100644
--- a/lib/CommandLine.hs
+++ b/lib/CommandLine.hs
@@ -37,6 +37,7 @@ import Numeric.Interval (Interval(..), singleton, (...), inf, sup, hull)
 import qualified Numeric.Interval as I
 import Numeric.Interval.Bounded
 import SuperOrd
+import Data.List.Merge
 
 -- trace :: String -> a -> a
 -- trace _ x = x
@@ -120,51 +121,6 @@ packBits bs = sum $ zipWith (\b n -> if b then n else 0) bs $ iterate (*2) 1
  -}
 
 
--- | mergeData
---
---   > mergeData compare [1,3,5] [2,2,4,6]  ==> [(1,LT),(2,GT),(1,LT),(1,GT),(1,LT),(1,GT)]
---
---   Given a comparison function and two sorted lists, 'mergeData' will return
---   a RLE compressed (run-length encoded) list of the comparison results
---   encountered while merging the lists.
---
---   This data is enough information to perform the merge without doing the
---   comparisons or to reverse a merged list back to two sorted lists.
---
---   When one list is exausted, the length of the remaining list is returned as
---   a run-length for LT or GT depending on whether the left list or the right
---   list has elements.
-mergeData :: (a -> a -> Ordering) -> [a] -> [a] -> [(Int,Ordering)]
-mergeData comp (x:xs) (y:ys)
-  | comp x y == LT = case mergeData comp xs (y:ys) of
-                        (n,LT):ys -> let n'=n+1 in n' `seq` (n',LT):ys
-                        ys        -> (1,LT):ys
-  | comp x y == EQ = case mergeData comp xs ys of
-                        (n,EQ):ys -> let n'=n+1 in n' `seq` (n',EQ):ys
-                        ys        -> (1,EQ):ys
-  | comp x y == GT = case mergeData comp (x:xs) ys of
-                        (n,GT):ys -> let n'=n+1 in n' `seq` (n',GT):ys
-                        ys        -> (1,GT):ys
-mergeData comp [] [] = []
-mergeData comp [] ys = (length ys, GT) : []
-mergeData comp xs [] = (length xs, LT) : []
-
-mergeLists :: [(Int,Ordering)] -> (a -> a -> a) -> [a] -> [a] -> [a]
-mergeLists ((n,LT):os) f xs ys = ls ++ mergeLists os f xs' ys
- where
-    (ls,xs') = splitAt n xs
-mergeLists ((n,EQ):os) f xs ys = es ++ mergeLists os f xs' ys'
- where
-    (les,xs') = splitAt n xs
-    (res,ys') = splitAt n ys
-    es = zipWith f les res
-mergeLists ((n,GT):os) f xs ys = gs ++ mergeLists os f xs ys'
- where
-    (gs,ys') = splitAt n ys
-mergeLists [] f [] ys = ys
-mergeLists [] f xs [] = xs
-mergeLists [] f xs ys = error "xs ++ ys"
-
 {-
 computeMask :: Int -> Ordering -> Ordering -> [(Int,Ordering)] -> Integer
 computeMask k w t [] = 0
@@ -207,21 +163,6 @@ mergeIntegers [] f !x !0 = x
 mergeIntegers [] f !x !y = error "x .|. y"
 -}
 
-splitLists :: [(Int,Ordering)] -> [a] -> ([a],[a])
-splitLists ((n,LT):os) xs = (ls ++ lls, rrs)
- where
-    (ls,xs') = splitAt n xs
-    (lls,rrs) = splitLists os xs'
-splitLists ((n,EQ):os) xs = (es ++ lls, es ++ rrs)
- where
-    (es,xs') = splitAt n xs
-    (lls,rrs) = splitLists os xs'
-splitLists ((n,GT):os) xs = (lls, rs ++ rrs)
- where
-    (rs,xs') = splitAt n xs
-    (lls,rrs) = splitLists os xs'
-splitLists [] xs = (xs,xs)
-
 {-
 mergeBy :: Show a => (a -> a -> Ordering) -> [a] -> [a]
     -> ( (Integer -> Integer -> Integer) -> Integer -> Integer -> Integer
@@ -452,10 +393,6 @@ removeIntersection [] ys = ([],ys)
 removeIntersection xs [] = (xs,[])
 
 
--- ordinary sorted list merge.
-mergeL :: Ord a => [a] -> [a] -> [a]
-mergeL as bs = mergeLists (mergeData compare as bs) const as bs
-
 -- | runArgs
 --
 --    (os,us)   - named arguments(options, name-value pairs), and unnamed arguments