Scala for Backend Engineering & Functional Programming · Lección

given/using de Scala 3

Sintaxis moderna

given/using de Scala 3 es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 2 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.

Los implícitos modernos en Scala 3

Scala 3 reemplaza la palabra clave sobrecargada implicit por una sintaxis más clara: given define un valor implícito y using declara un parámetro implícito. La intención resulta mucho más fácil de leer.

object Main:
  given greeting: String = "Hello"
  def greet(name: String)(using g: String): String = s"$g, $name!"
  def main(args: Array[String]): Unit =
    println(greet("Ann"))

given reemplaza a implicit val

Donde Scala 2 escribía implicit val x: T = ..., Scala 3 escribe given x: T = .... Esto declara un valor disponible para la resolución de implícitos.

object Main:
  given factor: Int = 10
  def scale(x: Int)(using f: Int): Int = x * f
  def main(args: Array[String]): Unit =
    println(scale(5))

using reemplaza a los parámetros implícitos

Una cláusula using marca una lista de parámetros como implícita. El compilador la completa a partir de un given compatible en el ámbito.

object Main:
  given unit: String = "kg"
  def label(n: Int)(using u: String): String = s"$n$u"
  def main(args: Array[String]): Unit =
    println(label(75))

given anónimos

Puede omitir el nombre de un given cuando nunca vaya a referirse a él directamente. El compilador seguirá encontrándolo por tipo.

object Main:
  given Int = 3
  def triple(x: Int)(using f: Int): Int = x * f
  def main(args: Array[String]): Unit =
    println(triple(7))

Obtener valores con summon

El summon[T] de Scala 3 reemplaza a implicitly[T]. Obtiene directamente el valor given de tipo T.

object Main:
  given name: String = "Scala 3"
  def main(args: Array[String]): Unit =
    val n = summon[String]
    println(n)

Parámetros using anónimos

Si solo necesita reenviar un parámetro using, puede dejarlo sin nombre en la cláusula: (using Int). Obténgalo dentro de ella con summon.

object Main:
  given Int = 100
  def boosted(x: Int)(using Int): Int = x + summon[Int]
  def main(args: Array[String]): Unit =
    println(boosted(5))

given para clases de tipos

El uso más idiomático de given/using corresponde a las clases de tipos. Defina un trait, proporcione una instancia given y exíjala con using.

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

object Main:
  given Show[Int] with
    def show(a: Int): String = s"Int($a)"

  def display[A](a: A)(using s: Show[A]): String = s.show(a)

  def main(args: Array[String]): Unit =
    println(display(42))

Los context bounds siguen funcionando

Los context bounds [A: Show] siguen disponibles y se transforman en un parámetro using. Combínelos con summon para acceder a la instancia.

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

object Main:
  given Show[String] with
    def show(a: String): String = s"Str($a)"

  def display[A: Show](a: A): String = summon[Show[A]].show(a)

  def main(args: Array[String]): Unit =
    println(display("hi"))

Pasar argumentos using explícitamente

Puede proporcionar explícitamente un parámetro using con la palabra clave using en el punto de llamada, reemplazando el given del ámbito.

object Main:
  given Int = 10
  def scale(x: Int)(using f: Int): Int = x * f
  def main(args: Array[String]): Unit =
    println(scale(5))
    println(scale(5)(using 2))

Importaciones de given

Scala 3 tiene una sintaxis específica para importar givens: import pkg.given o import pkg.{given Show[Int]}. Esto hace que las importaciones implícitas sean explícitas e intencionadas.

object Instances:
  given Int = 5

object Main:
  import Instances.given
  def addBase(x: Int)(using b: Int): Int = x + b
  def main(args: Array[String]): Unit =
    println(addBase(10))

Por qué existe la nueva sintaxis

En Scala 2, la única palabra clave implicit representaba varias cosas distintas. Scala 3 divide el concepto: given = proporcionar, using = exigir. El código es más claro y los errores resultan más fáciles de entender.

object Main:
  given pi: Double = 3.14159
  def area(r: Double)(using p: Double): Double = p * r * r
  def main(args: Array[String]): Unit =
    println(area(2.0))

Comprobación rápida

En Scala 3, ¿qué palabras clave reemplazan a implicit para proporcionar y exigir valores?

Repaso

Ha aprendido sobre given/using en Scala 3:

given proporciona un valor implícito (reemplaza a implicit val)
using declara un parámetro implícito
summon[T] reemplaza a implicitly[T]
Los givens pueden ser anónimos y son ideales para las clases de tipos
import pkg.given los importa explícitamente

Preguntas frecuentes

¿La lección «given/using de Scala 3» es gratis?

Sí — el texto completo de «given/using de Scala 3» 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 «given/using de Scala 3»?

Sintaxis moderna 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 2 de 4.

¿Cuánto tiempo toma la lección «given/using de Scala 3»?

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