-- __internal__ module
module Text.Regex.Do.Match.Matchf where

import Data.Tagged
import Data.ByteString as B
import Text.Regex.Do.Type.Do_
import Text.Regex.Do.Type.Reexport as R
import Text.Regex.Do.Match.Result as R
import Text.Regex.Base.RegexLike as R
import Text.Regex.Do.Type.MatchHint
import Text.Regex.Do.Type.Internal


type R_ b = R.RegexLike R.Regex b


class Matchf hint where
    type H hint
    type P hint
    marray_::R_ b => E R.Regex -> hint b -> H hint
    poslen_::R_ b => E R.Regex -> hint b -> P hint
    
    
instance Matchf (Tagged Once) where
    type H (Tagged Once) = E (Maybe MatchArray)
    type P (Tagged Once) = E [PosLen]
    marray_ :: E Regex -> Tagged Once b -> H (Tagged Once)
marray_ ep0 :: E Regex
ep0 (Tagged b0 :: b
b0) = E Regex
ep0 E Regex
-> (Regex -> Either String (Maybe MatchArray))
-> Either String (Maybe MatchArray)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ep1 :: Regex
ep1 -> Maybe MatchArray -> Either String (Maybe MatchArray)
forall a b. b -> Either a b
Right (Maybe MatchArray -> Either String (Maybe MatchArray))
-> Maybe MatchArray -> Either String (Maybe MatchArray)
forall a b. (a -> b) -> a -> b
$ Regex -> b -> Maybe MatchArray
forall regex source.
RegexLike regex source =>
regex -> source -> Maybe MatchArray
R.matchOnce Regex
ep1 b
b0 
    poslen_ :: E Regex -> Tagged Once b -> P (Tagged Once)
poslen_ ep0 :: E Regex
ep0 (Tagged b0 :: b
b0) = E Regex
ep0 E Regex
-> (Regex -> Either String [PosLen]) -> Either String [PosLen]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ep1 :: Regex
ep1 -> 
                let mpl1 :: Maybe [PosLen]
mpl1 = Maybe MatchArray -> Maybe [PosLen]
forall (f :: * -> *). Functor f => f MatchArray -> f [PosLen]
R.poslen (Maybe MatchArray -> Maybe [PosLen])
-> Maybe MatchArray -> Maybe [PosLen]
forall a b. (a -> b) -> a -> b
$ Regex -> b -> Maybe MatchArray
forall regex source.
RegexLike regex source =>
regex -> source -> Maybe MatchArray
R.matchOnce Regex
ep1 b
b0::Maybe [PosLen]
                in [PosLen] -> Either String [PosLen]
forall a b. b -> Either a b
Right ([PosLen] -> Either String [PosLen])
-> [PosLen] -> Either String [PosLen]
forall a b. (a -> b) -> a -> b
$ [PosLen] -> ([PosLen] -> [PosLen]) -> Maybe [PosLen] -> [PosLen]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] [PosLen] -> [PosLen]
forall a. a -> a
id Maybe [PosLen]
mpl1 


instance Matchf (Tagged All) where
    type H (Tagged All) = E [MatchArray]
    type P (Tagged All) = E [[PosLen]]
    marray_ :: E Regex -> Tagged All b -> H (Tagged All)
marray_ ep0 :: E Regex
ep0 (Tagged b0 :: b
b0) = E Regex
ep0 E Regex
-> (Regex -> Either String [MatchArray])
-> Either String [MatchArray]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ep1 :: Regex
ep1 -> [MatchArray] -> Either String [MatchArray]
forall a b. b -> Either a b
Right ([MatchArray] -> Either String [MatchArray])
-> [MatchArray] -> Either String [MatchArray]
forall a b. (a -> b) -> a -> b
$ Regex -> b -> [MatchArray]
forall regex source.
RegexLike regex source =>
regex -> source -> [MatchArray]
R.matchAll Regex
ep1 b
b0
    poslen_ :: E Regex -> Tagged All b -> P (Tagged All)
poslen_ ep0 :: E Regex
ep0 (Tagged b0 :: b
b0) = E Regex
ep0 E Regex
-> (Regex -> Either String [[PosLen]]) -> Either String [[PosLen]]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ep1 :: Regex
ep1 -> [[PosLen]] -> Either String [[PosLen]]
forall a b. b -> Either a b
Right ([[PosLen]] -> Either String [[PosLen]])
-> [[PosLen]] -> Either String [[PosLen]]
forall a b. (a -> b) -> a -> b
$ [MatchArray] -> [[PosLen]]
forall (f :: * -> *). Functor f => f MatchArray -> f [PosLen]
R.poslen ([MatchArray] -> [[PosLen]]) -> [MatchArray] -> [[PosLen]]
forall a b. (a -> b) -> a -> b
$ Regex -> b -> [MatchArray]
forall regex source.
RegexLike regex source =>
regex -> source -> [MatchArray]
R.matchAll Regex
ep1 b
b0


once::(R_ b, R.Extract b) =>
    R.Regex -> Tagged Once b -> [b]      -- ^ matched content
once :: Regex -> Tagged Once b -> [b]
once p0 :: Regex
p0 t0 :: Tagged Once b
t0@(Tagged b0 :: b
b0) = [b] -> ([b] -> [b]) -> Maybe [b] -> [b]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] [b] -> [b]
forall a. a -> a
id (Maybe [b] -> [b]) -> Maybe [b] -> [b]
forall a b. (a -> b) -> a -> b
$ Body b -> Maybe MatchArray -> Maybe [b]
forall (f :: * -> *) b.
(Functor f, Extract b) =>
Body b -> f MatchArray -> f [b]
R.allMatches (b -> Body b
forall b. b -> Body b
Body b
b0) Maybe MatchArray
r1 
    where Right r1 :: Maybe MatchArray
r1 = E Regex -> Tagged Once b -> H (Tagged Once)
forall (hint :: * -> *) b.
(Matchf hint, R_ b) =>
E Regex -> hint b -> H hint
marray_ (Regex -> E Regex
forall a b. b -> Either a b
Right Regex
p0) Tagged Once b
t0   


all::(R_ b, R.Extract b) =>
    R.Regex -> Tagged All b -> [[b]]       -- ^ matched content
all :: Regex -> Tagged All b -> [[b]]
all p0 :: Regex
p0 t0 :: Tagged All b
t0@(Tagged b0 :: b
b0) = Body b -> [MatchArray] -> [[b]]
forall (f :: * -> *) b.
(Functor f, Extract b) =>
Body b -> f MatchArray -> f [b]
R.allMatches (b -> Body b
forall b. b -> Body b
Body b
b0) [MatchArray]
r1 
    where Right r1 :: [MatchArray]
r1 = E Regex -> Tagged All b -> H (Tagged All)
forall (hint :: * -> *) b.
(Matchf hint, R_ b) =>
E Regex -> hint b -> H hint
marray_ (Regex -> E Regex
forall a b. b -> Either a b
Right Regex
p0) Tagged All b
t0


test::(R_ b, R.Extract b) =>
    R.Regex -> Tagged Test b -> Bool      -- ^ matched content
test :: Regex -> Tagged Test b -> Bool
test p0 :: Regex
p0 t0 :: Tagged Test b
t0@(Tagged b0 :: b
b0) = Regex -> b -> Bool
forall regex source.
RegexLike regex source =>
regex -> source -> Bool
R.matchTest Regex
p0 b
b0



tagOnce::b -> Tagged Once b
tagOnce :: b -> Tagged Once b
tagOnce = b -> Tagged Once b
forall k (s :: k) b. b -> Tagged s b
Tagged

tagAll::b -> Tagged All b
tagAll :: b -> Tagged All b
tagAll = b -> Tagged All b
forall k (s :: k) b. b -> Tagged s b
Tagged


checkPattern::ByteString -> ByteString
checkPattern :: ByteString -> ByteString
checkPattern bs0 :: ByteString
bs0 = if ByteString
bs0 ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString
B.empty then String -> ByteString
forall a. HasCallStack => String -> a
error "empty pattern"
      else ByteString
bs0