Checks whether a string matches a regex.

>>> :set -XQuasiQuotes
>>> :set -XFlexibleContexts
>>> "https://unrelenting.technology" =~ [re|^http.*|]
True

Same as =~.

Checks whether a string matches a regex.

>>> :set -XQuasiQuotes
>>> :set -XFlexibleContexts
>>> "https://unrelenting.technology" =~ [re|^http.*|]
True

Searches the string for all matches of a given regex.

>>> scan [re|\s*entry (\d+) (\w+)\s*&?|] (" entry 1 hello  &entry 2 hi" :: String)
[(" entry 1 hello  &",["1","hello"]),("entry 2 hi",["2","hi"])]

It is lazy! If you only need the first match, just apply head (or headMay from the "safe" library) -- no extra work will be performed!

>>> head $ scan [re|\s*entry (\d+) (\w+)\s*&?|] (" entry 1 hello  &entry 2 hi" :: String)
(" entry 1 hello  &",["1","hello"])

Exactly like scan, but passes runtime options to PCRE.

Searches the string for all matches of a given regex, like scan, but returns positions inside of the string.

>>> scanRanges [re|\s*entry (\d+) (\w+)\s*&?|] (" entry 1 hello  &entry 2 hi" :: String)
[((0,17),[(7,8),(9,14)]),((17,27),[(23,24),(25,27)])]

And just like scan, it's lazy.

Exactly like scanRanges, but passes runtime options to PCRE.

Replaces the first occurence of a given regex.

>>> sub [re|thing|] "world" "Hello, thing thing" :: String
"Hello, world thing"

>>> sub [re|a|] "b" "c" :: String
"c"

>>> sub [re|bad|] "xxxbad" "this is bad, right?" :: String
"this is xxxbad, right?"

You can use functions! A function of ConvertibleStrings SBS gets the full match. A function of [ConvertibleStrings SBS] gets the groups. A function of ConvertibleStrings SBS → [ConvertibleStrings SBS] gets both.

>>> sub [re|%(\d+)(\w+)|] (\(d:w:_) -> "{" ++ d ++ " of " ++ w ++ "}" :: String) "Hello, %20thing" :: String
"Hello, {20 of thing}"

Exactly like sub, but passes runtime options to PCRE.

Replaces all occurences of a given regex.

See sub for more documentation.

>>> gsub [re|thing|] "world" "Hello, thing thing" :: String
"Hello, world world"

>>> gsub [re||] "" "Hello, world" :: String
"Hello, world"

https://github.com/myfreeweb/pcre-heavy/issues/2 >>> gsub [re|good|] "bad" "goodgoodgood" :: String "badbadbad"

>>> gsub [re|bad|] "xxxbad" "this is bad, right? bad" :: String
"this is xxxbad, right? xxxbad"

>>> gsub [re|a|] "" "aaa" :: String
""

Exactly like gsub, but passes runtime options to PCRE.

Splits the string using the given regex.

Is lazy.

>>> split [re|%(begin|next|end)%|] ("%begin%hello%next%world%end%" :: String)
["","hello","world",""]

>>> split [re|%(begin|next|end)%|] ("" :: String)
[""]

Exactly like split, but passes runtime options to PCRE.

A QuasiQuoter for regular expressions that does a compile time check.

Returns a QuasiQuoter like re, but with given PCRE options.

An abstract pointer to a compiled PCRE Regex structure The structure allocated by the PCRE library will be deallocated automatically by the Haskell storage manager.

A type for PCRE compile-time options. These are newtyped CInts, which can be bitwise-or'd together, using '(Data.Bits..|.)'

compileM A safe version of compile with failure wrapped in an Either.

Examples,

> compileM ".*" [] :: Either String Regex
Right (Regex 0x000000004bb5b980 ".*")

> compileM "*" [] :: Either String Regex
Left "nothing to repeat"

Does raw PCRE matching (you probably shouldn't use this directly).

>>> :set -XOverloadedStrings
>>> rawMatch [re|\w{2}|] "a a ab abc ba" 0 []
Just [(4,6)]
>>> rawMatch [re|\w{2}|] "a a ab abc ba" 6 []
Just [(7,9)]
>>> rawMatch [re|(\w)(\w)|] "a a ab abc ba" 0 []
Just [(4,6),(4,5),(5,6)]