Predicate.Data.Regex

promoted regular expression functions

functions

data Re p

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

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

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

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

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

>>> pl @(Re "ab") "aB"
False (Re (ab) | aB)
Val False

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

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

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

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

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

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

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

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

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

Instances

P (ReT p) x => P (Re p :: Type) x

Defined in Predicate.Data.Regex

Associated Types

type PP (Re p) x

Methods

eval :: MonadEval m => proxy (Re p) -> POpts -> x -> m (TT (PP (Re p) x))

Show (Re p)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> Re p -> ShowS

show :: Re p -> String

showList :: [Re p] -> ShowS

type PP (Re p :: Type) x

Defined in Predicate.Data.Regex

type PP (Re p :: Type) x

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

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)
Val True

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

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

Instances

(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (Re' rs p q :: Type) x

Defined in Predicate.Data.Regex

Associated Types

type PP (Re' rs p q) x

Methods

eval :: MonadEval m => proxy (Re' rs p q) -> POpts -> x -> m (TT (PP (Re' rs p q) x))

Show (Re' rs p q)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> Re' rs p q -> ShowS

show :: Re' rs p q -> String

showList :: [Re' rs p q] -> ShowS

type PP (Re' rs p q :: Type) x

Defined in Predicate.Data.Regex

type PP (Re' rs p q :: Type) x = Bool

data Rescan p

see scan

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

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

>>> pl @(Rescan "(\\d+)\\D?" >> Map (Second (ReadP Int (OneP)))) "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"])]})
Val [("123-",123),("444-",444),("987",987)]

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

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

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

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

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

>>> pl @(Rescan "(\\d{1,3})(\\.(\\d{1,3}))+?") "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)
Val [("1.2",["1",".2","2"]),("3.4",["3",".4","4"])]

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

>>> pl @(Rescan "(\\d{1,3})(\\.(\\d{1,3}))+?") "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)
Val [("1.2",["1",".2","2"]),("3.4",["3",".4","4"])]

>>> pl @(Rescan "(\\d{1,3})(?:\\.(\\d{1,3}))+?") "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)
Val [("1.2",["1","2"]),("3.4",["3","4"])]

>>> pl @(Rescan "^(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$") "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)
Val [("1.2.3.4",["1","2","3","4"])]

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

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

Instances

P (RescanT p) x => P (Rescan p :: Type) x

Defined in Predicate.Data.Regex

Associated Types

type PP (Rescan p) x

Methods

eval :: MonadEval m => proxy (Rescan p) -> POpts -> x -> m (TT (PP (Rescan p) x))

Show (Rescan p)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> Rescan p -> ShowS

show :: Rescan p -> String

showList :: [Rescan p] -> ShowS

type PP (Rescan p :: Type) x

Defined in Predicate.Data.Regex

type PP (Rescan p :: Type) x

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

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")
Fail "Regex no results"

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

>>> pz @('(Id,Intercalate '["\\."] (Repeat 4 "([01]?\\d?\\d|2[0-4]\\d|25[0-5])") >> Concat) >> Rescan' '[] ("^" <> Snd <> "$") Fst) "1.2.3.255" -- have to use Rescan' here: Lift helps not!
Val [("1.2.3.255",["1","2","3","255"])]

>>> pz @('(Id,Intercalate '["\\."] (Repeat 4 "([01]?\\d?\\d|2[0-4]\\d|25[0-5])") >> Concat) >> Rescan' '[] ("^" <> Snd <> "$") Fst >> FMap (Second (FMap (ReadP Int Id)))) "1.2.3.255"
Val [("1.2.3.255",[1,2,3,255])]

Instances

(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (Rescan' rs p q :: Type) x

Defined in Predicate.Data.Regex

Associated Types

type PP (Rescan' rs p q) x

Methods

eval :: MonadEval m => proxy (Rescan' rs p q) -> POpts -> x -> m (TT (PP (Rescan' rs p q) x))

Show (Rescan' rs p q)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> Rescan' rs p q -> ShowS

show :: Rescan' rs p q -> String

showList :: [Rescan' rs p q] -> ShowS

type PP (Rescan' rs p q :: Type) x

Defined in Predicate.Data.Regex

type PP (Rescan' rs p q :: Type) x = [(String, [String])]

data RescanRanges p q

see scanRanges

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

Instances

P (RescanRangesT p q) x => P (RescanRanges p q :: Type) x

Defined in Predicate.Data.Regex

Associated Types

type PP (RescanRanges p q) x

Methods

eval :: MonadEval m => proxy (RescanRanges p q) -> POpts -> x -> m (TT (PP (RescanRanges p q) x))

Show (RescanRanges p q)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> RescanRanges p q -> ShowS

show :: RescanRanges p q -> String

showList :: [RescanRanges p q] -> ShowS

type PP (RescanRanges p q :: Type) x

Defined in Predicate.Data.Regex

type PP (RescanRanges p q :: Type) x

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

similar to RescanRanges but also allows the regex options rs to be specified

Instances

(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (RescanRanges' rs p q :: Type) x

Defined in Predicate.Data.Regex

Associated Types

type PP (RescanRanges' rs p q) x

Methods

eval :: MonadEval m => proxy (RescanRanges' rs p q) -> POpts -> x -> m (TT (PP (RescanRanges' rs p q) x))

Show (RescanRanges' rs p q)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> RescanRanges' rs p q -> ShowS

show :: RescanRanges' rs p q -> String

showList :: [RescanRanges' rs p q] -> ShowS

type PP (RescanRanges' rs p q :: Type) x

Defined in Predicate.Data.Regex

type PP (RescanRanges' rs p q :: Type) x = [((Int, Int), [(Int, Int)])]

data Resplit p

splits a string on a regex delimiter: see split

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

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

>>> pl @(Map' (ReadP Int Id) (Resplit "\\.") >> '(Id, '(Len == 4, All (0 <..> 0xff)))) "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))})
Val ([141,214,125,1,2,3333],(False,False))

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

>>> pl @(Resplit "\\." >> Map (ReadP Int Id) >> Id &&& ((Len == 4) &&& All (0 <..> 0xff))) "141.214.125."
Error ReadP Int () (Map(i=3, a="") excnt=1)
Fail "ReadP Int ()"

Instances

P (ResplitT p) x => P (Resplit p :: Type) x

Defined in Predicate.Data.Regex

Associated Types

type PP (Resplit p) x

Methods

eval :: MonadEval m => proxy (Resplit p) -> POpts -> x -> m (TT (PP (Resplit p) x))

Show (Resplit p)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> Resplit p -> ShowS

show :: Resplit p -> String

showList :: [Resplit p] -> ShowS

type PP (Resplit p :: Type) x

Defined in Predicate.Data.Regex

type PP (Resplit p :: Type) x

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

splits a string on a regex delimiter: see split

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

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

Instances

(GetROpts rs, PP p x ~ String, PP q x ~ String, P p x, P q x) => P (Resplit' rs p q :: Type) x

Defined in Predicate.Data.Regex

Associated Types

type PP (Resplit' rs p q) x

Methods

eval :: MonadEval m => proxy (Resplit' rs p q) -> POpts -> x -> m (TT (PP (Resplit' rs p q) x))

Show (Resplit' rs p q)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> Resplit' rs p q -> ShowS

show :: Resplit' rs p q -> String

showList :: [Resplit' rs p q] -> ShowS

type PP (Resplit' rs p q :: Type) x

Defined in Predicate.Data.Regex

type PP (Resplit' rs p q :: Type) x = [String]

data ReplaceAll p q r

replaces all values using regex p with a replacement function q inside the value r

Instances

P (ReplaceAllT p q r) x => P (ReplaceAll p q r :: Type) x

Defined in Predicate.Data.Regex

Associated Types

type PP (ReplaceAll p q r) x

Methods

eval :: MonadEval m => proxy (ReplaceAll p q r) -> POpts -> x -> m (TT (PP (ReplaceAll p q r) x))

Show (ReplaceAll p q r)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> ReplaceAll p q r -> ShowS

show :: ReplaceAll p q r -> String

showList :: [ReplaceAll p q r] -> ShowS

type PP (ReplaceAll p q r :: Type) x

Defined in Predicate.Data.Regex

type PP (ReplaceAll p q r :: Type) x

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

replaces all values using regex p with a replacement function q inside the value r using regex options rs

Instances

P (ReplaceAllT' rs p q r) x => P (ReplaceAll' rs p q r :: Type) x

Defined in Predicate.Data.Regex

Associated Types

type PP (ReplaceAll' rs p q r) x

Methods

eval :: MonadEval m => proxy (ReplaceAll' rs p q r) -> POpts -> x -> m (TT (PP (ReplaceAll' rs p q r) x))

Show (ReplaceAll' rs p q r)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> ReplaceAll' rs p q r -> ShowS

show :: ReplaceAll' rs p q r -> String

showList :: [ReplaceAll' rs p q r] -> ShowS

type PP (ReplaceAll' rs p q r :: Type) x

Defined in Predicate.Data.Regex

type PP (ReplaceAll' rs p q r :: Type) x

data ReplaceOne p q r

replaces first value using regex p with a replacement function q inside the value r

Instances

P (ReplaceOneT p q r) x => P (ReplaceOne p q r :: Type) x

Defined in Predicate.Data.Regex

Associated Types

type PP (ReplaceOne p q r) x

Methods

eval :: MonadEval m => proxy (ReplaceOne p q r) -> POpts -> x -> m (TT (PP (ReplaceOne p q r) x))

Show (ReplaceOne p q r)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> ReplaceOne p q r -> ShowS

show :: ReplaceOne p q r -> String

showList :: [ReplaceOne p q r] -> ShowS

type PP (ReplaceOne p q r :: Type) x

Defined in Predicate.Data.Regex

type PP (ReplaceOne p q r :: Type) x

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

replaces the first value using regex p with a replacement function q inside the value r using regex options rs

Instances

P (ReplaceOneT' rs p q r) x => P (ReplaceOne' rs p q r :: Type) x

Defined in Predicate.Data.Regex

Associated Types

type PP (ReplaceOne' rs p q r) x

Methods

eval :: MonadEval m => proxy (ReplaceOne' rs p q r) -> POpts -> x -> m (TT (PP (ReplaceOne' rs p q r) x))

Show (ReplaceOne' rs p q r)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> ReplaceOne' rs p q r -> ShowS

show :: ReplaceOne' rs p q r -> String

showList :: [ReplaceOne' rs p q r] -> ShowS

type PP (ReplaceOne' rs p q r :: Type) x

Defined in Predicate.Data.Regex

type PP (ReplaceOne' rs p q r :: Type) x

data ReplaceAllString o p q r

replace all occurrences of string p with q in r

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

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

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

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

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

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

>>> pz @(ReplaceAllString 'ROverWrite "\\." ":" Id) "141.201.1.22"
Val "141:201:1:22"

Instances

P (ReplaceAllStringT o p q r) x => P (ReplaceAllString o p q r :: Type) x

Defined in Predicate.Data.Regex

Associated Types

type PP (ReplaceAllString o p q r) x

Methods

eval :: MonadEval m => proxy (ReplaceAllString o p q r) -> POpts -> x -> m (TT (PP (ReplaceAllString o p q r) x))

Show (ReplaceAllString o p q r)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> ReplaceAllString o p q r -> ShowS

show :: ReplaceAllString o p q r -> String

showList :: [ReplaceAllString o p q r] -> ShowS

type PP (ReplaceAllString o p q r :: Type) x

Defined in Predicate.Data.Regex

type PP (ReplaceAllString o p q r :: Type) x

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

replace all occurrences of string p with q in r using regex options rs

Instances

P (ReplaceAllStringT' rs o p q r) x => P (ReplaceAllString' rs o p q r :: Type) x

Defined in Predicate.Data.Regex

Associated Types

type PP (ReplaceAllString' rs o p q r) x

Methods

eval :: MonadEval m => proxy (ReplaceAllString' rs o p q r) -> POpts -> x -> m (TT (PP (ReplaceAllString' rs o p q r) x))

Show (ReplaceAllString' rs o p q r)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> ReplaceAllString' rs o p q r -> ShowS

show :: ReplaceAllString' rs o p q r -> String

showList :: [ReplaceAllString' rs o p q r] -> ShowS

type PP (ReplaceAllString' rs o p q r :: Type) x

Defined in Predicate.Data.Regex

type PP (ReplaceAllString' rs o p q r :: Type) x

data ReplaceOneString (o :: ReplaceFnSub) p q r

replace first occurrence of string p with q in r

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

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

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

Instances

P (ReplaceOneStringT o p q r) x => P (ReplaceOneString o p q r :: Type) x

Defined in Predicate.Data.Regex

Associated Types

type PP (ReplaceOneString o p q r) x

Methods

eval :: MonadEval m => proxy (ReplaceOneString o p q r) -> POpts -> x -> m (TT (PP (ReplaceOneString o p q r) x))

Show (ReplaceOneString o p q r)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> ReplaceOneString o p q r -> ShowS

show :: ReplaceOneString o p q r -> String

showList :: [ReplaceOneString o p q r] -> ShowS

type PP (ReplaceOneString o p q r :: Type) x

Defined in Predicate.Data.Regex

type PP (ReplaceOneString o p q r :: Type) x

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

same as ReplaceOneString but allow setting regex options with rs

Instances

P (ReplaceOneStringT' rs o p q r) x => P (ReplaceOneString' rs o p q r :: Type) x

Defined in Predicate.Data.Regex

Associated Types

type PP (ReplaceOneString' rs o p q r) x

Methods

eval :: MonadEval m => proxy (ReplaceOneString' rs o p q r) -> POpts -> x -> m (TT (PP (ReplaceOneString' rs o p q r) x))

Show (ReplaceOneString' rs o p q r)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> ReplaceOneString' rs o p q r -> ShowS

show :: ReplaceOneString' rs o p q r -> String

showList :: [ReplaceOneString' rs o p q r] -> ShowS

type PP (ReplaceOneString' rs o p q r :: Type) x

Defined in Predicate.Data.Regex

type PP (ReplaceOneString' rs o p q r :: Type) x

data ReplaceFn (o :: ReplaceFnSub) p

Simple replacement string: see ReplaceAllString and ReplaceOneString

Instances

(GetReplaceFnSub r, PP p x ~ String, P p x) => P (ReplaceFn r p :: Type) x

Defined in Predicate.Data.Regex

Associated Types

type PP (ReplaceFn r p) x

Methods

eval :: MonadEval m => proxy (ReplaceFn r p) -> POpts -> x -> m (TT (PP (ReplaceFn r p) x))

Show (ReplaceFn o p)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> ReplaceFn o p -> ShowS

show :: ReplaceFn o p -> String

showList :: [ReplaceFn o p] -> ShowS

type PP (ReplaceFn r p :: Type) x

Defined in Predicate.Data.Regex

type PP (ReplaceFn r p :: Type) x = RReplace

data ReplaceFn1 p

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

Defined in Predicate.Data.Regex

Associated Types

type PP (ReplaceFn1 p) x

Methods

eval :: MonadEval m => proxy (ReplaceFn1 p) -> POpts -> x -> m (TT (PP (ReplaceFn1 p) x))

Show (ReplaceFn1 p)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> ReplaceFn1 p -> ShowS

show :: ReplaceFn1 p -> String

showList :: [ReplaceFn1 p] -> ShowS

type PP (ReplaceFn1 p :: Type) x

Defined in Predicate.Data.Regex

type PP (ReplaceFn1 p :: Type) x = RReplace

data ReplaceFn2 p

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) Snd) (\x -> x <> ":" <> x, "141.201.1.22")
Val "141.:.201.:.1.:.22"

Instances

(PP p x ~ (String -> String), P p x) => P (ReplaceFn2 p :: Type) x

Defined in Predicate.Data.Regex

Associated Types

type PP (ReplaceFn2 p) x

Methods

eval :: MonadEval m => proxy (ReplaceFn2 p) -> POpts -> x -> m (TT (PP (ReplaceFn2 p) x))

Show (ReplaceFn2 p)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> ReplaceFn2 p -> ShowS

show :: ReplaceFn2 p -> String

showList :: [ReplaceFn2 p] -> ShowS

type PP (ReplaceFn2 p :: Type) x

Defined in Predicate.Data.Regex

type PP (ReplaceFn2 p :: Type) x = RReplace

data ReplaceFn3 p

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) Snd) (\ys -> intercalate  " | " $ map (show . succ . readNote @Int "invalid int") ys, "141.201.1.22")
Val "142 | 202 | 2 | 23"

Instances

(PP p x ~ ([String] -> String), P p x) => P (ReplaceFn3 p :: Type) x

Defined in Predicate.Data.Regex

Associated Types

type PP (ReplaceFn3 p) x

Methods

eval :: MonadEval m => proxy (ReplaceFn3 p) -> POpts -> x -> m (TT (PP (ReplaceFn3 p) x))

Show (ReplaceFn3 p)

Defined in Predicate.Data.Regex

Methods

showsPrec :: Int -> ReplaceFn3 p -> ShowS

show :: ReplaceFn3 p -> String

showList :: [ReplaceFn3 p] -> ShowS

type PP (ReplaceFn3 p :: Type) x

Defined in Predicate.Data.Regex

type PP (ReplaceFn3 p :: Type) x = RReplace