Scala for Backend Engineering & Functional Programming · Lekcja

Typowe type classy

Show, Ordering, Numeric

Typowe type classy to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Scala for Backend Engineering & Functional Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.

Standardowe klasy typów

Biblioteka standardowa Scali udostępnia kilka klas typów, których używasz na co dzień, czasem nawet nie zdając sobie z tego sprawy:

Ordering[A] — sposób porównywania wartości,
Numeric[A] — działania arytmetyczne na liczbach,
renderowanie w stylu Show (własne lub Show z Cats).

Ordering umożliwia sorted

List.sorted wymaga niejawnej instancji Ordering[A]. Biblioteka standardowa udostępnia instancje dla liczb, napisów i innych typów.

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

Własny Ordering

Przekaż jawny Ordering, aby sortować w inny sposób, na przykład malejąco albo według wyprowadzonego klucza.

@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 dla klas case

Udostępnij instancję Ordering dla własnego typu, aby kolekcje tego typu można było sortować. Ordering.by wyprowadza instancję na podstawie klucza.

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 abstrahuje działania arytmetyczne

Numeric[A] pozwala pisać funkcje działające dla dowolnego typu liczbowego. Metoda sum na liście korzysta z tej klasy typów.

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

Pisanie generycznego kodu numerycznego

Dzięki context bound [A: Numeric] możesz generycznie dodawać lub mnożyć wartości dowolnego typu liczbowego. Korzystaj z operacji instancji za pośrednictwem 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)))
  }
}

Operatory numeryczne

Import instancji Implicits udostępnia zwykłe operatory (+, *) dla generycznych typów liczbowych, dzięki czemu kod jest naturalniejszy w czytaniu.

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))
  }
}

Klasa typów Show

Show renderuje wartości jako tekst w sposób bezpieczny typowo, w przeciwieństwie do toString, które istnieje dla wszystkiego. Cats udostępnia tę klasę; tutaj pokazano jej minimalną wersję.

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 oraz max/min

Metody takie jak max, min i maxBy w kolekcjach wewnętrznie korzystają z 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))
}

Łączenie obiektów Ordering

Możesz tworzyć złożone obiekty porządkujące za pomocą Ordering.by zastosowanego do krotki, sortując najpierw według jednego pola, a następnie według drugiego.

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)
  }
}

Dlaczego używamy tu klas typów

Ponieważ porównywanie i działania arytmetyczne są realizowane jako klasy typów, to samo sorted lub sum działa dla typów wbudowanych i własnych — wystarczy dostarczyć instancję. To biblioteka standardowa wykorzystująca polimorfizm ad hoc.

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat standardowych klas typów.

Podsumowanie

Poznałeś typowe standardowe klasy typów:

Ordering[A] obsługuje sorted, max i min; twórz je za pomocą Ordering.by.
Numeric[A] umożliwia generyczne działania arytmetyczne i zasila metodę sum.
Klasy w stylu Show renderują wartości w sposób bezpieczny typowo.

Często zadawane pytania

Czy lekcja „Typowe type classy” jest bezpłatna?

Tak — pełny tekst „Typowe type classy” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Scala for Backend Engineering & Functional Programming, przejdź na CoddyKit PRO. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.

Co nauczysz się w „Typowe type classy”?

Show, Ordering, Numeric Ćwiczysz Scala for Backend Engineering & Functional Programming z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Scala for Backend Engineering & Functional Programming?

Nie wymagamy żadnego doświadczenia. Scala for Backend Engineering & Functional Programming w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Typowe type classy”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Scala for Backend Engineering & Functional Programming?

Tak. Każda lekcja Scala for Backend Engineering & Functional Programming zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Scala for Backend Engineering & Functional Programming