{"id":528,"date":"2011-09-29T08:10:00","date_gmt":"2011-09-29T08:10:00","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/2012\/10\/scala-tutorial-conditional-execution-with-if-else-blocks-and-matching.html"},"modified":"2012-10-21T20:10:20","modified_gmt":"2012-10-21T20:10:20","slug":"scala-tutorial-conditional-execution","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2011\/09\/scala-tutorial-conditional-execution.html","title":{"rendered":"Scala Tutorial – conditional execution with if-else blocks and matching"},"content":{"rendered":"
\n

Preface<\/h2>\n

This is part 3 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

Conditionals<\/h2>\n

Variables come and variables go, and they take on different values depending on the input. We typically need to enact different behaviors conditioned on those values. For example, let\u2019s simulate a bar tender in Austin who must make sure that he doesn\u2019t give alcohol to individuals under 21 years of age.<\/p>\n

scala> def serveBeer (customerAge: Int) = if (customerAge >= 21) println(\"beer\") else println(\"water\")\r\nserveBeer: (customerAge: Int)Unit\r\n \r\nscala> serveBeer(23)\r\nbeer\r\n \r\nscala> serveBeer(19)\r\nwater\r\n<\/pre>\n
What we\u2019ve done here is a standard use of conditionals to produce one action or another \u2014 in this case just printing one message or another. The expression in the if (\u2026)<\/strong> is a Boolean value, either true<\/strong> or false<\/strong>. You can see this by just doing the inequality directly:<\/p>\n
scala> 19 >= 21\r\nres7: Boolean = false\r\n<\/pre>\n
And these expressions can be combined according to the standard rules for conjunction and disjunction of Booleans. Conjunction is indicated with &&<\/strong> and disjunction with ||<\/strong>.<\/p>\n
scala> 19 >= 21 || 5 > 2\r\nres8: Boolean = true\r\n \r\nscala> 19 >= 21 && 5 > 2\r\nres9: Boolean = false\r\n<\/pre>\n
To check equality, use ==<\/strong>.<\/p>\n
scala> 42 == 42\r\nres10: Boolean = true\r\n \r\nscala> \"the\" == \"the\"\r\nres11: Boolean = true\r\n \r\nscala> 3.14 == 6.28\r\nres12: Boolean = false\r\n \r\nscala> 2*3.14 == 6.28\r\nres13: Boolean = true\r\n \r\nscala> \"there\" == \"the\" + \"re\"\r\nres14: Boolean = true\r\n<\/pre>\n
The equality<\/em> operator ==<\/strong> is different from the assignment<\/em> operator =<\/strong>, and you\u2019ll get an error if you attempt to use =<\/strong> for equality tests.<\/p>\n
scala> 5 = 5\r\n<console>:1: error: ';' expected but '=' found.\r\n5 = 5\r\n^\r\n \r\nscala> x = 5\r\n<console>:10: error: not found: value x\r\nval synthvar$0 = x\r\n^\r\n<console>:7: error: not found: value x\r\nx = 5\r\n^\r\n<\/pre>\n
The first example is completely bad because we cannot hope to assign a value to a constant like 5. With the latter example, the error complains about not finding a value x<\/em>. That\u2019s because it is a valid construct, assuming that a var<\/strong> variable x<\/em> has been previously defined.<\/p>\n
scala> var x = 0\r\nx: Int = 0\r\n \r\nscala> x = 5\r\nx: Int = 5\r\n<\/pre>\n
Recall that with var<\/strong> variables, it is possible to assign them a new value. However, it is actually not necessary to use vars much of the time, and there are many advantages with sticking with vals<\/strong>. I\u2019ll be helping you think in these terms as we go along. For now, try to ignore the fact that vars exist in the language!<\/p>\n
Back to conditionals. First, here are more comparison operators:<\/p>\n
x == y   (x is equal to y)
\nx != y    (x does not equal y)
\nx > y     (x is larger than y)
\nx < y     (x is less than y)
\nx >= y   (x is equal to y, or larger than y)
\nx <= y   (x is equal to y, or less than y)<\/p>\n<\/div>\n
These operators work on any type that has a natural ordering, including Strings.<\/p>\n
scala> \"armadillo\" < \"bear\"\r\nres25: Boolean = true\r\n \r\nscala> \"armadillo\" < \"Bear\"\r\nres26: Boolean = false\r\n \r\nscala> \"Armadillo\" < \"Bear\"\r\nres27: Boolean = true\r\n<\/pre>\n
Clearly, this isn\u2019t the usual alphabetic ordering you are used to. Instead it is based on ASCII character encodings.<\/p>\n
A very beautiful and useful thing about conditionals in Scala is that they return a value. So, the following is a valid way to set the values of the variables x<\/em> and y<\/em>.<\/p>\n
scala> val x = if (true) 1 else 0\r\nx: Int = 1\r\n \r\nscala> val y = if (false) 1 else 0\r\ny: Int = 0\r\n<\/pre>\n
Not so impressive here, but let\u2019s return to the bartender, and rather than the serveBeer<\/strong> function printing a String, we can have it return a String representing a beverage, \u201cbeer\u201d in the case of a 21+ year old and \u201cwater\u201d otherwise.<\/p>\n
scala> def serveBeer (customerAge: Int) = if (customerAge >= 21) \"beer\" else \"water\"\r\nserveBeer: (customerAge: Int)java.lang.String\r\n \r\nscala> serveBeer(42)\r\nres21: java.lang.String = beer\r\n \r\nscala> serveBeer(20)\r\nres22: java.lang.String = water\r\n<\/pre>\n
Notice how the first serveBeer<\/strong> function returned Unit<\/strong> but this one returns a String. Unit means that no value is returned \u2014 in general this is to be discouraged for reasons we won\u2019t get into here. Regardless of that, the general pattern of conditional assignment shown above is something you\u2019ll be using a lot.<\/p>\n
Conditionals can also have more than just the single if<\/strong> and else<\/strong>.  For example, let\u2019s say that the bartender simply serves age appropriate drinks to each customer, and that 21+ get beer, teenagers get soda and little kids should get juice.<\/p>\n
scala> def serveDrink (customerAge: Int) = {\r\n|     if (customerAge >= 21) \"beer\"\r\n|     else if (customerAge >= 13) \"soda\"\r\n|     else \"juice\"\r\n| }\r\nserveDrink: (customerAge: Int)java.lang.String\r\n \r\nscala> serveDrink(42)\r\nres35: java.lang.String = beer\r\n \r\nscala> serveDrink(16)\r\nres36: java.lang.String = soda\r\n \r\nscala> serveDrink(6)\r\nres37: java.lang.String = juice\r\n<\/pre>\n
And of course, the Boolean expressions in any of the ifs<\/strong> or else ifs<\/strong> can be complex conjunctions and disjunctions of smaller expressions. Let\u2019s consider a computational linguistics oriented example now that can take advantage of that, and which we will continue to build on in later tutorials.
 
<\/div> <\/div><\/p>\n
Everybody (hopefully) knows what a part-of-speech is. (If not, go check out Grammar Rock on YouTube.) In computational linguistics, we tend to use very detailed tagsets that go far beyond \u201cnoun\u201d, \u201cverb\u201d, \u201cadjective\u201d and so on. For example, the tagset from the Penn Treebank<\/a> uses NN for singular nouns (table), NNS for plural nouns (tables), NNP for singular proper noun (John), and NNPS for plural proper noun (Vikings).<\/p>\n
Here\u2019s an annotated sentence with postags from the first sentence of the Wall Street Journal portion of the Penn Treebank, in the format word\/postag.<\/p>\n
The\/DT index\/NN of\/IN the\/DT 100\/CD largest\/JJS Nasdaq\/NNP financial\/JJ stocks\/NNS rose\/VBD modestly\/RB as\/IN well\/RB .\/.<\/em>
\n
\n<\/em><\/div>\n
We\u2019ll see how to process these en masse<\/em> shortly, but for now, let\u2019s build a function that turns single tags like \u201cNNP\u201d into \u201cNN\u201d and \u201cJJS\u201d into \u201cJJ\u201d, using conditionals. We\u2019ll let all the other postags stay as they are.<\/p>\n
We\u2019ll start with a suboptimal solution, and then refine it. The first thing you might try is to create a case for every full form tag and output its corresponding shortened tag.<\/p>\n
scala> def shortenPos (tag: String) = {\r\n|     if (tag == \"NN\") \"NN\"\r\n|     else if (tag == \"NNS\") \"NN\"\r\n|     else if (tag == \"NNP\") \"NN\"\r\n|     else if (tag == \"NNPS\") \"NN\"\r\n|     else if (tag == \"JJ\") \"JJ\"\r\n|     else if (tag == \"JJR\") \"JJ\"\r\n|     else if (tag == \"JJS\") \"JJ\"\r\n|     else tag\r\n| }\r\nshortenPos: (tag: String)java.lang.String\r\n \r\nscala> shortenPos(\"NNP\")\r\nres47: java.lang.String = NN\r\n \r\nscala> shortenPos(\"JJS\")\r\nres48: java.lang.String = JJ\r\n<\/pre>\n
So, it\u2019s doing the job, but there is a lot of redundancy \u2014 in particular, the return value is the same for many cases. We can use disjunctions to deal with this.<\/p>\n
def shortenPos2 (tag: String) = {\r\n  if (tag == \"NN\" || tag == \"NNS\" || tag == \"NNP\" || tag == \"NNP\") \"NN\"\r\n  else if (tag == \"JJ\" || tag == \"JJR\" || tag == \"JJS\") \"JJ\"\r\n  else tag\r\n}\r\n<\/pre>\n
These are logically equivalent.<\/p>\n
There is an easier way of doing this, using properties of Strings. Here, the startsWith<\/strong> method is very useful.<\/p>\n
scala> \"NNP\".startsWith(\"NN\")\r\nres51: Boolean = true\r\n \r\nscala> \"NNP\".startsWith(\"VB\")\r\nres52: Boolean = false\r\n<\/pre>\n
We can use this to simplify the postag shortening function.<\/p>\n
def shortenPos3 (tag: String) = {\r\n  if (tag.startsWith(\"NN\")) \"NN\"\r\n  else if (tag.startsWith(\"JJ\")) \"JJ\"\r\n  else tag\r\n}\r\n<\/pre>\n
This makes it very easy to add an additional condition that collapses all of the verb tags to \u201cVB\u201d. (Left as an exercise.)<\/p>\n
A final note of conditional assignments: they can return anything you like, so, for example, the following are all valid. For example, here is a (very) simple (and very imperfect) English stemmer that returns the stem and and suffix.<\/p>\n
scala> def splitWord (word: String) = {\r\n|     if (word.endsWith(\"ing\")) (word.slice(0,word.length-3), \"ing\")\r\n|     else if (word.endsWith(\"ed\")) (word.slice(0,word.length-2), \"ed\")\r\n|     else if (word.endsWith(\"er\")) (word.slice(0,word.length-2), \"er\")\r\n|     else if (word.endsWith(\"s\")) (word.slice(0,word.length-1), \"s\")\r\n|     else (word,\"\")\r\n| }\r\nsplitWord: (word: String)(String, java.lang.String)\r\n \r\nscala> splitWord(\"walked\")\r\nres10: (String, java.lang.String) = (walk,ed)\r\n \r\nscala> splitWord(\"walking\")\r\nres11: (String, java.lang.String) = (walk,ing)\r\n \r\nscala> splitWord(\"booking\")\r\nres12: (String, java.lang.String) = (book,ing)\r\n \r\nscala> splitWord(\"baking\")\r\nres13: (String, java.lang.String) = (bak,ing)\r\n<\/pre>\n
If we wanted to work with the stem and suffix directly with variables, we can assign them straight away.<\/p>\n
scala> val (stem, suffix) = splitWord(\"walked\")\r\nstem: String = walk\r\nsuffix: java.lang.String = ed\r\n<\/pre>\n
             Matching<\/h2>\n
Scala provides another very powerful way to encode conditional execution called matching<\/em>. They have much in common with if-else blocks, but come with some nice extra features. We\u2019ll go back to the postag shortener, starting with a full list out of the tags and what to do in each case, like our first attempt with if-else.<\/p>\n
def shortenPosMatch (tag: String) = tag match {\r\n  case \"NN\" => \"NN\"\r\n  case \"NNS\" => \"NN\"\r\n  case \"NNP\" => \"NN\"\r\n  case \"NNPS\" => \"NN\"\r\n  case \"JJ\" => \"JJ\"\r\n  case \"JJR\" => \"JJ\"\r\n  case \"JJS\" => \"JJ\"\r\n  case _ => tag\r\n}\r\n \r\nscala> shortenPosMatch(\"JJR\")\r\nres14: java.lang.String = JJ\r\n<\/pre>\n
Note that the last case, with the underscore \u201c_\u201d is the default<\/em> action to take, similar to the \u201celse\u201d at the end of an if-else block.<\/p>\n
Compare this to the if-else function shortenPos<\/strong> from before, which had lots of repetition in its definition of the form \u201celse if (tag ==<\/strong> \u201c. Match statements allow you to do the same thing, but much more concisely and arguably, much more clearly. Of course, we can shorten this up.<\/p>\n
def shortenPosMatch2 (tag: String) = tag match {\r\n  case \"NN\" | \"NNS\" | \"NNP\" | \"NNPS\" => \"NN\"\r\n  case \"JJ\" | \"JJR\" | \"JJS\" => \"JJ\"\r\n  case _ => tag\r\n}\r\n<\/pre>\n
Which is quite a bit more readable than the if-else shortenPosMatch2<\/strong> defined earlier.<\/p>\n
In addition to readability, match statements provide some logical protection. For example, if you accidentally have two cases that overlap, you\u2019ll get an error.<\/p>\n
scala> def shortenPosMatchOops (tag: String) = tag match {\r\n|   case \"NN\" | \"NNS\" | \"NNP\" | \"NNPS\" => \"NN\"\r\n|   case \"JJ\" | \"JJR\" | \"JJS\" => \"JJ\"\r\n|   case \"NN\" => \"oops\"\r\n|   case _ => tag\r\n| }\r\n<console>:10: error: unreachable code\r\ncase \"NN\" => \"oops\"\r\n<\/pre>\n
This is an obvious example, but with more complex match options, it can save you from bugs!<\/p>\n
We cannot use the startsWith<\/strong> method the same way we did with the if-else shortenPosMatch3<\/strong>. However, we can use regular expressions very nicely with match statements, which we\u2019ll get to in a later tutorial.<\/p>\n
Where match statements really shine is that they can match on much more than just the value of simple variables like Strings and Ints.  One use of matches is to check the types of the input to a function that can take a supertype of many types. Recall that Any<\/strong> is the supertype of all types; if we have the following function that takes an argument with any type, we can use matching to inspect what the type of the argument is and do different behaviors accordingly.<\/p>\n
scala> def multitypeMatch (x: Any) = x match {\r\n|    case i: Int => \"an Int: \" + i*i\r\n|    case d: Double => \"a Double: \" + d\/2\r\n|    case b: Boolean => \"a Boolean: \" + !b\r\n|    case s: String => \"a String: \" + s.length\r\n|    case (p1: String, p2: Int) => \"a Tuple[String, Int]: \" + p2*p2 + p1.length\r\n|    case (p1: Any, p2: Any) => \"a Tuple[Any, Any]: (\" + p1 + \",\" + p2 + \")\"\r\n|    case _ => \"some other type \" + x\r\n| }\r\nmultitypeMatch: (x: Any)java.lang.String\r\n \r\nscala> multitypeMatch(true)\r\nres4: java.lang.String = a Boolean: false\r\n \r\nscala> multitypeMatch(3)\r\nres5: java.lang.String = an Int: 9\r\n \r\nscala> multitypeMatch((1,3))\r\nres6: java.lang.String = a Tuple[Any, Any]: (1,3)\r\n \r\nscala> multitypeMatch((\"hi\",3))\r\nres7: java.lang.String = a Tuple[String, Int]: 92\r\n<\/pre>\n
So, for example, if it is an Int, we can do things like multiplication, if it is a Boolean we can negate it (with !), and so on. In the case statement, we provide a new variable that will have the type that is matched, and then after the arrow =>, we can use that variable in a type safe manner. Later we\u2019ll see how to create classes (and in particular case classes), where this sort of matching based function is used regularly.<\/p>\n
In the meantime, here\u2019s an example of a simple addition function that allows one to enter a String or Int to specify its arguments. For example, the behavior we desire is this:<\/p>\n
scala> add(1,3)\r\nres4: Int = 4\r\n \r\nscala> add(\"one\",3)\r\nres5: Int = 4\r\n \r\nscala> add(1,\"three\")\r\nres6: Int = 4\r\n \r\nscala> add(\"one\",\"three\")\r\nres7: Int = 4\r\n<\/pre>\n
Let\u2019s assume that we only handle the spelled out versions of 1 through 5, and that any string we cannot handle (e.g. \u201csix\u201d and aardvark\u201d) is considered to be 0. Then the following two functions using matches handle it.<\/p>\n
def convertToInt (x: String) = x match {\r\n  case \"one\" => 1\r\n  case \"two\" => 2\r\n  case \"three\" => 3\r\n  case \"four\" => 4\r\n  case \"five\" => 5\r\n  case _ => 0\r\n}\r\n \r\ndef add (x: Any, y: Any) = (x,y) match {\r\n  case (x: Int, y: Int) => x + y\r\n  case (x: String, y: Int) => convertToInt(x) + y\r\n  case (x: Int, y: String) => x + convertToInt(y)\r\n  case (x: String, y: String) => convertToInt(x) + convertToInt(y)\r\n  case _ => 0\r\n}\r\n<\/pre>\n
Like if-else blocks, matches can return whatever type you like, including Tuples, Lists and more.<\/p>\n
Match blocks are used in many other useful contexts that we\u2019ll come to later. In the meantime, it is also worth pointing out that matching is actually used in variable assignment. We\u2019ve seen it already with Tuples, but it can be done with Lists and other types.<\/p>\n
scala> val (x,y) = (1,2)\r\nx: Int = 1\r\ny: Int = 2\r\n \r\nscala> val colors = List(\"blue\",\"red\",\"yellow\")\r\ncolors: List[java.lang.String] = List(blue, red, yellow)\r\n \r\nscala> val List(color1, color2, color3) = colors\r\ncolor1: java.lang.String = blue\r\ncolor2: java.lang.String = red\r\ncolor3: java.lang.String = yellow\r\n<\/pre>\n
This is especially useful in the case of the args Array that comes from the command line when creating a script with Scala. For example, consider a program that is run as following.<\/p>\n
$ scala nextYear.scala John 35\r\nNext year John will be 36 years old.\r\n<\/pre>\n
Here\u2019s how we can do it. (Save the next two lines as nextYear.scala and try it out.)<\/p>\n
val Array(name, age) = args\r\nprintln(\"Next year \" + name + \" will be \" + (age.toInt + 1) + \" years old.\")\r\n<\/pre>\n
Notice that we had to do age.toInt<\/strong>. That is because age itself is a String, not an Int.
\nConditional execution with if-else blocks and match blocks is a powerful part of building complex behaviors into your programs that you\u2019ll see and use frequently!<\/p>\n
Reference: <\/i><\/strong>First steps in Scala for beginning programmers, Part 3<\/a> from our JCG partner<\/a> Jason Baldridge at the Bcomposes<\/a> blog.<\/p>\n
Related Articles :<\/i><\/strong><\/p>\n