Move utilities from .Common to new Utils module (formal API change)

Author: andreasabel

lib/Text/Regex/TDFA/Common.hs

@@ -21,6 +21,7 @@ import Data.Sequence as S(Seq)
 --import Debug.Trace
 
 import Text.Regex.TDFA.IntArrTrieSet(TrieSet)
+import Utils
 
 {-# INLINE look #-}
 look :: Int -> IntMap a -> a
@@ -30,43 +31,6 @@ common_error :: String -> String -> a
 common_error moduleName message =
   error ("Explict error in module "++moduleName++" : "++message)
 
-on :: (t1 -> t1 -> t2) -> (t -> t1) -> t -> t -> t2
-f `on` g = (\x y -> (g x) `f` (g y))
-
--- | After 'sort' or 'sortBy' the use of 'nub' or 'nubBy' can be replaced by 'norep' or 'norepBy'.
-norep :: (Eq a) => [a]->[a]
-norep [] = []
-norep x@[_] = x
-norep (a:bs@(c:cs)) | a==c = norep (a:cs)
-                    | otherwise = a:norep bs
-
--- | After 'sort' or 'sortBy' the use of 'nub' or 'nubBy' can be replaced by 'norep' or 'norepBy'.
-norepBy :: (a -> a -> Bool) -> [a] -> [a]
-norepBy _ [] = []
-norepBy _ x@[_] = x
-norepBy eqF (a:bs@(c:cs)) | a `eqF` c = norepBy eqF (a:cs)
-                          | otherwise = a:norepBy eqF bs
-
-mapFst :: (Functor f) => (t -> t2) -> f (t, t1) -> f (t2, t1)
-mapFst f = fmap (\ (a,b) -> (f a,b))
-
-mapSnd :: (Functor f) => (t1 -> t2) -> f (t, t1) -> f (t, t2)
-mapSnd f = fmap (\ (a,b) -> (a,f b))
-
-fst3 :: (a,b,c) -> a
-fst3 (x,_,_) = x
-
-snd3 :: (a,b,c) -> b
-snd3 (_,x,_) = x
-
-thd3 :: (a,b,c) -> c
-thd3 (_,_,x) = x
-
-flipOrder :: Ordering -> Ordering
-flipOrder GT = LT
-flipOrder LT = GT
-flipOrder EQ = EQ
-
 noWin :: WinTags -> Bool
 noWin = null
 

lib/Text/Regex/TDFA/CorePattern.hs

@@ -49,6 +49,7 @@ import Data.Semigroup as Sem
 
 import Text.Regex.TDFA.Common {- all -}
 import Text.Regex.TDFA.Pattern(Pattern(..),starTrans)
+import Utils
 -- import Debug.Trace
 
 {- By Chris Kuklewicz, 2007. BSD License, see the LICENSE file. -}

lib/Text/Regex/TDFA/TDFA.hs

@@ -28,6 +28,7 @@ import qualified Text.Regex.TDFA.IntArrTrieSet as Trie(lookupAsc,fromSinglesMerg
 import Text.Regex.TDFA.Pattern(Pattern)
 --import Text.Regex.TDFA.RunMutState(toInstructions)
 import Text.Regex.TDFA.TNFA(patternToNFA)
+import Utils
 --import Debug.Trace
 
 {- By Chris Kuklewicz, 2007. BSD License, see the LICENSE file. -}

lib/Text/Regex/TDFA/TNFA.hs

@@ -55,11 +55,12 @@ import qualified Data.Set as S (insert, toAscList)
 import Text.Regex.TDFA.Common(QT(..),QNFA(..),QTrans,TagTask(..),TagUpdate(..),DoPa(..)
                              ,CompOption(..)
                              ,Tag,TagTasks,TagList,Index,WinTags,GroupIndex,GroupInfo(..)
-                             ,common_error,noWin,snd3,mapSnd)
+                             ,common_error,noWin)
 import Text.Regex.TDFA.CorePattern(Q(..),P(..),OP(..),WhichTest,cleanNullView,NullView
                                   ,SetTestInfo(..),Wanted(..),TestInfo
                                   ,mustAccept,cannotAccept,patternToQ)
 import Text.Regex.TDFA.Pattern (Pattern(..), decodePatternSet)
+import Utils
 
 ecart :: String -> a -> a
 ecart _ = id

lib/Utils.hs

@@ -0,0 +1,83 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE RankNTypes #-}
+
+-- | Internal module for utilities used in the implementation.
+
+module Utils (module Utils, module X) where
+
+import Control.Applicative      (Const(..))
+import Control.Applicative as X ((<*>))
+import Control.Monad.Identity
+import Data.Foldable       as X (foldMap)
+import Data.Functor        as X
+import Data.Monoid         as X (Monoid(..))
+import Data.Semigroup      as X (Semigroup(..))
+
+-- * Lenses
+---------------------------------------------------------------------------
+
+type Lens' o i = forall f. Functor f => (i -> f i) -> (o -> f o)
+
+type LensGet o i = o -> i
+type LensSet o i = i -> o -> o
+type LensMap o i = (i -> i) -> o -> o
+
+infixl 8 ^.
+-- | Get inner part @i@ of structure @o@ as designated by @Lens' o i@.
+(^.) :: o -> Lens' o i -> i
+o ^. l = getConst $ l Const o
+
+-- | Set inner part @i@ of structure @o@ as designated by @Lens' o i@.
+set :: Lens' o i -> LensSet o i
+set l = over l . const
+
+-- | Modify inner part @i@ of structure @o@ using a function @i -> i@.
+over :: Lens' o i -> LensMap o i
+over l f o = runIdentity $ l (Identity . f) o
+
+-- * Misc
+---------------------------------------------------------------------------
+
+#if !MIN_VERSION_base(4,7,0)
+($>) :: Functor f => f a -> b -> f b
+($>) = flip (<$)
+#endif
+
+#if !MIN_VERSION_base(4,11,0)
+(<&>) :: Functor f => f a -> (a -> b) -> f b
+(<&>) = flip fmap
+#endif
+
+-- | After 'sort' or 'sortBy' the use of 'nub' or 'nubBy' can be replaced by 'norep' or 'norepBy'.
+norep :: (Eq a) => [a]->[a]
+norep [] = []
+norep x@[_] = x
+norep (a:bs@(c:cs)) | a==c = norep (a:cs)
+                    | otherwise = a:norep bs
+
+-- | After 'sort' or 'sortBy' the use of 'nub' or 'nubBy' can be replaced by 'norep' or 'norepBy'.
+norepBy :: (a -> a -> Bool) -> [a] -> [a]
+norepBy _ [] = []
+norepBy _ x@[_] = x
+norepBy eqF (a:bs@(c:cs)) | a `eqF` c = norepBy eqF (a:cs)
+                          | otherwise = a:norepBy eqF bs
+
+mapFst :: (Functor f) => (t -> t2) -> f (t, t1) -> f (t2, t1)
+mapFst f = fmap (\ (a,b) -> (f a,b))
+
+mapSnd :: (Functor f) => (t1 -> t2) -> f (t, t1) -> f (t, t2)
+mapSnd f = fmap (\ (a,b) -> (a,f b))
+
+fst3 :: (a,b,c) -> a
+fst3 (x,_,_) = x
+
+snd3 :: (a,b,c) -> b
+snd3 (_,x,_) = x
+
+thd3 :: (a,b,c) -> c
+thd3 (_,_,x) = x
+
+flipOrder :: Ordering -> Ordering
+flipOrder GT = LT
+flipOrder LT = GT
+flipOrder EQ = EQ

regex-tdfa.cabal

@@ -84,7 +84,8 @@ library
                         Text.Regex.TDFA.Text
                         Text.Regex.TDFA.Text.Lazy
 
-  other-modules:        Paths_regex_tdfa
+  other-modules:        Utils
+                        Paths_regex_tdfa
 
   -- Support Semigroup instances uniformly
   --
@@ -105,6 +106,8 @@ library
                       , parsec             == 3.1.*
                       , regex-base         == 0.94.*
                       , text               >= 1.2.3  && < 2.1
+                      , transformers       >= 0.2.2.1 && < 0.7
+                          -- For Control.Monad.Identity across GHC versions
 
   default-language:     Haskell2010
   default-extensions:   BangPatterns
@@ -123,6 +126,7 @@ library
                         UnboxedTuples
                         UnliftedFFITypes
   other-extensions:     CPP
+                        RankNTypes
 
   ghc-options:          -Wall -funbox-strict-fields -fspec-constr-count=10 -fno-warn-orphans