{"id":649,"date":"2011-10-04T21:25:00","date_gmt":"2011-10-04T21:25:00","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/2012\/10\/scala-tutorial-regular-expressions-matching.html"},"modified":"2012-10-21T20:32:43","modified_gmt":"2012-10-21T20:32:43","slug":"scala-tutorial-regular-expressions","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2011\/10\/scala-tutorial-regular-expressions.html","title":{"rendered":"Scala Tutorial – regular expressions, matching"},"content":{"rendered":"
\n

Preface<\/h2>\n

This is part 5 of tutorials for first-time programmers getting into Scala. Other posts are on this blog, and you can get links to those and other resources on the links page of the Computational Linguistics course<\/a> I\u2019m creating these for. Additionally you can find this and other tutorial series on the JCG Java Tutorials<\/a> page.<\/p>\n

This post is the first of two about regular expressions (regexes), which are essential for a wide range of programming tasks, and for computational linguistics tasks in particular. This tutorial explains how to use them with Scala, assuming that the reader is already familiar with regular expression syntax. It shows how to create regular expressions in Scala and use them with Scala powerful pattern matching capabilities, in particular for variable assignment and cases in match expressions.<\/p>\n

Creating regular expressions<\/h2>\n

Scala provides a very simple way to create regexes: just define a regex as a string and then call the r<\/strong> method on it. The following defines a regular expression that characterizes the string language \"a^mb^n\" (one or more a<\/em>\u2018s followed by one or more b\u2019<\/em>s, not necessarily the same as the number of a<\/em>\u2018s).<\/p>\n

scala> val AmBn = \"a+b+\".r\r\nAmBn: scala.util.matching.Regex = a+b+\r\n<\/pre>\n
To use meta-characters, like \\s<\/em>, \\w<\/em>, and \\d<\/em>, you must either escape the slashes or use multiquoted strings, which are referred to as raw strings. The following are two equivalent ways to write a regex that covers strings of a sequence of word characters followed by a sequence of digits.<\/p>\n
scala> val WordDigit1 = \"\\\\w+\\\\d+\".r\r\nWordDigit1: scala.util.matching.Regex = \\w+\\d+\r\n \r\nscala> val WordDigit2 = \"\"\"\\w+\\d+\"\"\".r\r\nWordDigit2: scala.util.matching.Regex = \\w+\\d+\r\n<\/pre>\n
Whether escaping or using raw strings is preferable depends on the context. For example, with the above, I\u2019d go with the raw string. However, for using a regex to split a string on whitespace characters, escaping is somewhat preferable.<\/p>\n
scala> val adder = \"We're as similar as two dissimilar things in a pod.\\n\\t-Blackadder\"\r\nadder: java.lang.String =\r\nWe're as similar as two dissimilar things in a pod.\r\n-Blackadder\r\n \r\nscala> adder.split(\"\\\\s+\")\r\nres2: Array[java.lang.String] = Array(We're, as, similar, as, two, dissimilar, things, in, a, pod., -Blackadder)\r\n \r\nscala> adder.split(\"\"\"\\s+\"\"\")\r\nres3: Array[java.lang.String] = Array(We're, as, similar, as, two, dissimilar, things, in, a, pod., -Blackadder)\r\n<\/pre>\n
A note on naming: the convention in Scala is to use variable names with the first letter uppercased for Regex objects. This makes them consistent with the use of pattern matching in match statements, as shown below.<\/p>\n
         Matching with regexes<\/h2>\n
We saw above that using the r<\/strong> method on a String returns a value that is a Regex object (more on the scala.util.matching<\/strong> part below). How do you actually do useful things with these Regex objects? There are a number of ways. The prettiest, and perhaps most common for the non-computational linguist, is to use them in tandem with Scala\u2019s standard pattern matching capabilities. Let\u2019s consider the task of parsing names and turning them into useful data structures that we can do various useful things with.<\/p>\n
scala> val Name = \"\"\"(Mr|Mrs|Ms)\\. ([A-Z][a-z]+) ([A-Z][a-z]+)\"\"\".r\r\nName: scala.util.matching.Regex = (Mr|Mrs|Ms)\\. ([A-Z][a-z]+) ([A-Z][a-z]+)\r\n \r\nscala> val Name(title, first, last) = \"Mr. James Stevens\"\r\ntitle: String = Mr\r\nfirst: String = James\r\nlast: String = Stevens\r\n \r\nscala> val Name(title, first, last) = \"Ms. Sally Kenton\"\r\ntitle: String = Ms\r\nfirst: String = Sally\r\nlast: String = Kenton\r\n<\/pre>\n
Notice the similarity with pattern matching on types like Array and List.<\/p>\n
scala> val Array(title, first, last) = \"Mr. James Stevens\".split(\" \")\r\ntitle: java.lang.String = Mr.\r\nfirst: java.lang.String = James\r\nlast: java.lang.String = Stevens\r\n \r\nscala> val List(title, first, last) = \"Mr. James Stevens\".split(\" \").toList\r\ntitle: java.lang.String = Mr.\r\nfirst: java.lang.String = James\r\nlast: java.lang.String = Stevens\r\n<\/pre>\n
Of course, notice that here the \u201c.\u201d was captured, while the regex excised it. A more substantive difference with the regular expression is that it only accepts strings with the right form and will reject others, unlike simple splitting and matching to Array.<\/p>\n
scala> val Array(title, first, last) = \"221B Baker Street\".split(\" \")\r\ntitle: java.lang.String = 221B\r\nfirst: java.lang.String = Baker\r\nlast: java.lang.String = Street\r\n \r\nscala> val Name(title, first, last) = \"221B Baker Street\"\r\nscala.MatchError: 221B Baker Street (of class java.lang.String)\r\nat .<init>(<console>:12)\r\nat .<clinit>(<console>)\r\nat .<init>(<console>:11)\r\nat .<clinit>(<console>)\r\nat $export(<console>)\r\nat sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\r\nat sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)\r\nat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)\r\nat java.lang.reflect.Method.invoke(Method.java:597)\r\nat scala.tools.nsc.interpreter.IMain$ReadEvalPrint.call(IMain.scala:592)\r\nat scala.tools.nsc.interpreter.IMain$Request$$anonfun$10.apply(IMain.scala:828)\r\nat scala.tools.nsc.interpreter.Line$$anonfun$1.apply$mcV$sp(Line.scala:43)\r\nat scala.tools.nsc.io.package$$anon$2.run(package.scala:31)\r\nat java.lang.Thread.run(Thread.java:680)\r\n<\/pre>\n
That\u2019s a lot of complaining, of course, but actually you would generally be either (a) absolutely sure that you have strings that are in the correct format or (b) you will be checking for such possible exceptions or (c) you\u2019ll be using the regex as one option of many in a match expression.<\/p>\n
For now, let\u2019s assume the input is appropriate. This means we can easily convert a list of names as strings into a list of tuples using map and a match expression.
 
<\/div> <\/div><\/p>\n
scala> val names = List(\"Mr. James Stevens\", \"Ms. Sally Kenton\", \"Mrs. Jane Doe\", \"Mr. John Doe\", \"Mr. James Smith\")\r\nnames: List[java.lang.String] = List(Mr. James Stevens, Ms. Sally Kenton, Mrs. Jane Doe, Mr. John Doe, Mr. James Smith)\r\n \r\nscala> names.map(x => x match { case Name(title, first, last) => (title, first, last) })\r\nres11: List[(String, String, String)] = List((Mr,James,Stevens), (Ms,Sally,Kenton), (Mrs,Jane,Doe), (Mr,John,Doe), (Mr,James,Smith))\r\n<\/pre>\n
Note the crucial use of groups in the Name<\/em> regex: the number of groups equal the number of variables being initialized in the match. The first group is needed for the alternatives Mr, Mrs,<\/em> and Ms<\/em>. Without the other groups, we get an error. (From here on, I\u2019ll shorten the MatchError output.)<\/p>\n
scala> val NameOneGroup = \"\"\"(Mr|Mrs|Ms)\\. [A-Z][a-z]+ [A-Z][a-z]+\"\"\".r\r\nNameOneGroup: scala.util.matching.Regex = (Mr|Mrs|Ms)\\. [A-Z][a-z]+ [A-Z][a-z]+\r\n \r\nscala> val NameOneGroup(title, first, last) = \"Mr. James Stevens\"\r\nscala.MatchError: Mr. James Stevens (of class java.lang.String)\r\n<\/pre>\n
Of course, we can still match to the first group.<\/p>\n
scala> val NameOneGroup(title) = \"Mr. James Stevens\"\r\ntitle: String = Mr\r\n<\/pre>\n
What if we go in the other direction, creating more groups so that we can, for example, share the \u201cM\u201d in the various titles? Here\u2019s an attempt.<\/p>\n
scala> val NameShareM = \"\"\"(M(r|rs|s))\\. ([A-Z][a-z]+) ([A-Z][a-z]+)\"\"\".r\r\nNameShareM: scala.util.matching.Regex = (M(r|rs|s))\\. ([A-Z][a-z]+) ([A-Z][a-z]+)\r\n \r\nscala> val NameShareM(title, first, last) = \"Mr. James Stevens\"\r\nscala.MatchError: Mr. James Stevens (of class java.lang.String)\r\n<\/pre>\n
What happened is that a new group was created, so there are now four groups to match.<\/p>\n
scala> val NameShareM(title, titleEnding, first, last) = \"Mr. James Stevens\"\r\ntitle: String = Mr\r\ntitleEnding: String = r\r\nfirst: String = James\r\nlast: String = Stevens\r\n \r\nscala> val NameShareM(title, titleEnding, first, last) = \"Mrs. Sally Kenton\"\r\ntitle: String = Mrs\r\ntitleEnding: String = rs\r\nfirst: String = Sally\r\nlast: String = Kenton\r\n<\/pre>\n
So, there is submatched group capturing. To stop the (r|rs|s)<\/strong> part from creating a match group while still being able to use it to group alternatives in a disjunction, use the ?<\/strong>: operator.<\/p>\n
scala> val NameShareMThreeGroups = \"\"\"(M(?:r|rs|s))\\. ([A-Z][a-z]+) ([A-Z][a-z]+)\"\"\".r\r\nNameShareMThreeGroups: scala.util.matching.Regex = (M(?:r|rs|s))\\. ([A-Z][a-z]+) ([A-Z][a-z]+)\r\n \r\nscala> val NameShareMThreeGroups(title, first, last) = \"Mr. James Stevens\"\r\ntitle: String = Mr\r\nfirst: String = James\r\nlast: String = Stevens\r\n<\/pre>\n
By this point, sharing the M<\/strong> hasn\u2019t saved anything over (Mr|Mrs|Ms)<\/strong>, but there are plenty of situations where this is quite useful.<\/p>\n
We can also use regex backreferences. Say we want to match names like \u201cMr. John Bohn<\/em>\u201c, \u201cMr. Joe Doe<\/em>\u201c, and \u201cMrs. Jill Hill<\/em>\u201c.<\/p>\n
scala> val RhymeName = \"\"\"(Mr|Mrs|Ms)\\. ([A-Z])([a-z]+) ([A-Z])\\3\"\"\".r\r\nRhymeName: scala.util.matching.Regex = (Mr|Mrs|Ms)\\. ([A-Z])([a-z]+) ([A-Z])\\3\r\n \r\nscala> val RhymeName(title, firstInitial, firstRest, lastInitial) = \"Mr. John Bohn\"\r\ntitle: String = Mr\r\nfirstInitial: String = J\r\nfirstRest: String = ohn\r\nlastInitial: String = B\r\n<\/pre>\n
Then we could piece things together to get the names we wanted.<\/p>\n
scala> val first = firstInitial+firstRest\r\nfirst: java.lang.String = John\r\n \r\nscala> val last = lastInitial+firstRest\r\nlast: java.lang.String = Bohn\r\n<\/pre>\n
But we can do better by using an embedded group and just thowing its match result away with the underscore _<\/strong>.<\/p>\n
scala> val RhymeName2 = \"\"\"(Mr|Mrs|Ms)\\. ([A-Z]([a-z]+)) ([A-Z]\\3)\"\"\".r\r\nRhymeName2: scala.util.matching.Regex = (Mr|Mrs|Ms)\\. ([A-Z]([a-z]+)) ([A-Z]\\3)\r\n \r\nscala> val RhymeName2(title, first, _, last) = \"Mr. John Bohn\"\r\ntitle: String = Mr\r\nfirst: String = John\r\nlast: String = Bohn\r\n<\/pre>\n
Note<\/em>: we can\u2019t use the ?:<\/strong> operator with ([a-z]+)<\/strong> to stop the match because we need exactly that string to match with the \\3<\/strong> later.<\/p>\n
Using regexes for assignment via pattern matching requires full string match.<\/p>\n
scala> val Name(title, first, last) = \"Mr. James Stevens\"\r\ntitle: String = Mr\r\nfirst: String = James\r\nlast: String = Stevens\r\n \r\nscala> val Name(title, first, last) = \"Mr. James Stevens walked to the door.\"\r\nscala.MatchError: Mr. James Stevens walked to the door. (of class java.lang.String)\r\n<\/pre>\n
This is a crucial aspect of using them in match expressions. Consider an application that needs to be able to parse telephone numbers in different formats, like (123)555-5555<\/em> and 123-555-5555<\/em>. Here are regexes for these two patterns and their use to parse these numbers.<\/p>\n
scala> val Phone1 = \"\"\"\\((\\d{3})\\)\\s*(\\d{3})-(\\d{4})\"\"\".r\r\nPhone1: scala.util.matching.Regex = \\((\\d{3})\\)\\s*(\\d{3})-(\\d{4})\r\n \r\nscala> val Phone2 = \"\"\"(\\d{3})-(\\d{3})-(\\d{4})\"\"\".r\r\nPhone2: scala.util.matching.Regex = (\\d{3})-(\\d{3})-(\\d{4})\r\n \r\nscala> val Phone1(area, first3, last4) = \"(123) 555-5555\"\r\narea: String = 123\r\nfirst3: String = 555\r\nlast4: String = 5555\r\n \r\nscala> val Phone2(area, first3, last4) = \"123-555-5555\"\r\narea: String = 123\r\nfirst3: String = 555\r\nlast4: String = 5555\r\n<\/pre>\n
We could of course use a single regular expression, but we\u2019ll go with these two so that they can be used as separate case statements in a match expression that is part of a function that takes a string representation of a phone number and returns a tuple of three strings (thus normalizing the numbers).<\/p>\n
def normalizePhoneNumber (number: String) = number match {\r\n  case Phone1(x,y,z) => (x,y,z)\r\n  case Phone2(x,y,z) => (x,y,z)\r\n}\r\n<\/pre>\n
The action being taken for each match is just to package the separate values up in a Tuple3<\/strong> \u2014 more interesting things could be done if one were looking for country codes, dealing with multiple countries, etc. The point here is to see how the regular expressions are used for the cases to capture values and assign them to local variables, each time appropriate for the form of the string that is brought in. (We\u2019ll see in a later tutorial how to protect such a method from inputs that are not phone numbers and such.)<\/p>\n
Now that we have that function, we can easily apply it to a list of strings representing phone numbers and filter out just those in a specific area, for example.<\/p>\n
scala> val numbers = List(\"(123) 555-5555\", \"123-555-5555\", \"(321) 555-0000\")\r\nnumbers: List[java.lang.String] = List((123) 555-5555, 123-555-5555, (321) 555-0000)\r\n \r\nscala> numbers.map(normalizePhoneNumber)\r\nres16: List[(String, String, String)] = List((123,555,5555), (123,555,5555), (321,555,0000))\r\n \r\nscala> numbers.map(normalizePhoneNumber).filter(n => n._1==\"123\")\r\nres17: List[(String, String, String)] = List((123,555,5555), (123,555,5555))\r\n<\/pre>\n
         Building Regexes from Strings<\/h2>\n
Sometimes one wants to build up a regex from smaller component parts, for example, defining what a noun phrase is and then searching for sequence of noun phrases. To do this, we first must see the longer form of creating a regex.<\/p>\n
scala> val AmBn = new scala.util.matching.Regex(\"a+b+\")\r\nAmBn: scala.util.matching.Regex = a+b+\r\n<\/pre>\n
This is the first time in these tutorials that we are explicitly creating an object using the reserved word new<\/strong>. We\u2019ll be covering objects in more detail later, but what you need to know now is that Scala has a great deal of functionality that is not available by default. Mostly, we\u2019ve been working with things like Strings, Ints, Doubles, Lists, and so on \u2014 and for the most part it has appeared to you as though they are \u201cjust\u201d Strings, Ints, Doubles, and Lists. However, that is not the case: actually they are fully specified as:<\/p>\n