diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -1,3 +1,8 @@
+#####   2.6.2
+  compatible with 2.6.1
+  
+  add makeRegexM, makeRegexOptM, RegexResult to catch regex construction errors
+
 #####   2.6.1
   compatible with 2.6
   
diff --git a/regex-do.cabal b/regex-do.cabal
--- a/regex-do.cabal
+++ b/regex-do.cabal
@@ -1,5 +1,5 @@
 name:                regex-do
-version:             2.6.1
+version:             2.6.2
 synopsis:            PCRE wrapper
 description:         format, search, replace (String | ByteString) with PCRE regex. Utf8-safe
 author:              Imants Cekusins
@@ -40,7 +40,6 @@
 
   other-modules:
           Text.Regex.Do.Result
-
   ghc-options:  -fwarn-unused-imports
     
   build-depends:  base <= 5.0,
@@ -48,6 +47,7 @@
               regex-pcre,
               stringsearch,
               bytestring,
+              mtl,
               array,
               text
 
@@ -92,6 +92,7 @@
         TestRegex.TestTrim
         TestRegex.TestReplaceOpen
         TestRegex.TestReplaceUtf
+        TestRegex.TestMakeRegexM
 
   build-depends:  base <= 5.0,
                   hspec,
@@ -99,6 +100,7 @@
                   regex-base,
                   regex-pcre,
                   stringsearch,
+                  mtl,
                   bytestring,
                   array,
                   text,
diff --git a/src/Text/Regex/Do/Format.hs b/src/Text/Regex/Do/Format.hs
--- a/src/Text/Regex/Do/Format.hs
+++ b/src/Text/Regex/Do/Format.hs
@@ -1,3 +1,17 @@
+{- | ==== placeholder syntax:
+
+       * index based
+
+            { Int }
+
+       * key based
+
+            { 'String' | 'ByteString' | 'Text' }
+
+    other placeholders may be implemented with
+
+    "Text.Regex.Do.Pcre.Ascii.Replace" or "Text.Regex.Do.Pcre.Utf8.Replace"       -}
+
 module Text.Regex.Do.Format
     (Format(..),
     ReplaceOne(..),
@@ -20,7 +34,9 @@
     * 'Text'      -}
 
 class Format a arg where
-   format::a -> arg -> a
+   format::a    -- ^ text to format e.g. "today is {0}"
+        -> arg  -- ^ replacement: [a] or [(a,a)]
+        -> a    -- ^ formatted text
 
 
 instance ReplaceOne Int a =>
diff --git a/src/Text/Regex/Do/Pcre/Ascii/Match.hs b/src/Text/Regex/Do/Pcre/Ascii/Match.hs
--- a/src/Text/Regex/Do/Pcre/Ascii/Match.hs
+++ b/src/Text/Regex/Do/Pcre/Ascii/Match.hs
@@ -19,31 +19,37 @@
 import Text.Regex.Do.Type.MatchHint
 
 
+{- | short version of 'match': arg without newtypes
+
+    is borrowed from "Text.Regex.PCRE.Wrap"    -}
+(=~)::Match a b out =>
+    a     -- ^ pattern
+    -> b    -- ^ body
+    -> out
+(=~) p0 b0 = match (Pattern p0) (Body b0)
+
+
+
 {- | * a:  'String', 'ByteString', 'Regex'
     * b:  'String', 'ByteString'
-    * out: ['String'], [['String']], ['ByteString'], [['ByteString']], 'Bool', ['PosLen'], [['PosLen']]
+    * out:
 
-    'match' covers all result types
+        * ['String'], [['String']]
+        * ['ByteString'], [['ByteString']]
+        * 'Bool'
+        * ['PosLen'], [['PosLen']]
 
-    compiler looks up the appropriate function depending on the result type
 
-    '=~' is borrowed from "Text.Regex.PCRE.Wrap",
-    is a short version of 'match'
-
     precompiled Regex may be used as pattern too. see "Text.Regex.Do.Pcre.Utf8.Match"
 
-    See also "Text.Regex.Do.Pcre.Ascii.MatchHint"       -}
+    See also "Text.Regex.Do.Pcre.Ascii.MatchHint"
 
+    to catch regex construction __errors__, precompile 'Regex' with 'makeRegexM' or 'makeRegexOptM'     -}
+
 class Match a b out where
     match::Pattern a -> Body b -> out
 
 
--- | synonym for 'match'. arg without newtypes
-(=~)::Match a b out =>
-    a     -- ^ pattern
-    -> b    -- ^ body
-    -> out
-(=~) p0 b0 = match (Pattern p0) (Body b0)
 
 
 -- | match once
@@ -56,16 +62,16 @@
     match p0 (Body b0) = R.matchTest (makeRegex p0) b0
 {- ^ test
 
-    >>> "в" =~ "тихо в лесу"::Bool
+    >>> "chilly" =~ "it's chilly inside, chilly outside"::Bool
 
     True    -}
 
 -- | match all
 instance Rx_ a b => Match a b [[b]] where
     match p0 = F.all (makeRegex' p0)
-{- ^  >>> "well" =~ "all is well that ends well"::[[ByteString]]
+{- ^  >>> "chilly" =~ "it's chilly inside, chilly outside"::[[ByteString]]
 
-     \[["well"\],\["well"\]]        -}
+     \[["chilly"\],\["chilly"\]]        -}
 
 -- | match once
 instance Rx_ a b => Match a b [PosLen] where
diff --git a/src/Text/Regex/Do/Pcre/Ascii/MatchHint.hs b/src/Text/Regex/Do/Pcre/Ascii/MatchHint.hs
--- a/src/Text/Regex/Do/Pcre/Ascii/MatchHint.hs
+++ b/src/Text/Regex/Do/Pcre/Ascii/MatchHint.hs
@@ -3,15 +3,24 @@
 
     this module is similar to "Text.Regex.Do.Pcre.Ascii.Match". The differences are:
 
-    "Text.Regex.Do.Pcre.Ascii.Match" is more flexible:
+    * "Text.Regex.Do.Pcre.Ascii.Match" is more flexible:
+
         accepts 'Pattern' Regex,
+
         accepts 'Pattern' and 'Body' of different types
 
-    "Text.Regex.Do.Pcre.Ascii.Match" needs to infer result type
+    * "Text.Regex.Do.Pcre.Ascii.Match" needs to infer result type
 
-    in this module the result type is determined by the hint
-    -}
+    this module:
 
+    * 'Pattern' and 'Body' are of the same type
+
+    * 'Hint' and inferrable 'Pattern' or 'Body' type determine the instance
+
+        the result type is determined by the hint
+
+    * handy when working with 'OverloadedStrings', in other cases when compiler needs a hint  -}
+
 module Text.Regex.Do.Pcre.Ascii.MatchHint where
 
 import Text.Regex.Do.Type.Do hiding (Once,All)
@@ -23,13 +32,7 @@
 
 {- | * hint: 'Once', 'All', 'Test', 'PosLen'', 'PosLen_'
     * a: 'String', 'ByteString'
-
-    picks 'M.Match' instance where 'Pattern' and 'Body' are of the same type
-
-    'Hint' and inferrable 'Pattern' or 'Body' type determine the instance
-
-    handy when working with 'OverloadedStrings', in other cases when compiler needs a hint  -}
-
+-}
 
 
 class (Hint hint, M.Match a a (F hint a)) =>
diff --git a/src/Text/Regex/Do/Pcre/Ascii/Replace.hs b/src/Text/Regex/Do/Pcre/Ascii/Replace.hs
--- a/src/Text/Regex/Do/Pcre/Ascii/Replace.hs
+++ b/src/Text/Regex/Do/Pcre/Ascii/Replace.hs
@@ -25,6 +25,8 @@
         * ('All' | 'Once' (a))
         * ('All' | 'Once' ('Pattern' a))
 
+    to catch regex construction __errors__, precompile 'Regex' with 'makeRegexM' or 'makeRegexOptM'
+
     * repl:  b: 'String' | 'ByteString'
 
         * ('Replacement' b)
diff --git a/src/Text/Regex/Do/Pcre/Utf8/Match.hs b/src/Text/Regex/Do/Pcre/Utf8/Match.hs
--- a/src/Text/Regex/Do/Pcre/Utf8/Match.hs
+++ b/src/Text/Regex/Do/Pcre/Utf8/Match.hs
@@ -24,20 +24,30 @@
 import Data.ByteString
 
 
-{- | * enc: 'Utf8_'
-    * a:  'String', 'ByteString', 'Regex'
-    * b:  'String', 'ByteString'
-    * out: ['String'], [['String']], ['ByteString'], [['ByteString']], 'Bool', ['PosLen'], [['PosLen']]
-    -}
-class Match enc a b out where
-    match::Pattern (enc a) -> Body (enc b) -> out
-
 -- | synonym for 'match'. arg without newtypes
 (=~)::Match Utf8_ a b out =>
     a     -- ^ pattern
     -> b    -- ^ body
     -> out
 (=~) p0 b0 = match (Pattern $ Utf8_ p0) (Body $ Utf8_ b0)
+
+
+
+{- | * enc: 'Utf8_'
+    * a:  'String', 'ByteString', 'Regex'
+
+    to catch regex construction __errors__, precompile 'Regex' with 'makeRegexM' or 'makeRegexOptM'
+
+    * b:  'String', 'ByteString'
+    * out:
+
+        * ['String'], [['String']]
+        * ['ByteString'], [['ByteString']]
+        * 'Bool'
+        * ['PosLen'], [['PosLen']]      -}
+
+class Match enc a b out where
+    match::Pattern (enc a) -> Body (enc b) -> out
 
 
 {- | match once
diff --git a/src/Text/Regex/Do/Pcre/Utf8/MatchHint.hs b/src/Text/Regex/Do/Pcre/Utf8/MatchHint.hs
--- a/src/Text/Regex/Do/Pcre/Utf8/MatchHint.hs
+++ b/src/Text/Regex/Do/Pcre/Utf8/MatchHint.hs
@@ -15,12 +15,8 @@
 {- | * hint: 'Once', 'All', 'Test', 'PosLen'', 'PosLen_'
     * a: 'String', 'ByteString'
     * enc: 'Utf8_'
-
-    picks 'M.Match' instance where 'Pattern' and 'Body' are of the same type
-
-    'Hint' and inferrable 'Pattern' or 'Body' type determine the instance
+-}
 
-    handy when working with 'OverloadedStrings', in other cases when compiler needs a hint  -}
 class (Hint hint, M.Match enc a a (F hint a)) =>
     MatchHint hint enc a where
     type F hint a
diff --git a/src/Text/Regex/Do/Pcre/Utf8/Replace.hs b/src/Text/Regex/Do/Pcre/Utf8/Replace.hs
--- a/src/Text/Regex/Do/Pcre/Utf8/Replace.hs
+++ b/src/Text/Regex/Do/Pcre/Utf8/Replace.hs
@@ -20,6 +20,8 @@
 
 {- | see "Text.Regex.Do.Pcre.Ascii.Replace" for implemented types
 
+    to catch regex construction __errors__, precompile 'Regex' with 'makeRegexM' or 'makeRegexOptM'
+
     in full typed instance every b is wrapped in 'Utf8_' newtype
 
     'GroupReplacer' is implemented only for 'ByteString'    -}
diff --git a/src/Text/Regex/Do/Type/Regex.hs b/src/Text/Regex/Do/Type/Regex.hs
--- a/src/Text/Regex/Do/Type/Regex.hs
+++ b/src/Text/Regex/Do/Type/Regex.hs
@@ -2,6 +2,7 @@
     (Regex(..),
     makeRegex',
     makeRegexOpt',
+    RegexResult(..),
     Rx_, Opt_, Ro_) where
 
 import qualified Text.Regex.Base.RegexLike as R
@@ -13,9 +14,34 @@
 
 class Regex a where
    makeRegex::Pattern a -> R.Regex
+   makeRegexM::Monad m => Pattern a -> m R.Regex
    makeRegexOpt::Pattern a -> [Comp] -> [Exec] -> R.Regex
+   makeRegexOptM::Monad m => Pattern a -> [Comp] -> [Exec] -> m R.Regex
 
+{- ^ monadic
 
+        * 'makeRegexM'
+        * 'makeRegexOptM'
+
+        let catch regex construction errors
+
+    for 'm' to catch errors, implement 'fail' in 'm'
+
+    default 'm' implementation: 'RegexResult'
+
+    ==== makeRegexM test case:
+
+    >>>  it "RegexResult test case" $ do
+            rx1 `shouldNotSatisfy` isok1
+            rx2 `shouldSatisfy` isok1
+        where rx1 = T.makeRegexM $ Pattern "[["::RegexResult R.Regex
+              rx2 = T.makeRegexM $ Pattern "."::RegexResult R.Regex
+              isok1 (RegexResult (Left e1)) = traceShow e1 False
+              isok1 _ = True
+
+    >>> instance Show (RegexResult R.Regex) where
+            show _ = "bon"       -}
+
 makeRegex'::Regex a => Pattern a -> Pattern R.Regex
 makeRegex' = Pattern . makeRegex
 
@@ -26,22 +52,30 @@
 
 instance Regex a => Regex (Utf8_ a) where
    makeRegex p0 = makeRegexOpt (Pattern val <*> p0) [Utf8] []
+   makeRegexM p0 = makeRegexOptM (Pattern val <*> p0) [Utf8] []
    makeRegexOpt p0 c0 e0 = makeRegexOpt (Pattern val <*> p0) (Utf8:c0) e0
+   makeRegexOptM p0 c0 e0 = makeRegexOptM (Pattern val <*> p0) (Utf8:c0) e0
 
 
 instance Regex ByteString where
    makeRegex (Pattern p0) = R.makeRegex p0
+   makeRegexM (Pattern p0) = R.makeRegexM p0
    makeRegexOpt = makeRegexOpts
+   makeRegexOptM = makeRegexOptsM
 
 
 instance Regex String where
    makeRegex (Pattern p0) = R.makeRegex p0
+   makeRegexM (Pattern p0) = R.makeRegexM p0
    makeRegexOpt = makeRegexOpts
+   makeRegexOptM = makeRegexOptsM
 
 
 instance Regex R.Regex where
    makeRegex (Pattern p0) = p0
+   makeRegexM (Pattern p0) = pure p0
    makeRegexOpt (Pattern p0) _ _ = p0
+   makeRegexOptM (Pattern p0) _ _ = pure p0
 
 
 -- | tweak Regex with options
@@ -55,6 +89,33 @@
          rx1 = R.makeRegexOpts c1 e1 pat0
 
 
+makeRegexOptsM::(Monad m, Opt_ a) =>
+    Pattern a ->
+        [Comp] -> [Exec] ->
+            m R.Regex
+makeRegexOptsM (Pattern pat0) comp0 exec0 = rx1
+   where c1 = comp comp0
+         e1 = exec exec0
+         rx1 = R.makeRegexOptsM c1 e1 pat0
+
+
+
 type Rx_ a b = (Regex a, R.Extract b, R.RegexLike R.Regex b)
 type Opt_ a = R.RegexMaker R.Regex R.CompOption R.ExecOption a
 type Ro_ rx = (Regex rx, Opt_ rx)
+
+
+{- | catches regex construction __errors__  -}
+newtype RegexResult a = RegexResult (Either [String] a) deriving (Functor)
+
+instance Applicative RegexResult where
+    pure = RegexResult . Right
+    (<*>) (RegexResult (Left e1)) (RegexResult (Left e2)) = RegexResult $ Left $ e1 ++ e2
+    (<*>) (RegexResult (Right fn0)) (RegexResult (Left e1)) = RegexResult $ Left e1
+    (<*>) (RegexResult (Left e1)) (RegexResult (Right r1)) = RegexResult $ Left e1
+    (<*>) (RegexResult (Right fn0)) (RegexResult (Right a0)) = pure $ fn0 a0
+
+instance Monad RegexResult where
+    (>>=) (RegexResult (Left e1)) fn0 = RegexResult $ Left e1
+    (>>=) (RegexResult (Right a0)) fn0 = fn0 a0
+    fail s0 = RegexResult $ Left [s0]
diff --git a/test/Main.hs b/test/Main.hs
--- a/test/Main.hs
+++ b/test/Main.hs
@@ -7,7 +7,7 @@
 import qualified TestRegex.TestReplaceOpen as O
 import qualified TestRegex.TestSplit as S
 import qualified TestRegex.TestTrim as T
-
+import qualified TestRegex.TestMakeRegexM as E
 
 main::IO()
 main = do
@@ -18,3 +18,4 @@
             O.main
             R.main
             U.main
+            E.main
diff --git a/test/TestRegex/TestMakeRegexM.hs b/test/TestRegex/TestMakeRegexM.hs
new file mode 100644
--- /dev/null
+++ b/test/TestRegex/TestMakeRegexM.hs
@@ -0,0 +1,25 @@
+{-# LANGUAGE NoOverloadedStrings #-}
+module TestRegex.TestMakeRegexM where
+
+import Test.Hspec
+import Text.Regex.Do.Type.Reexport as R
+import Text.Regex.Do.Type.Regex as T
+import Text.Regex.Do.Type.Do as T
+import Debug.Trace
+
+
+main::IO()
+main = hspec $ do
+       describe "TestRegex.TestMakeRegexM" $ do
+          it "RegexResult test case" $ do
+            rx1 `shouldNotSatisfy` isok1
+            rx2 `shouldSatisfy` isok1
+        where rx1 = T.makeRegexM $ Pattern "[["::RegexResult R.Regex
+              rx2 = T.makeRegexM $ Pattern "."::RegexResult R.Regex
+
+              isok1 (RegexResult (Left e1)) = traceShow e1 False
+              isok1 _ = True
+
+
+instance Show (RegexResult R.Regex) where
+    show _ = "rx"
diff --git a/test/TestRegex/TestPcre.hs b/test/TestRegex/TestPcre.hs
--- a/test/TestRegex/TestPcre.hs
+++ b/test/TestRegex/TestPcre.hs
@@ -23,10 +23,11 @@
      it " cd " $ S.match (PosLen' $ Pattern ("^cd"::String)) (Body "abcde") `shouldBe` []
      it " ab " $ S.match (Test $ Pattern ("^ab"::String)) (Body "abc") `shouldBe` True
      it "doc 1" $ Test ("в"::ByteString) S.=~ "тихо в лесу" `shouldBe` True
-     it "doc 1" $ Test (toByteString "в") Su.=~ toByteString "тихо в лесу" `shouldBe` True
+     it "doc 1.2" $ Test ("chilly"::ByteString) S.=~ "it's chilly inside, chilly outside" `shouldBe` True
+     it "doc 1.3" $ Test (toByteString "в") Su.=~ toByteString "тихо в лесу" `shouldBe` True
      it "doc 2" $ S.Once ("^all"::String) S.=~ "all the time" `shouldBe` ["all"]
      it "doc 3" $ S.Once ("^all"::ByteString) S.=~ "all the time" `shouldBe` ["all"]
-     it "doc 4" $ S.All ("well"::ByteString) S.=~ "all is well that ends well" `shouldBe` ([["well"],["well"]])
+     it "doc 4" $ S.All ("chilly"::ByteString) S.=~ "it's chilly inside, chilly outside" `shouldBe` ([["chilly"],["chilly"]])
      it "doc 5" $ PosLen' ("и"::String) S.=~ "бывает и хуже" `shouldBe` [(13,2)]
      it "doc 6" $ PosLen' ("à"::String) S.=~ "tourner à gauche" `shouldBe` [(8,2)]
      it "doc 7" $ do