Scala for Backend Engineering & Functional Programming · Lección

Type Classes comunes

Show, Ordering, Numeric

Type Classes comunes es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

Clases de tipos estándar

La biblioteca estándar de Scala incluye varias clases de tipos que utiliza a diario, a veces sin darse cuenta:

Ordering[A] — cómo comparar valores.
Numeric[A] — operaciones aritméticas con números.
Representación al estilo de Show (personalizada o la Show de Cats).

Ordering permite usar sorted

List.sorted necesita un Ordering[A] implícito. La biblioteca estándar proporciona instancias para números, cadenas y otros tipos.

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

Ordering personalizado

Pase un Ordering explícito para ordenar de otra forma, por ejemplo, en orden descendente o según una clave derivada.

@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 para case classes

Proporcione una instancia de Ordering para su propio tipo, de modo que se puedan ordenar las colecciones que lo contienen. Ordering.by deriva una instancia a partir de una clave.

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 abstrae la aritmética

Numeric[A] permite escribir funciones que funcionan con cualquier tipo numérico. sum sobre una lista depende de él.

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

Escribir código numérico genérico

Con un context bound [A: Numeric] puede sumar o multiplicar cualquier tipo numérico de forma genérica. Utilice las operaciones de la instancia mediante 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)))
  }
}

Operadores numéricos

Importar Implicits de la instancia proporciona los operadores habituales (+, *) para tipos numéricos genéricos, lo que hace que el código resulte más natural.

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 clase de tipos Show

Show representa valores como texto de forma segura respecto a los tipos, a diferencia de toString, que existe en todo. Cats la proporciona; aquí se muestra una versión mínima.

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

Métodos de las colecciones como max, min y maxBy utilizan 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))
}

Combinar Ordering

Puede crear ordenaciones compuestas con Ordering.by sobre una tupla, ordenando primero por un campo y después por otro.

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

Por qué usar clases de tipos aquí

Como la comparación y la aritmética son clases de tipos, el mismo sorted o sum funciona con tipos integrados y propios, simplemente proporcionando una instancia. Así utiliza la biblioteca estándar el polimorfismo ad hoc.

Comprobación rápida

Compruebe sus conocimientos sobre las clases de tipos estándar.

Resumen

Ha conocido clases de tipos estándar habituales:

Ordering[A] controla sorted, max y min; se construye con Ordering.by.
Numeric[A] permite la aritmética genérica y sustenta sum.
Las clases al estilo de Show representan valores de forma segura respecto a los tipos.

Preguntas frecuentes

¿La lección «Type Classes comunes» es gratis?

Sí — el texto completo de «Type Classes comunes» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

¿Qué aprenderé en «Type Classes comunes»?

Show, Ordering, Numeric Practicas Scala for Backend Engineering & Functional Programming con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Scala for Backend Engineering & Functional Programming?

No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Type Classes comunes»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Scala for Backend Engineering & Functional Programming?

Sí. Cada lección de Scala for Backend Engineering & Functional Programming incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Scala for Backend Engineering & Functional Programming