module Text.Regex.Do.Match.Regex
    (Regex(..),
    E(..)) where

import qualified Text.Regex.Base.RegexLike as R
import qualified Text.Regex.Do.Type.Reexport as R
import Control.Monad.Fail
import Data.ByteString
import Text.Regex.Do.Type.Do hiding (Regex)
import Text.Regex.Do.Match.Option
import Data.List as L


class Regex a where
   makeRegex::a -> E R.Regex
   makeRegexOpt::a -> [Comp] -> [Exec] -> E R.Regex


instance Regex ByteString where
   makeRegex :: ByteString -> E Regex
makeRegex p0 :: ByteString
p0 = RegexResult Regex -> E Regex
forall a. RegexResult a -> Either String a
rre (RegexResult Regex -> E Regex) -> RegexResult Regex -> E Regex
forall a b. (a -> b) -> a -> b
$ ByteString -> RegexResult Regex
forall regex compOpt execOpt source (m :: * -> *).
(RegexMaker regex compOpt execOpt source, MonadFail m) =>
source -> m regex
R.makeRegexM ByteString
p0 
   makeRegexOpt :: ByteString -> [Comp] -> [Exec] -> E Regex
makeRegexOpt p0 :: ByteString
p0 o0 :: [Comp]
o0 e0 :: [Exec]
e0 = RegexResult Regex -> E Regex
forall a. RegexResult a -> Either String a
rre (RegexResult Regex -> E Regex) -> RegexResult Regex -> E Regex
forall a b. (a -> b) -> a -> b
$ ByteString -> [Comp] -> [Exec] -> RegexResult Regex
forall (m :: * -> *) a.
(Monad m, Opt_ a, MonadFail m) =>
a -> [Comp] -> [Exec] -> m Regex
makeRegexOptsM ByteString
p0 [Comp]
o0 [Exec]
e0 


instance Regex String where
   makeRegex :: String -> E Regex
makeRegex p0 :: String
p0 = RegexResult Regex -> E Regex
forall a. RegexResult a -> Either String a
rre (RegexResult Regex -> E Regex) -> RegexResult Regex -> E Regex
forall a b. (a -> b) -> a -> b
$ String -> RegexResult Regex
forall regex compOpt execOpt source (m :: * -> *).
(RegexMaker regex compOpt execOpt source, MonadFail m) =>
source -> m regex
R.makeRegexM String
p0
   makeRegexOpt :: String -> [Comp] -> [Exec] -> E Regex
makeRegexOpt p0 :: String
p0 o0 :: [Comp]
o0 e0 :: [Exec]
e0 = RegexResult Regex -> E Regex
forall a. RegexResult a -> Either String a
rre (RegexResult Regex -> E Regex) -> RegexResult Regex -> E Regex
forall a b. (a -> b) -> a -> b
$ String -> [Comp] -> [Exec] -> RegexResult Regex
forall (m :: * -> *) a.
(Monad m, Opt_ a, MonadFail m) =>
a -> [Comp] -> [Exec] -> m Regex
makeRegexOptsM String
p0 [Comp]
o0 [Exec]
e0 


instance Regex R.Regex where
   makeRegex :: Regex -> E Regex
makeRegex p0 :: Regex
p0 = Regex -> E Regex
forall (f :: * -> *) a. Applicative f => a -> f a
pure Regex
p0
   makeRegexOpt :: Regex -> [Comp] -> [Exec] -> E Regex
makeRegexOpt p0 :: Regex
p0 _ _ = Regex -> E Regex
forall (f :: * -> *) a. Applicative f => a -> f a
pure Regex
p0


makeRegexOptsM::(Monad m, Opt_ a, Control.Monad.Fail.MonadFail m) =>
    a -> [Comp] -> [Exec] ->
            m R.Regex
makeRegexOptsM :: a -> [Comp] -> [Exec] -> m Regex
makeRegexOptsM pat0 :: a
pat0 comp0 :: [Comp]
comp0 exec0 :: [Exec]
exec0 = m Regex
rx1
   where c1 :: CompOption
c1 = [Comp] -> CompOption
comp [Comp]
comp0
         e1 :: ExecOption
e1 = [Exec] -> ExecOption
exec [Exec]
exec0
         rx1 :: m Regex
rx1 = CompOption -> ExecOption -> a -> m Regex
forall regex compOpt execOpt source (m :: * -> *).
(RegexMaker regex compOpt execOpt source, MonadFail m) =>
compOpt -> execOpt -> source -> m regex
R.makeRegexOptsM CompOption
c1 ExecOption
e1 a
pat0


-- | internal type
type Opt_ a = R.RegexMaker R.Regex R.CompOption R.ExecOption a


rre::RegexResult a -> Either String a
rre :: RegexResult a -> Either String a
rre (RegexResult e0 :: Either [String] a
e0) = ([String] -> Either String a)
-> (a -> Either String a) -> Either [String] a -> Either String a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (String -> Either String a
forall a b. a -> Either a b
Left (String -> Either String a)
-> ([String] -> String) -> [String] -> Either String a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> [String] -> String
forall a. [a] -> [[a]] -> [a]
L.intercalate " ")) a -> Either String a
forall a b. b -> Either a b
Right Either [String] a
e0


{- | catches regex construction __errors__  -}
newtype RegexResult a = RegexResult (Either [String] a) deriving (a -> RegexResult b -> RegexResult a
(a -> b) -> RegexResult a -> RegexResult b
(forall a b. (a -> b) -> RegexResult a -> RegexResult b)
-> (forall a b. a -> RegexResult b -> RegexResult a)
-> Functor RegexResult
forall a b. a -> RegexResult b -> RegexResult a
forall a b. (a -> b) -> RegexResult a -> RegexResult b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> RegexResult b -> RegexResult a
$c<$ :: forall a b. a -> RegexResult b -> RegexResult a
fmap :: (a -> b) -> RegexResult a -> RegexResult b
$cfmap :: forall a b. (a -> b) -> RegexResult a -> RegexResult b
Functor)

instance Applicative RegexResult where
    pure :: a -> RegexResult a
pure = Either [String] a -> RegexResult a
forall a. Either [String] a -> RegexResult a
RegexResult (Either [String] a -> RegexResult a)
-> (a -> Either [String] a) -> a -> RegexResult a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either [String] a
forall a b. b -> Either a b
Right
    <*> :: RegexResult (a -> b) -> RegexResult a -> RegexResult b
(<*>) (RegexResult (Left e1 :: [String]
e1)) (RegexResult (Left e2 :: [String]
e2)) = Either [String] b -> RegexResult b
forall a. Either [String] a -> RegexResult a
RegexResult (Either [String] b -> RegexResult b)
-> Either [String] b -> RegexResult b
forall a b. (a -> b) -> a -> b
$ [String] -> Either [String] b
forall a b. a -> Either a b
Left ([String] -> Either [String] b) -> [String] -> Either [String] b
forall a b. (a -> b) -> a -> b
$ [String]
e1 [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String]
e2
    (<*>) (RegexResult (Right fn0 :: a -> b
fn0)) (RegexResult (Left e1 :: [String]
e1)) = Either [String] b -> RegexResult b
forall a. Either [String] a -> RegexResult a
RegexResult (Either [String] b -> RegexResult b)
-> Either [String] b -> RegexResult b
forall a b. (a -> b) -> a -> b
$ [String] -> Either [String] b
forall a b. a -> Either a b
Left [String]
e1
    (<*>) (RegexResult (Left e1 :: [String]
e1)) (RegexResult (Right r1 :: a
r1)) = Either [String] b -> RegexResult b
forall a. Either [String] a -> RegexResult a
RegexResult (Either [String] b -> RegexResult b)
-> Either [String] b -> RegexResult b
forall a b. (a -> b) -> a -> b
$ [String] -> Either [String] b
forall a b. a -> Either a b
Left [String]
e1
    (<*>) (RegexResult (Right fn0 :: a -> b
fn0)) (RegexResult (Right a0 :: a
a0)) = b -> RegexResult b
forall (f :: * -> *) a. Applicative f => a -> f a
pure (b -> RegexResult b) -> b -> RegexResult b
forall a b. (a -> b) -> a -> b
$ a -> b
fn0 a
a0

instance Monad RegexResult where
    >>= :: RegexResult a -> (a -> RegexResult b) -> RegexResult b
(>>=) (RegexResult (Left e1 :: [String]
e1)) fn0 :: a -> RegexResult b
fn0 = Either [String] b -> RegexResult b
forall a. Either [String] a -> RegexResult a
RegexResult (Either [String] b -> RegexResult b)
-> Either [String] b -> RegexResult b
forall a b. (a -> b) -> a -> b
$ [String] -> Either [String] b
forall a b. a -> Either a b
Left [String]
e1
    (>>=) (RegexResult (Right a0 :: a
a0)) fn0 :: a -> RegexResult b
fn0 = a -> RegexResult b
fn0 a
a0

instance MonadFail RegexResult where
    fail :: String -> RegexResult a
    fail :: String -> RegexResult a
fail err0 :: String
err0 = Either [String] a -> RegexResult a
forall a. Either [String] a -> RegexResult a
RegexResult (Either [String] a -> RegexResult a)
-> Either [String] a -> RegexResult a
forall a b. (a -> b) -> a -> b
$ [String] -> Either [String] a
forall a b. a -> Either a b
Left [String
err0]