ReadableRegex

ReadableRegex.jl gives you a syntax that is much easier to write and understand than the rather cryptic standard Regex. The syntax is as close as possible to a natural language description of the Regex. Especially for nested and grouped expressions with special characters it is orders of magnitudes easier to understand than a simple regex string. You can also compile the function expression before using it with the @compile macro for lower runtime costs.

Here's an example:

regex = r"[\+-]?(?:\d*\.)?\d+"

regex = maybe(["-", "+"]) *
            maybe(zero_or_more(DIGIT) * ".") *
            one_or_more(DIGIT)

Both of these match all kinds of floating point numbers like these:

"1 2.0 .3 -.4 -5 60 700 800.9 +9000"

But to understand the Regex you have to mentally parse it into the second version. Why not avoid that effort?

ReadableRegex also escapes reserved regex characters like "." by default, saving you a lot of backslashes.

ReadableRegex uses a simple intermediary type RegexString which holds a string representation of a regex, the same thing you'd normally write yourself.

These RegexStrings can be concatenated together with the * operator. You can convert them into a Regex by calling Regex(rs::RegexString), or use them directly with match and eachmatch.

Let's say we wanted to extract all the possible integers from the list above. One way could be this:

julia> reg = @compile look_for(
                maybe(char_in("+-")) * one_or_more(DIGIT),
                not_after = ".",
                not_before = NON_SEPARATOR)

r"(?:(?<!\.)(?:(?:[+\-])?(?:\d)+))(?!\P{Z})"
# you do not want to read or write that...

julia> eachmatch(reg, "1 2.0 .3 -.4 -5 60 700 800.9 +9000") .|> println;

RegexMatch("1")
RegexMatch("-5") 
RegexMatch("60") 
RegexMatch("700")
RegexMatch("+9000")

Note that the regex string representation is currently not as parsimonious as possible, as non-capturing groups are used more freely than strictly needed to keep the logic simple. This should not affect performance, though.

If you need to, you can create a RegexString using its constructor with a properly escaped string.

r = RegexString("\\w")

Alternatively, there is the @rs_str macro which allows you to use normal regex syntax, without special escaping rules.

r = rs"\w"

This can also be useful if you want to start a chain of concatenated parts where the multiplication operator needs one of the two first elements to be a RegexString.

r = rs"c" * ["at", "ool", "ute"]

Some constructs from Base Julia are useful to express building blocks of regular expression. You can define Base.convert(::Type{RegexString}, obj) to use these directly in ReadableRegex expressions. All building block functions call convert on their inputs, and so does the multiplication operator *.

Some predefined examples:

Strings and char_in are escaped when converted, so you can use .+[]^$ etc. without escaping them manually.

one_or_more("+")
maybe("[text in brackets]")

Char ranges can be used directly and match any char within the range.

one_or_more('a':'z')
between(1, 4, '🌑':'🌘')

Using an AbstractVector or a Tuple is the same as calling either(vec_or_tup...). That means you can use any element that is itself convertible to a RegexString.

exactly(3, ['a':'z', "ha"])
maybe(('x', 'Y'))

You can use the @compile macro to build a finished Regex out of the following expression. This might help to avoid some runtime costs. You can only use literals and the ReadableRegex constants in these expressions.

julia> @allocated BEGIN * maybe('a':'z') * exactly(1, ["hello", "hi", "what's up"]) * END
2528

julia> @allocated @compile BEGIN * maybe('a':'z') * exactly(1, ["hello", "hi", "what's up"]) * END
0

These constants reference commonly used character classes:

These constants access unicode categories. For brevity, the negated variants are not listed. They all start with NON_, like NON_LETTER, NON_PUNCTUATION, etc.