Scala voor backend-engineering en functioneel programmeren · Les

Veelgebruikte typeclasses

Show, Ordering, Numeric

Les 3 van 413 stappen

Veelgebruikte typeclasses is een gratis Scala voor backend-engineering en functioneel programmeren-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Scala voor backend-engineering en functioneel programmeren. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Scala voor backend-engineering en functioneel programmeren bevat in totaal 4 lessen.

Standaardtypeklassen

De standaardbibliotheek van Scala bevat verschillende typeklassen die je dagelijks gebruikt, soms zonder het te beseffen:

Ordering[A] — hoe waarden worden vergeleken.
Numeric[A] — rekenkundige bewerkingen op getallen.
Weergave in de stijl van Show (aangepast of de Show van Cats).

Ordering maakt sorted mogelijk

List.sorted heeft een impliciete Ordering[A] nodig. De standaardbibliotheek biedt instanties voor getallen, tekenreeksen en meer.

@main def run(): Unit = {
  println(List(3, 1, 2).sorted)
  println(List("pear", "apple", "fig").sorted)
}

Aangepaste Ordering

Geef een expliciete Ordering door om op een andere manier te sorteren, bijvoorbeeld aflopend of op basis van een afgeleide sleutel.

@main def run(): Unit = {
  val nums = List(3, 1, 2)
  println(nums.sorted(Ordering.Int.reverse))
  val words = List("bbb", "a", "cc")
  println(words.sortBy(_.length))
}

Ordering voor case classes

Lever een Ordering-instantie voor je eigen type, zodat verzamelingen daarvan kunnen worden gesorteerd. Ordering.by leidt een instantie af op basis van een sleutel.

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

object Main {
  implicit val byAge: Ordering[Person] = Ordering.by(_.age)

  def main(args: Array[String]): Unit = {
    val people = List(Person("A", 30), Person("B", 20))
    println(people.sorted)
  }
}

Numeric abstraheert rekenkunde

Met Numeric[A] kun je functies schrijven die met elk numeriek type werken. sum op een lijst steunt hierop.

@main def run(): Unit = {
  println(List(1, 2, 3).sum)
  println(List(1.5, 2.5).sum)
}

Generieke numerieke code schrijven

Met een contextgrens [A: Numeric] kun je elk numeriek type generiek optellen of vermenigvuldigen. Gebruik de bewerkingen van de instantie via Numeric[A].

object Main {
  def addAll[A: Numeric](xs: List[A]): A = {
    val num = implicitly[Numeric[A]]
    xs.foldLeft(num.zero)(num.plus)
  }

  def main(args: Array[String]): Unit = {
    println(addAll(List(1, 2, 3)))
    println(addAll(List(1.0, 2.0, 3.5)))
  }
}

Numerieke operatoren

Als je de Implicits van de instantie importeert, krijg je de gebruikelijke operatoren (+, *) voor generieke numerieke typen, waardoor de code natuurlijk leest.

object Main {
  def square[A](a: A)(implicit num: Numeric[A]): A = {
    import num._
    a * a
  }

  def main(args: Array[String]): Unit = {
    println(square(5))
    println(square(2.5))
  }
}

Een Show-typeklasse

Show geeft waarden op een typeveilige manier weer als tekst, in tegenstelling tot toString, dat op alles bestaat. Cats biedt deze typeklasse; hier zie je een minimale versie.

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

object Show {
  implicit val intShow: Show[Int] = n => s"Int($n)"
  def apply[A](implicit s: Show[A]): Show[A] = s
}

object Main {
  def main(args: Array[String]): Unit = {
    println(Show[Int].show(42))
  }
}

Ordering en max/min

Methoden zoals max, min en maxBy op verzamelingen gebruiken onder de motorkap allemaal Ordering.

@main def run(): Unit = {
  val xs = List(4, 9, 1, 7)
  println(xs.max)
  println(xs.min)
  println(List("a", "abc", "ab").maxBy(_.length))
}

Orderings combineren

Je kunt samengestelde orderings maken met Ordering.by op een tuple, waarbij je eerst op het ene veld en daarna op het andere sorteert.

case class Rec(group: String, score: Int)

object Main {
  implicit val ord: Ordering[Rec] = Ordering.by(r => (r.group, -r.score))

  def main(args: Array[String]): Unit = {
    val data = List(Rec("b", 5), Rec("a", 1), Rec("a", 9))
    data.sorted.foreach(println)
  }
}

Waarom hier typeklassen worden gebruikt

Omdat vergelijken en rekenen typeklassen zijn, werken dezelfde functies sorted en sum voor ingebouwde typen en je eigen typen, simpelweg door een instantie aan te leveren. Dit is ad-hocpolymorfisme in de standaardbibliotheek.

Korte controle

Test je kennis van standaardtypeklassen.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt kennisgemaakt met veelgebruikte standaardtypeklassen:

Ordering[A] stuurt sorted, max en min aan; maak er een met Ordering.by.
Numeric[A] maakt generieke rekenkunde mogelijk en vormt de basis voor sum.
Typeklassen in de stijl van Show geven waarden typeveilig weer.

Gratis beginnen

Leer Scala met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 39
Lessen: 143

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Veelgebruikte typeclasses” gratis?

Ja — de volledige tekst van “Veelgebruikte typeclasses” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Scala voor backend-engineering en functioneel programmeren wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Scala voor backend-engineering en functioneel programmeren bevat in totaal 4 lessen.

Wat leer ik in “Veelgebruikte typeclasses”?

Show, Ordering, Numeric Je oefent met Scala voor backend-engineering en functioneel programmeren door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Scala voor backend-engineering en functioneel programmeren te beginnen?

Ervaring vooraf is niet nodig. Scala voor backend-engineering en functioneel programmeren op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Veelgebruikte typeclasses”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Scala voor backend-engineering en functioneel programmeren?

Ja. Elke les over Scala voor backend-engineering en functioneel programmeren bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Scala voor backend-engineering en functioneel programmeren