--
-- (c) 2012 Wei Ke
--      license:          GPL-3
--      license-file:     LICENSE
--
-- |
-- The "Misc" module defines some list and maybe operations for convenience. 
--
module Misc where

import ErrMsg

--
-- additional list and maybe operations
--

rep       :: Int -> (a -> (a, b)) -> a -> (a, [b])
rep n f e =  rep0 n (e, []) where
    rep0 0 (d, s) = (d, s)
    rep0 m (d, s) = rep0 (m-1) (d', x:s) where (d', x) = f d

findm          :: (a -> Maybe b) -> [a] -> Maybe b
findm p (x:xs) =  case p x of my@(Just _) -> my
                              _           -> findm p xs
findm _ _      =  Nothing

(~>>) :: Maybe a -> Maybe b -> Maybe b
x ~>> y = case x of Nothing -> y
                    _       -> Nothing

(&>>) :: Bool -> Maybe a -> Maybe a
x &>> y = case x of True -> y
                    _    -> Nothing

(?>>=) :: (Maybe a, b) -> ((a -> b) -> b)
(x, d) ?>>= f = case x of Just y -> f y
                          _      -> d
                         
findm2      :: Eq a => 
               (a -> a -> Maybe b) -> [a] -> Maybe b
findm2 p xs =  findm (\(x, x') -> p x x') [(x, x') | x <- xs, x' <- xs, x /= x'] 

setEq       :: Eq a => [a] -> [a] -> Bool
setEq xs ys = all (`elem` ys) xs && all (`elem` xs) ys 

isDisjoint        :: Eq a => 
                     [[a]] -> Bool
isDisjoint []     =  True
isDisjoint [_]    =  True
isDisjoint (x:xs) =  all (\i -> all (i `notElem`) xs) x && isDisjoint xs

arrangeBy           :: Eq a => [a] -> [(a, b)] -> Maybe [(a, b)]
arrangeBy xs ps     =  arrange0 xs ps [] where
        arrange0 [] [] [] =  Just []
        arrange0 (y:ys) ((y', z):qs) qs'
                          | y == y'   = arrange0 ys (qs ++ qs') [] >>= \qs'' -> Just ((y', z):qs'')
                          | otherwise = arrange0 (y:ys) qs ((y', z):qs')
        arrange0 _ _ _    = Nothing

foldm                   :: (a -> b -> Maybe a) -> Maybe a -> [b] -> Maybe a
foldm _ e []            =  e
foldm _ Nothing _       =  Nothing
foldm f (Just x) (y:ys) =  foldm f (f x y) ys 

mape          :: (a -> ErrMsg b) -> [a] -> ErrMsg [b]
mape _ []     =  return []
mape f (x:xs) =  f x >>= \y -> mape f xs >>= \ys -> return (y:ys)

folde2            :: (a -> b -> ErrMsg (a, d)) -> a -> [b] -> ErrMsg (a, [d])
folde2 _ x []     =  return (x, [])
folde2 f x (y:ys) =  f x y >>= \(x', y') -> folde2 f x' ys >>= \(x'', ys') -> return (x'', y':ys')

showElems :: Show a => [a] -> String
showElems [] = ""
showElems [x] = show x
showElems (x:xs) = show x ++ "," ++ showElems xs

--
-- end of Misc
--
-- --$Id: Misc.hs 1182 2012-11-12 10:11:40Z wke@IPM.EDU.MO $