Scala for Backend Engineering & Functional Programming · Lesson

Type Class Derivation

Automatic instances.

Type Class Derivation is a free Scala for Backend Engineering & Functional Programming lesson on CoddyKit — lesson 4 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Scala for Backend Engineering & Functional Programming learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

What is Derivation?

Type class derivation generates instances automatically from a type's structure, so you do not hand-write boilerplate for every case class. The compiler builds the instance from its fields.

The Boilerplate Problem

Without derivation, every new case class needs a manual instance. For a Show over twenty case classes, that is twenty near-identical definitions. Derivation removes that repetition.

Manual Composition First

Before automatic derivation, note that you can compose instances by hand from field instances. This is the principle derivation automates.

trait Show[A] { def show(a: A): String }

case class User(name: String, age: Int)

object Main {
  implicit val strShow: Show[String] = s => s
  implicit val intShow: Show[Int] = _.toString

  implicit val userShow: Show[User] = (u: User) =>
    s"User(${strShow.show(u.name)}, ${intShow.show(u.age)})"

  def main(args: Array[String]): Unit = {
    println(userShow.show(User("Ann", 30)))
  }
}

Inductive Instances

Derivation works inductively: define instances for primitive types, then combine them for products (case classes) and sums (sealed traits). A derived instance is built from its parts.

Scala 3 derives Keyword

Scala 3 supports the derives clause. A type class with a derived method can be attached to a type with one keyword. (Conceptual snippet; requires a derivable type class.)

enum Color derives CanEqual:
  case Red, Green, Blue

@main def run(): Unit =
  println(Color.Red == Color.Red)

Mirror-Based Derivation

Scala 3 derivation uses scala.deriving.Mirror, which exposes a type's structure (field types and names) at compile time. A derived method folds over the mirror's element instances to build the whole.

Semi-Automatic Derivation

Libraries like Cats offer semi-automatic derivation: you opt in per type with a one-liner such as deriveShow, keeping compile times predictable while removing boilerplate.

Automatic vs Semi-Automatic

Two styles:

Automatic: instances appear wherever needed via an implicit import; convenient but can slow compilation.
Semi-automatic: you write one explicit derive call per type; more control, faster builds.

Derivation for Sealed Traits

For a sealed hierarchy (a sum type), a derived instance dispatches on which subtype a value is. Here a manual version shows the idea derivation automates.

trait Show[A] { def show(a: A): String }

sealed trait Shape
case class Circle(r: Int) extends Shape
case class Square(s: Int) extends Shape

object Main {
  implicit val shapeShow: Show[Shape] = {
    case Circle(r) => s"Circle($r)"
    case Square(s) => s"Square($s)"
  }

  def main(args: Array[String]): Unit = {
    println(shapeShow.show(Circle(5)))
    println(shapeShow.show(Square(3)))
  }
}

When to Use Derivation

Reach for derivation when:

You have many data types needing the same type class (JSON codecs, Show, Eq).
The instance is mechanical from the structure.

Write instances by hand when the behavior is custom or performance-critical.

A Generic Equality Example

Equality is a classic derivable type class. The standard == on case classes is itself a kind of structural equality the compiler generates for you.

case class Coord(x: Int, y: Int)

object Main {
  def main(args: Array[String]): Unit = {
    println(Coord(1, 2) == Coord(1, 2))
    println(Coord(1, 2) == Coord(3, 4))
  }
}

Quick Check

Test your understanding of derivation.

Recap

You learned type class derivation:

Instances are built inductively from field/case instances.
Scala 3 uses Mirror and the derives keyword.
Choose automatic for convenience, semi-automatic for control.
Use it to eliminate boilerplate across many data types.

Frequently asked questions

Is the “Type Class Derivation” lesson free?

Yes — the full text of “Type Class Derivation” is free to read here on the web, and the Scala for Backend Engineering & Functional Programming course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Scala for Backend Engineering & Functional Programming course, upgrade to CoddyKit PRO.

What will I learn in “Type Class Derivation”?

Automatic instances. You practise Scala for Backend Engineering & Functional Programming with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Scala for Backend Engineering & Functional Programming?

No prior experience is required. Scala for Backend Engineering & Functional Programming on CoddyKit is structured for beginners through advanced learners; this is — lesson 4 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Type Class Derivation” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Scala for Backend Engineering & Functional Programming lesson?

Yes. Every Scala for Backend Engineering & Functional Programming lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Scala for Backend Engineering & Functional Programming