regex 0.14.0.0 → 1.0.0.0

raw patch · 41 files changed

+1178/−552 lines, 41 filesdep −regex-pcre-builtinPVP ok

version bump matches the API change (PVP)

Dependencies removed: regex-pcre-builtin

API changes (from Hackage documentation)

Files

• README.markdown +2/−2
• Text/RE.hs +1/−39
• Text/RE/REOptions.lhs +16/−3
• Text/RE/Replace.hs +20/−9
• Text/RE/Summa.hs +4/−4
• Text/RE/TDFA.hs +105/−21
• Text/RE/TDFA/ByteString.hs +60/−16
• Text/RE/TDFA/ByteString/Lazy.hs +60/−16
• Text/RE/TDFA/Sequence.hs +60/−16
• Text/RE/TDFA/String.hs +60/−16
• Text/RE/TDFA/Text.hs +60/−16
• Text/RE/TDFA/Text/Lazy.hs +60/−16
• Text/RE/TestBench.hs +16/−24
• Text/RE/TestBench/Parsers.hs +23/−0
• Text/RE/Tools.hs +16/−5
• Text/RE/Tools/Edit.lhs +29/−10
• Text/RE/Tools/Find.lhs +24/−4
• Text/RE/Tools/Grep.lhs +30/−5
• Text/RE/Tools/IsRegex.hs +17/−0
• Text/RE/Tools/Lex.hs +17/−4
• Text/RE/Tools/Sed.lhs +33/−10
• Text/RE/ZeInternals.hs +51/−8
• Text/RE/ZeInternals/NamedCaptures.lhs +6/−4
• Text/RE/ZeInternals/PreludeMacros.hs +2/−2
• Text/RE/ZeInternals/SearchReplace/TDFA/ByteString.hs +48/−36
• Text/RE/ZeInternals/SearchReplace/TDFA/ByteString/Lazy.hs +48/−36
• Text/RE/ZeInternals/SearchReplace/TDFA/Sequence.hs +48/−36
• Text/RE/ZeInternals/SearchReplace/TDFA/String.hs +48/−36
• Text/RE/ZeInternals/SearchReplace/TDFA/Text.hs +48/−36
• Text/RE/ZeInternals/SearchReplace/TDFA/Text/Lazy.hs +48/−36
• Text/RE/ZeInternals/SearchReplace/TDFAEdPrime.hs +2/−3
• Text/RE/ZeInternals/TDFA.hs +55/−44
• Text/RE/ZeInternals/Tools/Lex.lhs +2/−0
• Text/RE/ZeInternals/Types/CaptureID.hs +3/−7
• Text/RE/ZeInternals/Types/IsRegex.lhs +2/−0
• Text/RE/ZeInternals/Types/Match.lhs +8/−10
• Text/RE/ZeInternals/Types/Matches.lhs +3/−3
• Text/RE/ZeInternals/Types/SearchReplace.hs +0/−15
• Text/RE/ZeInternals/Types/SearchReplace.lhs +23/−0
• changelog +13/−1
• regex.cabal +7/−3

@@ -12,7 +12,7 @@   * regular expression macros including:       + a number of useful RE macros;       + a test bench for testing and documenting new macro environments;-  * built-in support for the TDFA and PCRE backends;+  * built-in support for the TDFA and PCRE back ends;   * comprehensive documentation, tutorials and copious examples.  @@ -78,7 +78,7 @@      ☒  2017-04-04  v0.14.0.0 [Move IsOption, rename Find functions](https://github.com/iconnect/regex/milestone/18) -    ☐  2017-04-10  v1.0.0.0  [First stable release](https://github.com/iconnect/regex/milestone/3)+    ☒  2017-04-10  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) 

@@ -17,36 +17,8 @@    -- * Further Use   -- $further--  -- * The regex Foundational Types-  -- ** Matches-    Matches-  , matchesSource-  , allMatches-  , anyMatches-  , countMatches-  , matches-  -- ** Match-  , Match-  , matchSource-  , matched-  , matchedText--  -- * IsRegex-  -- $isregex-  , IsRegex(..)-  , searchReplaceAll-  , searchReplaceFirst-  -- * IsRegex Instances-  -- $instances-  , module Text.RE.TDFA   ) where -import           Text.RE.TDFA()-import           Text.RE.ZeInternals.Types.IsRegex-import           Text.RE.ZeInternals.Types.Match-import           Text.RE.ZeInternals.Types.Matches- -- $tutorial -- -- We have a regex tutorial at <http://tutorial.regex.uk>.@@ -91,17 +63,7 @@ -- For more specialist applications we have the following: -- -- * "Text.RE.REOptions" for specifying back-end specific options;--- * "Text.RE.Replace"   for the full replace toolkit;+-- * "Text.RE.Replace"   for the full text-replacement toolkit; -- * "Text.RE.TestBench" for building up, testing and doumenting; --   macro environments  for use in REs; -- * "Text.RE.Tools"     for an AWK-like text-processing toolkit.---- $isregex--- Class @IsRegex re t@ provides methods for matching the @t@ type for--- the @re@ back end as well as compiling REs from @t@ to @re@ and--- getting the source @t@ back again. The 'Replace' superclass of--- @IsRegex@ contains a useful toolkit for converting between @t@ and--- 'String' abd @Text@.---- $instances--- This module import just imports the @IsRegex TDFA s@ instances.

@@ -12,8 +12,12 @@  module Text.RE.REOptions   (-  -- * RE Options+  -- * The Options Tutorial+  -- $tutorial++  -- * 'SimpleREOptions'     SimpleREOptions(..)+  -- * 'REOptions_'   , REOptions_(..)   -- * The Macro Tables   , Macros@@ -60,7 +64,7 @@ -- and its @CompOption@ and @ExecOption@ types (the compile-time and -- execution time options, respectively); each back end will define an -- @REOptions@ type that fills out these three type parameters with the--- apropriate types (see, for example, "Text.RE.ZeInternals.TDFA")+-- apropriate types (see, for example, "Text.RE.TDFA") data REOptions_ r c e =   REOptions     { optionsMacs :: !(Macros r)    -- ^ the available TestBench RE macros@@ -75,7 +79,7 @@ ----------------  \begin{code}--- | our macro tables are parameterised over the backend @RE@ type and+-- | our macro tables are parameterised over the back end @RE@ type and -- and just associate each @MacroID@ with an @RE@ (which may in turn -- contain macros to be expanded) type Macros r = HM.HashMap MacroID r@@ -99,4 +103,13 @@ -- | a macro table containing no entries emptyMacros :: Macros r emptyMacros = HM.empty+\end{code}+++\begin{code}+-- $tutorial+-- This API module provides the generic types used to specify the options+-- when compiling REs for each of the backl ends.+--+-- See the tutorials at http://re-tutorial-options.regex.uk \end{code}

@@ -1,11 +1,10 @@ module Text.RE.Replace   (-  -- * REContext and RELocation-    REContext(..)-  , RELocation(..)-  , isTopLocation+  -- * The Replacing Tutorial+  -- $tutorial+   -- * replaceAll-  , replaceAll+    replaceAll   , replaceAllCaptures   , replaceAllCaptures_   , replaceAllCapturesM@@ -14,10 +13,10 @@   , replaceCaptures   , replaceCaptures_   , replaceCapturesM-  -- * Replace and ReplaceMethods-  , Replace(..)-  , ReplaceMethods(..)-  , replaceMethods+  -- * REContext and RELocation+  , REContext(..)+  , RELocation(..)+  , isTopLocation   -- * Matches   , Matches(..)   , anyMatches@@ -53,6 +52,10 @@   , CaptureName(..)   , CaptureOrdinal(..)   , findCaptureID+  -- * Replace and ReplaceMethods+  , Replace(..)+  , ReplaceMethods(..)+  , replaceMethods   ) where  import           Text.RE.ZeInternals.Replace@@ -60,3 +63,11 @@ import           Text.RE.ZeInternals.Types.CaptureID import           Text.RE.ZeInternals.Types.Match import           Text.RE.ZeInternals.Types.Matches++-- $tutorial+-- This API module covers the specialised regex tools for doing general+-- editing on text, including the internal details of the 'Matches' and+-- 'Match' types and the associated functions for extracting captures+-- and applying functions to them to transform the subject text.+--+-- See the tutorials at http://re-tutorial-replacing.regex.uk

@@ -14,7 +14,7 @@ -- $collection -- -- This module collects together all of the generic regex APIs not--- exported by the back-end-specific API modules. The regex--- API is modular with only the most common types and functions being--- exported by these modules but the remaining modules may be imported--- en masse by importing this module.+-- exported by the principal API modules, specialised for each back end+-- and text type. The regex API is modular with only the most common types+-- and functions being exported by these modules but the remaining modules+-- may be imported en masse by importing this module.

@@ -14,50 +14,96 @@   -- * About this Module   -- $about -  -- * The Match Operators+  -- * The 'Matches' and 'Match' Operators     (*=~)   , (?=~)-  -- * The SearchReplace Operators+  -- * The 'SearchReplace' Operators   , (*=~/)   , (?=~/)-  -- * Matches+  -- * The 'Matches' Type   , Matches   , matchesSource   , allMatches   , anyMatches   , countMatches   , matches-  -- * Match+  -- * The 'Match' Type   , Match   , matchSource   , matched   , matchedText+  -- * The Macros and Parsers+  -- $macros+  , module Text.RE.TestBench.Parsers   -- * The 'RE' Type   , RE+  , regexType+  , reOptions   , reSource+  , reCaptureNames+  , reRegex   -- * Options   -- $options   , SimpleREOptions(..)+  , IsOption(..)+  , REOptions+  , defaultREOptions+  , noPreludeREOptions+  , unpackSimpleREOptions   -- * Compiling and Escaping REs   , SearchReplace(..)   , compileRegex   , compileRegexWith+  , compileRegexWithOptions   , compileSearchReplace   , compileSearchReplaceWith+  , compileSearchReplaceWithOptions   , escape   , escapeWith+  , escapeWithOptions   , escapeREString-  -- * The Classic rexex-base Match Operators+  -- * The Classic regex-base Match Operators   , (=~)   , (=~~)-  -- * IsRegex-  , IsRegex(..)-  -- * The Quasi Quoters and Minor Functions+  -- * The re Quasi Quoters   -- $re-  , module Text.RE.ZeInternals.TDFA+  , re+  , reMultilineSensitive+  , reMultilineInsensitive+  , reBlockSensitive+  , reBlockInsensitive+  , reMS+  , reMI+  , reBS+  , reBI+  , re_+  -- * The Ed Quasi Quoters   -- $ed-  , module Text.RE.ZeInternals.SearchReplace.TDFA-  -- * The Operator Instances+  , ed+  , edMultilineSensitive+  , edMultilineInsensitive+  , edBlockSensitive+  , edBlockInsensitive+  , edMS+  , edMI+  , edBS+  , edBI+  , ed_+  -- * The cp Quasi Quoters+  , cp+  -- * RE Macros Standard Environment+  -- $prelude+  , prelude+  , preludeEnv+  , preludeTestsFailing+  , preludeTable+  , preludeSummary+  , preludeSources+  , preludeSource+  -- * IsRegex+  -- $isregex+  , module Text.RE.Tools.IsRegex+  -- * The IsRegex Instances   -- $instances   , module Text.RE.TDFA.ByteString   , module Text.RE.TDFA.ByteString.Lazy@@ -68,18 +114,18 @@   ) where  import           Text.RE.REOptions+import           Text.RE.Replace import           Text.RE.TDFA.ByteString() import           Text.RE.TDFA.ByteString.Lazy() import           Text.RE.TDFA.Sequence() import           Text.RE.TDFA.String() import           Text.RE.TDFA.Text() import           Text.RE.TDFA.Text.Lazy()-import           Text.RE.ZeInternals.AddCaptureNames+import           Text.RE.TestBench.Parsers+import           Text.RE.Tools.IsRegex+import           Text.RE.ZeInternals import           Text.RE.ZeInternals.SearchReplace.TDFA import           Text.RE.ZeInternals.TDFA-import           Text.RE.ZeInternals.Types.IsRegex-import           Text.RE.ZeInternals.Types.Match-import           Text.RE.ZeInternals.Types.Matches import qualified Text.Regex.Base                          as B import qualified Text.Regex.TDFA                          as TDFA @@ -144,26 +190,64 @@ -- $about -- This module provides access to the back end through polymorphic functions -- that operate over all of the String\/Text\/ByteString types supported by the--- back end. If you don't need this generality then you might want to consider--- using one of the modules that have been specialised for each of these types:+-- back end. The module also provides all of the specialised back-end functionality+-- that will not be needed by most regex clientts. If you don't need this generality+-- then you might want to consider using one of the simpler modules that have been+-- specialised for each of these types: -- -- * "Text.RE.TDFA.ByteString" -- * "Text.RE.TDFA.ByteString.Lazy"--- * "Text.RE.ZeInternals.TDFA" -- * "Text.RE.TDFA.Sequence" -- * "Text.RE.TDFA.String" -- * "Text.RE.TDFA.Text" -- * "Text.RE.TDFA.Text.Lazy" +-- $macros+-- There are a number of RE macros and corresponding Haskell parsers+-- for parsing the matched text into appropriate Haskell types. See+-- the [Macros Tables](http://regex.uk/macros) for details.++-- $options+-- You can specify different compilation options by appending a+-- to the name of an [re| ... |] or [ed| ... \/\/\/ ... |] quasi quoter+-- to select the corresponding compilation option. For example, the+-- section,+--+--  @(?=~/ [edBlockInsensitive|foo$\/\/\/bar|])@+--+-- will replace a @foo@ suffix of the argument text, of any+-- capitalisation, with a (lower case) @bar@. If you need to specify the+-- options dynamically, use the @[re_| ... |]@ and @[ed_| ... \/\/\/ ... |]@+-- quasi quoters, which generate functions that take an 'IsOption' option+-- (e.g., a 'SimpleReOptions' value) and yields a 'RE' or 'SearchReplace'+-- as apropriate. For example if you have a 'SimpleReOptions' value in+-- @sro@ then+--+--  @(?=~/ [ed_|foo$\/\/\/bar|] sro)@+--+-- will compile the @foo$@ RE according to the value of @sro@. For more+-- on specifying RE options see "Text.RE.REOptions".+ -- $re -- The @[re|.*|]@ quasi quoters, with variants for specifing different -- options to the RE compiler (see "Text.RE.REOptions"), and the -- specialised back-end types and functions.  -- $ed--- The @[ed|.*\/\/\/foo|]@ quasi quoters, with variants for specifing different--- options to the RE compiler (see "Text.RE.REOptions").+-- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for example,+--+--  @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@+--+-- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date+-- into a DD\/MM\/YYYY format date.+--+-- The only difference betweem these quasi quoters is the RE options that are set,+-- using the same conventions as the @[re| ... |]@ quasi quoters. +-- $isregex+-- The 'IsRegex' class is used to abstact over the different regex back ends and+-- the text types they work with -- see "Text.RE.Tools.IsRegex" for details.+ -- $instances ----- These modules merely provide the 'IsRegex' instances.+-- These module exports merely provide the 'IsRegex' instances.

@@ -20,18 +20,21 @@   -- * The 'SearchReplace' Operators   , (*=~/)   , (?=~/)-  -- * Matches+  -- * The 'Matches' Type   , Matches   , matchesSource   , allMatches   , anyMatches   , countMatches   , matches-  -- * Match+  -- * The 'Match' Type   , Match   , matchSource   , matched   , matchedText+  -- * The Macros and Parsers+  -- $macros+  , module Text.RE.TestBench.Parsers   -- * The 'RE' Type   , RE   , reSource@@ -47,16 +50,38 @@   , escape   , escapeWith   , escapeREString-  -- * The Classic rexex-base Match Operators+  -- * The Classic regex-base Match Operators   , (=~)   , (=~~)-  -- * IsRegex-  , IsRegex(..)-  -- * The Quasi Quoters and Minor Functions+  -- * The re Quasi Quoters   -- $re-  , module Text.RE.ZeInternals.TDFA+  , re+  , reMultilineSensitive+  , reMultilineInsensitive+  , reBlockSensitive+  , reBlockInsensitive+  , reMS+  , reMI+  , reBS+  , reBI+  , re_+  -- * The Ed Quasi Quoters   -- $ed-  , module Text.RE.ZeInternals.SearchReplace.TDFA.ByteString+  , edMultilineSensitive+  , edMultilineInsensitive+  , edBlockSensitive+  , edBlockInsensitive+  , ed+  , edMS+  , edMI+  , edBS+  , edBI+  , ed_+  -- * The cp Quasi Quoters+  , cp+  -- * IsRegex+  -- $isregex+  , module Text.RE.Tools.IsRegex   ) where  import qualified Data.ByteString               as B@@ -64,10 +89,11 @@ import           Prelude.Compat import           Text.RE.REOptions import           Text.RE.Replace-import           Text.RE.ZeInternals.AddCaptureNames+import           Text.RE.TestBench.Parsers+import           Text.RE.Tools.IsRegex+import           Text.RE.ZeInternals import           Text.RE.ZeInternals.SearchReplace.TDFA.ByteString import           Text.RE.ZeInternals.TDFA-import           Text.RE.ZeInternals.Types.IsRegex import           Text.Regex.Base import qualified Text.Regex.TDFA               as TDFA @@ -102,7 +128,7 @@ (*=~/) = flip searchReplaceAll  -- | search and replace the first occurrence only (if any) in the input text--- e.g., to prefix the first string of four hex digits in the imput text,+-- e.g., to prefix the first string of four hex digits in the input text, -- if any, with @0x@: -- --  @(?=~\/ [ed|[0-9A-Fa-f]{4}\/\/\/0x$0|])@@@ -110,22 +136,20 @@ (?=~/) :: B.ByteString -> SearchReplace RE B.ByteString -> B.ByteString (?=~/) = flip searchReplaceFirst --- | the regex-base polymorphic match operator+-- | the `regex-base` polymorphic match operator (=~) :: ( Typeable a         , RegexContext TDFA.Regex B.ByteString a-        , RegexMaker   TDFA.Regex TDFA.CompOption TDFA.ExecOption String         )      => B.ByteString      -> RE      -> a (=~) bs rex = addCaptureNames (reCaptureNames rex) $ match (reRegex rex) bs --- | the regex-base monadic, polymorphic match operator+-- | the `regex-base` monadic, polymorphic match operator (=~~) :: ( Monad m          , Functor m          , Typeable a          , RegexContext TDFA.Regex B.ByteString a-         , RegexMaker   TDFA.Regex TDFA.CompOption TDFA.ExecOption String          )       => B.ByteString       -> RE@@ -142,6 +166,11 @@ -- $tutorial -- We have a regex tutorial at <http://tutorial.regex.uk>. +-- $macros+-- There are a number of RE macros and corresponding Haskell parsers+-- for parsing the matched text into appropriate Haskell types. See+-- the [Macros Tables](http://regex.uk/macros) for details.+ -- $options -- You can specify different compilation options by appending a -- to the name of an [re| ... |] or [ed| ... \/\/\/ ... |] quasi quoter@@ -152,7 +181,7 @@ -- -- will replace a @foo@ suffix of the argument text, of any -- capitalisation, with a (lower case) @bar@. If you need to specify the--- options dynamically, use the @[re_| ... |]@ and @[red_| ... \/\/\/ ... |]@+-- options dynamically, use the @[re_| ... |]@ and @[ed_| ... \/\/\/ ... |]@ -- quasi quoters, which generate functions that take an 'IsOption' option -- (e.g., a 'SimpleReOptions' value) and yields a 'RE' or 'SearchReplace' -- as apropriate. For example if you have a 'SimpleReOptions' value in@@ -171,3 +200,18 @@ -- $ed -- The @[ed|.*\/\/\/foo|]@ quasi quoters, with variants for specifing different -- options to the RE compiler (see "Text.RE.REOptions").++-- $ed+-- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for example,+--+--  @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@+--+-- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date+-- into a DD\/MM\/YYYY format date.+--+-- The only difference betweem these quasi quoters is the RE options that are set,+-- using the same conventions as the @[re| ... |]@ quasi quoters.++-- $isregex+-- The 'IsRegex' class is used to abstact over the different regex back ends and+-- the text types they work with -- see "Text.RE.Tools.IsRegex" for details.

@@ -20,18 +20,21 @@   -- * The 'SearchReplace' Operators   , (*=~/)   , (?=~/)-  -- * Matches+  -- * The 'Matches' Type   , Matches   , matchesSource   , allMatches   , anyMatches   , countMatches   , matches-  -- * Match+  -- * The 'Match' Type   , Match   , matchSource   , matched   , matchedText+  -- * The Macros and Parsers+  -- $macros+  , module Text.RE.TestBench.Parsers   -- * The 'RE' Type   , RE   , reSource@@ -47,16 +50,38 @@   , escape   , escapeWith   , escapeREString-  -- * The Classic rexex-base Match Operators+  -- * The Classic regex-base Match Operators   , (=~)   , (=~~)-  -- * IsRegex-  , IsRegex(..)-  -- * The Quasi Quoters and Minor Functions+  -- * The re Quasi Quoters   -- $re-  , module Text.RE.ZeInternals.TDFA+  , re+  , reMultilineSensitive+  , reMultilineInsensitive+  , reBlockSensitive+  , reBlockInsensitive+  , reMS+  , reMI+  , reBS+  , reBI+  , re_+  -- * The Ed Quasi Quoters   -- $ed-  , module Text.RE.ZeInternals.SearchReplace.TDFA.ByteString.Lazy+  , edMultilineSensitive+  , edMultilineInsensitive+  , edBlockSensitive+  , edBlockInsensitive+  , ed+  , edMS+  , edMI+  , edBS+  , edBI+  , ed_+  -- * The cp Quasi Quoters+  , cp+  -- * IsRegex+  -- $isregex+  , module Text.RE.Tools.IsRegex   ) where  import qualified Data.ByteString.Lazy.Char8    as LBS@@ -64,10 +89,11 @@ import           Prelude.Compat import           Text.RE.REOptions import           Text.RE.Replace-import           Text.RE.ZeInternals.AddCaptureNames+import           Text.RE.TestBench.Parsers+import           Text.RE.Tools.IsRegex+import           Text.RE.ZeInternals import           Text.RE.ZeInternals.SearchReplace.TDFA.ByteString.Lazy import           Text.RE.ZeInternals.TDFA-import           Text.RE.ZeInternals.Types.IsRegex import           Text.Regex.Base import qualified Text.Regex.TDFA               as TDFA @@ -102,7 +128,7 @@ (*=~/) = flip searchReplaceAll  -- | search and replace the first occurrence only (if any) in the input text--- e.g., to prefix the first string of four hex digits in the imput text,+-- e.g., to prefix the first string of four hex digits in the input text, -- if any, with @0x@: -- --  @(?=~\/ [ed|[0-9A-Fa-f]{4}\/\/\/0x$0|])@@@ -110,22 +136,20 @@ (?=~/) :: LBS.ByteString -> SearchReplace RE LBS.ByteString -> LBS.ByteString (?=~/) = flip searchReplaceFirst --- | the regex-base polymorphic match operator+-- | the `regex-base` polymorphic match operator (=~) :: ( Typeable a         , RegexContext TDFA.Regex LBS.ByteString a-        , RegexMaker   TDFA.Regex TDFA.CompOption TDFA.ExecOption String         )      => LBS.ByteString      -> RE      -> a (=~) bs rex = addCaptureNames (reCaptureNames rex) $ match (reRegex rex) bs --- | the regex-base monadic, polymorphic match operator+-- | the `regex-base` monadic, polymorphic match operator (=~~) :: ( Monad m          , Functor m          , Typeable a          , RegexContext TDFA.Regex LBS.ByteString a-         , RegexMaker   TDFA.Regex TDFA.CompOption TDFA.ExecOption String          )       => LBS.ByteString       -> RE@@ -142,6 +166,11 @@ -- $tutorial -- We have a regex tutorial at <http://tutorial.regex.uk>. +-- $macros+-- There are a number of RE macros and corresponding Haskell parsers+-- for parsing the matched text into appropriate Haskell types. See+-- the [Macros Tables](http://regex.uk/macros) for details.+ -- $options -- You can specify different compilation options by appending a -- to the name of an [re| ... |] or [ed| ... \/\/\/ ... |] quasi quoter@@ -152,7 +181,7 @@ -- -- will replace a @foo@ suffix of the argument text, of any -- capitalisation, with a (lower case) @bar@. If you need to specify the--- options dynamically, use the @[re_| ... |]@ and @[red_| ... \/\/\/ ... |]@+-- options dynamically, use the @[re_| ... |]@ and @[ed_| ... \/\/\/ ... |]@ -- quasi quoters, which generate functions that take an 'IsOption' option -- (e.g., a 'SimpleReOptions' value) and yields a 'RE' or 'SearchReplace' -- as apropriate. For example if you have a 'SimpleReOptions' value in@@ -171,3 +200,18 @@ -- $ed -- The @[ed|.*\/\/\/foo|]@ quasi quoters, with variants for specifing different -- options to the RE compiler (see "Text.RE.REOptions").++-- $ed+-- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for example,+--+--  @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@+--+-- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date+-- into a DD\/MM\/YYYY format date.+--+-- The only difference betweem these quasi quoters is the RE options that are set,+-- using the same conventions as the @[re| ... |]@ quasi quoters.++-- $isregex+-- The 'IsRegex' class is used to abstact over the different regex back ends and+-- the text types they work with -- see "Text.RE.Tools.IsRegex" for details.

@@ -20,18 +20,21 @@   -- * The 'SearchReplace' Operators   , (*=~/)   , (?=~/)-  -- * Matches+  -- * The 'Matches' Type   , Matches   , matchesSource   , allMatches   , anyMatches   , countMatches   , matches-  -- * Match+  -- * The 'Match' Type   , Match   , matchSource   , matched   , matchedText+  -- * The Macros and Parsers+  -- $macros+  , module Text.RE.TestBench.Parsers   -- * The 'RE' Type   , RE   , reSource@@ -47,16 +50,38 @@   , escape   , escapeWith   , escapeREString-  -- * The Classic rexex-base Match Operators+  -- * The Classic regex-base Match Operators   , (=~)   , (=~~)-  -- * IsRegex-  , IsRegex(..)-  -- * The Quasi Quoters and Minor Functions+  -- * The re Quasi Quoters   -- $re-  , module Text.RE.ZeInternals.TDFA+  , re+  , reMultilineSensitive+  , reMultilineInsensitive+  , reBlockSensitive+  , reBlockInsensitive+  , reMS+  , reMI+  , reBS+  , reBI+  , re_+  -- * The Ed Quasi Quoters   -- $ed-  , module Text.RE.ZeInternals.SearchReplace.TDFA.Sequence+  , edMultilineSensitive+  , edMultilineInsensitive+  , edBlockSensitive+  , edBlockInsensitive+  , ed+  , edMS+  , edMI+  , edBS+  , edBI+  , ed_+  -- * The cp Quasi Quoters+  , cp+  -- * IsRegex+  -- $isregex+  , module Text.RE.Tools.IsRegex   ) where  import qualified Data.Sequence                 as S@@ -64,10 +89,11 @@ import           Prelude.Compat import           Text.RE.REOptions import           Text.RE.Replace-import           Text.RE.ZeInternals.AddCaptureNames+import           Text.RE.TestBench.Parsers+import           Text.RE.Tools.IsRegex+import           Text.RE.ZeInternals import           Text.RE.ZeInternals.SearchReplace.TDFA.Sequence import           Text.RE.ZeInternals.TDFA-import           Text.RE.ZeInternals.Types.IsRegex import           Text.Regex.Base import qualified Text.Regex.TDFA               as TDFA @@ -102,7 +128,7 @@ (*=~/) = flip searchReplaceAll  -- | search and replace the first occurrence only (if any) in the input text--- e.g., to prefix the first string of four hex digits in the imput text,+-- e.g., to prefix the first string of four hex digits in the input text, -- if any, with @0x@: -- --  @(?=~\/ [ed|[0-9A-Fa-f]{4}\/\/\/0x$0|])@@@ -110,22 +136,20 @@ (?=~/) :: (S.Seq Char) -> SearchReplace RE (S.Seq Char) -> (S.Seq Char) (?=~/) = flip searchReplaceFirst --- | the regex-base polymorphic match operator+-- | the `regex-base` polymorphic match operator (=~) :: ( Typeable a         , RegexContext TDFA.Regex (S.Seq Char) a-        , RegexMaker   TDFA.Regex TDFA.CompOption TDFA.ExecOption String         )      => (S.Seq Char)      -> RE      -> a (=~) bs rex = addCaptureNames (reCaptureNames rex) $ match (reRegex rex) bs --- | the regex-base monadic, polymorphic match operator+-- | the `regex-base` monadic, polymorphic match operator (=~~) :: ( Monad m          , Functor m          , Typeable a          , RegexContext TDFA.Regex (S.Seq Char) a-         , RegexMaker   TDFA.Regex TDFA.CompOption TDFA.ExecOption String          )       => (S.Seq Char)       -> RE@@ -142,6 +166,11 @@ -- $tutorial -- We have a regex tutorial at <http://tutorial.regex.uk>. +-- $macros+-- There are a number of RE macros and corresponding Haskell parsers+-- for parsing the matched text into appropriate Haskell types. See+-- the [Macros Tables](http://regex.uk/macros) for details.+ -- $options -- You can specify different compilation options by appending a -- to the name of an [re| ... |] or [ed| ... \/\/\/ ... |] quasi quoter@@ -152,7 +181,7 @@ -- -- will replace a @foo@ suffix of the argument text, of any -- capitalisation, with a (lower case) @bar@. If you need to specify the--- options dynamically, use the @[re_| ... |]@ and @[red_| ... \/\/\/ ... |]@+-- options dynamically, use the @[re_| ... |]@ and @[ed_| ... \/\/\/ ... |]@ -- quasi quoters, which generate functions that take an 'IsOption' option -- (e.g., a 'SimpleReOptions' value) and yields a 'RE' or 'SearchReplace' -- as apropriate. For example if you have a 'SimpleReOptions' value in@@ -171,3 +200,18 @@ -- $ed -- The @[ed|.*\/\/\/foo|]@ quasi quoters, with variants for specifing different -- options to the RE compiler (see "Text.RE.REOptions").++-- $ed+-- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for example,+--+--  @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@+--+-- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date+-- into a DD\/MM\/YYYY format date.+--+-- The only difference betweem these quasi quoters is the RE options that are set,+-- using the same conventions as the @[re| ... |]@ quasi quoters.++-- $isregex+-- The 'IsRegex' class is used to abstact over the different regex back ends and+-- the text types they work with -- see "Text.RE.Tools.IsRegex" for details.

@@ -20,18 +20,21 @@   -- * The 'SearchReplace' Operators   , (*=~/)   , (?=~/)-  -- * Matches+  -- * The 'Matches' Type   , Matches   , matchesSource   , allMatches   , anyMatches   , countMatches   , matches-  -- * Match+  -- * The 'Match' Type   , Match   , matchSource   , matched   , matchedText+  -- * The Macros and Parsers+  -- $macros+  , module Text.RE.TestBench.Parsers   -- * The 'RE' Type   , RE   , reSource@@ -47,16 +50,38 @@   , escape   , escapeWith   , escapeREString-  -- * The Classic rexex-base Match Operators+  -- * The Classic regex-base Match Operators   , (=~)   , (=~~)-  -- * IsRegex-  , IsRegex(..)-  -- * The Quasi Quoters and Minor Functions+  -- * The re Quasi Quoters   -- $re-  , module Text.RE.ZeInternals.TDFA+  , re+  , reMultilineSensitive+  , reMultilineInsensitive+  , reBlockSensitive+  , reBlockInsensitive+  , reMS+  , reMI+  , reBS+  , reBI+  , re_+  -- * The Ed Quasi Quoters   -- $ed-  , module Text.RE.ZeInternals.SearchReplace.TDFA.String+  , edMultilineSensitive+  , edMultilineInsensitive+  , edBlockSensitive+  , edBlockInsensitive+  , ed+  , edMS+  , edMI+  , edBS+  , edBI+  , ed_+  -- * The cp Quasi Quoters+  , cp+  -- * IsRegex+  -- $isregex+  , module Text.RE.Tools.IsRegex   ) where  @@ -64,10 +89,11 @@ import           Prelude.Compat import           Text.RE.REOptions import           Text.RE.Replace-import           Text.RE.ZeInternals.AddCaptureNames+import           Text.RE.TestBench.Parsers+import           Text.RE.Tools.IsRegex+import           Text.RE.ZeInternals import           Text.RE.ZeInternals.SearchReplace.TDFA.String import           Text.RE.ZeInternals.TDFA-import           Text.RE.ZeInternals.Types.IsRegex import           Text.Regex.Base import qualified Text.Regex.TDFA               as TDFA @@ -102,7 +128,7 @@ (*=~/) = flip searchReplaceAll  -- | search and replace the first occurrence only (if any) in the input text--- e.g., to prefix the first string of four hex digits in the imput text,+-- e.g., to prefix the first string of four hex digits in the input text, -- if any, with @0x@: -- --  @(?=~\/ [ed|[0-9A-Fa-f]{4}\/\/\/0x$0|])@@@ -110,22 +136,20 @@ (?=~/) :: String -> SearchReplace RE String -> String (?=~/) = flip searchReplaceFirst --- | the regex-base polymorphic match operator+-- | the `regex-base` polymorphic match operator (=~) :: ( Typeable a         , RegexContext TDFA.Regex String a-        , RegexMaker   TDFA.Regex TDFA.CompOption TDFA.ExecOption String         )      => String      -> RE      -> a (=~) bs rex = addCaptureNames (reCaptureNames rex) $ match (reRegex rex) bs --- | the regex-base monadic, polymorphic match operator+-- | the `regex-base` monadic, polymorphic match operator (=~~) :: ( Monad m          , Functor m          , Typeable a          , RegexContext TDFA.Regex String a-         , RegexMaker   TDFA.Regex TDFA.CompOption TDFA.ExecOption String          )       => String       -> RE@@ -142,6 +166,11 @@ -- $tutorial -- We have a regex tutorial at <http://tutorial.regex.uk>. +-- $macros+-- There are a number of RE macros and corresponding Haskell parsers+-- for parsing the matched text into appropriate Haskell types. See+-- the [Macros Tables](http://regex.uk/macros) for details.+ -- $options -- You can specify different compilation options by appending a -- to the name of an [re| ... |] or [ed| ... \/\/\/ ... |] quasi quoter@@ -152,7 +181,7 @@ -- -- will replace a @foo@ suffix of the argument text, of any -- capitalisation, with a (lower case) @bar@. If you need to specify the--- options dynamically, use the @[re_| ... |]@ and @[red_| ... \/\/\/ ... |]@+-- options dynamically, use the @[re_| ... |]@ and @[ed_| ... \/\/\/ ... |]@ -- quasi quoters, which generate functions that take an 'IsOption' option -- (e.g., a 'SimpleReOptions' value) and yields a 'RE' or 'SearchReplace' -- as apropriate. For example if you have a 'SimpleReOptions' value in@@ -171,3 +200,18 @@ -- $ed -- The @[ed|.*\/\/\/foo|]@ quasi quoters, with variants for specifing different -- options to the RE compiler (see "Text.RE.REOptions").++-- $ed+-- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for example,+--+--  @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@+--+-- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date+-- into a DD\/MM\/YYYY format date.+--+-- The only difference betweem these quasi quoters is the RE options that are set,+-- using the same conventions as the @[re| ... |]@ quasi quoters.++-- $isregex+-- The 'IsRegex' class is used to abstact over the different regex back ends and+-- the text types they work with -- see "Text.RE.Tools.IsRegex" for details.

@@ -20,18 +20,21 @@   -- * The 'SearchReplace' Operators   , (*=~/)   , (?=~/)-  -- * Matches+  -- * The 'Matches' Type   , Matches   , matchesSource   , allMatches   , anyMatches   , countMatches   , matches-  -- * Match+  -- * The 'Match' Type   , Match   , matchSource   , matched   , matchedText+  -- * The Macros and Parsers+  -- $macros+  , module Text.RE.TestBench.Parsers   -- * The 'RE' Type   , RE   , reSource@@ -47,16 +50,38 @@   , escape   , escapeWith   , escapeREString-  -- * The Classic rexex-base Match Operators+  -- * The Classic regex-base Match Operators   , (=~)   , (=~~)-  -- * IsRegex-  , IsRegex(..)-  -- * The Quasi Quoters and Minor Functions+  -- * The re Quasi Quoters   -- $re-  , module Text.RE.ZeInternals.TDFA+  , re+  , reMultilineSensitive+  , reMultilineInsensitive+  , reBlockSensitive+  , reBlockInsensitive+  , reMS+  , reMI+  , reBS+  , reBI+  , re_+  -- * The Ed Quasi Quoters   -- $ed-  , module Text.RE.ZeInternals.SearchReplace.TDFA.Text+  , edMultilineSensitive+  , edMultilineInsensitive+  , edBlockSensitive+  , edBlockInsensitive+  , ed+  , edMS+  , edMI+  , edBS+  , edBI+  , ed_+  -- * The cp Quasi Quoters+  , cp+  -- * IsRegex+  -- $isregex+  , module Text.RE.Tools.IsRegex   ) where  import qualified Data.Text                     as T@@ -64,10 +89,11 @@ import           Prelude.Compat import           Text.RE.REOptions import           Text.RE.Replace-import           Text.RE.ZeInternals.AddCaptureNames+import           Text.RE.TestBench.Parsers+import           Text.RE.Tools.IsRegex+import           Text.RE.ZeInternals import           Text.RE.ZeInternals.SearchReplace.TDFA.Text import           Text.RE.ZeInternals.TDFA-import           Text.RE.ZeInternals.Types.IsRegex import           Text.Regex.Base import qualified Text.Regex.TDFA               as TDFA @@ -102,7 +128,7 @@ (*=~/) = flip searchReplaceAll  -- | search and replace the first occurrence only (if any) in the input text--- e.g., to prefix the first string of four hex digits in the imput text,+-- e.g., to prefix the first string of four hex digits in the input text, -- if any, with @0x@: -- --  @(?=~\/ [ed|[0-9A-Fa-f]{4}\/\/\/0x$0|])@@@ -110,22 +136,20 @@ (?=~/) :: T.Text -> SearchReplace RE T.Text -> T.Text (?=~/) = flip searchReplaceFirst --- | the regex-base polymorphic match operator+-- | the `regex-base` polymorphic match operator (=~) :: ( Typeable a         , RegexContext TDFA.Regex T.Text a-        , RegexMaker   TDFA.Regex TDFA.CompOption TDFA.ExecOption String         )      => T.Text      -> RE      -> a (=~) bs rex = addCaptureNames (reCaptureNames rex) $ match (reRegex rex) bs --- | the regex-base monadic, polymorphic match operator+-- | the `regex-base` monadic, polymorphic match operator (=~~) :: ( Monad m          , Functor m          , Typeable a          , RegexContext TDFA.Regex T.Text a-         , RegexMaker   TDFA.Regex TDFA.CompOption TDFA.ExecOption String          )       => T.Text       -> RE@@ -142,6 +166,11 @@ -- $tutorial -- We have a regex tutorial at <http://tutorial.regex.uk>. +-- $macros+-- There are a number of RE macros and corresponding Haskell parsers+-- for parsing the matched text into appropriate Haskell types. See+-- the [Macros Tables](http://regex.uk/macros) for details.+ -- $options -- You can specify different compilation options by appending a -- to the name of an [re| ... |] or [ed| ... \/\/\/ ... |] quasi quoter@@ -152,7 +181,7 @@ -- -- will replace a @foo@ suffix of the argument text, of any -- capitalisation, with a (lower case) @bar@. If you need to specify the--- options dynamically, use the @[re_| ... |]@ and @[red_| ... \/\/\/ ... |]@+-- options dynamically, use the @[re_| ... |]@ and @[ed_| ... \/\/\/ ... |]@ -- quasi quoters, which generate functions that take an 'IsOption' option -- (e.g., a 'SimpleReOptions' value) and yields a 'RE' or 'SearchReplace' -- as apropriate. For example if you have a 'SimpleReOptions' value in@@ -171,3 +200,18 @@ -- $ed -- The @[ed|.*\/\/\/foo|]@ quasi quoters, with variants for specifing different -- options to the RE compiler (see "Text.RE.REOptions").++-- $ed+-- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for example,+--+--  @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@+--+-- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date+-- into a DD\/MM\/YYYY format date.+--+-- The only difference betweem these quasi quoters is the RE options that are set,+-- using the same conventions as the @[re| ... |]@ quasi quoters.++-- $isregex+-- The 'IsRegex' class is used to abstact over the different regex back ends and+-- the text types they work with -- see "Text.RE.Tools.IsRegex" for details.

@@ -20,18 +20,21 @@   -- * The 'SearchReplace' Operators   , (*=~/)   , (?=~/)-  -- * Matches+  -- * The 'Matches' Type   , Matches   , matchesSource   , allMatches   , anyMatches   , countMatches   , matches-  -- * Match+  -- * The 'Match' Type   , Match   , matchSource   , matched   , matchedText+  -- * The Macros and Parsers+  -- $macros+  , module Text.RE.TestBench.Parsers   -- * The 'RE' Type   , RE   , reSource@@ -47,16 +50,38 @@   , escape   , escapeWith   , escapeREString-  -- * The Classic rexex-base Match Operators+  -- * The Classic regex-base Match Operators   , (=~)   , (=~~)-  -- * IsRegex-  , IsRegex(..)-  -- * The Quasi Quoters and Minor Functions+  -- * The re Quasi Quoters   -- $re-  , module Text.RE.ZeInternals.TDFA+  , re+  , reMultilineSensitive+  , reMultilineInsensitive+  , reBlockSensitive+  , reBlockInsensitive+  , reMS+  , reMI+  , reBS+  , reBI+  , re_+  -- * The Ed Quasi Quoters   -- $ed-  , module Text.RE.ZeInternals.SearchReplace.TDFA.Text.Lazy+  , edMultilineSensitive+  , edMultilineInsensitive+  , edBlockSensitive+  , edBlockInsensitive+  , ed+  , edMS+  , edMI+  , edBS+  , edBI+  , ed_+  -- * The cp Quasi Quoters+  , cp+  -- * IsRegex+  -- $isregex+  , module Text.RE.Tools.IsRegex   ) where  import qualified Data.Text.Lazy                as TL@@ -64,10 +89,11 @@ import           Prelude.Compat import           Text.RE.REOptions import           Text.RE.Replace-import           Text.RE.ZeInternals.AddCaptureNames+import           Text.RE.TestBench.Parsers+import           Text.RE.Tools.IsRegex+import           Text.RE.ZeInternals import           Text.RE.ZeInternals.SearchReplace.TDFA.Text.Lazy import           Text.RE.ZeInternals.TDFA-import           Text.RE.ZeInternals.Types.IsRegex import           Text.Regex.Base import qualified Text.Regex.TDFA               as TDFA @@ -102,7 +128,7 @@ (*=~/) = flip searchReplaceAll  -- | search and replace the first occurrence only (if any) in the input text--- e.g., to prefix the first string of four hex digits in the imput text,+-- e.g., to prefix the first string of four hex digits in the input text, -- if any, with @0x@: -- --  @(?=~\/ [ed|[0-9A-Fa-f]{4}\/\/\/0x$0|])@@@ -110,22 +136,20 @@ (?=~/) :: TL.Text -> SearchReplace RE TL.Text -> TL.Text (?=~/) = flip searchReplaceFirst --- | the regex-base polymorphic match operator+-- | the `regex-base` polymorphic match operator (=~) :: ( Typeable a         , RegexContext TDFA.Regex TL.Text a-        , RegexMaker   TDFA.Regex TDFA.CompOption TDFA.ExecOption String         )      => TL.Text      -> RE      -> a (=~) bs rex = addCaptureNames (reCaptureNames rex) $ match (reRegex rex) bs --- | the regex-base monadic, polymorphic match operator+-- | the `regex-base` monadic, polymorphic match operator (=~~) :: ( Monad m          , Functor m          , Typeable a          , RegexContext TDFA.Regex TL.Text a-         , RegexMaker   TDFA.Regex TDFA.CompOption TDFA.ExecOption String          )       => TL.Text       -> RE@@ -142,6 +166,11 @@ -- $tutorial -- We have a regex tutorial at <http://tutorial.regex.uk>. +-- $macros+-- There are a number of RE macros and corresponding Haskell parsers+-- for parsing the matched text into appropriate Haskell types. See+-- the [Macros Tables](http://regex.uk/macros) for details.+ -- $options -- You can specify different compilation options by appending a -- to the name of an [re| ... |] or [ed| ... \/\/\/ ... |] quasi quoter@@ -152,7 +181,7 @@ -- -- will replace a @foo@ suffix of the argument text, of any -- capitalisation, with a (lower case) @bar@. If you need to specify the--- options dynamically, use the @[re_| ... |]@ and @[red_| ... \/\/\/ ... |]@+-- options dynamically, use the @[re_| ... |]@ and @[ed_| ... \/\/\/ ... |]@ -- quasi quoters, which generate functions that take an 'IsOption' option -- (e.g., a 'SimpleReOptions' value) and yields a 'RE' or 'SearchReplace' -- as apropriate. For example if you have a 'SimpleReOptions' value in@@ -171,3 +200,18 @@ -- $ed -- The @[ed|.*\/\/\/foo|]@ quasi quoters, with variants for specifing different -- options to the RE compiler (see "Text.RE.REOptions").++-- $ed+-- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for example,+--+--  @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@+--+-- represents a @SearchReplace@ that will convert a YYYY-MM-DD format date+-- into a DD\/MM\/YYYY format date.+--+-- The only difference betweem these quasi quoters is the RE options that are set,+-- using the same conventions as the @[re| ... |]@ quasi quoters.++-- $isregex+-- The 'IsRegex' class is used to abstact over the different regex back ends and+-- the text types they work with -- see "Text.RE.Tools.IsRegex" for details.

@@ -3,6 +3,9 @@  module Text.RE.TestBench   (+  -- * The Test Bench Tutorial+  -- $tutorial+   -- * The Test Bench     MacroEnv   , MacroDescriptor(..)@@ -19,34 +22,23 @@   , formatMacroSummary   , formatMacroSources   , formatMacroSource+  , mdRegexSource   -- ** Formatting Macros   , testMacroEnv   , runTests   , runTests'-  -- * Parsing-  , parseInteger-  , parseHex-  , parseDouble-  , parseString-  , parseSimpleString-  , parseDate-  , parseSlashesDate-  , parseTimeOfDay-  , parseTimeZone-  , parseDateTime-  , parseDateTime8601-  , parseDateTimeCLF-  , parseShortMonth-  , shortMonthArray-  , IPV4Address-  , parseIPv4Address-  , Severity(..)-  , parseSeverity-  , severityKeywords-  -- * Text.RE-  , module Text.RE+  -- * The Parsers+  , module Text.RE.TestBench.Parsers+  -- * The Match Type+  , Match   ) where -import           Text.RE+import           Text.RE.TestBench.Parsers import           Text.RE.ZeInternals.TestBench-import           Text.RE.ZeInternals.TestBench.Parsers+import           Text.RE.ZeInternals.Types.Match++-- $tutorial+-- This API module provides a test bench for developing, documenting and+-- testing regex RE macros.+--+-- See the tutorials at http://re-tutorial-testbench.regex.uk

@@ -0,0 +1,23 @@+module Text.RE.TestBench.Parsers+  ( parseInteger+  , parseHex+  , parseDouble+  , parseString+  , parseSimpleString+  , parseDate+  , parseSlashesDate+  , parseTimeOfDay+  , parseTimeZone+  , parseDateTime+  , parseDateTime8601+  , parseDateTimeCLF+  , parseShortMonth+  , shortMonthArray+  , IPV4Address+  , parseIPv4Address+  , Severity(..)+  , parseSeverity+  , severityKeywords+  ) where++import           Text.RE.ZeInternals.TestBench.Parsers

@@ -1,7 +1,9 @@+{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}+ module Text.RE.Tools   (-  -- * The Tools-  -- $tools+  -- * The Tools Tutorial+  -- $tutorial    -- * Sed     sed@@ -25,6 +27,9 @@   , findMatches_'   -- * IsRegex   , IsRegex(..)+  , SearchReplace(..)+  , searchReplaceAll+  , searchReplaceFirst   -- * Edit   , Edits(..)   , Edit(..)@@ -37,13 +42,19 @@   , firstLine   , getLineNo   , lineNo-  -- * Text.RE-  , module Text.RE+  -- * Replace+  , module Text.RE.Replace   ) where -import           Text.RE+import           Text.RE.Replace import           Text.RE.Tools.Edit import           Text.RE.Tools.Find import           Text.RE.Tools.Grep import           Text.RE.Tools.Lex import           Text.RE.Tools.Sed++-- $tutorial+-- This API module provides some familiar RE tools on top of the core+-- package functions and types.+--+-- See the Regex Tools tutorial at http://re-tutorial-tools.regex.uk

@@ -10,52 +10,63 @@ module Text.RE.Tools.Edit   (   -- * Editing+  -- $tutorial     Edits(..)   , Edit(..)-  , SearchReplace(..)   , LineEdit(..)   , applyEdits   , applyEdit   , applyLineEdit+  -- * IsRegex+  , IsRegex(..)+  , SearchReplace(..)+  , searchReplaceAll+  , searchReplaceFirst   -- * LineNo   , LineNo(..)   , firstLine   , getLineNo   , lineNo-  -- * Text.RE-  , module Text.RE+  -- * Replace+  , module Text.RE.Replace   ) where  import           Data.Maybe import           Prelude.Compat-import           Text.RE import           Text.RE.Replace-import           Text.RE.ZeInternals.Types.IsRegex+import           Text.RE.Tools.IsRegex import           Text.RE.ZeInternals.Types.LineNo+\end{code}  +\begin{code} -- | an 'Edits' script will, for each line in the file, either perform -- the action selected by the first RE in the list, or perform all of the -- actions on line, arranged as a pipeline data Edits m re s-  = Select ![Edit m re s]-  | Pipe   ![Edit m re s]+  = Select ![Edit m re s]   -- ^ for each line select the first @Edit@ to match each line and edit the line with it+  | Pipe   ![Edit m re s]   -- ^ for each line apply every edit that matches in turn to the line  -- | each Edit action specifies how the match should be processed data Edit m re s   = Template !(SearchReplace re s)+        -- ^ replace the match with this template text, substituting ${capture} as apropriate   | Function !re REContext !(LineNo->Match s->RELocation->Capture s->m (Maybe s))+        -- ^ use this function to replace the 'REContext' specified captures in each line matched   | LineEdit !re           !(LineNo->Matches s->m (LineEdit s))+        -- ^ use this function to edit each line matched  -- | a LineEdit is the most general action thar can be performed on a line -- and is the only means of deleting a line data LineEdit s-  = NoEdit-  | ReplaceWith !s-  | Delete+  = NoEdit                  -- ^ do not edit this line but leave as is+  | ReplaceWith !s          -- ^ replace the line with this text (terminating newline should not be included)+  | Delete                  -- ^ delete the this line altogether   deriving (Functor,Show)+\end{code}  +\begin{code} -- | apply an 'Edit' script to a single line applyEdits :: (IsRegex re s,Monad m,Functor m)            => LineNo@@ -122,4 +133,12 @@     f edit act = do       s <- act       fromMaybe s <$> applyEdit id lno edit s+\end{code}++\begin{code}+-- $tutorial+-- The Edit toolkit looks for REs that match a text and runs the+-- associated actions.+--+-- See the Regex Tools tutorial at http://re-tutorial-tools.regex.uk \end{code}

@@ -7,19 +7,29 @@ #endif  module Text.RE.Tools.Find-  ( FindMethods(..)+  (+  -- * Find+  -- $tutorial+    FindMethods(..)   , findMatches_   , findMatches_'-  -- * Text.RE-  , module Text.RE+  -- * IsRegex+  , IsRegex(..)+  , SearchReplace(..)+  , searchReplaceAll+  , searchReplaceFirst+  -- * Replace+  , module Text.RE.Replace   ) where  import qualified Data.List                      as L import           Prelude.Compat-import           Text.RE import           Text.RE.Replace+import           Text.RE.Tools.IsRegex+\end{code}  +\begin{code} -- | as we don't want the @directory@ and FilePath dependencies -- we will abstract the three calls we need into this record type data FindMethods s =@@ -31,8 +41,10 @@                                               -- System.Directory     , combineDM            :: s -> s -> s     -- ^ </> from System.FilePath     }+\end{code}  +\begin{code} -- | recursively list all files whose filename matches given RE, -- sorting the list into ascending order; if the argument path has a -- trailing '/' then it will be removed@@ -68,4 +80,12 @@   where     abs_path fn_ = fp `combineDM` fn_     ordinary fn_ = not $ fn_ `elem` [packR ".",packR ".."]+\end{code}++\begin{code}+-- $tutorial+-- The Find toolkit traverses directory trees invoking actions for each+-- file that matches a RE.+--+-- See the Regex Tools tutorial at http://re-tutorial-tools.regex.uk \end{code}

@@ -5,7 +5,10 @@ {-# LANGUAGE CPP                        #-}  module Text.RE.Tools.Grep-  ( grep+  (+  -- Grep+  -- $tutorial+    grep   , Verbosity(..)   , Line(..)   , grepLines@@ -16,33 +19,42 @@   , linesMatched   -- * IsRegex   , IsRegex(..)+  , SearchReplace(..)+  , searchReplaceAll+  , searchReplaceFirst   -- * LineNo   , LineNo(..)   , firstLine   , getLineNo   , lineNo-  -- * Text.RE-  , module Text.RE+  -- * Replace+  , module Text.RE.Replace   ) where  import qualified Data.ByteString.Lazy.Char8               as LBS import           Prelude.Compat import           Text.Printf-import           Text.RE-import           Text.RE.ZeInternals.Replace+import           Text.RE.Replace+import           Text.RE.Tools.IsRegex import           Text.RE.ZeInternals.Types.LineNo+\end{code}  +\begin{code} -- | operates a bit like classic @grep@ printing out the lines matched grep :: IsRegex re LBS.ByteString => Verbosity -> re -> FilePath -> IO () grep v rex fp = grepLines rex fp >>= putStr . report v+\end{code} +\begin{code} -- | specifies whether to return the linss matched or missed data Verbosity   = LinesMatched   | LinesNotMatched   deriving (Show,Eq,Ord)+\end{code} +\begin{code} -- | 'grepLines' returns a 'Line' for each line in the file, listing all -- of the 'Matches' for that line data Line s =@@ -51,7 +63,9 @@     , getLineMatches :: Matches s -- ^ all the 'Matches' of the RE on this line     }   deriving (Show)+\end{code} +\begin{code} -- | returns a 'Line' for each line in the file, enumerating all of the -- matches for that line grepLines :: IsRegex re LBS.ByteString@@ -59,14 +73,18 @@           -> FilePath           -> IO [Line LBS.ByteString] grepLines rex fp = grepFilter rex <$> LBS.readFile fp+\end{code} +\begin{code} -- | returns a 'Line' for each line in the argument text, enumerating -- all of the matches for that line grepFilter :: IsRegex re s => re -> s -> [Line s] grepFilter rex = grepWithScript [(rex,mk)] . linesR   where     mk i mtchs = Just $ Line i mtchs+\end{code} +\begin{code} -- | a GrepScript lists RE-action associations, with the first RE to match -- a line selecting the action to be executed on each line in the file type GrepScript re s t = [(re,LineNo -> Matches s -> Maybe t)]@@ -99,4 +117,11 @@     f = case v of       LinesMatched    -> id       LinesNotMatched -> not+\end{code}++\begin{code}+-- $tutorial+-- The Grep toolkit matches REs againt each line of a text.+--+-- See the Regex Tools tutorial at http://re-tutorial-tools.regex.uk \end{code}

@@ -0,0 +1,17 @@+module Text.RE.Tools.IsRegex+  (+  -- * IsRegex+  -- $tutorial+    IsRegex(..)+  , SearchReplace(..)+  , searchReplaceAll+  , searchReplaceFirst+  ) where++import Text.RE.ZeInternals.Types.IsRegex++-- $tutorial+-- The @IsRegex@ class abstracts over each regex back end and the+-- text types they support allowing general regex tools to constructed.+--+-- See the Regex Tools tutorial at http://re-tutorial-tools.regex.uk

@@ -1,11 +1,24 @@ module Text.RE.Tools.Lex-  ( alex+  (+  -- * Find+  -- $tutorial+    alex   , alex'   -- * IsRegex   , IsRegex(..)-  -- * Text.RE-  , module Text.RE+  , SearchReplace(..)+  , searchReplaceAll+  , searchReplaceFirst+  -- * Replace+  , module Text.RE.Replace   ) where -import           Text.RE+import           Text.RE.Replace+import           Text.RE.Tools.IsRegex import           Text.RE.ZeInternals.Tools.Lex++-- $tutorial+-- The Lex toolkit uses REs to identify tokens in a file, returning a+-- list of tokens.+--+-- See the Regex Tools tutorial at http://re-tutorial-tools.regex.uk

@@ -8,10 +8,11 @@ #endif  module Text.RE.Tools.Sed-  ( sed+  (+  -- * Sed+  -- $tutorial+    sed   , sed'-  -- * IsRegex-  , IsRegex(..)   -- * Edit   , Edits(..)   , Edit(..)@@ -19,22 +20,28 @@   , applyEdits   , applyEdit   , applyLineEdit+  -- * IsRegex+  , IsRegex(..)+  , SearchReplace(..)+  , searchReplaceAll+  , searchReplaceFirst   -- * LineNo   , LineNo(..)   , firstLine   , getLineNo   , lineNo-  -- * Text.RE-  , module Text.RE+  -- * Replace+  , module Text.RE.Replace   ) where  import qualified Data.ByteString.Lazy.Char8               as LBS import           Prelude.Compat-import           Text.RE import           Text.RE.Replace import           Text.RE.Tools.Edit+\end{code}  +\begin{code} -- | read a file, apply an 'Edits' script to each line it and -- write the file out again; "-" is used to indicate standard input -- standard output as appropriate@@ -43,25 +50,31 @@     -> FilePath     -> FilePath     -> IO ()-sed as i_fp o_fp = do+sed escr i_fp o_fp = do   lns  <- LBS.lines <$> read_file i_fp   lns' <- sequence-    [ applyEdits lno as s+    [ applyEdits lno escr s         | (lno,s)<-zip [firstLine..] lns         ]   write_file o_fp $ LBS.concat lns'+\end{code} ++\begin{code} -- | apply an 'Edits' script to each line of the argument text sed' :: (IsRegex re a,Monad m,Functor m)      => Edits m re a      -> a      -> m a-sed' as t = do+sed' escr t = do   mconcat <$> sequence-    [ applyEdits lno as s+    [ applyEdits lno escr s         | (lno,s)<-zip [firstLine..] $ linesR t         ]+\end{code} ++\begin{code} read_file :: FilePath -> IO LBS.ByteString read_file "-" = LBS.getContents read_file fp  = LBS.readFile fp@@ -69,4 +82,14 @@ write_file :: FilePath -> LBS.ByteString ->IO () write_file "-" = LBS.putStr write_file fp  = LBS.writeFile fp+\end{code}+++\begin{code}+-- $tutorial+-- The Sed toolkit applyies @Edits@ scripts to each line+-- of a text, running the actions and adjusting each line+-- accordingly.+--+-- See the Regex Tools tutorial at http://re-tutorial-tools.regex.uk \end{code}

@@ -2,14 +2,57 @@   (   -- * The regex Internal Modules   -- $internals++  -- * Text.RE.ZeInternals.AddCaptureNames+    addCaptureNames+  , addCaptureNamesToMatches+  , addCaptureNamesToMatch+  -- * Text.RE.ZeInternals.EscapeREString+  , escapeREString+  -- * Text.RE.ZeInternals.NamedCaptures+  , cp+  , extractNamedCaptures+  , idFormatTokenREOptions+  , Token+  , validToken+  , formatTokens+  , formatTokens'+  , formatTokens0+  , scan+  -- * Text.RE.ZeInternals.Replace+  , expandMacros+  -- * Text.RE.ZeInternals.PreludeMacros+  , PreludeMacro(..)+  , presentPreludeMacro+  , preludeMacros+  , preludeMacroTable+  , preludeMacroSummary+  , preludeMacroSources+  , preludeMacroSource+  , preludeMacroEnv+  -- * Text.RE.ZeInternals.SearchReplace+  , unsafeCompileSearchReplace_+  , compileSearchReplace_+  , compileSearchAndReplace_+  -- * Text.RE.ZeInternals.QQ+  , QQFailure(..)+  , qq0+  -- * Text.RE.ZeInternals.TestBench+  , mkTDFA+  , mkPCRE+  , badMacros   ) where +import           Text.RE.ZeInternals.AddCaptureNames+import           Text.RE.ZeInternals.EscapeREString+import           Text.RE.ZeInternals.NamedCaptures+import           Text.RE.ZeInternals.PreludeMacros+import           Text.RE.ZeInternals.QQ+import           Text.RE.ZeInternals.Replace+import           Text.RE.ZeInternals.SearchReplace+import           Text.RE.ZeInternals.TestBench+ -- $internals--- The modules under 'ZeInternals' do not belong to the /official/ regex--- API, though their contents will so belong if they are listed in the outside--- `Text.RE` modules. This doesn't mean that they cannot be used but be aware--- that they may not be as stable or as well documented as the official API--- modules.------ If you do notice anything in here that you think we have missed that--- should be listed in the official API then please drop us a line.+-- This module contains just what the test suite (re-tests) in regex-examples+-- needs from the package internals to do its job and the ZeInternals+-- types and functions needed by the regex-with-pcre package

@@ -36,7 +36,9 @@ import           Text.Regex.TDFA  --- | quasi quoter for CaptureID ([cp|0|],[cp|y|], etc.)+-- | quasi quoter for CaptureID: @[cp|0|]@, @[cp|0|]@, etc.,+-- indexing captures by classic positional numbers, and @[cp|foo|]@,+-- etc., referencing a named capture @[re| ... ${foo}( ... ) ... |]@. cp :: QuasiQuoter cp =     (qq0 "cp")@@ -115,7 +117,7 @@ \begin{code} -- | scan a RE string into a list of RE Token scan :: String -> [Token]-scan = alex' match al oops+scan = alex' match al $ oops "top"   where     al :: [(Regex,Match String->Maybe Token)]     al =@@ -131,11 +133,11 @@     x_1     = captureText $ IsCaptureOrdinal $ CaptureOrdinal 1      s2c [c] = c-    s2c _   = error "scan:s2c:internal error"+    s2c _   = oops "s2c"      mk s f  = (either error id $ makeRegexM s,Just . f) -    oops    = error "reScanner"+    oops  m = error $ "NamedCaptures.scan: " ++ m \end{code}  

@@ -242,7 +242,7 @@     , macroCounterSamples = counter_samples     , macroTestResults    = []     , macroParser          = Just "parseInteger"-    , macroDescription     = "a decimal integer"+    , macroDescription     = "a decimal natural number"     }   where     samples :: [(String,Double)]@@ -315,7 +315,7 @@       , macroCounterSamples = counter_samples       , macroTestResults    = []       , macroParser          = Just "parseSimpleString"-      , macroDescription     = "a decimal integer"+      , macroDescription     = "a simple quoted string"       }   where     samples :: [(String,String)]

@@ -7,17 +7,15 @@ #endif  module Text.RE.ZeInternals.SearchReplace.TDFA.ByteString-  ( -- * The ed Quasi Quoters-    -- $qq-    ed-  , edMS-  , edMI-  , edBS-  , edBI+  ( ed   , edMultilineSensitive   , edMultilineInsensitive   , edBlockSensitive   , edBlockInsensitive+  , edMS+  , edMI+  , edBS+  , edBI   , ed_   ) where @@ -25,47 +23,61 @@ import           Language.Haskell.TH import           Language.Haskell.TH.Quote import           Text.RE.REOptions+import           Text.RE.Tools.IsRegex import           Text.RE.ZeInternals.SearchReplace.TDFAEdPrime import           Text.RE.ZeInternals.TDFA-import           Text.RE.ZeInternals.Types.SearchReplace +-- | @[ed| ... \/\/\/ ... |]@, is equivalent to @[edMultilineSensitive| ... \/\/\/ ... |]@,+-- compiling a case-sensitive, multi-line 'SearchReplace'+ed                      :: QuasiQuoter+ed                       = ed' sr_cast $ Just minBound -ed-  , edMS-  , edMI-  , edBS-  , edBI-  , edMultilineSensitive-  , edMultilineInsensitive-  , edBlockSensitive-  , edBlockInsensitive-  , ed_ :: QuasiQuoter+-- | @[edMultilineSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, multi-line 'SearchReplace' template+edMultilineSensitive    :: QuasiQuoter+edMultilineSensitive     = ed' sr_cast $ Just  MultilineSensitive -ed                       = ed' sr_cast $ Just minBound+-- | @[edMultilineInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, multi-line 'SearchReplace' template+edMultilineInsensitive  :: QuasiQuoter+edMultilineInsensitive   = ed' sr_cast $ Just  MultilineInsensitive++-- | @[edBlockSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, non-multi-line 'SearchReplace' template+edBlockSensitive        :: QuasiQuoter+edBlockSensitive         = ed' sr_cast $ Just  BlockSensitive++-- | @[edBlockInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, non-multi-line 'SearchReplace' template+edBlockInsensitive      :: QuasiQuoter+edBlockInsensitive       = ed' sr_cast $ Just  BlockInsensitive++-- | @[edMS| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineSensitive| ... \/\/\/ ... |]@+edMS                    :: QuasiQuoter edMS                     = edMultilineSensitive++-- | @[edMI| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineInsensitive| ... \/\/\/ ... |]@+edMI                    :: QuasiQuoter edMI                     = edMultilineInsensitive++-- | @[edBS| ... \/\/\/ ... |]@ is a shorthand for @[edBlockSensitive| ... \/\/\/ ... |]@+edBS                    :: QuasiQuoter edBS                     = edBlockSensitive++-- | @[edBI| ... \/\/\/ ... |]@ is a shorthand for @[edBlockInsensitive| ... \/\/\/ ... |]@+edBI                    :: QuasiQuoter 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_| ... \/\/\/ ... |]@ compiles a 'SearchReplace' template to produce a function that+-- takes the RE options (e.g., a 'SimpleREOptions' value) and yields the+-- 'SearchReplace' template compiled with those options. For example,+--+--   @s *=~/ [ed_|${hex}([0-9a-f]+)\/\/\/0x${hex}|] MultilineInsensitive@+--+-- prefixes the hexadecimal digit strings in s with @0x@, allowing for+-- upper- or lower-case hex didgits (which is entirely equivalent+-- in this example to just using @[edMultilineInsensitive|[0-9a-f]+|]@).+ed_                     :: QuasiQuoter 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|]---- $qq--- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for exaple,------  @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@------ represents a @SearchReplace@ that will convert a YYYY-MM-DD format date--- into a DD\/MM\/YYYY format date.------ The only difference betweem these quasi quoters is the RE options that are set:--- see the "Text.RE.REOptions" documentation for details.---+fn_cast = [|\f x -> f x :: SearchReplace RE B.ByteString|]

@@ -7,17 +7,15 @@ #endif  module Text.RE.ZeInternals.SearchReplace.TDFA.ByteString.Lazy-  ( -- * The ed Quasi Quoters-    -- $qq-    ed-  , edMS-  , edMI-  , edBS-  , edBI+  ( ed   , edMultilineSensitive   , edMultilineInsensitive   , edBlockSensitive   , edBlockInsensitive+  , edMS+  , edMI+  , edBS+  , edBI   , ed_   ) where @@ -25,47 +23,61 @@ import           Language.Haskell.TH import           Language.Haskell.TH.Quote import           Text.RE.REOptions+import           Text.RE.Tools.IsRegex import           Text.RE.ZeInternals.SearchReplace.TDFAEdPrime import           Text.RE.ZeInternals.TDFA-import           Text.RE.ZeInternals.Types.SearchReplace +-- | @[ed| ... \/\/\/ ... |]@, is equivalent to @[edMultilineSensitive| ... \/\/\/ ... |]@,+-- compiling a case-sensitive, multi-line 'SearchReplace'+ed                      :: QuasiQuoter+ed                       = ed' sr_cast $ Just minBound -ed-  , edMS-  , edMI-  , edBS-  , edBI-  , edMultilineSensitive-  , edMultilineInsensitive-  , edBlockSensitive-  , edBlockInsensitive-  , ed_ :: QuasiQuoter+-- | @[edMultilineSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, multi-line 'SearchReplace' template+edMultilineSensitive    :: QuasiQuoter+edMultilineSensitive     = ed' sr_cast $ Just  MultilineSensitive -ed                       = ed' sr_cast $ Just minBound+-- | @[edMultilineInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, multi-line 'SearchReplace' template+edMultilineInsensitive  :: QuasiQuoter+edMultilineInsensitive   = ed' sr_cast $ Just  MultilineInsensitive++-- | @[edBlockSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, non-multi-line 'SearchReplace' template+edBlockSensitive        :: QuasiQuoter+edBlockSensitive         = ed' sr_cast $ Just  BlockSensitive++-- | @[edBlockInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, non-multi-line 'SearchReplace' template+edBlockInsensitive      :: QuasiQuoter+edBlockInsensitive       = ed' sr_cast $ Just  BlockInsensitive++-- | @[edMS| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineSensitive| ... \/\/\/ ... |]@+edMS                    :: QuasiQuoter edMS                     = edMultilineSensitive++-- | @[edMI| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineInsensitive| ... \/\/\/ ... |]@+edMI                    :: QuasiQuoter edMI                     = edMultilineInsensitive++-- | @[edBS| ... \/\/\/ ... |]@ is a shorthand for @[edBlockSensitive| ... \/\/\/ ... |]@+edBS                    :: QuasiQuoter edBS                     = edBlockSensitive++-- | @[edBI| ... \/\/\/ ... |]@ is a shorthand for @[edBlockInsensitive| ... \/\/\/ ... |]@+edBI                    :: QuasiQuoter 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_| ... \/\/\/ ... |]@ compiles a 'SearchReplace' template to produce a function that+-- takes the RE options (e.g., a 'SimpleREOptions' value) and yields the+-- 'SearchReplace' template compiled with those options. For example,+--+--   @s *=~/ [ed_|${hex}([0-9a-f]+)\/\/\/0x${hex}|] MultilineInsensitive@+--+-- prefixes the hexadecimal digit strings in s with @0x@, allowing for+-- upper- or lower-case hex didgits (which is entirely equivalent+-- in this example to just using @[edMultilineInsensitive|[0-9a-f]+|]@).+ed_                     :: QuasiQuoter 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|]---- $qq--- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for exaple,------  @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@------ represents a @SearchReplace@ that will convert a YYYY-MM-DD format date--- into a DD\/MM\/YYYY format date.------ The only difference betweem these quasi quoters is the RE options that are set:--- see the "Text.RE.REOptions" documentation for details.---+fn_cast = [|\f x -> f x :: SearchReplace RE LBS.ByteString|]

@@ -7,17 +7,15 @@ #endif  module Text.RE.ZeInternals.SearchReplace.TDFA.Sequence-  ( -- * The ed Quasi Quoters-    -- $qq-    ed-  , edMS-  , edMI-  , edBS-  , edBI+  ( ed   , edMultilineSensitive   , edMultilineInsensitive   , edBlockSensitive   , edBlockInsensitive+  , edMS+  , edMI+  , edBS+  , edBI   , ed_   ) where @@ -25,47 +23,61 @@ import           Language.Haskell.TH import           Language.Haskell.TH.Quote import           Text.RE.REOptions+import           Text.RE.Tools.IsRegex import           Text.RE.ZeInternals.SearchReplace.TDFAEdPrime import           Text.RE.ZeInternals.TDFA-import           Text.RE.ZeInternals.Types.SearchReplace +-- | @[ed| ... \/\/\/ ... |]@, is equivalent to @[edMultilineSensitive| ... \/\/\/ ... |]@,+-- compiling a case-sensitive, multi-line 'SearchReplace'+ed                      :: QuasiQuoter+ed                       = ed' sr_cast $ Just minBound -ed-  , edMS-  , edMI-  , edBS-  , edBI-  , edMultilineSensitive-  , edMultilineInsensitive-  , edBlockSensitive-  , edBlockInsensitive-  , ed_ :: QuasiQuoter+-- | @[edMultilineSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, multi-line 'SearchReplace' template+edMultilineSensitive    :: QuasiQuoter+edMultilineSensitive     = ed' sr_cast $ Just  MultilineSensitive -ed                       = ed' sr_cast $ Just minBound+-- | @[edMultilineInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, multi-line 'SearchReplace' template+edMultilineInsensitive  :: QuasiQuoter+edMultilineInsensitive   = ed' sr_cast $ Just  MultilineInsensitive++-- | @[edBlockSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, non-multi-line 'SearchReplace' template+edBlockSensitive        :: QuasiQuoter+edBlockSensitive         = ed' sr_cast $ Just  BlockSensitive++-- | @[edBlockInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, non-multi-line 'SearchReplace' template+edBlockInsensitive      :: QuasiQuoter+edBlockInsensitive       = ed' sr_cast $ Just  BlockInsensitive++-- | @[edMS| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineSensitive| ... \/\/\/ ... |]@+edMS                    :: QuasiQuoter edMS                     = edMultilineSensitive++-- | @[edMI| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineInsensitive| ... \/\/\/ ... |]@+edMI                    :: QuasiQuoter edMI                     = edMultilineInsensitive++-- | @[edBS| ... \/\/\/ ... |]@ is a shorthand for @[edBlockSensitive| ... \/\/\/ ... |]@+edBS                    :: QuasiQuoter edBS                     = edBlockSensitive++-- | @[edBI| ... \/\/\/ ... |]@ is a shorthand for @[edBlockInsensitive| ... \/\/\/ ... |]@+edBI                    :: QuasiQuoter 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_| ... \/\/\/ ... |]@ compiles a 'SearchReplace' template to produce a function that+-- takes the RE options (e.g., a 'SimpleREOptions' value) and yields the+-- 'SearchReplace' template compiled with those options. For example,+--+--   @s *=~/ [ed_|${hex}([0-9a-f]+)\/\/\/0x${hex}|] MultilineInsensitive@+--+-- prefixes the hexadecimal digit strings in s with @0x@, allowing for+-- upper- or lower-case hex didgits (which is entirely equivalent+-- in this example to just using @[edMultilineInsensitive|[0-9a-f]+|]@).+ed_                     :: QuasiQuoter 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)|]---- $qq--- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for exaple,------  @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@------ represents a @SearchReplace@ that will convert a YYYY-MM-DD format date--- into a DD\/MM\/YYYY format date.------ The only difference betweem these quasi quoters is the RE options that are set:--- see the "Text.RE.REOptions" documentation for details.---+fn_cast = [|\f x -> f x :: SearchReplace RE (S.Seq Char)|]

@@ -7,17 +7,15 @@ #endif  module Text.RE.ZeInternals.SearchReplace.TDFA.String-  ( -- * The ed Quasi Quoters-    -- $qq-    ed-  , edMS-  , edMI-  , edBS-  , edBI+  ( ed   , edMultilineSensitive   , edMultilineInsensitive   , edBlockSensitive   , edBlockInsensitive+  , edMS+  , edMI+  , edBS+  , edBI   , ed_   ) where @@ -25,47 +23,61 @@ import           Language.Haskell.TH import           Language.Haskell.TH.Quote import           Text.RE.REOptions+import           Text.RE.Tools.IsRegex import           Text.RE.ZeInternals.SearchReplace.TDFAEdPrime import           Text.RE.ZeInternals.TDFA-import           Text.RE.ZeInternals.Types.SearchReplace +-- | @[ed| ... \/\/\/ ... |]@, is equivalent to @[edMultilineSensitive| ... \/\/\/ ... |]@,+-- compiling a case-sensitive, multi-line 'SearchReplace'+ed                      :: QuasiQuoter+ed                       = ed' sr_cast $ Just minBound -ed-  , edMS-  , edMI-  , edBS-  , edBI-  , edMultilineSensitive-  , edMultilineInsensitive-  , edBlockSensitive-  , edBlockInsensitive-  , ed_ :: QuasiQuoter+-- | @[edMultilineSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, multi-line 'SearchReplace' template+edMultilineSensitive    :: QuasiQuoter+edMultilineSensitive     = ed' sr_cast $ Just  MultilineSensitive -ed                       = ed' sr_cast $ Just minBound+-- | @[edMultilineInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, multi-line 'SearchReplace' template+edMultilineInsensitive  :: QuasiQuoter+edMultilineInsensitive   = ed' sr_cast $ Just  MultilineInsensitive++-- | @[edBlockSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, non-multi-line 'SearchReplace' template+edBlockSensitive        :: QuasiQuoter+edBlockSensitive         = ed' sr_cast $ Just  BlockSensitive++-- | @[edBlockInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, non-multi-line 'SearchReplace' template+edBlockInsensitive      :: QuasiQuoter+edBlockInsensitive       = ed' sr_cast $ Just  BlockInsensitive++-- | @[edMS| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineSensitive| ... \/\/\/ ... |]@+edMS                    :: QuasiQuoter edMS                     = edMultilineSensitive++-- | @[edMI| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineInsensitive| ... \/\/\/ ... |]@+edMI                    :: QuasiQuoter edMI                     = edMultilineInsensitive++-- | @[edBS| ... \/\/\/ ... |]@ is a shorthand for @[edBlockSensitive| ... \/\/\/ ... |]@+edBS                    :: QuasiQuoter edBS                     = edBlockSensitive++-- | @[edBI| ... \/\/\/ ... |]@ is a shorthand for @[edBlockInsensitive| ... \/\/\/ ... |]@+edBI                    :: QuasiQuoter 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_| ... \/\/\/ ... |]@ compiles a 'SearchReplace' template to produce a function that+-- takes the RE options (e.g., a 'SimpleREOptions' value) and yields the+-- 'SearchReplace' template compiled with those options. For example,+--+--   @s *=~/ [ed_|${hex}([0-9a-f]+)\/\/\/0x${hex}|] MultilineInsensitive@+--+-- prefixes the hexadecimal digit strings in s with @0x@, allowing for+-- upper- or lower-case hex didgits (which is entirely equivalent+-- in this example to just using @[edMultilineInsensitive|[0-9a-f]+|]@).+ed_                     :: QuasiQuoter 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|]---- $qq--- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for exaple,------  @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@------ represents a @SearchReplace@ that will convert a YYYY-MM-DD format date--- into a DD\/MM\/YYYY format date.------ The only difference betweem these quasi quoters is the RE options that are set:--- see the "Text.RE.REOptions" documentation for details.---+fn_cast = [|\f x -> f x :: SearchReplace RE String|]

@@ -7,17 +7,15 @@ #endif  module Text.RE.ZeInternals.SearchReplace.TDFA.Text-  ( -- * The ed Quasi Quoters-    -- $qq-    ed-  , edMS-  , edMI-  , edBS-  , edBI+  ( ed   , edMultilineSensitive   , edMultilineInsensitive   , edBlockSensitive   , edBlockInsensitive+  , edMS+  , edMI+  , edBS+  , edBI   , ed_   ) where @@ -25,47 +23,61 @@ import           Language.Haskell.TH import           Language.Haskell.TH.Quote import           Text.RE.REOptions+import           Text.RE.Tools.IsRegex import           Text.RE.ZeInternals.SearchReplace.TDFAEdPrime import           Text.RE.ZeInternals.TDFA-import           Text.RE.ZeInternals.Types.SearchReplace +-- | @[ed| ... \/\/\/ ... |]@, is equivalent to @[edMultilineSensitive| ... \/\/\/ ... |]@,+-- compiling a case-sensitive, multi-line 'SearchReplace'+ed                      :: QuasiQuoter+ed                       = ed' sr_cast $ Just minBound -ed-  , edMS-  , edMI-  , edBS-  , edBI-  , edMultilineSensitive-  , edMultilineInsensitive-  , edBlockSensitive-  , edBlockInsensitive-  , ed_ :: QuasiQuoter+-- | @[edMultilineSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, multi-line 'SearchReplace' template+edMultilineSensitive    :: QuasiQuoter+edMultilineSensitive     = ed' sr_cast $ Just  MultilineSensitive -ed                       = ed' sr_cast $ Just minBound+-- | @[edMultilineInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, multi-line 'SearchReplace' template+edMultilineInsensitive  :: QuasiQuoter+edMultilineInsensitive   = ed' sr_cast $ Just  MultilineInsensitive++-- | @[edBlockSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, non-multi-line 'SearchReplace' template+edBlockSensitive        :: QuasiQuoter+edBlockSensitive         = ed' sr_cast $ Just  BlockSensitive++-- | @[edBlockInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, non-multi-line 'SearchReplace' template+edBlockInsensitive      :: QuasiQuoter+edBlockInsensitive       = ed' sr_cast $ Just  BlockInsensitive++-- | @[edMS| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineSensitive| ... \/\/\/ ... |]@+edMS                    :: QuasiQuoter edMS                     = edMultilineSensitive++-- | @[edMI| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineInsensitive| ... \/\/\/ ... |]@+edMI                    :: QuasiQuoter edMI                     = edMultilineInsensitive++-- | @[edBS| ... \/\/\/ ... |]@ is a shorthand for @[edBlockSensitive| ... \/\/\/ ... |]@+edBS                    :: QuasiQuoter edBS                     = edBlockSensitive++-- | @[edBI| ... \/\/\/ ... |]@ is a shorthand for @[edBlockInsensitive| ... \/\/\/ ... |]@+edBI                    :: QuasiQuoter 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_| ... \/\/\/ ... |]@ compiles a 'SearchReplace' template to produce a function that+-- takes the RE options (e.g., a 'SimpleREOptions' value) and yields the+-- 'SearchReplace' template compiled with those options. For example,+--+--   @s *=~/ [ed_|${hex}([0-9a-f]+)\/\/\/0x${hex}|] MultilineInsensitive@+--+-- prefixes the hexadecimal digit strings in s with @0x@, allowing for+-- upper- or lower-case hex didgits (which is entirely equivalent+-- in this example to just using @[edMultilineInsensitive|[0-9a-f]+|]@).+ed_                     :: QuasiQuoter ed_                      = ed' fn_cast   Nothing  sr_cast :: Q Exp sr_cast = [|\x -> x :: SearchReplace RE T.Text|]  fn_cast :: Q Exp-fn_cast = [|\x -> x :: SimpleREOptions -> SearchReplace RE T.Text|]---- $qq--- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for exaple,------  @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@------ represents a @SearchReplace@ that will convert a YYYY-MM-DD format date--- into a DD\/MM\/YYYY format date.------ The only difference betweem these quasi quoters is the RE options that are set:--- see the "Text.RE.REOptions" documentation for details.---+fn_cast = [|\f x -> f x :: SearchReplace RE T.Text|]

@@ -7,17 +7,15 @@ #endif  module Text.RE.ZeInternals.SearchReplace.TDFA.Text.Lazy-  ( -- * The ed Quasi Quoters-    -- $qq-    ed-  , edMS-  , edMI-  , edBS-  , edBI+  ( ed   , edMultilineSensitive   , edMultilineInsensitive   , edBlockSensitive   , edBlockInsensitive+  , edMS+  , edMI+  , edBS+  , edBI   , ed_   ) where @@ -25,47 +23,61 @@ import           Language.Haskell.TH import           Language.Haskell.TH.Quote import           Text.RE.REOptions+import           Text.RE.Tools.IsRegex import           Text.RE.ZeInternals.SearchReplace.TDFAEdPrime import           Text.RE.ZeInternals.TDFA-import           Text.RE.ZeInternals.Types.SearchReplace +-- | @[ed| ... \/\/\/ ... |]@, is equivalent to @[edMultilineSensitive| ... \/\/\/ ... |]@,+-- compiling a case-sensitive, multi-line 'SearchReplace'+ed                      :: QuasiQuoter+ed                       = ed' sr_cast $ Just minBound -ed-  , edMS-  , edMI-  , edBS-  , edBI-  , edMultilineSensitive-  , edMultilineInsensitive-  , edBlockSensitive-  , edBlockInsensitive-  , ed_ :: QuasiQuoter+-- | @[edMultilineSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, multi-line 'SearchReplace' template+edMultilineSensitive    :: QuasiQuoter+edMultilineSensitive     = ed' sr_cast $ Just  MultilineSensitive -ed                       = ed' sr_cast $ Just minBound+-- | @[edMultilineInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, multi-line 'SearchReplace' template+edMultilineInsensitive  :: QuasiQuoter+edMultilineInsensitive   = ed' sr_cast $ Just  MultilineInsensitive++-- | @[edBlockSensitive| ... \/\/\/ ... |]@ compiles a case-sensitive, non-multi-line 'SearchReplace' template+edBlockSensitive        :: QuasiQuoter+edBlockSensitive         = ed' sr_cast $ Just  BlockSensitive++-- | @[edBlockInsensitive| ... \/\/\/ ... |]@ compiles a case-insensitive, non-multi-line 'SearchReplace' template+edBlockInsensitive      :: QuasiQuoter+edBlockInsensitive       = ed' sr_cast $ Just  BlockInsensitive++-- | @[edMS| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineSensitive| ... \/\/\/ ... |]@+edMS                    :: QuasiQuoter edMS                     = edMultilineSensitive++-- | @[edMI| ... \/\/\/ ... |]@ is a shorthand for @[edMultilineInsensitive| ... \/\/\/ ... |]@+edMI                    :: QuasiQuoter edMI                     = edMultilineInsensitive++-- | @[edBS| ... \/\/\/ ... |]@ is a shorthand for @[edBlockSensitive| ... \/\/\/ ... |]@+edBS                    :: QuasiQuoter edBS                     = edBlockSensitive++-- | @[edBI| ... \/\/\/ ... |]@ is a shorthand for @[edBlockInsensitive| ... \/\/\/ ... |]@+edBI                    :: QuasiQuoter 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_| ... \/\/\/ ... |]@ compiles a 'SearchReplace' template to produce a function that+-- takes the RE options (e.g., a 'SimpleREOptions' value) and yields the+-- 'SearchReplace' template compiled with those options. For example,+--+--   @s *=~/ [ed_|${hex}([0-9a-f]+)\/\/\/0x${hex}|] MultilineInsensitive@+--+-- prefixes the hexadecimal digit strings in s with @0x@, allowing for+-- upper- or lower-case hex didgits (which is entirely equivalent+-- in this example to just using @[edMultilineInsensitive|[0-9a-f]+|]@).+ed_                     :: QuasiQuoter ed_                      = ed' fn_cast   Nothing  sr_cast :: Q Exp sr_cast = [|\x -> x :: SearchReplace RE TL.Text|]  fn_cast :: Q Exp-fn_cast = [|\x -> x :: SimpleREOptions -> SearchReplace RE TL.Text|]---- $qq--- The -- | the @[ed| ... \/\/\/ ... |]@ quasi quoters; for exaple,------  @[ed|${y}([0-9]{4})-0*${m}([0-9]{2})-0*${d}([0-9]{2})\/\/\/${d}\/${m}\/${y}|])@------ represents a @SearchReplace@ that will convert a YYYY-MM-DD format date--- into a DD\/MM\/YYYY format date.------ The only difference betweem these quasi quoters is the RE options that are set:--- see the "Text.RE.REOptions" documentation for details.---+fn_cast = [|\f x -> f x :: SearchReplace RE TL.Text|]

@@ -18,10 +18,9 @@ import           Prelude.Compat import           Text.RE.REOptions import           Text.RE.Replace-import           Text.RE.ZeInternals.QQ-import           Text.RE.ZeInternals.SearchReplace+import           Text.RE.Tools.IsRegex+import           Text.RE.ZeInternals import           Text.RE.ZeInternals.TDFA-import           Text.RE.ZeInternals.Types.IsRegex   -- | construct a quasi quoter from a casting function and @Just sro@

@@ -30,6 +30,7 @@   , REOptions   , defaultREOptions   , noPreludeREOptions+  , unpackSimpleREOptions   -- * Compiling Regular Expressions   , compileRegex   , compileRegexWith@@ -37,7 +38,7 @@   -- * Compiling Search-Replace Templates   , compileSearchReplace   , compileSearchReplaceWith-  , compileSearchReplaceWithREOptions+  , compileSearchReplaceWithOptions   -- * Escaping String   , escape   , escapeWith@@ -51,7 +52,6 @@   , preludeSummary   , preludeSources   , preludeSource-  , unpackSimpleREOptions   -- * The Quasi Quoters   , re   , reMS@@ -71,15 +71,10 @@ import           Language.Haskell.TH.Quote import           Prelude.Compat import           Text.RE.REOptions-import           Text.RE.ZeInternals.EscapeREString-import           Text.RE.ZeInternals.NamedCaptures-import           Text.RE.ZeInternals.PreludeMacros-import           Text.RE.ZeInternals.QQ-import           Text.RE.ZeInternals.Replace-import           Text.RE.ZeInternals.SearchReplace-import           Text.RE.ZeInternals.TestBench-import           Text.RE.ZeInternals.Types.CaptureID-import           Text.RE.ZeInternals.Types.IsRegex+import           Text.RE.Replace+import           Text.RE.TestBench+import           Text.RE.Tools+import           Text.RE.ZeInternals import           Text.Regex.TDFA  @@ -95,7 +90,7 @@  -- | some functions in the "Text.RE.TestBench" need the back end to -- be passed dynamically as a 'RegexType' parameters: use 'regexType'--- fpr this backend+-- for this regexType :: RegexType regexType =   mkTDFA $ \txt env md -> txt =~ mdRegexSource regexType ExclCaptures env md@@ -227,12 +222,12 @@ -- | compile a SearchReplace template, with general options, generating -- errors if the RE or the template are not well formed, all capture -- references being checked-compileSearchReplaceWithREOptions :: (Monad m,Functor m,IsRegex RE s)-                                  => REOptions-                                  -> String-                                  -> String-                                  -> m (SearchReplace RE s)-compileSearchReplaceWithREOptions os = compileSearchAndReplace_ packR $ compileRegexWithOptions os+compileSearchReplaceWithOptions :: (Monad m,Functor m,IsRegex RE s)+                                => REOptions+                                -> String+                                -> String+                                -> m (SearchReplace RE s)+compileSearchReplaceWithOptions os = compileSearchAndReplace_ packR $ compileRegexWithOptions os   ------------------------------------------------------------------------@@ -312,37 +307,53 @@ -- Quasi Quoters ------------------------------------------------------------------------ --- | the @[re| ... |]@ and @[ed| ... /// ... |]@ quasi quoters-re-  , reMS-  , reMI-  , reBS-  , reBI-  , reMultilineSensitive-  , reMultilineInsensitive-  , reBlockSensitive-  , reBlockInsensitive-  , re_ :: QuasiQuoter-  -- , ed-  -- , edMS-  -- , edMI-  -- , edBS-  -- , edBI-  -- , edMultilineSensitive-  -- , edMultilineInsensitive-  -- , edBlockSensitive-  -- , edBlockInsensitive-  -- , ed_ :: QuasiQuoter-+-- | @[re| ... |]@, is equivalent to @[reMultilineSensitive| ... |]@,+-- compiling a case-sensitive, multi-line RE+re                      :: QuasiQuoter re                       = re' $ Just minBound-reMS                     = reMultilineSensitive-reMI                     = reMultilineInsensitive-reBS                     = reBlockSensitive-reBI                     = reBlockInsensitive++-- | @[reMultilineSensitive| ... |]@, compiles a case-sensitive, multi-line RE+reMultilineSensitive    :: QuasiQuoter reMultilineSensitive     = re' $ Just  MultilineSensitive++-- | @[reMultilineInsensitive| ... |]@, compiles a case-insensitive, multi-line RE+reMultilineInsensitive  :: QuasiQuoter reMultilineInsensitive   = re' $ Just  MultilineInsensitive++-- | @[reMultilineInsensitive| ... |]@, compiles a case-sensitive, non-multi-line RE+reBlockSensitive        :: QuasiQuoter reBlockSensitive         = re' $ Just  BlockSensitive++-- | @[reMultilineInsensitive| ... |]@, compiles a case-insensitive, non-multi-line RE+reBlockInsensitive      :: QuasiQuoter reBlockInsensitive       = re' $ Just  BlockInsensitive++-- | @[reMS| ... |]@ is a shorthand for @[reMultilineSensitive| ... |]@+reMS                     :: QuasiQuoter+reMS                     = reMultilineSensitive++-- | @[reMI| ... |]@ is a shorthand for @[reMultilineInsensitive| ... |]@+reMI                    :: QuasiQuoter+reMI                     = reMultilineInsensitive++-- | @[reBS| ... |]@ is a shorthand for @[reBlockSensitive| ... |]@+reBS                    :: QuasiQuoter+reBS                     = reBlockSensitive++-- | @[reBI| ... |]@ is a shorthand for @[reBlockInsensitive| ... |]@+reBI                    :: QuasiQuoter+reBI                     = reBlockInsensitive++-- | @[re_| ... |]@ compiles a RE to produce a function that takes+-- the RE options (e.g., a 'SimpleREOptions' value) and yields the+-- RE compiled with those options. For example,+--+--   @countMatches $ s *=~ [re_|[0-9a-f]+|] MultilineInsensitive@+--+-- counts the number of hexadecimal digit strings in 's', allowing+-- for upper- or lower-case hex didgits (which is entirely equivalent+-- in this example to just using @[reMultilineInsensitive|[0-9a-f]+|]@).+re_                     :: QuasiQuoter re_                      = re'   Nothing  

@@ -9,8 +9,10 @@ import           Prelude.Compat import           Text.RE.Replace import           Text.RE.ZeInternals.Types.IsRegex+\end{code}  +\begin{code} -- | a simple regex-based scanner interpretter for prototyping -- scanners alex :: IsRegex re s => [(re,Match s->Maybe t)] -> t -> s -> [t]

@@ -37,14 +37,10 @@   deriving (Show,Ord,Eq,Enum,Ix,Num)  -- | look up a 'CaptureID' in the 'CaptureNames' dictionary-unsafeFindCaptureID :: CaptureID -> CaptureNames -> Int-unsafeFindCaptureID cid = either error id . findCaptureID cid---- | look up a 'CaptureID' in the 'CaptureNames' dictionary-findCaptureID :: CaptureID -> CaptureNames -> Either String Int-findCaptureID (IsCaptureOrdinal o) _   = Right $ getCaptureOrdinal o+findCaptureID :: CaptureID -> CaptureNames -> Either String CaptureOrdinal+findCaptureID (IsCaptureOrdinal o) _   = Right o findCaptureID (IsCaptureName    n) hms =-    maybe oops (Right . getCaptureOrdinal) $ HMS.lookup n hms+    maybe oops Right $ HMS.lookup n hms   where     oops = Left $ unlines $       ("lookupCaptureID: " ++ T.unpack t ++ " not found in:") :

@@ -47,7 +47,9 @@   makeSearchReplace   = makeSearchReplaceWith minBound   makeEscaped         = makeEscapedWith       minBound   makeEscapedWith o f = makeRegexWith o . f . packR . escapeREString . unpackR+\end{code} +\begin{code} -- | search and replace all matches in the argument text; e.g., this function -- will convert every YYYY-MM-DD format date in its argument text into a -- DD\/MM\/YYYY date:

@@ -39,10 +39,8 @@ \end{code}  \begin{code}--- | the result of matching a RE to a text once, listing the text that--- was matched and the named captures in the RE and all of the substrings--- matched, with the text captured by the whole RE; a complete failure--- to match will be represented with an empty array (with bounds (0,-1))+-- | the result of matching a RE to a text once (with @?=~@), retaining+-- the text that was matched against data Match a =   Match     { matchSource  :: !a                -- ^ the whole source text@@ -81,7 +79,7 @@ matched :: Match a -> Bool matched = isJust . matchCapture --- | tests whether the RE matched the source text at all+-- | yields the text matched by the RE, Nothing if no match matchedText :: Match a -> Maybe a matchedText = fmap capturedText . matchCapture @@ -90,8 +88,8 @@ matchCapture :: Match a -> Maybe (Capture a) matchCapture = fmap fst . matchCaptures --- | the top-level capture and the sub captures if the text matched--- the RE, Nothing otherwise+-- | the main top-level capture (capture \'0'') and the sub captures+-- if the text matched the RE, @Nothing@ otherwise matchCaptures :: Match a -> Maybe (Capture a,[Capture a]) matchCaptures Match{..} = case rangeSize (bounds matchArray) == 0 of   True  -> Nothing@@ -143,14 +141,14 @@ captureMaybe :: CaptureID -> Match a -> Maybe (Capture a) captureMaybe cid mtch@Match{..} = do   i   <- lookupCaptureID cid mtch-  cap <- case bounds matchArray `inRange` CaptureOrdinal i of-    True  -> Just $ matchArray ! CaptureOrdinal i+  cap <- case bounds matchArray `inRange` i of+    True  -> Just $ matchArray ! i     False -> Nothing   case hasCaptured cap of     True  -> Just cap     False -> Nothing -lookupCaptureID :: CaptureID -> Match a -> Maybe Int+lookupCaptureID :: CaptureID -> Match a -> Maybe CaptureOrdinal lookupCaptureID cid Match{..} =     either (const Nothing) Just $ findCaptureID cid captureNames \end{code}

@@ -26,8 +26,8 @@   \begin{code}--- | the result type to use when every match is needed, not just the--- first match of the RE against the source+-- | the result of matching a RE against a text (with @*=~@), retaining+-- the text that was matched against data Matches a =   Matches     { matchesSource :: !a          -- ^ the source text being matched@@ -54,7 +54,7 @@ countMatches :: Matches a -> Int countMatches = length . allMatches --- | list the Matches+-- | list the texts that Matched matches :: Matches a -> [a] matches = map capturedText . mainCaptures 

@@ -1,15 +0,0 @@--module Text.RE.ZeInternals.Types.SearchReplace-  ( SearchReplace(..)-  ) where---- | contains a compiled RE and replacement template-data SearchReplace re s =-  SearchReplace-    { getSearch   :: !re    -- ^ the RE-    , getTemplate :: !s     -- ^ the replacement template-    }-  deriving (Show)--instance Functor (SearchReplace re) where-  fmap f (SearchReplace re x) = SearchReplace re (f x)

@@ -0,0 +1,23 @@+\begin{code}+module Text.RE.ZeInternals.Types.SearchReplace+  ( SearchReplace(..)+  ) where+\end{code}++\begin{code}+-- | contains a compiled RE and replacement template+data SearchReplace re s =+  SearchReplace+    { getSearch   :: !re    -- ^ the RE to match a string to replace+    , getTemplate :: !s     -- ^ the replacement template with ${cap}+                            -- used to identify a capture (by number or+                            -- name if one was given) and '$$' being+                            -- used to escape a single '$'+    }+  deriving (Show)+\end{code}++\begin{code}+instance Functor (SearchReplace re) where+  fmap f (SearchReplace re x) = SearchReplace re (f x)+\end{code}

@@ -1,5 +1,17 @@ -*-change-log-*- +1.0.0.0 Chris Dornan <chris.dornan@irisconnect.co.uk> 2017-04-10+  * Rewrite tutorials (#113)+  * Add Text.RE.Tools.IsRegex (#122)+  * Include Macro Parsers in Core API (#123)+  * Adjust type of lookupCaptureID and friends (#124)+  * re-prep to handle cast example expressions (#125)+  * Rename compileSearchReplaceWithOptions (#126)+  * Hide ZeInternals, Evacuate Text.RE (#127)+  * Proper Haddocks for the quasi quoters (#128)+  * ed_ quasi quoters are being restricted to SimpleREOptions (#129)+  * regex dependeny on pcre-builtin (#130)+ 0.14.0.0 Chris Dornan <chris.dornan@irisconnect.co.uk> 2017-04-05   * Move IsOption into the back ends (#115)   * Rename Find functions (#116)@@ -71,7 +83,7 @@   * Fix .travis.yml release-stack script (#67)  0.6.0.0 Chris Dornan <chris.dornan@irisconnect.co.uk> 2017-03-13-  * Split out rexex-with-pcre package (#65)+  * Split out regex-with-pcre package (#65)  0.5.0.0 Chris Dornan <chris.dornan@irisconnect.co.uk> 2017-03-05   * Fix inter-operation of =~ & =~~ and named captures (#55)

@@ -1,5 +1,5 @@ Name:                   regex-Version:                0.14.0.0+Version:                1.0.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@@ -32,7 +32,7 @@ Source-Repository this     Type:               git     Location:           https://github.com/iconnect/regex.git-    Tag:                0.14.0.0+    Tag:                1.0.0.0   @@ -51,13 +51,17 @@       Text.RE.TDFA.Text       Text.RE.TDFA.Text.Lazy       Text.RE.TestBench+      Text.RE.TestBench.Parsers       Text.RE.Tools       Text.RE.Tools.Edit       Text.RE.Tools.Find       Text.RE.Tools.Grep+      Text.RE.Tools.IsRegex       Text.RE.Tools.Lex       Text.RE.Tools.Sed       Text.RE.ZeInternals++    Other-Modules:       Text.RE.ZeInternals.AddCaptureNames       Text.RE.ZeInternals.EscapeREString       Text.RE.ZeInternals.NamedCaptures@@ -85,6 +89,7 @@       Text.RE.ZeInternals.Types.Matches       Text.RE.ZeInternals.Types.SearchReplace +     Default-Language:   Haskell2010      Other-Extensions:@@ -125,7 +130,6 @@       , containers           >= 0.4       , hashable             >= 1.2.3.3       , regex-base           >= 0.93.2-      , regex-pcre-builtin   >= 0.94.4.8.8.35       , regex-tdfa           >= 1.2.0       , regex-tdfa-text      >= 1.0.0.3       , template-haskell     >= 2.7