mmsyn5 0.3.0.0 → 0.4.0.0

raw patch · 5 files changed

+100/−80 lines, 5 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• ChangeLog.md +5/−0
• Data/List/InnToOut.hs +0/−78
• Data/List/InnToOut/Basic.hs +49/−0
• Data/List/InnToOut/Unsafe.hs +44/−0
• mmsyn5.cabal +2/−2

@@ -46,3 +46,8 @@ ## 0.3.0.0 -- 2019-11-08  * Third version. Added functions with intermediate Monads.++## 0.4.0.0 -- 2019-11-08++* Fourth version. Changed the modules structure because of mixed safe and unsafe code and behaviour.+

@@ -1,78 +0,0 @@--- |--- Module      :  Data.List.InnToOut--- Copyright   :  (c) OleksandrZhabenko 2019--- License     :  MIT------ Maintainer  :  olexandr543@yahoo.com------ Various additional operations on lists. Some of them have additional intermediate Monads inside.-----module Data.List.InnToOut -  (-    -- * Operations to apply a function that creates an inner list to an element of the outer list   -       mapI-       , mapI2-       , mapI22-       , mapI12-       , mapI21-    -- * Operations to obtain intermediate Monads-       , mapI22M-       , mapI2M2-       , mapI2M2M   -       , mapI12M-       , mapI2M1-  ) where---- | Function that applies additional function @f :: a -> [a]@ to @a@ if @p a = True@-mapI :: (a -> Bool) -> (a -> [a]) -> [a] -> [a]-mapI p f = concatMap (\x -> if p x then f x else [x])-{-#INLINE mapI#-}---- | Function that applies additional function @f :: a -> b@ to @a@ if @p a = True@ and otherwise another function @g :: a -> [b]@  to @[a]@ to obtain @[b]@-mapI2 :: (a -> Bool) -> (a -> b) -> (a -> [b]) -> [a] -> [b]-mapI2 p f g = concatMap (\x -> if p x then [f x] else g x)-{-#INLINE mapI2#-}---- | Function that can apply two different ways of computing something depending of the predicate value @p :: a -> Bool@ and the structure of transition the data for the @[a]@. --- It is used if there are two ways to transform data both of them consists of two applied functoins. Similar to arrow techniques.-mapI22 :: (a -> Bool) -> (a -> b) -> (b -> d) -> (a -> c) -> (c -> d) -> [a] -> [d]-mapI22 p f1 g f2 h = map (\x -> if p x then g (f1 x) else h (f2 x)) -{-#INLINE mapI22#-}---- | Variant of the function 'mapI22' in which the second intermediate result @c@ is in the @Monad m@.-mapI22M :: Monad m => (a -> Bool) -> (a -> b) -> (b -> d) -> (a -> m c) -> (m c -> d) -> [a] -> [d]-mapI22M p f1 g f2 h = map (\x -> if p x then g (f1 x) else h (f2 x)) -{-#INLINE mapI22M#-}---- | Variant of the function 'mapI22' in which the first intermediate result @b@ is in the @Monad m@.-mapI2M2 :: Monad m => (a -> Bool) -> (a -> m b) -> (m b -> d) -> (a -> c) -> (c -> d) -> [a] -> [d]-mapI2M2 p f1 g f2 h = map (\x -> if p x then g (f1 x) else h (f2 x)) -{-#INLINE mapI2M2#-}---- | Variant of the function 'mapI22' in which both the intermediate results @b@ and @c@ are in the Monads.-mapI2M2M :: (Monad m0, Monad m) => (a -> Bool) -> (a -> m0 b) -> (m0 b -> d) -> (a -> m c) -> (m c -> d) -> [a] -> [d]-mapI2M2M p f1 g f2 h = map (\x -> if p x then g (f1 x) else h (f2 x)) -{-#INLINE mapI2M2M#-}---- | Function that can apply two different ways of computing something depending of the predicate value @p :: a -> Bool@ and the structure of transition the data for the @[a]@. --- It is used if there are two ways to transform data and the first one consists of one function and another -- from two applied consequently ones. Similar to arrow techniques.-mapI12 :: (a -> Bool) -> (a -> c) -> (a -> b) -> (b -> c) -> [a] -> [c]-mapI12 p f g h = map (\x -> if p x then f x else h (g x)) -{-#INLINE mapI12#-}---- | Variant of the function 'mapI12' in which the second intermediate result @b@ is in the @Monad m@.-mapI12M :: Monad m => (a -> Bool) -> (a -> c) -> (a -> m b) -> (m b -> c) -> [a] -> [c]-mapI12M p f g h = map (\x -> if p x then f x else h (g x)) -{-#INLINE mapI12M#-}---- | Function that can apply two different ways of computing something depending of the predicate value @p :: a -> Bool@ and the structure of transition the data for the @[a]@. --- It is used if there are two ways to transform data and the first one consists of two applied consequently functions and the second -- from one applied function. Similar to arrow techniques.-mapI21 :: (a -> Bool) -> (a -> b) -> (b -> c) -> (a -> c) -> [a] -> [c]-mapI21 p f g h = map (\x -> if p x then g (f x) else h x) -{-#INLINE mapI21#-}---- | Variant of the function 'mapI21' in which the first intermediate result @b@ is in the @Monad m@.-mapI2M1 :: Monad m => (a -> Bool) -> (a -> m b) -> (m b -> c) -> (a -> c) -> [a] -> [c]-mapI2M1 p f g h = map (\x -> if p x then g (f x) else h x) -{-#INLINE mapI2M1#-}

@@ -0,0 +1,49 @@+-- |+-- Module      :  Data.List.InnToOut.Basic+-- Copyright   :  (c) OleksandrZhabenko 2019+-- License     :  MIT+--+-- Maintainer  :  olexandr543@yahoo.com+--+-- Various additional operations on lists+--++module Data.List.InnToOut.Basic +  (+    -- * Operations to apply a function or different functions (some can create an inner list) to an element of the outer list   +       mapI+       , mapI2+       , mapI22+       , mapI12+       , mapI21+  ) where++-- | Function that applies additional function @f :: a -> [a]@ to @a@ if @p a = True@+mapI :: (a -> Bool) -> (a -> [a]) -> [a] -> [a]+mapI p f = concatMap (\x -> if p x then f x else [x])+{-#INLINE mapI#-}++-- | Function that applies additional function @f :: a -> b@ to @a@ if @p a = True@ and otherwise another function @g :: a -> [b]@  to @[a]@ to obtain @[b]@+mapI2 :: (a -> Bool) -> (a -> b) -> (a -> [b]) -> [a] -> [b]+mapI2 p f g = concatMap (\x -> if p x then [f x] else g x)+{-#INLINE mapI2#-}++-- | Function that can apply two different ways of computing something depending of the predicate value @p :: a -> Bool@ and the structure of transition the data for the @[a]@. +-- It is used if there are two ways to transform data both of them consists of two applied functoins. Similar to arrow techniques.+mapI22 :: (a -> Bool) -> (a -> b) -> (b -> d) -> (a -> c) -> (c -> d) -> [a] -> [d]+mapI22 p f1 g f2 h = map (\x -> if p x then g (f1 x) else h (f2 x)) +{-#INLINE mapI22#-}++-- | Function that can apply two different ways of computing something depending of the predicate value @p :: a -> Bool@ and the structure of transition the data for the @[a]@. +-- It is used if there are two ways to transform data and the first one consists of one function and another -- from two applied consequently ones. Similar to arrow techniques.+mapI12 :: (a -> Bool) -> (a -> c) -> (a -> b) -> (b -> c) -> [a] -> [c]+mapI12 p f g h = map (\x -> if p x then f x else h (g x)) +{-#INLINE mapI12#-}++-- | Function that can apply two different ways of computing something depending of the predicate value @p :: a -> Bool@ and the structure of transition the data for the @[a]@. +-- It is used if there are two ways to transform data and the first one consists of two applied consequently functions and the second -- from one applied function. Similar to arrow techniques.+mapI21 :: (a -> Bool) -> (a -> b) -> (b -> c) -> (a -> c) -> [a] -> [c]+mapI21 p f g h = map (\x -> if p x then g (f x) else h x) +{-#INLINE mapI21#-}++

@@ -0,0 +1,44 @@+-- |+-- Module      :  Data.List.InnToOut.Unsafe+-- Copyright   :  (c) OleksandrZhabenko 2019+-- License     :  MIT+--+-- Maintainer  :  olexandr543@yahoo.com+--+-- Various additional operations on lists that have additional intermediate Monads inside.+--++module Data.List.InnToOut.Unsafe +  (+    -- * Operations to obtain intermediate Monads. Like the 'UnsafePerformIO' function they can have unpredictable behaviour. Use them ONLY if you surely know what you are doing.+       mapI22M+       , mapI2M2+       , mapI2M2M   +       , mapI12M+       , mapI2M1+  ) where++-- | Variant of the function 'Data.List.InnToOut.mapI22' in which the second intermediate result @c@ is in the @Monad m@.+mapI22M :: Monad m => (a -> Bool) -> (a -> b) -> (b -> d) -> (a -> m c) -> (m c -> d) -> [a] -> [d]+mapI22M p f1 g f2 h = map (\x -> if p x then g (f1 x) else h (f2 x)) +{-#INLINE mapI22M#-}++-- | Variant of the function 'Data.List.InnToOut.mapI22' in which the first intermediate result @b@ is in the @Monad m@.+mapI2M2 :: Monad m => (a -> Bool) -> (a -> m b) -> (m b -> d) -> (a -> c) -> (c -> d) -> [a] -> [d]+mapI2M2 p f1 g f2 h = map (\x -> if p x then g (f1 x) else h (f2 x)) +{-#INLINE mapI2M2#-}++-- | Variant of the function 'Data.List.InnToOut.mapI22' in which both the intermediate results @b@ and @c@ are in the Monads.+mapI2M2M :: (Monad m0, Monad m) => (a -> Bool) -> (a -> m0 b) -> (m0 b -> d) -> (a -> m c) -> (m c -> d) -> [a] -> [d]+mapI2M2M p f1 g f2 h = map (\x -> if p x then g (f1 x) else h (f2 x)) +{-#INLINE mapI2M2M#-}++-- | Variant of the function 'Data.List.InnToOut.mapI12' in which the second intermediate result @b@ is in the @Monad m@.+mapI12M :: Monad m => (a -> Bool) -> (a -> c) -> (a -> m b) -> (m b -> c) -> [a] -> [c]+mapI12M p f g h = map (\x -> if p x then f x else h (g x)) +{-#INLINE mapI12M#-}++-- | Variant of the function 'Data.List.InnToOut.mapI21' in which the first intermediate result @b@ is in the @Monad m@.+mapI2M1 :: Monad m => (a -> Bool) -> (a -> m b) -> (m b -> c) -> (a -> c) -> [a] -> [c]+mapI2M1 p f g h = map (\x -> if p x then g (f x) else h x) +{-#INLINE mapI2M1#-}

@@ -2,7 +2,7 @@ -- documentation, see http://haskell.org/cabal/users-guide/  name:                mmsyn5-version:             0.3.0.0+version:             0.4.0.0 synopsis:            Various additional operations on lists (some with intermediate Monads) description:         A small library to deal with a little bit more complex operations on lists than Data.List module homepage:            http://hackage.haskell.org/package/mmsyn5@@ -17,7 +17,7 @@ cabal-version:       >=1.10  library-  exposed-modules:     Data.List.InnToOut+  exposed-modules:     Data.List.InnToOut.Basic, Data.List.InnToOut.Unsafe   -- other-modules:   -- other-extensions:   build-depends:       base >=4.7 && <4.14