diff --git a/README.markdown b/README.markdown --- a/README.markdown +++ b/README.markdown @@ -64,6 +64,8 @@     ☒  2017-03-18 v0.9.0.0 [Finish tidying up the API, Add type-safe replacement templates and exploit TemplateHaskellQuotes](https://github.com/iconnect/regex/milestone/9) +    ☒  2017-03-18 v0.10.0.0 [Tweak TypeSafe SearchReplace templates](https://github.com/iconnect/regex/milestone/11) +     ☐  2017-03-31 v1.0.0.0 [First stable release](https://github.com/iconnect/regex/milestone/3)     ☐  2017-08-31 v2.0.0.0 [Fast text replacement with benchmarks](https://github.com/iconnect/regex/milestone/4) diff --git a/Text/RE/Internal/SearchReplace/PCRE.hs b/Text/RE/Internal/SearchReplace/PCRE.hs new file mode 100644 --- /dev/null +++ b/Text/RE/Internal/SearchReplace/PCRE.hs @@ -0,0 +1,54 @@ +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE CPP #-} +#if __GLASGOW_HASKELL__ >= 800 +{-# LANGUAGE TemplateHaskellQuotes #-} +#else +{-# LANGUAGE QuasiQuotes #-} +{-# LANGUAGE TemplateHaskell #-} +#endif + +module Text.RE.Internal.SearchReplace.PCRE + ( ed + , edMS + , edMI + , edBS + , edBI + , edMultilineSensitive + , edMultilineInsensitive + , edBlockSensitive + , edBlockInsensitive + , ed_ + ) where + +import Language.Haskell.TH +import Language.Haskell.TH.Quote +import Prelude.Compat +import Text.RE.Internal.SearchReplace.PCREEdPrime +import Text.RE.Types.REOptions + + +-- | the @[ed| ... /// ... |]@ quasi quoters +ed + , edMS + , edMI + , edBS + , edBI + , edMultilineSensitive + , edMultilineInsensitive + , edBlockSensitive + , edBlockInsensitive + , ed_ :: QuasiQuoter + +ed = ed' cast $ Just minBound +edMS = edMultilineSensitive +edMI = edMultilineInsensitive +edBS = edBlockSensitive +edBI = edBlockInsensitive +edMultilineSensitive = ed' cast $ Just MultilineSensitive +edMultilineInsensitive = ed' cast $ Just MultilineInsensitive +edBlockSensitive = ed' cast $ Just BlockSensitive +edBlockInsensitive = ed' cast $ Just BlockInsensitive +ed_ = ed' cast Nothing + +cast :: Q Exp +cast = [|id|] diff --git a/Text/RE/Internal/SearchReplace/PCRE/ByteString.hs b/Text/RE/Internal/SearchReplace/PCRE/ByteString.hs new file mode 100644 --- /dev/null +++ b/Text/RE/Internal/SearchReplace/PCRE/ByteString.hs @@ -0,0 +1,58 @@ +{-# LANGUAGE CPP #-} +#if __GLASGOW_HASKELL__ >= 800 +{-# LANGUAGE TemplateHaskellQuotes #-} +#else +{-# LANGUAGE QuasiQuotes #-} +{-# LANGUAGE TemplateHaskell #-} +#endif + +module Text.RE.Internal.SearchReplace.PCRE.ByteString + ( ed + , edMS + , edMI + , edBS + , edBI + , edMultilineSensitive + , edMultilineInsensitive + , edBlockSensitive + , edBlockInsensitive + , ed_ + ) where + +import qualified Data.ByteString.Char8 as B +import Language.Haskell.TH +import Language.Haskell.TH.Quote +import Text.RE.PCRE.RE +import Text.RE.Internal.SearchReplace.PCREEdPrime +import Text.RE.SearchReplace +import Text.RE.Types.REOptions + + +-- | the @[ed| ... /// ... |]@ quasi quoters +ed + , edMS + , edMI + , edBS + , edBI + , edMultilineSensitive + , edMultilineInsensitive + , edBlockSensitive + , edBlockInsensitive + , ed_ :: QuasiQuoter + +ed = ed' sr_cast $ Just minBound +edMS = edMultilineSensitive +edMI = edMultilineInsensitive +edBS = edBlockSensitive +edBI = edBlockInsensitive +edMultilineSensitive = ed' sr_cast $ Just MultilineSensitive +edMultilineInsensitive = ed' sr_cast $ Just MultilineInsensitive +edBlockSensitive = ed' sr_cast $ Just BlockSensitive +edBlockInsensitive = ed' sr_cast $ Just BlockInsensitive +ed_ = ed' fn_cast Nothing + +sr_cast :: Q Exp +sr_cast = [|\x -> x :: SearchReplace RE B.ByteString|] + +fn_cast :: Q Exp +fn_cast = [|\x -> x :: SimpleREOptions -> SearchReplace RE B.ByteString|] diff --git a/Text/RE/Internal/SearchReplace/PCRE/ByteString/Lazy.hs b/Text/RE/Internal/SearchReplace/PCRE/ByteString/Lazy.hs new file mode 100644 --- /dev/null +++ b/Text/RE/Internal/SearchReplace/PCRE/ByteString/Lazy.hs @@ -0,0 +1,58 @@ +{-# LANGUAGE CPP #-} +#if __GLASGOW_HASKELL__ >= 800 +{-# LANGUAGE TemplateHaskellQuotes #-} +#else +{-# LANGUAGE QuasiQuotes #-} +{-# LANGUAGE TemplateHaskell #-} +#endif + +module Text.RE.Internal.SearchReplace.PCRE.ByteString.Lazy + ( ed + , edMS + , edMI + , edBS + , edBI + , edMultilineSensitive + , edMultilineInsensitive + , edBlockSensitive + , edBlockInsensitive + , ed_ + ) where + +import qualified Data.ByteString.Lazy.Char8 as LBS +import Language.Haskell.TH +import Language.Haskell.TH.Quote +import Text.RE.PCRE.RE +import Text.RE.Internal.SearchReplace.PCREEdPrime +import Text.RE.SearchReplace +import Text.RE.Types.REOptions + + +-- | the @[ed| ... /// ... |]@ quasi quoters +ed + , edMS + , edMI + , edBS + , edBI + , edMultilineSensitive + , edMultilineInsensitive + , edBlockSensitive + , edBlockInsensitive + , ed_ :: QuasiQuoter + +ed = ed' sr_cast $ Just minBound +edMS = edMultilineSensitive +edMI = edMultilineInsensitive +edBS = edBlockSensitive +edBI = edBlockInsensitive +edMultilineSensitive = ed' sr_cast $ Just MultilineSensitive +edMultilineInsensitive = ed' sr_cast $ Just MultilineInsensitive +edBlockSensitive = ed' sr_cast $ Just BlockSensitive +edBlockInsensitive = ed' sr_cast $ Just BlockInsensitive +ed_ = ed' fn_cast Nothing + +sr_cast :: Q Exp +sr_cast = [|\x -> x :: SearchReplace RE LBS.ByteString|] + +fn_cast :: Q Exp +fn_cast = [|\x -> x :: SimpleREOptions -> SearchReplace RE LBS.ByteString|] diff --git a/Text/RE/Internal/SearchReplace/PCRE/Sequence.hs b/Text/RE/Internal/SearchReplace/PCRE/Sequence.hs new file mode 100644 --- /dev/null +++ b/Text/RE/Internal/SearchReplace/PCRE/Sequence.hs @@ -0,0 +1,58 @@ +{-# LANGUAGE CPP #-} +#if __GLASGOW_HASKELL__ >= 800 +{-# LANGUAGE TemplateHaskellQuotes #-} +#else +{-# LANGUAGE QuasiQuotes #-} +{-# LANGUAGE TemplateHaskell #-} +#endif + +module Text.RE.Internal.SearchReplace.PCRE.Sequence + ( ed + , edMS + , edMI + , edBS + , edBI + , edMultilineSensitive + , edMultilineInsensitive + , edBlockSensitive + , edBlockInsensitive + , ed_ + ) where + +import qualified Data.Sequence as S +import Language.Haskell.TH +import Language.Haskell.TH.Quote +import Text.RE.PCRE.RE +import Text.RE.Internal.SearchReplace.PCREEdPrime +import Text.RE.SearchReplace +import Text.RE.Types.REOptions + + +-- | the @[ed| ... /// ... |]@ quasi quoters +ed + , edMS + , edMI + , edBS + , edBI + , edMultilineSensitive + , edMultilineInsensitive + , edBlockSensitive + , edBlockInsensitive + , ed_ :: QuasiQuoter + +ed = ed' sr_cast $ Just minBound +edMS = edMultilineSensitive +edMI = edMultilineInsensitive +edBS = edBlockSensitive +edBI = edBlockInsensitive +edMultilineSensitive = ed' sr_cast $ Just MultilineSensitive +edMultilineInsensitive = ed' sr_cast $ Just MultilineInsensitive +edBlockSensitive = ed' sr_cast $ Just BlockSensitive +edBlockInsensitive = ed' sr_cast $ Just BlockInsensitive +ed_ = ed' fn_cast Nothing + +sr_cast :: Q Exp +sr_cast = [|\x -> x :: SearchReplace RE (S.Seq Char)|] + +fn_cast :: Q Exp +fn_cast = [|\x -> x :: SimpleREOptions -> SearchReplace RE (S.Seq Char)|] diff --git a/Text/RE/Internal/SearchReplace/PCRE/String.hs b/Text/RE/Internal/SearchReplace/PCRE/String.hs new file mode 100644 --- /dev/null +++ b/Text/RE/Internal/SearchReplace/PCRE/String.hs @@ -0,0 +1,58 @@ +{-# LANGUAGE CPP #-} +#if __GLASGOW_HASKELL__ >= 800 +{-# LANGUAGE TemplateHaskellQuotes #-} +#else +{-# LANGUAGE QuasiQuotes #-} +{-# LANGUAGE TemplateHaskell #-} +#endif + +module Text.RE.Internal.SearchReplace.PCRE.String + ( ed + , edMS + , edMI + , edBS + , edBI + , edMultilineSensitive + , edMultilineInsensitive + , edBlockSensitive + , edBlockInsensitive + , ed_ + ) where + + +import Language.Haskell.TH +import Language.Haskell.TH.Quote +import Text.RE.PCRE.RE +import Text.RE.Internal.SearchReplace.PCREEdPrime +import Text.RE.SearchReplace +import Text.RE.Types.REOptions + + +-- | the @[ed| ... /// ... |]@ quasi quoters +ed + , edMS + , edMI + , edBS + , edBI + , edMultilineSensitive + , edMultilineInsensitive + , edBlockSensitive + , edBlockInsensitive + , ed_ :: QuasiQuoter + +ed = ed' sr_cast $ Just minBound +edMS = edMultilineSensitive +edMI = edMultilineInsensitive +edBS = edBlockSensitive +edBI = edBlockInsensitive +edMultilineSensitive = ed' sr_cast $ Just MultilineSensitive +edMultilineInsensitive = ed' sr_cast $ Just MultilineInsensitive +edBlockSensitive = ed' sr_cast $ Just BlockSensitive +edBlockInsensitive = ed' sr_cast $ Just BlockInsensitive +ed_ = ed' fn_cast Nothing + +sr_cast :: Q Exp +sr_cast = [|\x -> x :: SearchReplace RE String|] + +fn_cast :: Q Exp +fn_cast = [|\x -> x :: SimpleREOptions -> SearchReplace RE String|] diff --git a/Text/RE/Internal/SearchReplace/PCREEdPrime.hs b/Text/RE/Internal/SearchReplace/PCREEdPrime.hs new file mode 100644 --- /dev/null +++ b/Text/RE/Internal/SearchReplace/PCREEdPrime.hs @@ -0,0 +1,63 @@ +{-# LANGUAGE NoImplicitPrelude #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE CPP #-} +#if __GLASGOW_HASKELL__ >= 800 +{-# OPTIONS_GHC -fno-warn-redundant-constraints #-} +{-# LANGUAGE TemplateHaskellQuotes #-} +#else +{-# LANGUAGE QuasiQuotes #-} +{-# LANGUAGE TemplateHaskell #-} +#endif + +module Text.RE.Internal.SearchReplace.PCREEdPrime + ( ed' + ) where + +import Language.Haskell.TH +import Language.Haskell.TH.Quote +import Prelude.Compat +import Text.RE.Internal.SearchReplace +import Text.RE.Internal.QQ +import Text.RE.PCRE.RE +import Text.RE.SearchReplace +import Text.RE.Types.IsRegex +import Text.RE.Types.REOptions +import Text.RE.Types.Replace +import Text.Regex.PCRE + + +-- | construct a quasi quoter from a casting function and @Just sro@ +-- if the options are known, otherwise a function take takes the +-- 'SimpleREOptions' and constructs the 'SearchReplace' template +ed' :: Q Exp -> Maybe SimpleREOptions -> QuasiQuoter +ed' qe mb = case mb of + Nothing -> + (qq0 "ed'") + { quoteExp = parse minBound $ \rs -> AppE <$> qe <*> [|flip unsafe_compile_sr rs|] + } + Just sro -> + (qq0 "ed'") + { quoteExp = parse sro $ \rs -> AppE <$> qe <*> [|unsafe_compile_sr_simple sro rs|] + } + where + parse :: SimpleREOptions -> (String->Q Exp) -> String -> Q Exp + parse sro mk ts = either error (\_->mk ts) ei + where + ei :: Either String (SearchReplace RE String) + ei = compileSearchReplace_ id (compileRegexWith sro) ts + +unsafe_compile_sr_simple :: IsRegex RE s + => SimpleREOptions + -> String + -> SearchReplace RE s +unsafe_compile_sr_simple sro = + unsafe_compile_sr $ unpackSimpleREOptions sro + +unsafe_compile_sr :: ( IsOption o RE CompOption ExecOption + , IsRegex RE s + ) + => o + -> String + -> SearchReplace RE s +unsafe_compile_sr os = + unsafeCompileSearchReplace_ packR $ compileRegexWithOptions os diff --git a/Text/RE/PCRE.hs b/Text/RE/PCRE.hs --- a/Text/RE/PCRE.hs +++ b/Text/RE/PCRE.hs @@ -41,6 +41,8 @@ , escape , escapeWith , module Text.RE.PCRE.RE + -- * The [ed| ... |] quasi quoters + , module Text.RE.Internal.SearchReplace.PCRE -- * The Operator Instances -- $instances , module Text.RE.PCRE.ByteString @@ -54,6 +56,7 @@ import qualified Text.Regex.Base as B import Text.RE import Text.RE.Internal.AddCaptureNames +import Text.RE.Internal.SearchReplace.PCRE import Text.RE.PCRE.RE import qualified Text.Regex.PCRE as PCRE import Text.RE.PCRE.ByteString() @@ -111,5 +114,4 @@ -- $instances -- --- These modules merely provide the instances for the above regex --- match operators at the various text types. +-- These modules merely provide the 'IsRegex' instances. diff --git a/Text/RE/PCRE/ByteString.hs b/Text/RE/PCRE/ByteString.hs --- a/Text/RE/PCRE/ByteString.hs +++ b/Text/RE/PCRE/ByteString.hs @@ -44,6 +44,7 @@ , escape , escapeWith , module Text.RE.PCRE.RE + , module Text.RE.Internal.SearchReplace.PCRE.ByteString ) where import Prelude.Compat @@ -52,6 +53,7 @@ import Text.Regex.Base import Text.RE import Text.RE.Internal.AddCaptureNames +import Text.RE.Internal.SearchReplace.PCRE.ByteString import Text.RE.SearchReplace import Text.RE.Types.IsRegex import Text.RE.Types.REOptions diff --git a/Text/RE/PCRE/ByteString/Lazy.hs b/Text/RE/PCRE/ByteString/Lazy.hs --- a/Text/RE/PCRE/ByteString/Lazy.hs +++ b/Text/RE/PCRE/ByteString/Lazy.hs @@ -44,6 +44,7 @@ , escape , escapeWith , module Text.RE.PCRE.RE + , module Text.RE.Internal.SearchReplace.PCRE.ByteString.Lazy ) where import Prelude.Compat @@ -52,6 +53,7 @@ import Text.Regex.Base import Text.RE import Text.RE.Internal.AddCaptureNames +import Text.RE.Internal.SearchReplace.PCRE.ByteString.Lazy import Text.RE.SearchReplace import Text.RE.Types.IsRegex import Text.RE.Types.REOptions diff --git a/Text/RE/PCRE/RE.hs b/Text/RE/PCRE/RE.hs --- a/Text/RE/PCRE/RE.hs +++ b/Text/RE/PCRE/RE.hs @@ -59,16 +59,16 @@ , reBlockSensitive , reBlockInsensitive , re_ - , ed - , edMS - , edMI - , edBS - , edBI - , edMultilineSensitive - , edMultilineInsensitive - , edBlockSensitive - , edBlockInsensitive - , ed_ + -- , ed + -- , edMS + -- , edMI + -- , edBS + -- , edBI + -- , edMultilineSensitive + -- , edMultilineInsensitive + -- , edBlockSensitive + -- , edBlockInsensitive + -- , ed_ , cp ) where @@ -81,6 +81,7 @@ import Text.RE.Internal.NamedCaptures import Text.RE.Internal.PreludeMacros import Text.RE.Internal.QQ +import Text.RE.Internal.SearchReplace import Text.RE.SearchReplace import Text.RE.TestBench import Text.RE.Types.CaptureID @@ -321,17 +322,17 @@ , reMultilineInsensitive , reBlockSensitive , reBlockInsensitive - , re_ - , ed - , edMS - , edMI - , edBS - , edBI - , edMultilineSensitive - , edMultilineInsensitive - , edBlockSensitive - , edBlockInsensitive - , ed_ :: QuasiQuoter + , re_ :: QuasiQuoter + -- , ed + -- , edMS + -- , edMI + -- , edBS + -- , edBI + -- , edMultilineSensitive + -- , edMultilineInsensitive + -- , edBlockSensitive + -- , edBlockInsensitive + -- , ed_ :: QuasiQuoter re = re' $ Just minBound reMS = reMultilineSensitive @@ -344,16 +345,16 @@ reBlockInsensitive = re' $ Just BlockInsensitive re_ = re' Nothing -ed = ed' $ Just minBound -edMS = edMultilineSensitive -edMI = edMultilineInsensitive -edBS = edBlockSensitive -edBI = edBlockInsensitive -edMultilineSensitive = ed' $ Just MultilineSensitive -edMultilineInsensitive = ed' $ Just MultilineInsensitive -edBlockSensitive = ed' $ Just BlockSensitive -edBlockInsensitive = ed' $ Just BlockInsensitive -ed_ = ed' Nothing +-- ed = ed' $ Just minBound +-- edMS = edMultilineSensitive +-- edMI = edMultilineInsensitive +-- edBS = edBlockSensitive +-- edBI = edBlockInsensitive +-- edMultilineSensitive = ed' $ Just MultilineSensitive +-- edMultilineInsensitive = ed' $ Just MultilineInsensitive +-- edBlockSensitive = ed' $ Just BlockSensitive +-- edBlockInsensitive = ed' $ Just BlockInsensitive +-- ed_ = ed' Nothing ------------------------------------------------------------------------ @@ -421,47 +422,61 @@ -- ed Helpers ------------------------------------------------------------------------ -ed' :: Maybe SimpleREOptions -> QuasiQuoter -ed' mb = case mb of - Nothing -> - (qq0 "ed'") - { quoteExp = parse minBound (\rs->[|flip unsafe_compile_sr rs|]) - } - Just sro -> - (qq0 "ed'") - { quoteExp = parse sro (\rs->[|unsafe_compile_sr_simple sro rs|]) - } - where - parse :: SimpleREOptions -> (String->Q Exp) -> String -> Q Exp - parse sro mk ts = either error (\_->mk ts) ei - where - ei :: Either String (SearchReplace RE String) - ei = compileSearchReplace_ id (compileRegexWith sro) ts - -unsafe_compile_sr_simple :: IsRegex RE s - => SimpleREOptions - -> String - -> SearchReplace RE s -unsafe_compile_sr_simple sro = - unsafe_compile_sr $ unpackSimpleREOptions sro - -unsafe_compile_sr :: ( IsOption o RE CompOption ExecOption - , IsRegex RE s - ) - => o - -> String - -> SearchReplace RE s -unsafe_compile_sr os = - unsafeCompileSearchReplace_ packR $ compileRegexWithOptions os - - - - - - - - - +-- edS :: QuasiQuoter +-- edS = cast_ed [|\x -> x :: SearchReplace RE String|] $ Just minBound +-- +-- edS_ :: QuasiQuoter +-- edS_ = cast_ed [|\x -> x :: SimpleREOptions -> SearchReplace RE String|] Nothing +-- +-- cast_ed :: Q Exp -> Maybe SimpleREOptions -> QuasiQuoter +-- cast_ed qe mb = case mb of +-- Nothing -> +-- (qq0 "ed'") +-- { quoteExp = parse minBound $ \rs -> AppE <$> qe <*> [|flip unsafe_compile_sr rs|] +-- } +-- Just sro -> +-- (qq0 "ed'") +-- { quoteExp = parse sro $ \rs -> AppE <$> qe <*> [|unsafe_compile_sr_simple sro rs|] +-- } +-- where +-- parse :: SimpleREOptions -> (String->Q Exp) -> String -> Q Exp +-- parse sro mk ts = either error (\_->mk ts) ei +-- where +-- ei :: Either String (SearchReplace RE String) +-- ei = compileSearchReplace_ id (compileRegexWith sro) ts +-- +-- ed' :: Maybe SimpleREOptions -> QuasiQuoter +-- ed' mb = case mb of +-- Nothing -> +-- (qq0 "ed'") +-- { quoteExp = parse minBound (\rs->[|flip unsafe_compile_sr rs|]) +-- } +-- Just sro -> +-- (qq0 "ed'") +-- { quoteExp = parse sro (\rs->[|unsafe_compile_sr_simple sro rs|]) +-- } +-- where +-- parse :: SimpleREOptions -> (String->Q Exp) -> String -> Q Exp +-- parse sro mk ts = either error (\_->mk ts) ei +-- where +-- ei :: Either String (SearchReplace RE String) +-- ei = compileSearchReplace_ id (compileRegexWith sro) ts +-- +-- unsafe_compile_sr_simple :: IsRegex RE s +-- => SimpleREOptions +-- -> String +-- -> SearchReplace RE s +-- unsafe_compile_sr_simple sro = +-- unsafe_compile_sr $ unpackSimpleREOptions sro +-- +-- unsafe_compile_sr :: ( IsOption o RE CompOption ExecOption +-- , IsRegex RE s +-- ) +-- => o +-- -> String +-- -> SearchReplace RE s +-- unsafe_compile_sr os = +-- unsafeCompileSearchReplace_ packR $ compileRegexWithOptions os def_comp_option :: CompOption def_comp_option = optionsComp defaultREOptions diff --git a/Text/RE/PCRE/Sequence.hs b/Text/RE/PCRE/Sequence.hs --- a/Text/RE/PCRE/Sequence.hs +++ b/Text/RE/PCRE/Sequence.hs @@ -44,6 +44,7 @@ , escape , escapeWith , module Text.RE.PCRE.RE + , module Text.RE.Internal.SearchReplace.PCRE.Sequence ) where import Prelude.Compat @@ -52,6 +53,7 @@ import Text.Regex.Base import Text.RE import Text.RE.Internal.AddCaptureNames +import Text.RE.Internal.SearchReplace.PCRE.Sequence import Text.RE.SearchReplace import Text.RE.Types.IsRegex import Text.RE.Types.REOptions diff --git a/Text/RE/PCRE/String.hs b/Text/RE/PCRE/String.hs --- a/Text/RE/PCRE/String.hs +++ b/Text/RE/PCRE/String.hs @@ -44,6 +44,7 @@ , escape , escapeWith , module Text.RE.PCRE.RE + , module Text.RE.Internal.SearchReplace.PCRE.String ) where import Prelude.Compat @@ -52,6 +53,7 @@ import Text.Regex.Base import Text.RE import Text.RE.Internal.AddCaptureNames +import Text.RE.Internal.SearchReplace.PCRE.String import Text.RE.SearchReplace import Text.RE.Types.IsRegex import Text.RE.Types.REOptions diff --git a/changelog b/changelog --- a/changelog +++ b/changelog @@ -1,5 +1,9 @@ -*-change-log-*- +0.10.0.0 Chris Dornan 2017-03-25 + * Tweak Type-Safe SearchReplace templates (#86) + * Add escape methods to IsRegex (#87) + 0.9.0.0 Chris Dornan 2017-03-23 * Flip the order of the arguments to replace (#78) * Add type-safe replacement templates (#60) diff --git a/regex-with-pcre.cabal b/regex-with-pcre.cabal --- a/regex-with-pcre.cabal +++ b/regex-with-pcre.cabal @@ -1,5 +1,5 @@ Name: regex-with-pcre -Version: 0.9.0.0 +Version: 0.10.0.0 Synopsis: Toolkit for regex-base Description: A Regular Expression Toolkit for regex-base with Compile-time checking of RE syntax, data types for @@ -31,12 +31,13 @@ Source-Repository this Type: git Location: https://github.com/iconnect/regex.git - Tag: 0.9.0.0 + Tag: 0.10.0.0 Library Hs-Source-Dirs: . + Exposed-Modules: Text.RE.PCRE Text.RE.PCRE.ByteString @@ -45,6 +46,14 @@ Text.RE.PCRE.Sequence Text.RE.PCRE.String + Other-Modules: + Text.RE.Internal.SearchReplace.PCRE + Text.RE.Internal.SearchReplace.PCRE.ByteString + Text.RE.Internal.SearchReplace.PCRE.ByteString.Lazy + Text.RE.Internal.SearchReplace.PCRE.Sequence + Text.RE.Internal.SearchReplace.PCRE.String + Text.RE.Internal.SearchReplace.PCREEdPrime + Default-Language: Haskell2010 Other-Extensions: @@ -78,7 +87,7 @@ -Wwarn Build-depends: - regex == 0.9.0.0 + regex == 0.10.0.0 , base >= 4 && < 5 , base-compat >= 0.6.0 , bytestring >= 0.10.2.0