{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
{-# LANGUAGE CPP #-}
#if __GLASGOW_HASKELL__ >= 800
{-# OPTIONS_GHC -fno-warn-redundant-constraints #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
#endif
module Text.RE.PCRE.Sequence
(
(*=~)
, (?=~)
, (*=~/)
, (?=~/)
, Matches
, matchesSource
, allMatches
, anyMatches
, countMatches
, matches
, Match
, matchSource
, matched
, matchedText
, module Text.RE.TestBench.Parsers
, RE
, reSource
, SimpleREOptions(..)
, SearchReplace(..)
, compileRegex
, compileRegexWith
, compileSearchReplace
, compileSearchReplaceWith
, escape
, escapeWith
, escapeREString
, (=~)
, (=~~)
, re
, reMultilineSensitive
, reMultilineInsensitive
, reBlockSensitive
, reBlockInsensitive
, reMS
, reMI
, reBS
, reBI
, re_
, edMultilineSensitive
, edMultilineInsensitive
, edBlockSensitive
, edBlockInsensitive
, ed
, edMS
, edMI
, edBS
, edBI
, ed_
, cp
, module Text.RE.Tools.IsRegex
) where
import Control.Monad.Fail
import qualified Data.Sequence as S
import Data.Typeable
import Prelude.Compat
import Text.RE.REOptions
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.Sequence
import Text.Regex.Base
import qualified Text.Regex.PCRE as PCRE
(*=~) :: (S.Seq Char)
-> RE
-> Matches (S.Seq Char)
*=~ :: Seq Char -> RE -> Matches (Seq Char)
(*=~) Seq Char
bs RE
rex = CaptureNames -> Matches (Seq Char) -> Matches (Seq Char)
forall a. CaptureNames -> Matches a -> Matches a
addCaptureNamesToMatches (RE -> CaptureNames
reCaptureNames RE
rex) (Matches (Seq Char) -> Matches (Seq Char))
-> Matches (Seq Char) -> Matches (Seq Char)
forall a b. (a -> b) -> a -> b
$ Regex -> Seq Char -> Matches (Seq Char)
forall regex source target.
RegexContext regex source target =>
regex -> source -> target
match (RE -> Regex
reRegex RE
rex) Seq Char
bs
(?=~) :: (S.Seq Char)
-> RE
-> Match (S.Seq Char)
?=~ :: Seq Char -> RE -> Match (Seq Char)
(?=~) Seq Char
bs RE
rex = CaptureNames -> Match (Seq Char) -> Match (Seq Char)
forall a. CaptureNames -> Match a -> Match a
addCaptureNamesToMatch (RE -> CaptureNames
reCaptureNames RE
rex) (Match (Seq Char) -> Match (Seq Char))
-> Match (Seq Char) -> Match (Seq Char)
forall a b. (a -> b) -> a -> b
$ Regex -> Seq Char -> Match (Seq Char)
forall regex source target.
RegexContext regex source target =>
regex -> source -> target
match (RE -> Regex
reRegex RE
rex) Seq Char
bs
(*=~/) :: (S.Seq Char) -> SearchReplace RE (S.Seq Char) -> (S.Seq Char)
*=~/ :: Seq Char -> SearchReplace RE (Seq Char) -> Seq Char
(*=~/) = (SearchReplace RE (Seq Char) -> Seq Char -> Seq Char)
-> Seq Char -> SearchReplace RE (Seq Char) -> Seq Char
forall a b c. (a -> b -> c) -> b -> a -> c
flip SearchReplace RE (Seq Char) -> Seq Char -> Seq Char
forall re s. IsRegex re s => SearchReplace re s -> s -> s
searchReplaceAll
(?=~/) :: (S.Seq Char) -> SearchReplace RE (S.Seq Char) -> (S.Seq Char)
?=~/ :: Seq Char -> SearchReplace RE (Seq Char) -> Seq Char
(?=~/) = (SearchReplace RE (Seq Char) -> Seq Char -> Seq Char)
-> Seq Char -> SearchReplace RE (Seq Char) -> Seq Char
forall a b c. (a -> b -> c) -> b -> a -> c
flip SearchReplace RE (Seq Char) -> Seq Char -> Seq Char
forall re s. IsRegex re s => SearchReplace re s -> s -> s
searchReplaceFirst
(=~) :: ( Typeable a
, RegexContext PCRE.Regex (S.Seq Char) a
)
=> (S.Seq Char)
-> RE
-> a
=~ :: Seq Char -> RE -> a
(=~) Seq Char
bs RE
rex = CaptureNames -> a -> a
forall a. Typeable a => CaptureNames -> a -> a
addCaptureNames (RE -> CaptureNames
reCaptureNames RE
rex) (a -> a) -> a -> a
forall a b. (a -> b) -> a -> b
$ Regex -> Seq Char -> a
forall regex source target.
RegexContext regex source target =>
regex -> source -> target
match (RE -> Regex
reRegex RE
rex) Seq Char
bs
(=~~) :: ( Monad m, MonadFail m
, Functor m
, Typeable a
, RegexContext PCRE.Regex (S.Seq Char) a
)
=> (S.Seq Char)
-> RE
-> m a
=~~ :: Seq Char -> RE -> m a
(=~~) Seq Char
bs RE
rex = CaptureNames -> a -> a
forall a. Typeable a => CaptureNames -> a -> a
addCaptureNames (RE -> CaptureNames
reCaptureNames RE
rex) (a -> a) -> m a -> m a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Regex -> Seq Char -> m a
forall regex source target (m :: * -> *).
(RegexContext regex source target, MonadFail m) =>
regex -> source -> m target
matchM (RE -> Regex
reRegex RE
rex) Seq Char
bs
instance IsRegex RE (S.Seq Char) where
matchOnce :: RE -> Seq Char -> Match (Seq Char)
matchOnce = (Seq Char -> RE -> Match (Seq Char))
-> RE -> Seq Char -> Match (Seq Char)
forall a b c. (a -> b -> c) -> b -> a -> c
flip Seq Char -> RE -> Match (Seq Char)
(?=~)
matchMany :: RE -> Seq Char -> Matches (Seq Char)
matchMany = (Seq Char -> RE -> Matches (Seq Char))
-> RE -> Seq Char -> Matches (Seq Char)
forall a b c. (a -> b -> c) -> b -> a -> c
flip Seq Char -> RE -> Matches (Seq Char)
(*=~)
makeRegexWith :: SimpleREOptions -> Seq Char -> m RE
makeRegexWith = \SimpleREOptions
o -> SimpleREOptions -> String -> m RE
forall (m :: * -> *).
(Functor m, Monad m, MonadFail m) =>
SimpleREOptions -> String -> m RE
compileRegexWith SimpleREOptions
o (String -> m RE) -> (Seq Char -> String) -> Seq Char -> m RE
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq Char -> String
forall a. Replace a => a -> String
unpackR
makeSearchReplaceWith :: SimpleREOptions
-> Seq Char -> Seq Char -> m (SearchReplace RE (Seq Char))
makeSearchReplaceWith = \SimpleREOptions
o Seq Char
r Seq Char
t -> SimpleREOptions
-> String -> String -> m (SearchReplace RE (Seq Char))
forall (m :: * -> *) s.
(Monad m, MonadFail m, Functor m, IsRegex RE s) =>
SimpleREOptions -> String -> String -> m (SearchReplace RE s)
compileSearchReplaceWith SimpleREOptions
o (Seq Char -> String
forall a. Replace a => a -> String
unpackR Seq Char
r) (Seq Char -> String
forall a. Replace a => a -> String
unpackR Seq Char
t)
regexSource :: RE -> Seq Char
regexSource = String -> Seq Char
forall a. Replace a => String -> a
packR (String -> Seq Char) -> (RE -> String) -> RE -> Seq Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RE -> String
reSource