Safe Haskell	None
Language	Haskell2010

Predicate.Data.Regex

Contents

regex expressions

Description

promoted regular expression functions

Synopsis

data Re p q
data Re' (rs :: [ROpt]) p q
data Rescan p q
data Rescan' (rs :: [ROpt]) p q
data RescanRanges p q
data RescanRanges' (rs :: [ROpt]) p q
data Resplit p q
data Resplit' (rs :: [ROpt]) p q
data ReplaceAll p q r
data ReplaceAll' (rs :: [ROpt]) p q r
data ReplaceOne p q r
data ReplaceOne' (rs :: [ROpt]) p q r
data ReplaceAllString o p q r
data ReplaceAllString' (rs :: [ROpt]) (o :: ReplaceFnSub) p q r
data ReplaceOneString (o :: ReplaceFnSub) p q r
data ReplaceOneString' (rs :: [ROpt]) (o :: ReplaceFnSub) p q r
data ReplaceFn (o :: ReplaceFnSub) p
data ReplaceFn1 p
data ReplaceFn2 p
data ReplaceFn3 p

regex expressions

data Re p q Source #

runs a regular expression and returns a boolean: see =~

>>> pz @(Re "^\\d{2}:\\d{2}:\\d{2}$" Id) "13:05:25"
TrueT

>>> pl @(Re "\\d{4}-\\d{3}" Id) "1234-123"
True (Re (\d{4}-\d{3}) | 1234-123)
TrueT

>>> pl @(Re "\\d{4}-\\d{3}" Id) "1234-1x3"
False (Re (\d{4}-\d{3}) | 1234-1x3)
FalseT

>>> pl @(Re "(?i)ab" Id) "aB" -- runtime [use 'Caseless instead]
True (Re ((?i)ab) | aB)
TrueT

>>> pl @(Re "ab" Id) "aB"
False (Re (ab) | aB)
FalseT

>>> pl @(Re "^\\d{1,3}(?:\\.\\d{1,3}){3}$" Id) "123.1.1.21"
True (Re (^\d{1,3}(?:\.\d{1,3}){3}$) | 123.1.1.21)
TrueT

>>> pl @(Guard "regex failed" (Re "^\\d+(?:\\.\\d+)?$" Id) >> ReadP Double Id) "13.345"
Present 13.345 ((>>) 13.345 | {ReadP Double 13.345})
PresentT 13.345

>>> pl @(Guard "regex failed" (Re "^\\d+(?:\\.\\d+)?$" Id) >> ReadP Double Id) "13"
Present 13.0 ((>>) 13.0 | {ReadP Double 13.0})
PresentT 13.0

>>> pl @(ExitWhen "regex failed" (Not (Re "^\\d+(?:\\.\\d+)?$" Id)) >> ReadP Double Id) "-13.4"
Error regex failed ((>>) lhs failed)
FailT "regex failed"

>>> pl @(Re "\\d{4}\\" Id) "ayx"
Error Regex failed to compile (Re (\d{4}\) ([],[]):\ at end of pattern)
FailT "Regex failed to compile"

>>> pl @(Re "^\\d+$" Id) "123\nx"
False (Re (^\d+$) | 123
x)
FalseT

>>> pl @(Re "(?m)^\\d+$" Id) "123\nx" -- (?m) anchors match beginning/end of line instead of whole string
True (Re ((?m)^\d+$) | 123
x)
TrueT

>>> pl @(Catch (Re "\\d+(" Id) 'False) "123"
False (Catch caught exception[Regex failed to compile])
FalseT

>>> pl @(Catch (Re "\\d+" Id) 'False) "123"
True (Catch did not fire)
TrueT

Instances

P (ReT p q) x => P (Re p q :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (Re p q) x :: Type Source # Methods eval :: MonadEval m => proxy (Re p q) -> POpts -> x -> m (TT (PP (Re p q) x)) Source #
type PP (Re p q :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (Re p q :: Type) x

data Re' (rs :: [ROpt]) p q Source #

runs a regular expression with given regex options and returns a boolean: see =~

>>> pl @(Re' '[ 'Caseless, 'Dotall ] "ab" Id) "aB"
True (Re' ['Caseless, 'Dotall] (ab) | aB)
TrueT

>>> pl @(Re' '[ 'Caseless, 'Dotall ] "ab." Id) "aB\n"
True (Re' ['Caseless, 'Dotall] (ab.) | aB
)
TrueT

>>> pl @(Re' '[ 'Caseless ] "ab." Id) "aB\n"
False (Re' ['Caseless] (ab.) | aB
)
FalseT

Instances

(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (Re' rs p q :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (Re' rs p q) x :: Type Source # Methods eval :: MonadEval m => proxy (Re' rs p q) -> POpts -> x -> m (TT (PP (Re' rs p q) x)) Source #
type PP (Re' rs p q :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (Re' rs p q :: Type) x = Bool

data Rescan p q Source #

see scan

>>> pz @(Rescan "^(\\d{2}):(\\d{2}):(\\d{2})$" Id) "13:05:25"
PresentT [("13:05:25",["13","05","25"])]

>>> pz @(Rescan (Snd Id) "13:05:25") ('a',"^(\\d{2}):(\\d{2}):(\\d{2})$")
PresentT [("13:05:25",["13","05","25"])]

>>> pz @(Rescan "^(\\d{2}):(\\d{2}):(\\d{2})$" Id >> Snd (Head Id) >> Map (ReadP Int Id) Id) "13:05:25"
PresentT [13,5,25]

>>> pl @(Rescan "(\\d+)\\D?" Id >> Map (Second (ReadP Int (OneP Id))) Id) "123-444-987"
Present [("123-",123),("444-",444),("987",987)] ((>>) [("123-",123),("444-",444),("987",987)] | {Map [("123-",123),("444-",444),("987",987)] | [("123-",["123"]),("444-",["444"]),("987",["987"])]})
PresentT [("123-",123),("444-",444),("987",987)]

>>> pl @(Rescan ".(.)" Id) "aBcd"
Present [("aB",["B"]),("cd",["d"])] (Rescan (.(.)) [("aB",["B"]),("cd",["d"])] | aBcd)
PresentT [("aB",["B"]),("cd",["d"])]

>>> pl @(Rescan "\\d{1,3}(\\.)?" Id) "123.8.99.21"
Present [("123.",["."]),("8.",["."]),("99.",["."]),("21",[])] (Rescan (\d{1,3}(\.)?) [("123.",["."]),("8.",["."]),("99.",["."]),("21",[])] | 123.8.99.21)
PresentT [("123.",["."]),("8.",["."]),("99.",["."]),("21",[])]

>>> pl @(Map (Fst Id) (Rescan "." (ShowP Id)) >> Filter (Same "2") Id) 12324
Present ["2","2"] ((>>) ["2","2"] | {Fst ["2","2"] | (["2","2"],["1","3","4"])})
PresentT ["2","2"]

>>> pl @(Rescan "(\\d)+?" Id) "1234"
Present [("1",["1"]),("2",["2"]),("3",["3"]),("4",["4"])] (Rescan ((\d)+?) [("1",["1"]),("2",["2"]),("3",["3"]),("4",["4"])] | 1234)
PresentT [("1",["1"]),("2",["2"]),("3",["3"]),("4",["4"])]

>>> pl @(Rescan "(\\d)+" Id) "1234"
Present [("1234",["4"])] (Rescan ((\d)+) [("1234",["4"])] | 1234)
PresentT [("1234",["4"])]

>>> pl @(Rescan "(\\d{1,3})(\\.(\\d{1,3}))+?" Id) "1.2.3.4" -- overcapturing
Present [("1.2",["1",".2","2"]),("3.4",["3",".4","4"])] (Rescan ((\d{1,3})(\.(\d{1,3}))+?) [("1.2",["1",".2","2"]),("3.4",["3",".4","4"])] | 1.2.3.4)
PresentT [("1.2",["1",".2","2"]),("3.4",["3",".4","4"])]

>>> pl @(Rescan "^(\\d)+?$" Id) "1234"
Present [("1234",["4"])] (Rescan (^(\d)+?$) [("1234",["4"])] | 1234)
PresentT [("1234",["4"])]

>>> pl @(Rescan "(\\d{1,3})(\\.(\\d{1,3}))+?" Id) "1.2.3.4"
Present [("1.2",["1",".2","2"]),("3.4",["3",".4","4"])] (Rescan ((\d{1,3})(\.(\d{1,3}))+?) [("1.2",["1",".2","2"]),("3.4",["3",".4","4"])] | 1.2.3.4)
PresentT [("1.2",["1",".2","2"]),("3.4",["3",".4","4"])]

>>> pl @(Rescan "(\\d{1,3})(?:\\.(\\d{1,3}))+?" Id) "1.2.3.4" -- bizzare!
Present [("1.2",["1","2"]),("3.4",["3","4"])] (Rescan ((\d{1,3})(?:\.(\d{1,3}))+?) [("1.2",["1","2"]),("3.4",["3","4"])] | 1.2.3.4)
PresentT [("1.2",["1","2"]),("3.4",["3","4"])]

>>> pl @(Rescan "^(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$" Id) "1.2.3.4"
Present [("1.2.3.4",["1","2","3","4"])] (Rescan (^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$) [("1.2.3.4",["1","2","3","4"])] | 1.2.3.4)
PresentT [("1.2.3.4",["1","2","3","4"])]

>>> pl @(Rescan "([[:xdigit:]]{2})" Id) "wfeb12az"
Present [("fe",["fe"]),("b1",["b1"]),("2a",["2a"])] (Rescan (([[:xdigit:]]{2})) [("fe",["fe"]),("b1",["b1"]),("2a",["2a"])] | wfeb12az)
PresentT [("fe",["fe"]),("b1",["b1"]),("2a",["2a"])]

Instances

P (RescanT p q) x => P (Rescan p q :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (Rescan p q) x :: Type Source # Methods eval :: MonadEval m => proxy (Rescan p q) -> POpts -> x -> m (TT (PP (Rescan p q) x)) Source #
type PP (Rescan p q :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (Rescan p q :: Type) x

data Rescan' (rs :: [ROpt]) p q Source #

runs a regex matcher returning the original values and optionally any groups: see scan

>>> pl @(Rescan' '[ 'Anchored ] "([[:xdigit:]]{2})" Id) "wfeb12az"
Error Regex no results (Rescan' ['Anchored] (([[:xdigit:]]{2})) | "wfeb12az")
FailT "Regex no results"

Instances

(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (Rescan' rs p q :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (Rescan' rs p q) x :: Type Source # Methods eval :: MonadEval m => proxy (Rescan' rs p q) -> POpts -> x -> m (TT (PP (Rescan' rs p q) x)) Source #
type PP (Rescan' rs p q :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (Rescan' rs p q :: Type) x = [(String, [String])]

data RescanRanges p q Source #

Instances

P (RescanRangesT p q) x => P (RescanRanges p q :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (RescanRanges p q) x :: Type Source # Methods eval :: MonadEval m => proxy (RescanRanges p q) -> POpts -> x -> m (TT (PP (RescanRanges p q) x)) Source #
type PP (RescanRanges p q :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (RescanRanges p q :: Type) x

data RescanRanges' (rs :: [ROpt]) p q Source #

see scanRanges

>>> pz @(RescanRanges "^(\\d{2}):(\\d{2}):(\\d{2})$" Id) "13:05:25"
PresentT [((0,8),[(0,2),(3,5),(6,8)])]

Instances

(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (RescanRanges' rs p q :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (RescanRanges' rs p q) x :: Type Source # Methods eval :: MonadEval m => proxy (RescanRanges' rs p q) -> POpts -> x -> m (TT (PP (RescanRanges' rs p q) x)) Source #
type PP (RescanRanges' rs p q :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (RescanRanges' rs p q :: Type) x = [((Int, Int), [(Int, Int)])]

data Resplit p q Source #

splits a string on a regex delimiter: see split

>>> pz @(Resplit "\\." Id) "141.201.1.22"
PresentT ["141","201","1","22"]

>>> pz @(Resplit (Singleton (Fst Id)) (Snd Id)) (':', "12:13:1")
PresentT ["12","13","1"]

>>> pl @(Resplit "\\." Id) "123.2.3.5.6"
Present ["123","2","3","5","6"] (Resplit (\.) ["123","2","3","5","6"] | 123.2.3.5.6)
PresentT ["123","2","3","5","6"]

>>> pl @(Map (ReadP Int Id) (Resplit "\\." Id) >> '(Id, '(Len == 4, All (Between 0 255 Id) Id))) "141.214.125.1.2.3333"
Present ([141,214,125,1,2,3333],(False,False)) ((>>) ([141,214,125,1,2,3333],(False,False)) | {'([141,214,125,1,2,3333],(False,False))})
PresentT ([141,214,125,1,2,3333],(False,False))

>>> pl @(Map (ReadP Int Id) (Resplit "\\." Id) >> Id &&& ((Len == 4) &&& All (Between 0 255 Id) Id)) "141.214.125.1.2.6"
Present ([141,214,125,1,2,6],(False,True)) ((>>) ([141,214,125,1,2,6],(False,True)) | {W '([141,214,125,1,2,6],(False,True))})
PresentT ([141,214,125,1,2,6],(False,True))

>>> pl @(Resplit "\\." Id >> Map (ReadP Int Id) Id >> Id &&& ((Len == 4) &&& All (Between 0 255 Id) Id)) "141.214.125."
Error ReadP Int () (["141","214","125",""] (>>) rhs failed)
FailT "ReadP Int ()"

Instances

P (ResplitT p q) x => P (Resplit p q :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (Resplit p q) x :: Type Source # Methods eval :: MonadEval m => proxy (Resplit p q) -> POpts -> x -> m (TT (PP (Resplit p q) x)) Source #
type PP (Resplit p q :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (Resplit p q :: Type) x

data Resplit' (rs :: [ROpt]) p q Source #

splits a string on a regex delimiter: see split

>>> pl @(Resplit' '[ 'Caseless ] "aBc" Id) "123AbC456abc"
Present ["123","456",""] (Resplit' ['Caseless] (aBc) ["123","456",""] | 123AbC456abc)
PresentT ["123","456",""]

Instances

(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (Resplit' rs p q :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (Resplit' rs p q) x :: Type Source # Methods eval :: MonadEval m => proxy (Resplit' rs p q) -> POpts -> x -> m (TT (PP (Resplit' rs p q) x)) Source #
type PP (Resplit' rs p q :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (Resplit' rs p q :: Type) x = [String]

data ReplaceAll p q r Source #

Instances

P (ReplaceAllT p q r) x => P (ReplaceAll p q r :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (ReplaceAll p q r) x :: Type Source # Methods eval :: MonadEval m => proxy (ReplaceAll p q r) -> POpts -> x -> m (TT (PP (ReplaceAll p q r) x)) Source #
type PP (ReplaceAll p q r :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (ReplaceAll p q r :: Type) x

data ReplaceAll' (rs :: [ROpt]) p q r Source #

Instances

P (ReplaceAllT' rs p q r) x => P (ReplaceAll' rs p q r :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (ReplaceAll' rs p q r) x :: Type Source # Methods eval :: MonadEval m => proxy (ReplaceAll' rs p q r) -> POpts -> x -> m (TT (PP (ReplaceAll' rs p q r) x)) Source #
type PP (ReplaceAll' rs p q r :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (ReplaceAll' rs p q r :: Type) x

data ReplaceOne p q r Source #

replace first occurrence of string 'p' with 'q' in 'r'

>>> pl @(ReplaceOneString 'ROverWrite "abc" "def" Id) "123abc456abc"
Present "123def456abc" (ReplaceOne (abc) 123abc456abc | 123def456abc)
PresentT "123def456abc"

>>> pz @(Rescan "^Date\\((\\d+[+-]\\d{4})\\)" Id >> Head Id >> Snd Id >> Id !! 0 >> ReplaceOneString 'RPrepend "\\d{3}[+-]" "." Id >> ParseTimeP ZonedTime "%s%Q%z" Id) "Date(1530144000123+0530)"
PresentT 2018-06-28 05:30:00.123 +0530

>>> pz @(Rescan "^Date\\((\\d+[+-]\\d{4})\\)" Id >> Head Id >> Snd Id >> Id !! 0 >> ReplaceOneString 'RPrepend "\\d{3}[+-]" "." Id >> ParseTimeP ZonedTime "%s%Q%z" Id) "Date(1593460089052+0800)"
PresentT 2020-06-30 03:48:09.052 +0800

>>> pz @(Rescan "^Date\\((\\d+)(\\d{3}[+-]\\d{4})\\)" Id >> Head Id >> Snd Id >> (Id !! 0 <> "." <> Id !! 1)  >> ParseTimeP ZonedTime "%s%Q%z" Id) "Date(1593460089052+0800)"
PresentT 2020-06-30 03:48:09.052 +0800

Instances

P (ReplaceOneT p q r) x => P (ReplaceOne p q r :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (ReplaceOne p q r) x :: Type Source # Methods eval :: MonadEval m => proxy (ReplaceOne p q r) -> POpts -> x -> m (TT (PP (ReplaceOne p q r) x)) Source #
type PP (ReplaceOne p q r :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (ReplaceOne p q r :: Type) x

data ReplaceOne' (rs :: [ROpt]) p q r Source #

Instances

P (ReplaceOneT' rs p q r) x => P (ReplaceOne' rs p q r :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (ReplaceOne' rs p q r) x :: Type Source # Methods eval :: MonadEval m => proxy (ReplaceOne' rs p q r) -> POpts -> x -> m (TT (PP (ReplaceOne' rs p q r) x)) Source #
type PP (ReplaceOne' rs p q r :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (ReplaceOne' rs p q r :: Type) x

data ReplaceAllString o p q r Source #

Instances

P (ReplaceAllStringT o p q r) x => P (ReplaceAllString o p q r :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (ReplaceAllString o p q r) x :: Type Source # Methods eval :: MonadEval m => proxy (ReplaceAllString o p q r) -> POpts -> x -> m (TT (PP (ReplaceAllString o p q r) x)) Source #
type PP (ReplaceAllString o p q r :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (ReplaceAllString o p q r :: Type) x

data ReplaceAllString' (rs :: [ROpt]) (o :: ReplaceFnSub) p q r Source #

replace all occurrences of string 'p' with 'q' in 'r'

>>> pl @(ReplaceAllString 'ROverWrite "abc" "def" Id) "123abc456abc"
Present "123def456def" (ReplaceAll (abc) 123abc456abc | 123def456def)
PresentT "123def456def"

>>> pl @(ReplaceAllString' '[] 'ROverWrite "abc" "def" Id) "123AbC456abc"
Present "123AbC456def" (ReplaceAll (abc) 123AbC456abc | 123AbC456def)
PresentT "123AbC456def"

>>> pl @(ReplaceAllString' '[ 'Caseless ] 'ROverWrite "abc" "def" Id) "123AbC456abc"
Present "123def456def" (ReplaceAll' ['Caseless] (abc) 123AbC456abc | 123def456def)
PresentT "123def456def"

>>> pl @(ReplaceAllString 'RPrepend "abc" "def" Id) "123AbC456abc"
Present "123AbC456defabc" (ReplaceAll (abc) 123AbC456abc | 123AbC456defabc)
PresentT "123AbC456defabc"

>>> pl @(ReplaceAllString 'ROverWrite "abc" "def" Id) "123AbC456abc"
Present "123AbC456def" (ReplaceAll (abc) 123AbC456abc | 123AbC456def)
PresentT "123AbC456def"

>>> pl @(ReplaceAllString 'RAppend "abc" "def" Id) "123AbC456abc"
Present "123AbC456abcdef" (ReplaceAll (abc) 123AbC456abc | 123AbC456abcdef)
PresentT "123AbC456abcdef"

Instances

P (ReplaceAllStringT' rs o p q r) x => P (ReplaceAllString' rs o p q r :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (ReplaceAllString' rs o p q r) x :: Type Source # Methods eval :: MonadEval m => proxy (ReplaceAllString' rs o p q r) -> POpts -> x -> m (TT (PP (ReplaceAllString' rs o p q r) x)) Source #
type PP (ReplaceAllString' rs o p q r :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (ReplaceAllString' rs o p q r :: Type) x

data ReplaceOneString (o :: ReplaceFnSub) p q r Source #

Instances

P (ReplaceOneStringT o p q r) x => P (ReplaceOneString o p q r :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (ReplaceOneString o p q r) x :: Type Source # Methods eval :: MonadEval m => proxy (ReplaceOneString o p q r) -> POpts -> x -> m (TT (PP (ReplaceOneString o p q r) x)) Source #
type PP (ReplaceOneString o p q r :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (ReplaceOneString o p q r :: Type) x

data ReplaceOneString' (rs :: [ROpt]) (o :: ReplaceFnSub) p q r Source #

Instances

P (ReplaceOneStringT' rs o p q r) x => P (ReplaceOneString' rs o p q r :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (ReplaceOneString' rs o p q r) x :: Type Source # Methods eval :: MonadEval m => proxy (ReplaceOneString' rs o p q r) -> POpts -> x -> m (TT (PP (ReplaceOneString' rs o p q r) x)) Source #
type PP (ReplaceOneString' rs o p q r :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (ReplaceOneString' rs o p q r :: Type) x

data ReplaceFn (o :: ReplaceFnSub) p Source #

Simple replacement string: see ReplaceAllString and ReplaceOneString

Instances

(GetReplaceFnSub r, PP p x ~ String, P p x) => P (ReplaceFn r p :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (ReplaceFn r p) x :: Type Source # Methods eval :: MonadEval m => proxy (ReplaceFn r p) -> POpts -> x -> m (TT (PP (ReplaceFn r p) x)) Source #
type PP (ReplaceFn r p :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (ReplaceFn r p :: Type) x = RReplace

data ReplaceFn1 p Source #

A replacement function (String -> [String] -> String) which returns the whole match and the groups Used by sub and gsub

Requires Text.Show.Functions

Instances

(PP p x ~ (String -> [String] -> String), P p x) => P (ReplaceFn1 p :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (ReplaceFn1 p) x :: Type Source # Methods eval :: MonadEval m => proxy (ReplaceFn1 p) -> POpts -> x -> m (TT (PP (ReplaceFn1 p) x)) Source #
type PP (ReplaceFn1 p :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (ReplaceFn1 p :: Type) x = RReplace

data ReplaceFn2 p Source #

A replacement function (String -> String) that yields the whole match Used by sub and gsub

Requires Text.Show.Functions

>>> :m + Text.Show.Functions
>>> pz @(ReplaceAll "\\." (ReplaceFn2 (Fst Id)) (Snd Id)) (\x -> x <> ":" <> x, "141.201.1.22")
PresentT "141.:.201.:.1.:.22"

Instances

(PP p x ~ (String -> String), P p x) => P (ReplaceFn2 p :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (ReplaceFn2 p) x :: Type Source # Methods eval :: MonadEval m => proxy (ReplaceFn2 p) -> POpts -> x -> m (TT (PP (ReplaceFn2 p) x)) Source #
type PP (ReplaceFn2 p :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (ReplaceFn2 p :: Type) x = RReplace

data ReplaceFn3 p Source #

A replacement function ([String] -> String) which yields the groups Used by sub and gsub

Requires Text.Show.Functions

>>> :m + Text.Show.Functions
>>> import Data.List (intercalate)
>>> pz @(ReplaceAll "^(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)$" (ReplaceFn3 (Fst Id)) (Snd Id)) (\ys -> intercalate  " | " $ map (show . succ . readNote @Int "invalid int") ys, "141.201.1.22")
PresentT "142 | 202 | 2 | 23"

Instances

(PP p x ~ ([String] -> String), P p x) => P (ReplaceFn3 p :: Type) x Source #
Instance details Defined in Predicate.Data.Regex Associated Types type PP (ReplaceFn3 p) x :: Type Source # Methods eval :: MonadEval m => proxy (ReplaceFn3 p) -> POpts -> x -> m (TT (PP (ReplaceFn3 p) x)) Source #
type PP (ReplaceFn3 p :: Type) x Source #
Instance details Defined in Predicate.Data.Regex type PP (ReplaceFn3 p :: Type) x = RReplace