diff --git a/README.markdown b/README.markdown
--- a/README.markdown
+++ b/README.markdown
@@ -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)
 
diff --git a/Text/RE/PCRE.hs b/Text/RE/PCRE.hs
--- a/Text/RE/PCRE.hs
+++ b/Text/RE/PCRE.hs
@@ -14,70 +14,114 @@
   -- * 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.PCRE
+  , re
+  , reMultilineSensitive
+  , reMultilineInsensitive
+  , reBlockSensitive
+  , reBlockInsensitive
+  , reMS
+  , reMI
+  , reBS
+  , reBI
+  , re_
+  -- * The Ed Quasi Quoters
   -- $ed
-  , module Text.RE.ZeInternals.SearchReplace.PCRE
-  -- * 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.PCRE.ByteString
   , module Text.RE.PCRE.ByteString.Lazy
   , module Text.RE.PCRE.Sequence
   , module Text.RE.PCRE.String
-
   ) where
 
-
 import           Text.RE.PCRE.ByteString()
 import           Text.RE.PCRE.ByteString.Lazy()
 import           Text.RE.PCRE.Sequence()
 import           Text.RE.PCRE.String()
 import           Text.RE.REOptions
-import           Text.RE.ZeInternals.AddCaptureNames
+import           Text.RE.Replace
+import           Text.RE.TestBench.Parsers
+import           Text.RE.Tools.IsRegex
+import           Text.RE.ZeInternals
 import           Text.RE.ZeInternals.PCRE
 import           Text.RE.ZeInternals.SearchReplace.PCRE
-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.PCRE                          as PCRE
 
@@ -147,16 +191,21 @@
 -- $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
--- PCRE back end. If you don't need this generality you might find it easier
--- to work with 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.PCRE.ByteString"
 -- * "Text.RE.PCRE.ByteString.Lazy"
--- * "Text.RE.ZeInternals.PCRE"
 -- * "Text.RE.PCRE.Sequence"
 -- * "Text.RE.PCRE.String"
 
+-- $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
@@ -167,7 +216,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
@@ -184,8 +233,20 @@
 -- 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 exportss merely provide the 'IsRegex' instances.
diff --git a/Text/RE/PCRE/ByteString.hs b/Text/RE/PCRE/ByteString.hs
--- a/Text/RE/PCRE/ByteString.hs
+++ b/Text/RE/PCRE/ByteString.hs
@@ -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.PCRE
+  , re
+  , reMultilineSensitive
+  , reMultilineInsensitive
+  , reBlockSensitive
+  , reBlockInsensitive
+  , reMS
+  , reMI
+  , reBS
+  , reBI
+  , re_
+  -- * The Ed Quasi Quoters
   -- $ed
-  , module Text.RE.ZeInternals.SearchReplace.PCRE.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.PCRE
 import           Text.RE.ZeInternals.SearchReplace.PCRE.ByteString
-import           Text.RE.ZeInternals.Types.IsRegex
 import           Text.Regex.Base
 import qualified Text.Regex.PCRE               as PCRE
 
@@ -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 PCRE.Regex B.ByteString a
-        , RegexMaker   PCRE.Regex PCRE.CompOption PCRE.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 PCRE.Regex B.ByteString a
-         , RegexMaker   PCRE.Regex PCRE.CompOption PCRE.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.
diff --git a/Text/RE/PCRE/ByteString/Lazy.hs b/Text/RE/PCRE/ByteString/Lazy.hs
--- a/Text/RE/PCRE/ByteString/Lazy.hs
+++ b/Text/RE/PCRE/ByteString/Lazy.hs
@@ -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.PCRE
+  , re
+  , reMultilineSensitive
+  , reMultilineInsensitive
+  , reBlockSensitive
+  , reBlockInsensitive
+  , reMS
+  , reMI
+  , reBS
+  , reBI
+  , re_
+  -- * The Ed Quasi Quoters
   -- $ed
-  , module Text.RE.ZeInternals.SearchReplace.PCRE.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          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.PCRE
 import           Text.RE.ZeInternals.SearchReplace.PCRE.ByteString.Lazy
-import           Text.RE.ZeInternals.Types.IsRegex
 import           Text.Regex.Base
 import qualified Text.Regex.PCRE               as PCRE
 
@@ -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 PCRE.Regex LBS.ByteString a
-        , RegexMaker   PCRE.Regex PCRE.CompOption PCRE.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 PCRE.Regex LBS.ByteString a
-         , RegexMaker   PCRE.Regex PCRE.CompOption PCRE.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.
diff --git a/Text/RE/PCRE/Sequence.hs b/Text/RE/PCRE/Sequence.hs
--- a/Text/RE/PCRE/Sequence.hs
+++ b/Text/RE/PCRE/Sequence.hs
@@ -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.PCRE
+  , re
+  , reMultilineSensitive
+  , reMultilineInsensitive
+  , reBlockSensitive
+  , reBlockInsensitive
+  , reMS
+  , reMI
+  , reBS
+  , reBI
+  , re_
+  -- * The Ed Quasi Quoters
   -- $ed
-  , module Text.RE.ZeInternals.SearchReplace.PCRE.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.PCRE
 import           Text.RE.ZeInternals.SearchReplace.PCRE.Sequence
-import           Text.RE.ZeInternals.Types.IsRegex
 import           Text.Regex.Base
 import qualified Text.Regex.PCRE               as PCRE
 
@@ -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 PCRE.Regex (S.Seq Char) a
-        , RegexMaker   PCRE.Regex PCRE.CompOption PCRE.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 PCRE.Regex (S.Seq Char) a
-         , RegexMaker   PCRE.Regex PCRE.CompOption PCRE.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.
diff --git a/Text/RE/PCRE/String.hs b/Text/RE/PCRE/String.hs
--- a/Text/RE/PCRE/String.hs
+++ b/Text/RE/PCRE/String.hs
@@ -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.PCRE
+  , re
+  , reMultilineSensitive
+  , reMultilineInsensitive
+  , reBlockSensitive
+  , reBlockInsensitive
+  , reMS
+  , reMI
+  , reBS
+  , reBI
+  , re_
+  -- * The Ed Quasi Quoters
   -- $ed
-  , module Text.RE.ZeInternals.SearchReplace.PCRE.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.PCRE
 import           Text.RE.ZeInternals.SearchReplace.PCRE.String
-import           Text.RE.ZeInternals.Types.IsRegex
 import           Text.Regex.Base
 import qualified Text.Regex.PCRE               as PCRE
 
@@ -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 PCRE.Regex String a
-        , RegexMaker   PCRE.Regex PCRE.CompOption PCRE.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 PCRE.Regex String a
-         , RegexMaker   PCRE.Regex PCRE.CompOption PCRE.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.
diff --git a/Text/RE/ZeInternals/PCRE.hs b/Text/RE/ZeInternals/PCRE.hs
--- a/Text/RE/ZeInternals/PCRE.hs
+++ b/Text/RE/ZeInternals/PCRE.hs
@@ -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
@@ -72,15 +72,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.PCRE
 
 
@@ -96,7 +91,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
+-- fpr this back end
 regexType :: RegexType
 regexType =
   mkPCRE $ \txt env md -> txt =~ mdRegexSource regexType ExclCaptures env md
@@ -231,12 +226,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
 
 
 ------------------------------------------------------------------------
@@ -277,26 +272,37 @@
 -- Macro Standard Environment
 ------------------------------------------------------------------------
 
+-- | the standard table of 'Macros' used to compile REs (which can be
+-- extended or replace: see "Text.RE.TestBench")
 prelude :: Macros RE
 prelude = runIdentity $ preludeMacros mk regexType ExclCaptures
   where
     mk = Identity . unsafeCompileRegex_ noPreludeREOptions
 
-preludeTestsFailing :: [MacroID]
-preludeTestsFailing = badMacros preludeEnv
-
+-- | the standard 'MacroEnv' for this back end (see "Text.RE.TestBench")
 preludeEnv :: MacroEnv
 preludeEnv = preludeMacroEnv regexType
 
+-- | the macros in the standard environment that are failing their tests
+-- (checked by the test suite to be empty)
+preludeTestsFailing :: [MacroID]
+preludeTestsFailing = badMacros preludeEnv
+
+-- | a table the standard macros in markdown format
 preludeTable :: String
 preludeTable = preludeMacroTable regexType
 
+-- | a summary of the macros in the standard environment for this back
+-- end in plain text
 preludeSummary :: PreludeMacro -> String
 preludeSummary = preludeMacroSummary regexType
 
+-- | a listing of the RE text for each macro in the standard environment
+-- with all macros expanded to normal form
 preludeSources :: String
 preludeSources = preludeMacroSources regexType
 
+-- | the prolude source of a given macro in the standard environment
 preludeSource :: PreludeMacro -> String
 preludeSource = preludeMacroSource regexType
 
@@ -305,27 +311,52 @@
 -- Quasi Quoters
 ------------------------------------------------------------------------
 
--- | the @[re| ... |]@ and @[ed| ... /// ... |]@ quasi quoters
-re
-  , reMS
-  , reMI
-  , reBS
-  , reBI
-  , reMultilineSensitive
-  , reMultilineInsensitive
-  , reBlockSensitive
-  , reBlockInsensitive
-  , re_ :: 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
+-- upper- or lower-case hex didgits.
+re_                     :: QuasiQuoter
 re_                      = re'   Nothing
 
 
diff --git a/Text/RE/ZeInternals/SearchReplace.hs b/Text/RE/ZeInternals/SearchReplace.hs
deleted file mode 100644
--- a/Text/RE/ZeInternals/SearchReplace.hs
+++ /dev/null
@@ -1,84 +0,0 @@
-{-# LANGUAGE NoImplicitPrelude          #-}
-{-# LANGUAGE RecordWildCards            #-}
-{-# LANGUAGE CPP                        #-}
-#if __GLASGOW_HASKELL__ >= 800
-{-# OPTIONS_GHC -fno-warn-redundant-constraints #-}
-{-# LANGUAGE TemplateHaskellQuotes      #-}
-#else
-{-# LANGUAGE QuasiQuotes                #-}
-{-# LANGUAGE TemplateHaskell            #-}
-#endif
-{-# OPTIONS_GHC -fno-warn-orphans       #-}
-
-module Text.RE.ZeInternals.SearchReplace
-  ( unsafeCompileSearchReplace_
-  , compileSearchReplace_
-  , compileSearchAndReplace_
-  ) where
-
-import qualified Data.HashMap.Strict            as HMS
-import           Prelude.Compat
-import           Text.RE.ZeInternals.NamedCaptures
-import           Text.RE.ZeInternals.Replace
-import           Text.RE.ZeInternals.Types.Capture
-import           Text.RE.ZeInternals.Types.CaptureID
-import           Text.RE.ZeInternals.Types.Matches
-import           Text.RE.ZeInternals.Types.SearchReplace
-import qualified Text.Regex.TDFA                as TDFA
-
-
--- | warapper on 'compileSearchReplace_' that will generate an error
--- if any compilation errors are found
-unsafeCompileSearchReplace_ :: (String->s)
-                            -> (String->Either String re)
-                            -> String
-                            -> SearchReplace re s
-unsafeCompileSearchReplace_ pk cf = either err id . compileSearchReplace_ pk cf
-  where
-    err msg = error $ "unsafeCompileSearchReplace_: " ++ msg
-
--- | compile a SearchReplace template generating errors if the RE or
--- the template are not well formed -- all capture references being checked
-compileSearchReplace_ :: (Monad m,Functor m)
-                      => (String->s)
-                      -> (String->Either String re)
-                      -> String
-                      -> m (SearchReplace re s)
-compileSearchReplace_ pack compile_re sr_tpl = either fail return $ do
-    case mainCaptures $ sr_tpl $=~ "///" of
-      [cap] ->
-        compileSearchAndReplace_ pack compile_re
-                      (capturePrefix cap) (captureSuffix cap)
-      _ -> Left $ "bad search-replace template syntax: " ++ sr_tpl
-
--- | compile 'SearcgReplace' from two strings containing the RE
--- and the replacement template
-compileSearchAndReplace_ :: (Monad m,Functor m)
-                         => (String->s)
-                         -> (String->Either String re)
-                         -> String
-                         -> String
-                         -> m (SearchReplace re s)
-compileSearchAndReplace_ pack compile_re re_s tpl = either fail return $ do
-    re           <- compile_re re_s
-    ((n,cnms),_) <- extractNamedCaptures re_s
-    mapM_ (check n cnms) $ templateCaptures id tpl
-    return $ SearchReplace re $ pack tpl
-  where
-    check :: Int -> CaptureNames -> CaptureID -> Either String ()
-    check n cnms cid = case cid of
-      IsCaptureOrdinal co -> check_co n    co
-      IsCaptureName    cn -> check_cn cnms cn
-
-    check_co n (CaptureOrdinal i) = case i <= n of
-      True  -> return ()
-      False -> Left $ "capture ordinal out of range: " ++
-                                      show i ++ " >= " ++ show n
-
-    check_cn cnms cnm = case cnm `HMS.member` cnms of
-      True  -> return ()
-      False -> Left $ "capture name not defined: " ++
-                                      show (getCaptureName cnm)
-
-($=~) :: String -> String -> Matches String
-($=~) = (TDFA.=~)
diff --git a/Text/RE/ZeInternals/SearchReplace/PCRE/ByteString.hs b/Text/RE/ZeInternals/SearchReplace/PCRE/ByteString.hs
--- a/Text/RE/ZeInternals/SearchReplace/PCRE/ByteString.hs
+++ b/Text/RE/ZeInternals/SearchReplace/PCRE/ByteString.hs
@@ -7,17 +7,15 @@
 #endif
 
 module Text.RE.ZeInternals.SearchReplace.PCRE.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.PCRE
 import           Text.RE.ZeInternals.SearchReplace.PCREEdPrime
-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|]
diff --git a/Text/RE/ZeInternals/SearchReplace/PCRE/ByteString/Lazy.hs b/Text/RE/ZeInternals/SearchReplace/PCRE/ByteString/Lazy.hs
--- a/Text/RE/ZeInternals/SearchReplace/PCRE/ByteString/Lazy.hs
+++ b/Text/RE/ZeInternals/SearchReplace/PCRE/ByteString/Lazy.hs
@@ -7,17 +7,15 @@
 #endif
 
 module Text.RE.ZeInternals.SearchReplace.PCRE.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.PCRE
 import           Text.RE.ZeInternals.SearchReplace.PCREEdPrime
-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|]
diff --git a/Text/RE/ZeInternals/SearchReplace/PCRE/Sequence.hs b/Text/RE/ZeInternals/SearchReplace/PCRE/Sequence.hs
--- a/Text/RE/ZeInternals/SearchReplace/PCRE/Sequence.hs
+++ b/Text/RE/ZeInternals/SearchReplace/PCRE/Sequence.hs
@@ -7,17 +7,15 @@
 #endif
 
 module Text.RE.ZeInternals.SearchReplace.PCRE.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.PCRE
 import           Text.RE.ZeInternals.SearchReplace.PCREEdPrime
-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)|]
diff --git a/Text/RE/ZeInternals/SearchReplace/PCRE/String.hs b/Text/RE/ZeInternals/SearchReplace/PCRE/String.hs
--- a/Text/RE/ZeInternals/SearchReplace/PCRE/String.hs
+++ b/Text/RE/ZeInternals/SearchReplace/PCRE/String.hs
@@ -7,17 +7,15 @@
 #endif
 
 module Text.RE.ZeInternals.SearchReplace.PCRE.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.PCRE
 import           Text.RE.ZeInternals.SearchReplace.PCREEdPrime
-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|]
diff --git a/Text/RE/ZeInternals/SearchReplace/PCREEdPrime.hs b/Text/RE/ZeInternals/SearchReplace/PCREEdPrime.hs
--- a/Text/RE/ZeInternals/SearchReplace/PCREEdPrime.hs
+++ b/Text/RE/ZeInternals/SearchReplace/PCREEdPrime.hs
@@ -18,10 +18,9 @@
 import           Prelude.Compat
 import           Text.RE.REOptions
 import           Text.RE.Replace
+import           Text.RE.Tools.IsRegex
+import           Text.RE.ZeInternals
 import           Text.RE.ZeInternals.PCRE
-import           Text.RE.ZeInternals.QQ
-import           Text.RE.ZeInternals.SearchReplace
-import           Text.RE.ZeInternals.Types.IsRegex
 
 
 -- | construct a quasi quoter from a casting function and @Just sro@
diff --git a/changelog b/changelog
--- a/changelog
+++ b/changelog
@@ -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)
diff --git a/regex-with-pcre.cabal b/regex-with-pcre.cabal
--- a/regex-with-pcre.cabal
+++ b/regex-with-pcre.cabal
@@ -1,5 +1,5 @@
 Name:                   regex-with-pcre
-Version:                0.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
 
 
 
@@ -45,8 +45,9 @@
       Text.RE.PCRE.ByteString.Lazy
       Text.RE.PCRE.Sequence
       Text.RE.PCRE.String
+
+    Other-Modules:
       Text.RE.ZeInternals.PCRE
-      Text.RE.ZeInternals.SearchReplace
       Text.RE.ZeInternals.SearchReplace.PCRE
       Text.RE.ZeInternals.SearchReplace.PCRE.ByteString
       Text.RE.ZeInternals.SearchReplace.PCRE.ByteString.Lazy
@@ -87,7 +88,7 @@
       -Wwarn
 
     Build-depends:
-        regex                == 0.14.0.0
+        regex                == 1.0.0.0
       , base                 >= 4 && < 5
       , base-compat          >= 0.6.0
       , bytestring           >= 0.10.2.0