monad-loops 0.3.1.1 → 0.3.2.0

raw patch · 2 files changed

+80/−8 lines, 2 filesdep ~basePVP ok

version bump matches the API change (PVP)

Dependency ranges changed: base

API changes (from Hackage documentation)

Files

• monad-loops.cabal +13/−5
• src/Control/Monad/Loops.hs +67/−3

@@ -1,20 +1,28 @@ name:                   monad-loops-version:                0.3.1.1+version:                0.3.2.0 stability:              provisional license:                BSD3 license-file:           LICENSE -cabal-version:          >= 1.2+cabal-version:          >= 1.6 build-type:             Simple  author:                 James Cook <mokus@deepbondi.net> maintainer:             James Cook <mokus@deepbondi.net>-homepage:               http://code.haskell.org/~mokus/monad-loops+homepage:               https://github.com/mokus0/monad-loops  category:               Control synopsis:               Monadic loops-description:            Some useful control operators for looping+description:            Some useful control operators for looping.+                        .+                        New in 0.3.2.0: various functions for traversing lists and +                        computing minima/maxima using arbitrary procedures to compare+                        or score the elements. +source-repository head+  type: git+  location: git://github.com/mokus0/monad-loops.git+ Flag useSTM   Description:          Include instances for STM types   Default:              True@@ -30,7 +38,7 @@     cpp-options:        -Dbase4     build-depends:      base >= 4 && <5   else-    build-depends:      base < 4+    build-depends:      base >= 2 && < 4    if flag(useSTM)     build-depends:      stm

@@ -39,6 +39,8 @@ import Control.Monad.Loops.STM #endif +import Data.Maybe (listToMaybe)+ -- possibly-useful addition? : -- concatMapM :: (Monad m, Traversable f, Monoid w) => (a -> m w) -> (f a) -> m w @@ -289,13 +291,13 @@ -- twist.  Rather than returning a list, it returns any MonadPlus type of your -- choice. unfoldrM' :: (Monad m, MonadPlus f) => (a -> m (Maybe (b,a))) -> a -> m (f b)-unfoldrM' f z = go z-    where go z = do+unfoldrM' f z = go+    where go = do             x <- f z             case x of                 Nothing         -> return mzero                 Just (x, z)     -> do-                        xs <- go z+                        xs <- go                         return (return x `mplus` xs)  {-# SPECIALIZE concatM :: [a -> IO a] -> (a -> IO a) #-}@@ -396,3 +398,65 @@         if q                 then return (Just x)                 else firstM p xs++{-# INLINE minimaOnByM #-}+minimaOnByM :: Monad m => (a -> m b) -> (b -> b -> m Ordering) -> [a] -> m [a]+minimaOnByM _   _ []     = return []+minimaOnByM f cmp (x:xs) = do+    fx<- f x+    loop (x:) fx xs+        where   loop ms _ []           = return (ms [])+                loop ms fm (x:xs) = do+                    fx  <- f x+                    ord <- cmp fm fx+                    case ord of+                        LT -> loop ms          fm xs+                        EQ -> loop (ms . (x:)) fm xs+                        GT -> loop (x:)        fx xs++{-# INLINE maximaOnByM #-}+maximaOnByM :: Monad m => (a -> m b) -> (b -> b -> m Ordering) -> [a] -> m [a]+maximaOnByM f = minimaOnByM f . flip++minimaByM :: Monad m => (a -> a -> m Ordering) -> [a] -> m [a]+minimaByM = minimaOnByM return++maximaByM :: Monad m => (a -> a -> m Ordering) -> [a] -> m [a]+maximaByM = maximaOnByM return++minimaOnM :: (Monad m, Ord b) => (a -> m b) -> [a] -> m [a]+minimaOnM f = minimaOnByM f (\x y -> return (compare x y))++maximaOnM :: (Monad m, Ord b) => (a -> m b) -> [a] -> m [a]+maximaOnM f = maximaOnByM f (\x y -> return (compare x y))++{-# INLINE minimumOnByM #-}+minimumOnByM :: Monad m => (a -> m b) -> (b -> b -> m Ordering) -> [a] -> m (Maybe a)+minimumOnByM _   _ []     = return Nothing+minimumOnByM f cmp (x:xs) = do+    fx <- f x+    loop x fx xs+        where   loop m _ []           = return (Just m)+                loop m fm (x:xs) = do+                    fx  <- f x+                    ord <- cmp fm fx+                    case ord of+                        LT -> loop m fm xs+                        EQ -> loop m fm xs+                        GT -> loop x fx xs++{-# INLINE maximumOnByM #-}+maximumOnByM :: Monad m => (a -> m b) -> (b -> b -> m Ordering) -> [a] -> m (Maybe a)+maximumOnByM f = minimumOnByM f . flip++minimumByM :: Monad m => (a -> a -> m Ordering) -> [a] -> m (Maybe a)+minimumByM = minimumOnByM return++maximumByM :: Monad m => (a -> a -> m Ordering) -> [a] -> m (Maybe a)+maximumByM = maximumOnByM return++minimumOnM :: (Monad m, Ord b) => (a -> m b) -> [a] -> m (Maybe a)+minimumOnM f = minimumOnByM f (\x y -> return (compare x y))++maximumOnM :: (Monad m, Ord b) => (a -> m b) -> [a] -> m (Maybe a)+maximumOnM f = maximumOnByM f (\x y -> return (compare x y))