{"id":246,"date":"2022-04-18T14:51:51","date_gmt":"2022-04-18T14:51:51","guid":{"rendered":"https:\/\/www.kindsonthegenius.com\/scala\/?p=246"},"modified":"2022-04-18T14:51:51","modified_gmt":"2022-04-18T14:51:51","slug":"scala-automatic-derivation-of-encoders-and-decoders","status":"publish","type":"post","link":"https:\/\/www.kindsonthegenius.com\/scala\/scala-automatic-derivation-of-encoders-and-decoders\/","title":{"rendered":"Scala – Automatic Derivation of Encoders and Decoders"},"content":{"rendered":"

In the previous two tutorials, we learnt how to build encoders and decoders. We used the forProductN(applicative-based decoders) and for comprehension (monadic decoders) to build decoders.<\/p>\n

In this tutorial, we would talk about auto and semi-auto derivation of decoders. In this case, we would not have to write all the boiler-plate codes.<\/p>\n

    \n
  1. Automatic Derivation of Encoders and Decoders<\/a><\/li>\n
  2. Semi-Automatic Derivation<\/a><\/li>\n
  3. Deriving Codecs<\/a><\/li>\n
  4. Creating Custom Codec<\/a><\/li>\n<\/ol>\n

     <\/p>\n

    1. Automatic Derivation<\/strong><\/h4>\n

    Automatic Derivation can be gotten from the implicit scope. To use it, you need to first add the following dependency to your build.sbt<\/p>\n

    libraryDependencies +=<\/span> \"io.circe\"<\/span> %%<\/span> \"circe-generic\"<\/span> %<\/span> \"0.14.1\"<\/span>\r\n<\/pre>\n
     <\/p>\n
    Then you also need to import generic.auto from io.circe like so:<\/p>\n
    import<\/span> io.circe.generic.auto._<\/span>\r\n<\/pre>\n
    Once we do this, circe would derive for us encoders and decoders for any case class whose fields also has encoders and decoders. This also works with nested case classes as well.<\/p>\n
    So assuming we have the following classes just like before:<\/p>\n
    \/\/The Author case class<\/span>\r\ncase<\/span> class<\/span> Author<\/span>(<\/span>\r\n                   name:<\/span> String<\/span>,<\/span>\r\n                   bio:<\/span> Option<\/span>[<\/span>String<\/span>]<\/span>\r\n                 )<\/span>\r\n\r\n\/\/The Article case class<\/span>\r\ncase<\/span> class<\/span> Article<\/span>(<\/span>\r\n                    id:<\/span> UUID<\/span>,<\/span>\r\n                    title:<\/span> String<\/span>,<\/span>\r\n                    content:<\/span> String<\/span>,<\/span>\r\n                    author:<\/span> Author<\/span>\r\n                  )<\/span>\r\n<\/pre>\n
     <\/p>\n
    Then we can simply have all the encoders and decoders from the implicit scope like so:<\/p>\n
    implicitly[<\/span>Encoder<\/span>[<\/span>Author<\/span>]]<\/span>\r\nimplicitly[<\/span>Decoder<\/span>[<\/span>Author<\/span>]]<\/span>\r\n\r\nimplicitly[<\/span>Encoder<\/span>[<\/span>Article<\/span>]]<\/span>\r\nimplicitly[<\/span>Decoder<\/span>[<\/span>Article<\/span>]]<\/span>\r\n<\/pre>\n
     <\/p>\n
    Then we can just encode and decode as usual using the encoders and decoders.<\/p>\n
     <\/p>\n
    2. Semi-Automatic Derivation<\/strong><\/h4>\n
    Semi-Automatic derivation uses macros to provide you with encoders and decoders for your type without having to write them manually. However, it requires you to ask for Codec explicitly for any type you want to work with.<\/p>\n
    The import is:<\/p>\n
    import<\/span> io.circe.generic.semiauto._<\/span>\r\n<\/pre>\n
     <\/p>\n
    With this, if you want to have a user class for instance<\/p>\n
    case<\/span> class<\/span> Person<\/span>(<\/span>\r\n               firstName:<\/span> String<\/span>,<\/span>\r\n               lastname:<\/span> String<\/span>,<\/span>\r\n               email:<\/span> String<\/span>\r\n               )<\/span>\r\n<\/pre>\n
     <\/p>\n
    We can then ask for encoder and decoder for the User type like so:<\/p>\n
    \/\/Request for encoder and decoder for the Person type<\/span>\r\nimplicit<\/span> val<\/span> personDecoder:<\/span> Decoder<\/span>[<\/span>Person<\/span>]<\/span> =<\/span> deriveDecoder[<\/span>Person<\/span>]<\/span>\r\nimplicit<\/span> val<\/span> personEncoder:<\/span> Encoder<\/span>[<\/span>Person<\/span>]<\/span>  =<\/span> deriveEncoder[<\/span>Person<\/span>]<\/span>\r\n<\/pre>\n
     <\/p>\n
    3. Deriving Codecs<\/strong><\/h4>\n
    You can also derive a Codec, which is a combination of Encoder and Decoder in a single structure. You can create a codec for Person using the line below:<\/p>\n
    <\/p>\n
    implicit<\/span> val<\/span> personCodec:<\/span> Codec<\/span>[<\/span>Person<\/span>]<\/span> =<\/span> deriveCodec[<\/span>Person<\/span>]<\/span>\r\n<\/pre>\n
     <\/p>\n
    4. Custom Codecs<\/strong><\/h4>\n
    We want to build an encoder for case classes User and YouTubeVideo. The YouTubeVideo class is a wrapper class around single property, video id. The User is a class with two properties: name and YouTubeVideo.<\/p>\n
    What we want to achieve is to serialise the User class such that the output would give name and an video url (built from the video id like http:\/\/yoube.com\/watch?v={videoId}.<\/p>\n
    The code below shows an Encoder that modifies the value of one of the fields<\/p>\n
    object<\/span> MyCodec<\/span> {<\/span>\r\n  \r\n  implicit<\/span> val<\/span> videoEncoder:<\/span> Encoder<\/span>[<\/span>YoutubeVideo<\/span>]<\/span> =<\/span> video =><\/span>\r\n    Json<\/span>.<\/span>fromString(<\/span>s\"http:\/\/www.youtube.com\/watch?v=${video.id}\"<\/span>)<\/span>\r\n\r\n}<\/span>\r\n<\/pre>\n
     <\/p>\n","protected":false},"excerpt":{"rendered":"
    In the previous two tutorials, we learnt how to build encoders and decoders. We used the forProductN(applicative-based decoders) and for comprehension (monadic decoders) to build … <\/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":[41,46,44,43],"class_list":["post-246","post","type-post","status-publish","format-standard","hentry","category-scala-programming","tag-circe","tag-codec","tag-decoder","tag-encoder"],"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/246","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=246"}],"version-history":[{"count":3,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/246\/revisions"}],"predecessor-version":[{"id":252,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/246\/revisions\/252"}],"wp:attachment":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/media?parent=246"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/categories?post=246"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/tags?post=246"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}