content: --  $Id: GenUtil.hs,v 1.53 2009/06/04 04:39:15 john Exp $
  -- arch-tag: 835e46b7-8ffd-40a0-aaf9-326b7e347760
  
  -- Copyright (c) 2002 John Meacham (john@foo.net)
  --
  -- Permission is hereby granted, free of charge, to any person obtaining a
  -- copy of this software and associated documentation files (the
  -- "Software"), to deal in the Software without restriction, including
  -- without limitation the rights to use, copy, modify, merge, publish,
  -- distribute, sublicense, and/or sell copies of the Software, and to
  -- permit persons to whom the Software is furnished to do so, subject to
  -- the following conditions:
  --
  -- The above copyright notice and this permission notice shall be included
  -- in all copies or substantial portions of the Software.
  --
  -- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  -- OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  -- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  -- IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  -- CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  -- TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  -- SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  
  ----------------------------------------
  -- | This is a collection of random useful utility functions written in pure
  -- Haskell 98. In general, it trys to conform to the naming scheme put forth
  -- the haskell prelude and fill in the obvious omissions, as well as provide
  -- useful routines in general. To ensure maximum portability, no instances are
  -- exported so it may be added to any project without conflicts.
  ----------------------------------------
  
  module GenUtil(
      -- * Functions
      -- ** Error reporting
      putErr,putErrLn,putErrDie,
      -- ** Simple deconstruction
      fromLeft,fromRight,fsts,snds,splitEither,rights,lefts,
      isLeft,isRight,
      fst3,snd3,thd3,
      -- ** System routines
      exitSuccess, exitFailure, epoch, lookupEnv,endOfTime,
      -- ** Random routines
      repMaybe,
      liftT2, liftT3, liftT4,
      snub, snubFst, snubUnder, smerge, sortFst, groupFst, foldl',
      fmapLeft,fmapRight,isDisjoint,isConjoint,
      groupUnder,
      sortUnder,
      minimumUnder,
      maximumUnder,
      sortGroupUnder,
      sortGroupUnderF,
      sortGroupUnderFG,
      sameLength,
      naturals,
  
      -- ** Monad routines
      perhapsM,
      repeatM, repeatM_, replicateM, replicateM_, maybeToMonad,
      toMonadM, ioM, ioMp, foldlM, foldlM_, foldl1M, foldl1M_,
      maybeM,
      -- ** Text Routines
      -- *** Quoting
      shellQuote, simpleQuote, simpleUnquote,
      -- *** Layout
      indentLines,
      buildTableLL,
      buildTableRL,
      buildTable,
      trimBlankLines,
      paragraph,
      paragraphBreak,
      expandTabs,
      chunkText,
      -- *** Scrambling
      rot13,
      -- ** Random
      intercalate,
      powerSet,
      randomPermute,
      randomPermuteIO,
      chunk,
      rtup,
      triple,
      fromEither,
      mapFst,
      mapSnd,
      mapFsts,
      mapSnds,
      tr,
      readHex,
      overlaps,
      showDuration,
      readM,
      readsM,
      split,
      tokens,
      count,
      hasRepeatUnder,
      -- ** Option handling
      getArgContents,
      parseOpt,
      getOptContents,
      doTime,
      getPrefix,
      rspan,
      rbreak,
      rdropWhile,
      rtakeWhile,
      rbdropWhile,
      concatMapM,
      on,
      mapMsnd,
      mapMfst,
      iocatch,
  
      -- * Classes
      UniqueProducer(..)
      ) where
  
  import Data.Char(isAlphaNum, isSpace, toLower, ord, chr)
  import Data.List
  import Control.Monad (join, liftM, MonadPlus, mzero)
  import qualified System.IO as IO
  import System.IO.Error (isDoesNotExistError)
  import Control.Exception
  import Prelude hiding (catch)
  import System.Random(StdGen, newStdGen, Random(randomR))
  import System.Time
  import System.CPUTime
  import System.Exit
  import System.Environment (getArgs, getEnv)
  
  {-# SPECIALIZE snub :: [String] -> [String] #-}
  {-# SPECIALIZE snub :: [Int] -> [Int] #-}
  
  {-# RULES "snub/snub" forall x . snub (snub x) = snub x #-}
  {-# RULES "snub/nub" forall x . snub (nub x) = snub x #-}
  {-# RULES "nub/snub" forall x . nub (snub x) = snub x #-}
  {-# RULES "snub/sort" forall x . snub (sort x) = snub x #-}
  {-# RULES "sort/snub" forall x . sort (snub x) = snub x #-}
  {-# RULES "snub/[]" snub [] = [] #-}
  {-# RULES "snub/[x]" forall x . snub [x] = [x] #-}
  
  -- | catch function only for IOException
  iocatch :: IO a -> (IOException -> IO a) -> IO a
  iocatch = catch
  
  -- | sorted nub of list, much more efficient than nub, but doesnt preserve ordering.
  snub :: Ord a => [a] -> [a]
  snub = map head . group . sort
  
  -- | sorted nub of list of tuples, based solely on the first element of each tuple.
  snubFst :: Ord a => [(a,b)] -> [(a,b)]
  snubFst = map head . groupBy (\(x,_) (y,_) -> x == y) . sortBy (\(x,_) (y,_) -> compare x y)
  
  -- | sorted nub of list based on function of values
  snubUnder :: Ord b => (a -> b) -> [a] -> [a]
  snubUnder f = map head . groupUnder f . sortUnder f
  
  -- | sort list of tuples, based on first element of each tuple.
  sortFst :: Ord a => [(a,b)] -> [(a,b)]
  sortFst = sortBy (\(x,_) (y,_) -> compare x y)
  
  -- | group list of tuples, based only on equality of the first element of each tuple.
  groupFst :: Eq a => [(a,b)] -> [[(a,b)]]
  groupFst = groupBy (\(x,_) (y,_) -> x == y)
  
  concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b]
  concatMapM f xs = do
      res <- mapM f xs
      return $ concat res
  
  on :: (a -> a -> b) -> (c -> a) -> c -> c -> b
  (*) `on` f = \x y -> f x * f y
  
  mapMsnd :: Monad m => (b -> m c) -> [(a,b)] -> m [(a,c)]
  mapMsnd f xs = do
      let g (a,b) = do
              c <- f b
              return (a,c)
      mapM g xs
  
  mapMfst :: Monad m => (b -> m c) -> [(b,a)] -> m [(c,a)]
  mapMfst f xs = do
      let g (a,b) = do
              c <- f a
              return (c,b)
      mapM g xs
  
  rspan :: (a -> Bool) -> [a] -> ([a], [a])
  rspan fn xs = f xs [] where
      f [] rs = ([],reverse rs)
      f (x:xs) rs
          | fn x = f xs (x:rs)
          | otherwise = (reverse rs ++ x:za,zb) where
              (za,zb) = f xs []
  
  rbreak :: (a -> Bool) -> [a] -> ([a], [a])
  rbreak fn xs = rspan (not . fn) xs
  
  rdropWhile :: (a -> Bool) -> [a] -> [a]
  rdropWhile fn xs = f xs [] where
      f [] _ = []
      f (x:xs) rs
          | fn x = f xs (x:rs)
          | otherwise = reverse rs ++ x:(f xs [])
  
  rtakeWhile :: (a -> Bool) -> [a] -> [a]
  rtakeWhile fn xs = f xs [] where
      f [] rs = reverse rs
      f (x:xs) rs
          | fn x = f xs (x:rs)
          | otherwise = f xs []
  
  rbdropWhile :: (a -> Bool) -> [a] -> [a]
  rbdropWhile fn xs = rdropWhile fn (dropWhile fn xs)
  
  -- | group a list based on a function of the values.
  groupUnder :: Eq b => (a -> b) -> [a] -> [[a]]
  groupUnder f = groupBy (\x y -> f x == f y)
  -- | sort a list based on a function of the values.
  sortUnder :: Ord b => (a -> b) -> [a] -> [a]
  sortUnder f = sortBy (\x y -> f x `compare` f y)
  
  -- | merge sorted lists in linear time
  smerge :: Ord a => [a] -> [a] -> [a]
  smerge (x:xs) (y:ys)
      | x == y = x:smerge xs ys
      | x < y = x:smerge xs (y:ys)
      | otherwise = y:smerge (x:xs) ys
  smerge [] ys = ys
  smerge xs [] = xs
  
  sortGroupUnder :: Ord a => (b -> a) -> [b] -> [[b]]
  sortGroupUnder f = groupUnder f . sortUnder f
  sortGroupUnderF :: Ord a => (b -> a) -> [b] -> [(a,[b])]
  sortGroupUnderF f xs = [ (f x, xs) |  xs@(x:_) <- sortGroupUnder f xs]
  
  sortGroupUnderFG :: Ord b => (a -> b) -> (a -> c) -> [a] -> [(b,[c])]
  sortGroupUnderFG f g xs = [ (f x, map g xs) |  xs@(x:_) <- sortGroupUnder f xs]
  
  minimumUnder :: Ord b => (a -> b) -> [a] -> a
  minimumUnder _ [] = error "minimumUnder: empty list"
  minimumUnder _ [x] = x
  minimumUnder f (x:xs) = g (f x) x xs where
      g _ x [] = x
      g fb b (x:xs)
          | fx < fb = g fx x xs
          | otherwise = g fb b xs where
              fx = f x
  
  maximumUnder :: Ord b => (a -> b) -> [a] -> a
  maximumUnder _ [] = error "maximumUnder: empty list"
  maximumUnder _ [x] = x
  maximumUnder f (x:xs) = g (f x) x xs where
      g _ x [] = x
      g fb b (x:xs)
          | fx > fb = g fx x xs
          | otherwise = g fb b xs where
              fx = f x
  
  -- | Flushes stdout and writes string to standard error
  putErr :: String -> IO ()
  putErr s = IO.hFlush IO.stdout >> IO.hPutStr IO.stderr s
  
  -- | Flush stdout and write string and newline to standard error
  putErrLn :: String -> IO ()
  putErrLn s = IO.hFlush IO.stdout >> IO.hPutStrLn IO.stderr s
  
  -- | Flush stdout, write string and newline to standard error,
  -- then exit program with failure.
  putErrDie :: String -> IO a
  putErrDie s = putErrLn s >> exitFailure
  
  {-# INLINE fromRight #-}
  fromRight :: Either a b -> b
  fromRight (Right x) = x
  fromRight _ = error "fromRight"
  
  {-# INLINE fromLeft #-}
  fromLeft :: Either a b -> a
  fromLeft (Left x) = x
  fromLeft _ = error "fromLeft"
  
  -- | recursivly apply function to value until it returns Nothing
  repMaybe :: (a -> Maybe a) -> a -> a
  repMaybe f e = case f e of
      Just e' -> repMaybe f e'
      Nothing -> e
  
  {-# INLINE liftT2 #-}
  {-# INLINE liftT3 #-}
  {-# INLINE liftT4 #-}
  
  liftT4 (f1,f2,f3,f4) (v1,v2,v3,v4) = (f1 v1, f2 v2, f3 v3, f4 v4)
  liftT3 (f,g,h) (x,y,z) = (f x, g y, h z)
  -- | apply functions to values inside a tupele. 'liftT3' and 'liftT4' also exist.
  liftT2 :: (a -> b, c -> d) -> (a,c) -> (b,d)
  liftT2 (f,g) (x,y) = (f x, g y)
  
  -- | class for monads which can generate
  -- unique values.
  class Monad m => UniqueProducer m where
      -- | produce a new unique value
      newUniq :: m Int
  
  rtup a b = (b,a)
  triple a b c = (a,b,c)
  
  fst3 (a,_,_) = a
  snd3 (_,b,_) = b
  thd3 (_,_,c) = c
  
  -- | the standard unix epoch
  epoch :: ClockTime
  epoch = toClockTime $ CalendarTime { ctYear = 1970, ctMonth = January, ctDay = 0, ctHour = 0, ctMin = 0, ctSec = 0, ctTZ = 0, ctPicosec = 0, ctWDay = undefined, ctYDay = undefined, ctTZName = undefined, ctIsDST = undefined}
  
  -- | an arbitrary time in the future
  endOfTime :: ClockTime
  endOfTime = toClockTime $ CalendarTime { ctYear = 2020, ctMonth = January, ctDay = 0, ctHour = 0, ctMin = 0, ctSec = 0, ctTZ = 0, ctPicosec = 0, ctWDay = undefined, ctYDay = undefined, ctTZName = undefined, ctIsDST = undefined}
  
  {-# INLINE fsts #-}
  -- | take the fst of every element of a list
  fsts :: [(a,b)] -> [a]
  fsts = map fst
  
  {-# INLINE snds #-}
  -- | take the snd of every element of a list
  snds :: [(a,b)] -> [b]
  snds = map snd
  
  {-# SPECIALIZE repeatM :: IO a -> IO [a] #-}
  repeatM :: Monad m => m a -> m [a]
  repeatM x = sequence $ repeat x
  
  {-# SPECIALIZE repeatM_ :: IO a -> IO () #-}
  repeatM_ :: Monad m => m a -> m ()
  repeatM_ x = sequence_ $ repeat x
  
  {-# RULES "replicateM/0" replicateM 0 = const (return []) #-}
  {-# RULES "replicateM_/0" replicateM_ 0 = const (return ()) #-}
  
  {-# SPECIALIZE replicateM :: Int -> IO a -> IO [a] #-}
  replicateM :: Monad m => Int -> m a -> m [a]
  replicateM n x = sequence $ replicate n x
  
  {-# SPECIALIZE replicateM_ :: Int -> IO a -> IO () #-}
  replicateM_ :: Monad m => Int -> m a -> m ()
  replicateM_ n x = sequence_ $ replicate n x
  
  -- | convert a maybe to an arbitrary failable monad
  maybeToMonad :: Monad m => Maybe a -> m a
  maybeToMonad (Just x) = return x
  maybeToMonad Nothing = fail "Nothing"
  
  -- | convert a maybe to an arbitrary failable monad
  maybeM :: Monad m => String -> Maybe a -> m a
  maybeM _ (Just x) = return x
  maybeM s Nothing = fail s
  
  toMonadM :: Monad m => m (Maybe a) -> m a
  toMonadM action = join $ liftM maybeToMonad action
  
  foldlM :: Monad m => (a -> b -> m a) -> a -> [b] -> m a
  foldlM f v (x:xs) = (f v x) >>= \a -> foldlM f a xs
  foldlM _ v [] = return v
  
  foldl1M :: Monad m => (a -> a -> m a) ->  [a] -> m a
  foldl1M f (x:xs) = foldlM f x xs
  foldl1M _ _ = error "foldl1M"
  
  foldlM_ :: Monad m => (a -> b -> m a) -> a -> [b] -> m ()
  foldlM_ f v xs = foldlM f v xs >> return ()
  
  foldl1M_ ::Monad m => (a -> a -> m a)  -> [a] -> m ()
  foldl1M_ f xs = foldl1M f xs >> return ()
  
  -- | partition a list of eithers.
  splitEither :: [Either a b] -> ([a],[b])
  splitEither  (r:rs) = case splitEither rs of
      (xs,ys) -> case r of
          Left x -> (x:xs,ys)
          Right y -> (xs,y:ys)
  splitEither          [] = ([],[])
  
  isLeft Left {} = True
  isLeft _ = False
  
  isRight Right {} = True
  isRight _ = False
  
  perhapsM :: Monad m => Bool -> a -> m a
  perhapsM True a = return a
  perhapsM False _ = fail "perhapsM"
  
  sameLength (_:xs) (_:ys) = sameLength xs ys
  sameLength [] [] = True
  sameLength _ _ = False
  
  fromEither :: Either a a -> a
  fromEither (Left x) = x
  fromEither (Right x) = x
  
  {-# INLINE mapFst #-}
  {-# INLINE mapSnd #-}
  mapFst :: (a -> b) -> (a,c) -> (b,c)
  mapFst  f   (x,y) = (f x,  y)
  mapSnd :: (a -> b) -> (c,a) -> (c,b)
  mapSnd    g (x,y) = (  x,g y)
  
  {-# INLINE mapFsts #-}
  {-# INLINE mapSnds #-}
  mapFsts :: (a -> b) -> [(a,c)] -> [(b,c)]
  mapFsts f xs = [(f x, y) | (x,y) <- xs]
  mapSnds :: (a -> b) -> [(c,a)] -> [(c,b)]
  mapSnds g xs = [(x, g y) | (x,y) <- xs]
  
  {-# INLINE rights #-}
  -- | take just the rights
  rights :: [Either a b] -> [b]
  rights xs = [x | Right x <- xs]
  
  {-# INLINE lefts #-}
  -- | take just the lefts
  lefts :: [Either a b] -> [a]
  lefts xs = [x | Left x <- xs]
  
  -- | Trasform IO errors into the failing of an arbitrary monad.
  ioM :: Monad m => IO a -> IO (m a)
  ioM action = iocatch (fmap return action) (\e -> return (fail (show e)))
  
  -- | Trasform IO errors into the mzero of an arbitrary member of MonadPlus.
  ioMp :: MonadPlus m => IO a -> IO (m a)
  ioMp action = iocatch (fmap return action) (\_ -> return mzero)
  
  -- | reformat a string to not be wider than a given width, breaking it up
  -- between words.
  
  paragraph :: Int -> String -> String
  paragraph maxn xs = drop 1 (f maxn (words xs)) where
      f n (x:xs) | lx < n = (' ':x) ++ f (n - lx) xs where
          lx = length x + 1
      f _ (x:xs) = '\n': (x ++ f (maxn - length x) xs)
      f _ [] = "\n"
  
  chunk :: Int -> [a] -> [[a]]
  chunk 0 _  = repeat []
  chunk _ [] = []
  chunk mw s = case splitAt mw s of
      (a,[]) -> [a]
      (a,b) -> a : chunk mw b
  
  chunkText :: Int -> String -> String
  chunkText mw s = concatMap (unlines . chunk mw) $ lines s
  
  rot13Char :: Char -> Char
  rot13Char c
      | c >= 'a' && c <= 'm' || c >= 'A' && c <= 'M' = chr $ ord c + 13
      | c >= 'n' && c <= 'z' || c >= 'N' && c <= 'Z' = chr $ ord c - 13
      | otherwise                                    = c
  
  rot13 :: String -> String
  rot13 = map rot13Char
  
  {-
  paragraphBreak :: Int -> String -> String
  paragraphBreak  maxn xs = unlines (map ( unlines . map (unlines . chunk maxn) . lines . f maxn ) $ lines xs) where
      f _ "" = ""
      f n xs | length ss > 0 = if length ss + r rs > n then '\n':f maxn rs else ss where
          (ss,rs) = span isSpace xs
      f n xs = ns ++ f (n - length ns) rs where
          (ns,rs) = span (not . isSpace) xs
      r xs = length $ fst $ span (not . isSpace) xs
  -}
  
  paragraphBreak :: Int -> String -> String
  paragraphBreak  maxn xs = unlines $ (map f) $ lines xs where
      f s | length s <= maxn = s
      f s | isSpace (head b) = a ++ "\n" ++ f (dropWhile isSpace b)
          | all (not . isSpace) a = a ++ "\n" ++ f b
          | otherwise  = reverse (dropWhile isSpace sa) ++ "\n" ++ f (reverse ea ++ b) where
              (ea, sa) = span (not . isSpace) $ reverse a
              (a,b) = splitAt maxn s
  
  expandTabs' :: Int -> Int -> String -> String
  expandTabs' 0 _ s = filter (/= '\t') s
  expandTabs' sz off ('\t':s) = replicate len ' ' ++ expandTabs' sz (off + len) s where
      len = (sz - (off `mod` sz))
  expandTabs' sz _ ('\n':s) = '\n': expandTabs' sz 0 s
  expandTabs' sz off (c:cs) = c: expandTabs' sz (off + 1) cs
  expandTabs' _ _ "" = ""
  
  -- | expand tabs into spaces in a string assuming tabs are every 8 spaces and we are starting at column 0.
  expandTabs :: String -> String
  expandTabs s = expandTabs' 8 0 s
  
  -- | Translate characters to other characters in a string, if the second argument is empty,
  -- delete the characters in the first argument, else map each character to the
  -- cooresponding one in the second argument, cycling the second argument if
  -- necessary.
  
  tr :: String -> String -> String -> String
  tr as "" s = filter (`notElem` as) s
  tr as bs s = map (f as bs) s where
      f (a:_) (b:_) c | a == c = b
      f (_:as) (_:bs) c = f as bs c
      f [] _ c = c
      f as' [] c = f as' bs c
      --f _ _ _ = error "invalid tr"
  
  -- | quote strings rc style. single quotes protect any characters between
  -- them, to get an actual single quote double it up. Inverse of 'simpleUnquote'
  simpleQuote :: [String] -> String
  simpleQuote ss = unwords (map f ss) where
      f s | any isBad s || null s = "'" ++ dquote s ++ "'"
      f s = s
      dquote s = concatMap (\c -> if c == '\'' then "''" else [c]) s
      isBad c = isSpace c || c == '\''
  
  -- | inverse of 'simpleQuote'
  simpleUnquote :: String -> [String]
  simpleUnquote s = f (dropWhile isSpace s)  where
      f [] = []
      f ('\'':xs) = case quote' "" xs of (x,y) ->  x:f (dropWhile isSpace y)
      f xs = case span (not . isSpace) xs of (x,y) ->  x:f (dropWhile isSpace y)
      quote' a ('\'':'\'':xs) = quote' ('\'':a) xs
      quote' a ('\'':xs) = (reverse a, xs)
      quote' a (x:xs) = quote' (x:a) xs
      quote' a [] = (reverse a, "")
  
  -- | quote a set of strings as would be appropriate to pass them as
  -- arguments to a sh style shell
  shellQuote :: [String] -> String
  shellQuote ss = unwords (map f ss) where
      f s | any (not . isGood) s || null s  = "'" ++ dquote s ++ "'"
      f s = s
      dquote s = concatMap (\c -> if c == '\'' then "'\\''" else [c]) s
      isGood c = isAlphaNum c || c `elem` "@/.-_:"
  
  -- | looks up an enviornment variable and returns it in an arbitrary Monad rather
  -- than raising an exception if the variable is not set.
  lookupEnv :: Monad m => String -> IO (m String)
  lookupEnv s = catch (fmap return $ getEnv s) (\e -> if isDoesNotExistError e then return (fail (show e)) else ioError e)
  
  {-# SPECIALIZE fmapLeft :: (a -> c) -> [(Either a b)] -> [(Either c b)] #-}
  fmapLeft :: Functor f => (a -> c) -> f (Either a b) -> f (Either c b)
  fmapLeft fn = fmap f where
      f (Left x) = Left (fn x)
      f (Right x)  = Right x
  
  {-# SPECIALIZE fmapRight :: (b -> c) -> [(Either a b)] -> [(Either a c)] #-}
  fmapRight :: Functor f => (b -> c) -> f (Either a b) -> f (Either a c)
  fmapRight fn = fmap f where
      f (Left x) = Left x
      f (Right x)  = Right (fn x)
  
  {-# SPECIALIZE isDisjoint :: [String] -> [String] -> Bool #-}
  {-# SPECIALIZE isConjoint :: [String] -> [String] -> Bool #-}
  {-# SPECIALIZE isDisjoint :: [Int] -> [Int] -> Bool #-}
  {-# SPECIALIZE isConjoint :: [Int] -> [Int] -> Bool #-}
  -- | set operations on lists. (slow!)
  isDisjoint, isConjoint :: Eq a => [a] -> [a] -> Bool
  isConjoint xs ys = or [x == y | x <- xs, y <- ys]
  isDisjoint xs ys = not (isConjoint xs ys)
  
  -- | place spaces before each line in string.
  indentLines :: Int -> String -> String
  indentLines n s = unlines $ map (replicate n ' ' ++)$ lines s
  
  -- | trim blank lines at beginning and end of string
  trimBlankLines :: String -> String
  trimBlankLines cs = unlines $ rbdropWhile (all isSpace) (lines cs)
  
  buildTableRL :: [(String,String)] -> [String]
  buildTableRL ps = map f ps where
      f (x,"") = x
      f (x,y) = replicate (bs - length x) ' ' ++ x ++ replicate 4 ' ' ++ y
      bs = maximum (map (length . fst) [ p | p@(_,_:_) <- ps ])
  
  buildTableLL :: [(String,String)] -> [String]
  buildTableLL ps = map f ps where
      f (x,y) = x ++ replicate (bs - length x) ' ' ++ replicate 4 ' ' ++ y
      bs = maximum (map (length . fst) ps)
  
  -- | count elements of list that have a given property
  count :: (a -> Bool) -> [a] -> Int
  count f xs = g 0 xs where
      g n [] = n
      g n (x:xs)
          | f x = let x = n + 1 in x `seq` g x xs
          | otherwise = g n xs
  
  -- | randomly permute a list, using the standard random number generator.
  randomPermuteIO :: [a] -> IO [a]
  randomPermuteIO xs = newStdGen >>= \g -> return (randomPermute g xs)
  
  -- | randomly permute a list given a RNG
  randomPermute :: StdGen -> [a] -> [a]
  randomPermute _   []  = []
  randomPermute gen xs  = (head tl) : randomPermute gen' (hd ++ tail tl)
     where (idx, gen') = randomR (0,length xs - 1) gen
           (hd,  tl)   = splitAt idx xs
  
  hasRepeatUnder f xs = any (not . null . tail) $ sortGroupUnder f xs
  
  -- | compute the power set of a list
  
  powerSet       :: [a] -> [[a]]
  powerSet []     = [[]]
  powerSet (x:xs) = xss /\/ map (x:) xss
                  where xss = powerSet xs
  
  -- | interleave two lists lazily, alternating elements from them. This can also be
  -- used instead of concatination to avoid space leaks in certain situations.
  
  (/\/)        :: [a] -> [a] -> [a]
  []     /\/ ys = ys
  (x:xs) /\/ ys = x : (ys /\/ xs)
  
  readHexChar a | a >= '0' && a <= '9' = return $ ord a - ord '0'
  readHexChar a | z >= 'a' && z <= 'f' = return $ 10 + ord z - ord 'a' where z = toLower a
  readHexChar x = fail $ "not hex char: " ++ [x]
  
  readHex :: Monad m => String -> m Int
  readHex [] = fail "empty string"
  readHex cs = mapM readHexChar cs >>= \cs' -> return (rh $ reverse cs') where
      rh (c:cs) =  c + 16 * (rh cs)
      rh [] =  0
  
  {-# SPECIALIZE overlaps :: (Int,Int) -> (Int,Int) -> Bool #-}
  
  -- | determine if two closed intervals overlap at all.
  
  overlaps :: Ord a => (a,a) -> (a,a) -> Bool
  (a,_) `overlaps` (_,y) | y < a = False
  (_,b) `overlaps` (x,_) | b < x = False
  _ `overlaps` _ = True
  
  -- | translate a number of seconds to a string representing the duration expressed.
  showDuration :: (Show a,Integral a) => a -> String
  showDuration x = st "d" dayI ++ st "h" hourI ++ st "m" minI ++ show secI ++ "s" where
          (dayI, hourI) = divMod hourI' 24
          (hourI', minI) = divMod minI' 60
          (minI',secI) = divMod x 60
          st _ 0 = ""
          st c n = show n ++ c
  
  -- | behave like while(<>) in perl, go through the argument list, reading the
  -- concation of each file name mentioned or stdin if '-' is on it. If no
  -- arguments are given, read stdin.
  
  getArgContents :: IO String
  getArgContents = do
      as <- getArgs
      let f "-" = getContents
          f fn = readFile fn
      cs <- mapM f as
      if null as then getContents else return $ concat cs
  
  -- | Combination of parseOpt and getArgContents.
  getOptContents :: String -> IO (String,[Char],[(Char,String)])
  getOptContents args = do
      as <- getArgs
      (as,o1,o2) <- parseOpt args as
      let f "-" = getContents
          f fn = readFile fn
      cs <- mapM f as
      s <- if null as then getContents else return $ concat cs
      return (s,o1,o2)
  
  -- | Process options with an option string like the standard C getopt function call.
  parseOpt :: Monad m =>
      String -- ^ Argument string, list of valid options with : after ones which accept an argument
      -> [String]  -- ^ Arguments
      -> m ([String],[Char],[(Char,String)])  -- ^ (non-options,flags,options with arguments)
  parseOpt ps as = f ([],[],[]) as where
      (args,oargs) = g ps [] [] where
          g (':':_) _ _ = error "getOpt: Invalid option string"
          g (c:':':ps) x y = g ps x (c:y)
          g (c:ps) x y = g ps (c:x) y
          g [] x y = (x,y)
      f cs [] = return cs
      f (xs,ys,zs) ("--":rs) = return (xs ++ rs, ys, zs)
      f cs (('-':as@(_:_)):rs) = z cs as where
          z (xs,ys,zs) (c:cs)
              | c `elem` args = z (xs,c:ys,zs) cs
              | c `elem` oargs = case cs of
                  [] -> case rs of
                      (x:rs) -> f (xs,ys,(c,x):zs) rs
                      [] -> fail $ "Option requires argument: " ++ [c]
                  x -> f (xs,ys,(c,x):zs) rs
              | otherwise = fail $ "Invalid option: " ++ [c]
          z cs [] = f cs rs
      f (xs,ys,zs) (r:rs) = f (xs ++ [r], ys, zs) rs
  
  readM :: (Monad m, Read a) => String -> m a
  readM cs = case [x | (x,t) <-  reads cs, ("","") <- lex t] of
      [x] -> return x
      [] -> fail "readM: no parse"
      _ -> fail "readM: ambiguous parse"
  
  readsM :: (Monad m, Read a) => String -> m (a,String)
  readsM cs = case readsPrec 0 cs of
      [(x,s)] -> return (x,s)
      _ -> fail "cannot readsM"
  
  -- | Splits a list into components delimited by separators, where the
  -- predicate returns True for a separator element.  The resulting
  -- components do not contain the separators.  Two adjacent separators
  -- result in an empty component in the output.  eg.
  --
  -- > split (=='a') "aabbaca"
  -- > ["", "", "bb", "c", ""]
  --
  split :: (a -> Bool) -> [a] -> [[a]]
  split p s = case rest of
                  []     -> [chunk]
                  _:rest -> chunk : split p rest
    where (chunk, rest) = break p s
  
  -- | Like 'split', except that sequences of adjacent separators are
  -- treated as a single separator. eg.
  --
  --   > tokens (=='a') "aabbaca"
  --   > ["bb","c"]
  tokens :: (a -> Bool) -> [a] -> [[a]]
  tokens p = filter (not.null) . split p
  
  buildTable ::  [String] -> [(String,[String])] -> String
  buildTable ts rs = bt [ x:xs | (x,xs) <- ("",ts):rs ] where
      bt ts = unlines (map f ts) where
          f xs = intercalate " " (zipWith es cw xs)
          cw = [ maximum (map length xs) | xs <- transpose ts]
      es n s = replicate (n - length s) ' ' ++ s
  
  -- | time task
  doTime :: String -> IO a -> IO a
  doTime str action = do
      start <- getCPUTime
      x <- action
      end <- getCPUTime
      putStrLn $ "Timing: " ++ str ++ " " ++ show ((end - start) `div` cpuTimePrecision)
      return x
  
  getPrefix :: Monad m => String -> String -> m String
  getPrefix a b = f a b where
      f [] ss = return ss
      f _  [] = fail "getPrefix: value too short"
      f (p:ps) (s:ss)
          | p == s = f ps ss
          | otherwise = fail $ "getPrefix: " ++ a ++ " " ++ b
  
  {-# INLINE naturals #-}
  naturals :: [Int]
  naturals = [0..]
  