{"id":281,"date":"2022-05-30T00:17:26","date_gmt":"2022-05-30T00:17:26","guid":{"rendered":"https:\/\/www.kindsonthegenius.com\/scala\/?p=281"},"modified":"2022-05-30T00:17:26","modified_gmt":"2022-05-30T00:17:26","slug":"scala-pattern-matching","status":"publish","type":"post","link":"https:\/\/www.kindsonthegenius.com\/scala\/scala-pattern-matching\/","title":{"rendered":"Scala – Pattern Matching"},"content":{"rendered":"

Pattern matching allows you to check a value against a given pattern. It is similar to Java<\/a> and C++<\/a> switch statement, but it’s more powerful.<\/p>\n

The syntax for Scala pattern matching is given below:<\/p>\n

val<\/span> scores =<\/span> Seq<\/span>(<\/span>30<\/span>,<\/span> 50<\/span>,<\/span> 60<\/span>,<\/span> 90<\/span>)<\/span>\r\nval<\/span> score =<\/span> scores(<\/span>Random<\/span>.<\/span>nextInt(<\/span>scores.<\/span>length))<\/span>\u00a0 score match<\/span> {<\/span>\r\n  case<\/span> 30<\/span> =><\/span> \"F - Fail\"<\/span>\r\n  case<\/span> 50<\/span> =><\/span> \"C - Good\"<\/span>\r\n  case<\/span> 60<\/span> =><\/span> \"B - Very Good\"<\/span>\r\n  case<\/span> 90<\/span> =><\/span> \"A - Excellent\"<\/span>\r\n}<\/span>\r\n<\/pre>\n
 <\/p>\n
In the example, we create a value, score, that gets a random number taken from a sequence of four integers 30, 50, 60 and 90. score<\/em><\/strong> now becomes the left operand of the match operator and on the right we have an expression with four cases. Also note the the match expression is a value that can be assigned.<\/p>\n
    \n
  1. Matching Case Classes<\/a><\/li>\n
  2. Matching on Types Only<\/a><\/li>\n<\/ol>\n
     <\/p>\n
    1. Matching Case Classes<\/strong><\/h4>\n
    Pattern matching is normally applied in case classes. Let’s assume we have this representation:<\/p>\n
    type  Message =\r\n      Email String String String\r\n    | SMS String String\r\n    | AudioMemo String String\r\n    | Letter\r\n<\/pre>\n
    This is and Elm syntax. You can learn Elm here<\/a>.<\/p>\n
    The means that we have four classes: Email, SMS, AudioMemo and Letter. All of them are derived from Message. Also, the parameters for the classes are specified against each of them.<\/p>\n
    The Scala equivalent for this is given below:<\/p>\n
    sealed<\/span> trait<\/span> Message\r\n<\/span>\r\ncase<\/span> class<\/span> Email<\/span> (<\/span>sender:<\/span>String<\/span>,<\/span> title:<\/span> String<\/span>,<\/span> body:<\/span> String<\/span>)<\/span> extends<\/span> Message<\/span>\r\ncase<\/span> class<\/span> SMS<\/span> (<\/span>caller:<\/span>String<\/span>,<\/span> message:<\/span> String<\/span>)<\/span> extends<\/span> Message<\/span>\r\ncase<\/span> class<\/span> AudioMemo<\/span> (<\/span>contact:<\/span>String<\/span>,<\/span> link:<\/span> String<\/span>)<\/span> extends<\/span> Message<\/span>\r\ncase<\/span> class<\/span> Letter<\/span>()<\/span> extends<\/span> Message<\/span>\r\n<\/pre>\n
     <\/p>\n
    Now, we would like to display a custom message based on the particular class. Therefore we would do pattern matching on the base class, Message. We’ll write a function that would take an argument of type Message and display a particular output based on which implementation of message it is.<\/p>\n
    The function is given below:<\/p>\n
    def<\/span> showMessage =<\/span> (<\/span>a:<\/span> Message<\/span>)<\/span> =><\/span> {<\/span>\r\n  a match<\/span> {<\/span>\r\n    case<\/span> Email<\/span>(<\/span>sender,<\/span> title,<\/span> _<\/span>)<\/span> =><\/span> {<\/span>\r\n      println(<\/span>s\"You received a mail from $sender with $title\"<\/span>)<\/span>\r\n    }<\/span>\r\n    case<\/span> SMS<\/span>(<\/span>caller,<\/span> message)<\/span> =><\/span> {<\/span>\r\n      println(<\/span>s\"An SMS arrived from $caller. Message: $message\"<\/span>)<\/span>\r\n    }<\/span>\r\n    case<\/span> AudioMemo<\/span>(<\/span>name,<\/span> link)<\/span> =><\/span> {<\/span>\r\n      println(<\/span>s\"Audio message from $name available here: $link\"<\/span>)<\/span>\r\n    }<\/span>\r\n    case<\/span> Letter<\/span>()<\/span> =><\/span> {<\/span>\r\n      println(<\/span>\"Please check your postbox\"<\/span>)<\/span>\r\n    }<\/span>\r\n  }<\/span>\r\n}<\/span>\r\n<\/pre>\n
     <\/p>\n
    Now we can call the function by and pass in a message type like so:<\/p>\n
    val<\/span> myMail =<\/span> new<\/span> Email<\/span>(<\/span>\"Kindson\"<\/span>,<\/span> \"Hello\"<\/span>,<\/span> \"Love you\"<\/span> )<\/span>\r\nshowMessage(<\/span>myMail)<\/span>\r\n\r\nval<\/span> myLetter =<\/span> new<\/span> Letter<\/span>()<\/span>\r\nshowMessage(<\/span>myLetter)<\/span>\r\n<\/pre>\n
    I recommend you run this code yourself and see what the output looks like.<\/p>\n
     <\/p>\n
    2. Matching on Only Types<\/strong><\/h4>\n
    In the example given in the preceding section, did pattern matching on the types as well as the arguments. But we can also perform pattern matching based on only the types. The code below illustrates that. Assuming we have two case classes Phone and Tablet that extends Device as shown below.<\/p>\n
    sealed<\/span> trait<\/span> Device<\/span>\r\n\r\ncase<\/span> class<\/span> Phone<\/span>(<\/span>make:<\/span> String<\/span>)<\/span> extends<\/span> Device<\/span>\r\ncase<\/span> class<\/span> Tablet<\/span>(<\/span>make:<\/span> String<\/span>)<\/span> extends<\/span> Device<\/span>\r\ncase<\/span> class<\/span> Laptop<\/span>(<\/span>make:<\/span> String<\/span>)<\/span> extends<\/span> Device<\/span>\r\n<\/pre>\n
     <\/p>\n
    Now we write a function that returns a string based on the implementation of the device. Note the structure of the case statement that no argument was used<\/p>\n
     def<\/span> tellMe(<\/span>device:<\/span> Device<\/span>)<\/span> =<\/span> device match<\/span> {<\/span>\r\n   case<\/span>  p:<\/span>Phone<\/span> =><\/span> \"This is a phone\"<\/span>\r\n   case<\/span> t:<\/span>Tablet<\/span> =><\/span> \"This is a tablet\"<\/span>\r\n   case<\/span> l:<\/span>Laptop<\/span> =><\/span> \"This is a laptop\"<\/span>\r\n }<\/span>\r\n<\/pre>\n
     <\/p>\n","protected":false},"excerpt":{"rendered":"
    Pattern matching allows you to check a value against a given pattern. It is similar to Java and C++ switch statement, but it’s more powerful. … <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[54],"class_list":["post-281","post","type-post","status-publish","format-standard","hentry","category-scala-programming","tag-pattern-matching"],"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/281","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/comments?post=281"}],"version-history":[{"count":2,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/281\/revisions"}],"predecessor-version":[{"id":283,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/281\/revisions\/283"}],"wp:attachment":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/media?parent=281"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/categories?post=281"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/tags?post=281"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}