Text.Regex.PCRE.Heavy

A usable regular expressions library on top of pcre-light.

Matching

(=~) :: (ConvertibleStrings SBS a, ConvertibleStrings a SBS) => a -> Regex -> Bool

Checks whether a string matches a regex.

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

(≈) :: (ConvertibleStrings SBS a, ConvertibleStrings a SBS) => a -> Regex -> Bool

Same as =~.

Checks whether a string matches a regex.

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

scan :: (ConvertibleStrings SBS a, ConvertibleStrings a SBS) => Regex -> a -> [(a, [a])]

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"])

scanO :: (ConvertibleStrings SBS a, ConvertibleStrings a SBS) => Regex -> [PCREExecOption] -> a -> [(a, [a])]

Exactly like scan, but passes runtime options to PCRE.

scanRanges :: (ConvertibleStrings SBS a, ConvertibleStrings a SBS) => Regex -> a -> [((Int, Int), [(Int, Int)])]

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.

scanRangesO :: (ConvertibleStrings SBS a, ConvertibleStrings a SBS) => Regex -> [PCREExecOption] -> a -> [((Int, Int), [(Int, Int)])]

Exactly like scanRanges, but passes runtime options to PCRE.

Replacement

sub :: (ConvertibleStrings SBS a, ConvertibleStrings a SBS, RegexReplacement r) => Regex -> r -> a -> a

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}"

subO :: (ConvertibleStrings SBS a, ConvertibleStrings a SBS, RegexReplacement r) => Regex -> [PCREExecOption] -> r -> a -> a

Exactly like sub, but passes runtime options to PCRE.

gsub :: (ConvertibleStrings SBS a, ConvertibleStrings a SBS, RegexReplacement r) => Regex -> r -> a -> a

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
""

gsubO :: (ConvertibleStrings SBS a, ConvertibleStrings a SBS, RegexReplacement r) => Regex -> [PCREExecOption] -> r -> a -> a

Exactly like gsub, but passes runtime options to PCRE.

Splitting

split :: (ConvertibleStrings SBS a, ConvertibleStrings a SBS) => Regex -> a -> [a]

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)
[""]

splitO :: (ConvertibleStrings SBS a, ConvertibleStrings a SBS) => Regex -> [PCREExecOption] -> a -> [a]

Exactly like split, but passes runtime options to PCRE.

QuasiQuoter

re :: QuasiQuoter

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

mkRegexQQ :: [PCREOption] -> QuasiQuoter

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

Types and stuff from pcre-light

data Regex :: *

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.

Instances

Eq Regex

Ord Regex

Show Regex

data PCREOption :: *

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

Instances

Eq PCREOption

Ord PCREOption

Read PCREOption

Show PCREOption

compileM :: ByteString -> [PCREOption] -> Either String Regex

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"

Advanced raw stuff

rawMatch :: Regex -> SBS -> Int -> [PCREExecOption] -> Maybe [(Int, Int)]

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)]

rawSub :: RegexReplacement r => Regex -> r -> SBS -> Int -> [PCREExecOption] -> Maybe (SBS, Int)