The first regex I wrote was while scrapping the Champions League results from the Rec.Sport.Soccer Statistics Foundation and I wanted to determine which spans contained the match result and which didn’t.

A matching line would look like this:

And a non matching one like this:

I wrote the following regex to detect match results:

I then wrote the following function using http://clojuredocs.org/clojure_core/clojure.core/re-matches which would return true or false depending on the input:

re-matches only returns matches if the whole string matches the pattern which means if we had a line with some spurious text after the score it wouldn’t match:

If we don’t mind that and we just want some part of the string to match our pattern then we can use http://clojuredocs.org/clojure_core/clojure.core/re-find instead:

The next thing I wanted to do was to capture the teams and the score of the match which I initially did using http://clojuredocs.org/clojure_core/clojure.core/re-seq:

I then extracted the various parts like so:

re-seq returns a list which contains consecutive matches of the regex. The list will either contain strings if we don’t specify capture groups or a vector containing the pattern matched and each of the capture groups.

For example if we now match only sequences of A-Z or spaces and remove the rest of the pattern from above we’d get the following results:

In our case re-find or re-matches actually makes more sense since we only want to match the pattern once. If there are further matches after this those aren’t included in the results. e.g.

re-matches returns nil here because there are characters in the string which don’t match the pattern i.e. the hyphen between the two scores.

If we tie that in with our capture groups we end up with the following:

I also came across the http://clojuredocs.org/clojure_core/clojure.core/re-pattern function which provides a more verbose way of creating a pattern and then evaluating it with re-find:

One difference here is that I had to escape the special sequence '\s' otherwise I was getting the following exception:

I wanted to play around with http://clojuredocs.org/clojure_core/clojure.core/re-groups as well but that seemed to throw an exception reasonably frequently when I expected it to work.</cite>

The last function I looked at was http://clojuredocs.org/clojure_core/clojure.core/re-matcher which seemed to be a long-hand for the '#""' syntax used earlier in the post to define matchers: _~lisp > (re-find (re-matcher #"()-([a-zA-Z\s]) ([0-9])[\s]?.[\s]?([0-9])" "FC Valencia-Internazionale Milaan 2 - 1")) ["FC Valencia-Internazionale Milaan 2 - 1" "FC Valencia" "Internazionale Milaan" "2" "1"] _~

So in summary I think most use cases are covered by re-find and re-matches and maybe re-seq on special occasions. I couldn’t see where I’d use the other functions but I’m happy to be proved wrong.