{"id":248,"date":"2011-03-06T18:19:39","date_gmt":"2011-03-06T16:19:39","guid":{"rendered":"http:\/\/misto.ch\/?p=248"},"modified":"2011-03-06T18:19:39","modified_gmt":"2011-03-06T16:19:39","slug":"eliminating-pattern-matching","status":"publish","type":"post","link":"https:\/\/misto.ch\/de\/2011\/03\/06\/eliminating-pattern-matching\/","title":{"rendered":"Eliminating Pattern Matching"},"content":{"rendered":"

In the last few years, I worked on several Java projects where we transformed and analyzed abstract syntax trees, so when I started learning Scala, pattern-matching quickly became one of my favorite language features. I could never warm up to the visitor pattern, so I was thankful that Scala offered a much more powerful alternative.<\/p>\n

What I also liked very much was Scala’s consistent use of the Option<\/tt> type in its standard library. Now, instead of having to read the documentation to find out whether some call could return null<\/tt>, the type checker forced me to handle this where necessary. So a lot of my early Scala code looked as follows:<\/p>\n

\ndoSomething() match {\n  case Some(value) => Some(doSomethingElse(value))\n  case None => None\n}\n<\/pre>\n
While it’s still possible to get a NPE in Scala, it just doesn’t happen with well-written libraries, simply because there’s no need to ever use null<\/tt>.<\/p>\n
(By the way, isn’t it funny that Java forces you to check exceptions but doesn’t help you with the much more common and annoying null<\/tt> problem?)<\/p>\n
So yes, in practice, Options<\/tt> do save you from NPEs. Does your code also get smaller (because usually, in Scala it will)? Not if you pattern match on Some<\/tt>\/None<\/tt>, all the un-wrapping and lifting is quite verbose.<\/p>\n
Nowadays, certainly influenced by all the discussions on monads, I realize that pattern-matching on Option<\/tt> is a very primitive  form of abstraction, and instead of the code above I now write:<\/p>\n
\ndoSomething() map (value => doSomethingElse(value))\n<\/pre>\n
(For those unfamiliar with functional programming, map<\/tt> applies the function to the value inside a Some<\/tt>, and does nothing when called on a None<\/tt>.)<\/p>\n
Even better, we can fully automate this refactoring! I’m currently working on a first version in the scala-refactoring library. So far, I’ve implemented the refactoring for map, but there are many more we can do, for example:<\/p>\n
    \n
  • If the Some<\/tt> case does not construct a Some<\/tt> but calls a function that returns an Option<\/tt>, we use flatMap<\/tt> instead of map<\/tt>.<\/li>\n
  • If the Some<\/tt> case evaluates to Boolean<\/tt> and the None<\/tt> case returns false<\/tt>, we can replace it with exists<\/tt>. If Some<\/tt> returns true<\/tt> and None<\/tt> returns false<\/tt>, we can just replace the whole pattern match with isDefined<\/tt>.<\/li>\n
  • When the None<\/tt> case is ()<\/tt>, we can transform to foreach<\/tt>.<\/li>\n<\/ul>\n
    So far we have only looked at Option<\/tt>, but there is more: for example, we could also replace pattern-matching on lists and recursion with folds. I’m sure somebody has already written a paper about such refactorings, but I haven’t found anything yet.<\/p>\n
    What do you think about eliminating pattern matching? Do you also prefer mapping to explicit pattern-matching?<\/p>\n","protected":false},"excerpt":{"rendered":"
    In the last few years, I worked on several Java projects where we transformed and analyzed abstract syntax trees, so when I started learning Scala, pattern-matching quickly became one of my favorite language features. I could never warm up to the visitor pattern, so I was thankful that Scala offered a much more powerful alternative. […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[26,27,1],"tags":[37,38],"class_list":["post-248","post","type-post","status-publish","format-standard","hentry","category-infoq","category-scala","category-uncategorized","tag-refactoring","tag-scala"],"_links":{"self":[{"href":"https:\/\/misto.ch\/de\/wp-json\/wp\/v2\/posts\/248","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/misto.ch\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/misto.ch\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/misto.ch\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/misto.ch\/de\/wp-json\/wp\/v2\/comments?post=248"}],"version-history":[{"count":0,"href":"https:\/\/misto.ch\/de\/wp-json\/wp\/v2\/posts\/248\/revisions"}],"wp:attachment":[{"href":"https:\/\/misto.ch\/de\/wp-json\/wp\/v2\/media?parent=248"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/misto.ch\/de\/wp-json\/wp\/v2\/categories?post=248"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/misto.ch\/de\/wp-json\/wp\/v2\/tags?post=248"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}