{"id":277,"date":"2022-05-29T14:40:49","date_gmt":"2022-05-29T14:40:49","guid":{"rendered":"https:\/\/www.kindsonthegenius.com\/scala\/?p=277"},"modified":"2022-05-29T14:41:18","modified_gmt":"2022-05-29T14:41:18","slug":"scala-algebraic-data-types-adt","status":"publish","type":"post","link":"https:\/\/www.kindsonthegenius.com\/scala\/scala-algebraic-data-types-adt\/","title":{"rendered":"Scala – Algebraic Data Types (ADT)"},"content":{"rendered":"

In this tutorial, you will learn about the very important concept of Algebraic Data Types (ADT) in Scala.<\/p>\n

Let’s begin with what we already know, enum<\/em> or enumeration<\/em> types.<\/p>\n

    \n
  1. Enumerations Types<\/a><\/li>\n
  2. What are ADTS<\/a><\/li>\n
  3. Sum Types (Union Types)<\/a><\/li>\n
  4. Pattern Matching on ADTs<\/a><\/li>\n<\/ol>\n

     <\/p>\n

    1. Enumeration Types<\/strong><\/h4>\n

    An enumeration is used to define a data type that consists of a set of named values. All the value in an enumeration share a unique type known as Value type member of the enumeration.<\/p>\n

    Creating Enums in Scala<\/strong><\/p>\n

    To create a enum type in Scala, we need to create an object that extends the Enumeration type. This is because Scala does not provide an enum<\/em> keyword.<\/p>\n

    The code below creates an enum type names Size with three values: Small, Medium and Large<\/p>\n

    object<\/span> Sizes<\/span> extends<\/span> Enumeration<\/span> {<\/span>\r\n  type<\/span> Sizes<\/span> =<\/span> Value<\/span>\r\n  val<\/span> Small<\/span>,<\/span> Medium<\/span>,<\/span> Large<\/span> =<\/span> Value<\/span>\r\n}<\/span>\r\n<\/pre>\n
     <\/p>\n
    You can print the string value of enumeration using\u00a0 the code below:<\/p>\n
    <\/p>\n
    println(<\/span>s\"My size is ${Size.Medium}\"<\/span>)<\/span>\r\n<\/pre>\n
     <\/p>\n
    Pattern Matching on Enum Values<\/strong><\/p>\n
    Although we’ll talk about pattern matching in a different tutorial, the code below shows how to perform some operation base on pattern matching on values of an enum.<\/p>\n
    Size<\/span>.<\/span>values.<\/span>foreach {<\/span>\r\n  case<\/span> s if<\/span> (<\/span>s ==<\/span> Size<\/span>.<\/span>Small<\/span> )<\/span> =><\/span> {<\/span>\r\n    println(<\/span>s)<\/span>\r\n  }<\/span>\r\n  case<\/span> s if<\/span> (<\/span>s ==<\/span> Size<\/span>.<\/span>Medium<\/span>)<\/span> =><\/span> {<\/span>\r\n    println(<\/span>s)<\/span>\r\n  }<\/span>\r\n  case<\/span> s if<\/span> (<\/span>s ==<\/span> Size<\/span>.<\/span>Large<\/span>)<\/span> =><\/span> {<\/span>\r\n    println(<\/span>s)<\/span>\r\n  }<\/span>\r\n}<\/span>\r\n<\/pre>\n
     <\/p>\n
    2. Algebraic Data Types<\/strong><\/h4>\n
    In theory, algebra can be viewed as:<\/p>\n
      \n
    • a set of objects<\/li>\n
    • as set of operations that can be applied to those objects to create new objects<\/li>\n<\/ul>\n
      For example, we can apply a set of arithmetic operations (+, -, * and \/) to a set of numbers to produce new numbers.<\/p>\n
      In Scala, we can apply certain operation to a set of types to produce\u00a0 new type(s).<\/p>\n
      Let’s create a new type called Weather from a set of objects: Windy, Cloudy, Rainy and Overcast<\/p>\n
      sealed<\/span>  trait<\/span> Weather<\/span>\r\n\r\ncase<\/span> object<\/span> Rainy<\/span> extends<\/span> Weather<\/span>\r\ncase<\/span> object<\/span> Windy<\/span> extends<\/span> Weather<\/span>\r\ncase<\/span> object<\/span> Cloudy<\/span> extends<\/span> Weather<\/span>\r\ncase<\/span> object<\/span> Overcast<\/span> extends<\/span> Weather<\/span>\r\n<\/pre>\n
       <\/p>\n
      The sealed trait<\/em> means that only these four values defined here can extend the Weather type. Let’s now talk about a specific algebraic data type: the sum type<\/p>\n
       <\/p>\n
      3. The Sum Type (Union Type)<\/strong><\/h4>\n
      The Sum type helps us define a type that can have certain values. With the sum type, we enumerate all the possible instances of a type. The following are important to know about the sum type:<\/p>\n
        \n
      • they are create with a sealed trait as\u00a0 the base type<\/li>\n
      • the individual instances are created as case objects<\/li>\n
      • the “is-a” relationship is used for describing the sum type<\/li>\n
      • instances of the sum type can be parameterized<\/li>\n<\/ul>\n
        In the code below, we define an Employee type which could be either a Doctor, Driver or Intern. This is represented below:<\/p>\n
          \n
        • Doctor has two parameter: name: String and specialty: String<\/li>\n
        • Driver has two parameter: name: String and assignedCar: String<\/li>\n
        • Intern has one parameter: age<\/li>\n<\/ul>\n
          The equivalent Scala code is given below:<\/p>\n
          sealed<\/span> trait<\/span> Employee<\/span>\r\n  case<\/span> class<\/span> Doctor<\/span>(<\/span>name:<\/span>String<\/span>,<\/span> specialty:<\/span> String<\/span>)<\/span> extends<\/span> Employee<\/span>\r\n  case<\/span> class<\/span> Driver<\/span>(<\/span>name:<\/span>String<\/span>,<\/span> assignedCar:<\/span> String<\/span>)<\/span> extends<\/span> Employee<\/span>\r\n  case<\/span> class<\/span> Intern<\/span>(<\/span>name:<\/span>String<\/span>,<\/span> age:<\/span> Int<\/span>)extends<\/span> Employee<\/span><\/span>\r\n<\/pre>\n
          Now you that you understand ADTs, you can create a couple more just to get used to it.<\/p>\n
           <\/p>\n
          4. Pattern Matching With ADTs<\/strong><\/h4>\n
          Pattern matching allows us to decompose a specified ADT using the extractor method. With it, we can extract the fields of an ADT. This means that the case classed would have to implement unapply method to be an extractor.<\/p>\n
          Let’s define a pattern match for our Employee ADT<\/p>\n
          def<\/span> isEmployee(<\/span>e:<\/span> Employee<\/span>)<\/span> :<\/span> Boolean<\/span> =<\/span> e match<\/span> {<\/span>\r\n  case<\/span> Doctor<\/span>(<\/span>name,<\/span> specialty)<\/span> =><\/span> true<\/span>\r\n  case<\/span> Driver<\/span>(<\/span>name,<\/span> assignedCar)<\/span> =>true<\/span>\r\n  case<\/span> Intern<\/span>(<\/span>name,<\/span> age)<\/span> =><\/span> false<\/span>\r\n}<\/span>\r\n<\/pre>\n
           <\/p>\n
          In the case of pattern matching code above, we define a function that takes an Employee object and returns a boolean depending on the particular instance.<\/p>\n
           <\/p>\n","protected":false},"excerpt":{"rendered":"
          In this tutorial, you will learn about the very important concept of Algebraic Data Types (ADT) in Scala. Let’s begin with what we already know, … <\/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":[52,53,54,55],"class_list":["post-277","post","type-post","status-publish","format-standard","hentry","category-scala-programming","tag-adt","tag-algebraic-data-types","tag-pattern-matching","tag-sum-type"],"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/277","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=277"}],"version-history":[{"count":3,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/277\/revisions"}],"predecessor-version":[{"id":280,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/277\/revisions\/280"}],"wp:attachment":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/media?parent=277"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/categories?post=277"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/tags?post=277"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}