Type class comuni
Show, Ordering, Numeric
Type class comuni è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
Classi di tipi standard
La libreria standard di Scala include diverse classi di tipi che usa ogni giorno, a volte senza rendersene conto:
Ordering[A]— come confrontare i valori.Numeric[A]— l'aritmetica sui numeri.- Rendering nello stile di
Show(personalizzato oppureShowdi Cats).
Ordering abilita sorted
List.sorted richiede un Ordering[A] implicito. La libreria standard fornisce istanze per numeri, stringhe e altri tipi.
@main def run(): Unit = {
println(List(3, 1, 2).sorted)
println(List("pear", "apple", "fig").sorted)
}Ordering personalizzato
Passi un Ordering esplicito per ordinare in modo diverso, ad esempio in ordine decrescente o in base a una chiave derivata.
@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 per le case class
Fornisca un'istanza Ordering per il proprio tipo, così le collezioni che lo contengono possono essere ordinate. Ordering.by ne deriva una a partire da una chiave.
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 astrae l'aritmetica
Numeric[A] consente di scrivere funzioni che lavorano con qualunque tipo numerico. Il metodo sum su una lista si basa su di esso.
@main def run(): Unit = {
println(List(1, 2, 3).sum)
println(List(1.5, 2.5).sum)
}Scrivere codice numerico generico
Con un context bound [A: Numeric] può sommare o moltiplicare qualunque tipo numerico in modo generico. Usi le operazioni dell'istanza tramite 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)))
}
}Operatori numerici
Importando Implicits dell'istanza, ottiene i normali operatori (+, *) sui tipi numerici generici, rendendo il codice più naturale da leggere.
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))
}
}Una classe di tipi Show
Show esegue il rendering dei valori come testo in modo type-safe, a differenza di toString, che esiste per ogni oggetto. Cats la fornisce; qui ne viene mostrata una versione minimale.
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 e max/min
Metodi delle collezioni come max, min e maxBy usano tutti Ordering internamente.
@main def run(): Unit = {
val xs = List(4, 9, 1, 7)
println(xs.max)
println(xs.min)
println(List("a", "abc", "ab").maxBy(_.length))
}Combinare gli Ordering
Può creare ordering compositi con Ordering.by applicato a una tupla, ordinando prima per un campo e poi per un altro.
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)
}
}Perché usare qui le classi di tipi
Poiché il confronto e l'aritmetica sono classi di tipi, lo stesso sorted o sum funziona con i tipi predefiniti e con i propri, semplicemente fornendo un'istanza. Questa è la libreria standard che usa il polimorfismo ad hoc.
Verifica rapida
Verifichi la sua conoscenza delle classi di tipi standard.
Riepilogo
Ha incontrato alcune comuni classi di tipi standard:
Ordering[A]gestiscesorted,maxemin; si costruisce conOrdering.by.Numeric[A]abilita l'aritmetica generica e supportasum.- Le classi nello stile di
Showeseguono il rendering dei valori in modo type-safe.
Domande Frequenti
La lezione «Type class comuni» è gratuita?
Sì — il testo completo di «Type class comuni» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
Cosa imparerò in «Type class comuni»?
Show, Ordering, Numeric Eserciti Scala for Backend Engineering & Functional Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Scala for Backend Engineering & Functional Programming?
Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Type class comuni»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Scala for Backend Engineering & Functional Programming?
Sì. Ogni lezione Scala for Backend Engineering & Functional Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.