lens-regex-pcre
- NOTE: I don't promise that this is fast yet;
- NOTE: currently only supports
Text but should be generalizable to more string-likes; open an issue if you need it
Based on pcre-heavy; so it should support any regexes which it supports.
I'll likely add a way to pass settings in soon; make an issue if you need this :)
Working with Regexes in Haskell kinda sucks; it's tough to figure out which libs
to use, and even after you pick one it's tough to figure out how to use it.
As it turns out; regexes are a very lens-like tool; Traversals allow you to select
and alter zero or more matches; traversals can even carry indexes so you know which match or group you're working
on.
Note that all traversals in this library are not techically lawful; the break the 'multi-set'
idempotence law; in reality this isn't usually a problem; but consider yourself warned. Test your code.
Here are a few examples:
-- Getting all matches:
> "one _two_ three _four_" ^.. regex [rx|_\w+_|] . match
["_two_","_four_"]
-- Regex replace/mutation
> "one _two_ three _four_" & regex [rx|_\w+_|] . match %~ T.toUpper
"one _TWO_ three _FOUR_"
-- Getting groups with their index.
> "1/2 and 3/4" ^.. regex [rx|(\d+)/(\d+)|] . igroups . withIndex
[(0,"1"),(1,"2"),(0,"3"),(1,"4")]
-- Check for any matches:
> has (regex [rx|ne+dle|]) "a needle in a haystack"
True
-- Check for matches which also match a predicate:
> has (regex [rx|\w+|] . match . filtered ((> 7) . T.length)) "one word here is loooooooong"
True
-- Get the third match
> "alpha beta charlie delta" ^? (iregex [rx|\w+|] . index 2 . match)
Just "charlie"
-- Replace the third match
> "alpha beta charlie delta" & (iregex [rx|\w+|] . index 2 . match) .~ "GAMMA"
"alpha beta GAMMA delta"
-- Sort all matches alphabetically in place
> "*charlie* beta = _alpha_ delta" & partsOf (iregex [rx|[a-z]+|] . match) %~ sort
"*alpha* beta = _charlie_ delta"
-- Match integers, 'Read' them into ints, then sort each match in-place
> "Monday: 29, Tuesday: 99, Wednesday: 3" & partsOf' (iregex [rx|\d+|] . match . unpacked . _Show @Int) %~ sort
"Monday: 3, Tuesday: 29, Wednesday: 99"
Basically anything you want to do is possible somehow.
Expected behaviour (and examples) can be found in the test suite:
import Control.Lens
import Control.Lens.Regex
describe "regex" $ do
describe "match" $ do
describe "getting" $ do
it "should find one match" $ do
"abc" ^.. regex [rx|b|] . match
`shouldBe` ["b"]
it "should find many matches" $ do
"a b c" ^.. regex [rx|\w|] . match
`shouldBe` ["a", "b", "c"]
it "should fold" $ do
"a b c" ^. regex [rx|\w|] . match
`shouldBe` "abc"
it "should match with a group" $ do
"a b c" ^.. regex [rx|(\w)|] . match
`shouldBe` ["a", "b", "c"]
it "should match with many groups" $ do
"a b c" ^.. regex [rx|(\w) (\w)|] . match
`shouldBe` ["a b"]
it "should be greedy when overlapping" $ do
"abc" ^.. regex [rx|\w+|] . match
`shouldBe`["abc"]
it "should respect lazy modifiers" $ do
"abc" ^.. regex [rx|\w+?|] . match
`shouldBe`["a", "b", "c"]
describe "setting" $ do
it "should allow setting" $ do
("one two three" & regex [rx|two|] . match .~ "new")
`shouldBe` "one new three"
it "should allow setting many" $ do
("one <two> three" & regex [rx|\w+|] . match .~ "new")
`shouldBe` "new <new> new"
it "should allow mutating" $ do
("one two three" & regex [rx|two|] . match %~ (<> "!!"). T.toUpper)
`shouldBe` "one TWO!! three"
it "should allow mutating many" $ do
("one two three" & regex [rx|two|] . match %~ T.toUpper)
`shouldBe` "one TWO three"
describe "groups" $ do
describe "getting" $ do
it "should get a group" $ do
"a b c" ^.. regex [rx|(\w)|] . groups
`shouldBe` ["a", "b", "c"]
it "should get many groups" $ do
"one two three" ^.. regex [rx|(\w+) (\w+)|] . groups
`shouldBe` ["one", "two"]
describe "setting" $ do
it "should allow setting" $ do
("one two three" & regex [rx|(\w+) (\w+)|] . groups .~ "new")
`shouldBe` "new new three"
it "should allow setting many" $ do
("one two three four" & regex [rx|(\w+) (\w+)|] . groups .~ "new")
`shouldBe` "new new new new"
it "should allow mutating" $ do
("one two three four" & regex [rx|one (two) three|] . groups %~ (<> "!!") . T.toUpper)
`shouldBe` "one TWO!! three four"
it "should allow mutating" $ do
("one two three four" & regex [rx|one (two) (three)|] . groups %~ (<> "!!") . T.toUpper)
`shouldBe` "one TWO!! THREE!! four"
describe "iregex" $ do
describe "match" $ do
it "should allow folding with index" $ do
("one two three" ^.. (iregex [rx|\w+|] <. match) . withIndex)
`shouldBe` [(0, "one"), (1, "two"), (2, "three")]
it "should allow getting with index" $ do
("one two three" ^.. iregex [rx|\w+|] . index 1 . match)
`shouldBe` ["two"]
it "should allow setting with index" $ do
("one two three" & iregex [rx|\w+|] <. match .@~ T.pack . show)
`shouldBe` "0 1 2"
it "should allow mutating with index" $ do
("one two three" & iregex [rx|\w+|] <. match %@~ \i s -> (T.pack $ show i) <> ": " <> s)
`shouldBe` "0: one 1: two 2: three"
describe "igroups" $ do
it "should allow folding with index" $ do
("one two three four" ^.. regex [rx|(\w+) (\w+)|] . igroups . withIndex)
`shouldBe` [(0, "one"), (1, "two"), (0, "three"), (1, "four")]
it "should allow getting a specific index" $ do
("one two three four" ^.. regex [rx|(\w+) (\w+)|] . igroups . index 1)
`shouldBe` ["two", "four"]
it "should allow setting with index" $ do
("one two three four" & regex [rx|(\w+) (\w+)|] . igroups .@~ T.pack . show)
`shouldBe` "0 1 0 1"
it "should allow mutating with index" $ do
("one two three four" & regex [rx|(\w+) (\w+)|] . igroups %@~ \i s -> (T.pack $ show i) <> ": " <> s)
`shouldBe` "0: one 1: two 0: three 1: four"
it "should compose indices with matches" $ do
("one two three four" ^.. (iregex [rx|(\w+) (\w+)|] <.> igroups) . withIndex)
`shouldBe` [((0, 0), "one"), ((0, 1), "two"), ((1, 0), "three"), ((1, 1), "four")]
describe "grouped" $ do
it "should get all groups in batches" $ do
"raindrops on roses and whiskers on kittens" ^.. regex [rx|(\w+) on (\w+)|] . grouped
`shouldBe` [["raindrops","roses"],["whiskers","kittens"]]
it "should allow editing when result list is the same length" $ do
("raindrops on roses and whiskers on kittens" & regex [rx|(\w+) on (\w+)|] . grouped %~ reverse)
`shouldBe` "roses on raindrops and kittens on whiskers"
describe "matchAndGroups" $ do
it "should get match and groups" $ do
"raindrops on roses and whiskers on kittens" ^.. regex [rx|(\w+) on (\w+)|] . matchAndGroups
`shouldBe` [("raindrops on roses",["raindrops","roses"]),("whiskers on kittens",["whiskers","kittens"])]
