Type Classes: How Scala Achieves Polymorphism Without Inheritance

"Imagine you're working with a third-party library that provides a User class. You need to add JSON serialization to it, but you can't modify the source code. Of course you can create a wrapper class or extend it, but that feels clunky and breaks existing code that expects the original type. This is where type classes shine. They're one of Scala's most powerful patterns, and they're the secret ingredient in popular libraries like Cats, Scalaz, and Circe."

"In Traditional OOP we use inheritance for polymorphism. If we want multiple types to share behavior we create an interface or abstract class. trait Printable { def print: String}case class User(name: String, age: Int) extends Printable { def print: String = s"User($name, $age)"} This works fine when you control the types, but is has serious limitations: You can't add interfaces to existing types - You cannot extend Int, Boolean or a library classes from Printable."

Type classes allow adding functionality to existing types without modifying their definitions. They separate type from behavior via three parts: a trait defining the interface, concrete instances implementing the trait, and interface methods for usage. This pattern avoids inheritance limits, such as inability to add interfaces to built-in or third-party types and tight coupling caused by modifying class definitions. Type classes enable adding behavior like JSON serialization to external types without wrappers or subclassing. The pattern underpins libraries like Cats, Scalaz, and Circe and changes approaches to polymorphism in Scala.

Read at Medium