Scala för backendutveckling och funktionell programmering · Lektion

Definiera instanser

Implicita instanser.

Lektion 2 av 413 steg

Definiera instanser är en gratis lektion i Scala för backendutveckling och funktionell programmering på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Scala för backendutveckling och funktionell programmering, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.

Definiera instanser

En instans talar om för kompilatorn hur en typklass fungerar för en viss typ. I Scala märks instanser vanligtvis med implicit (Scala 2) eller deklareras med given (Scala 3), så att de hittas automatiskt.

En implicit val-instans

För en enkel typklass räcker en implicit val. Kompilatorn hittar den när en funktion behöver en Show[Int].

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

object Main {
  implicit val intShow: Show[Int] = (a: Int) => s"Int=$a"

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

  def main(args: Array[String]): Unit = {
    println(display(123))
  }
}

implicitly: Hämta en instans

implicitly[Show[Int]] ber kompilatorn att hämta instansen som finns i det aktuella omfånget. Det är användbart för att testa att en instans finns eller för att komma åt den direkt.

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

object Main {
  implicit val intShow: Show[Int] = (a: Int) => s"<$a>"

  def main(args: Array[String]): Unit = {
    val s = implicitly[Show[Int]]
    println(s.show(8))
  }
}

Instanser för anpassade typer

Definiera en instans för Er egen case class. Dataklassen förblir ren, medan formateringen finns i instansen.

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

case class Point(x: Int, y: Int)

object Main {
  implicit val pointShow: Show[Point] = (p: Point) => s"(${p.x}, ${p.y})"

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

  def main(args: Array[String]): Unit = {
    println(display(Point(3, 4)))
  }
}

implicit def för generiska instanser

När en instans beror på en annan instans använder Ni implicit def. Här byggs en Show[List[A]] utifrån en Show[A].

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

object Main {
  implicit val intShow: Show[Int] = (a: Int) => a.toString

  implicit def listShow[A](implicit s: Show[A]): Show[List[A]] =
    (xs: List[A]) => xs.map(s.show).mkString("[", ", ", "]")

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

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

Instanser i companion object

Om Ni placerar instanser i typklassens companion object hittas de automatiskt utan någon import. Detta är den rekommenderade platsen för standardinstanser.

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

object Show {
  implicit val intShow: Show[Int] = (a: Int) => s"i:$a"
  implicit val strShow: Show[String] = (a: String) => s"s:$a"
}

object Main {
  def display[A](a: A)(implicit s: Show[A]): String = s.show(a)

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

Implicit omfång och prioritet

Kompilatorn söker efter en instans på flera platser: först i det lokala eller importerade omfånget och därefter i companion objects för de berörda typerna. Om två instanser är lika specifika får Ni ett fel om tvetydig implicit.

Kortform för kontextbundenhet

Syntaxen def f[A: Show](a: A) är en context bound: den innebär att det måste finnas en implicit Show[A] i omfånget. Inuti funktionen hämtar Ni den med implicitly.

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

object Main {
  implicit val intShow: Show[Int] = (a: Int) => s"n=$a"

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

  def main(args: Array[String]): Unit = {
    println(display(77))
  }
}

En hjälpfunktion för att hämta instanser

Bibliotek lägger till en apply-metod i companion object som en praktisk summoner: Show[Int] returnerar instansen. Det är renare än implicitly.

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

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

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

Undvik fristående instanser

En fristående instans är en instans som varken definieras tillsammans med typklassen eller med typen. De är tillåtna men kan orsaka inkonsekvent beteende mellan importer. Föredra instanser i companion objects för att hålla dem sammanhängande.

Sätt ihop allt

Ett komplett program: instanser i companion objects, en härledd listinstans och en summoner.

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

object Show {
  def apply[A](implicit s: Show[A]): Show[A] = s
  implicit val intShow: Show[Int] = _.toString
  implicit def listShow[A](implicit s: Show[A]): Show[List[A]] =
    (xs: List[A]) => xs.map(s.show).mkString(", ")
}

object Main {
  def main(args: Array[String]): Unit = {
    println(Show[List[Int]].show(List(4, 5, 6)))
  }
}

Snabbtest

Testa Era kunskaper om att definiera instanser.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt Er att definiera instanser:

implicit val för enkla instanser och implicit def för härledda instanser.
Hämta instanser med implicitly eller ett companion-apply.
Använd context bounds [A: Show] som kortform.
Placera instanser i companion objects för att undvika fristående instanser.

Gratis att börja

Lär dig Scala med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 39
Lektioner: 143

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Definiera instanser” gratis?

Ja – hela texten till ”Definiera instanser” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Scala för backendutveckling och funktionell programmering, kan Ni uppgradera till CoddyKit PRO. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.

Vad lär jag mig i ”Definiera instanser”?

Implicita instanser. Ni övar på Scala för backendutveckling och funktionell programmering med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Scala för backendutveckling och funktionell programmering?

Du behöver inga förkunskaper. Utbildningen i Scala för backendutveckling och funktionell programmering på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Definiera instanser”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Scala för backendutveckling och funktionell programmering-lektionen?

Ja. Varje Scala för backendutveckling och funktionell programmering-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Scala för backendutveckling och funktionell programmering