Scala for Backend Engineering & Functional Programming · Ders

Birleşim ve Kesişim Türleri

Yeni tür özellikleri

Birleşim ve Kesişim Türleri, CoddyKit'te ücretsiz bir Scala for Backend Engineering & Functional Programming dersidir. Bu, 4 dersinin 4. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Scala for Backend Engineering & Functional Programming öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Scala for Backend Engineering & Functional Programming kursu toplamda 4 dersten oluşur.

Yeni Tür Özellikleri

Scala 3, tür sistemine birleşim türlerini (A | B) ve kesişim türlerini (A & B) ekler. Bunlar, kalıtım hiyerarşileri olmadan değerleri daha kesin biçimde açıklamanızı sağlar.

object Main:
  def main(args: Array[String]): Unit =
    println("Union: A | B, Intersection: A & B")

Birleşim Türlerinin Temelleri

Bir birleşim türü olan A | B, A veya B türünde olan bir değeri temsil eder. Türler üzerinde küme kuramsal bir OR işlemidir.

object Main:
  def show(x: Int | String): String = x match
    case i: Int    => s"int $i"
    case s: String => s"str $s"

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

Birleşimler Ortak Üst Tür Gerektirmez

Scala 2'deki Either'dan farklı olarak birleşim türleri sarmalama gerektirmez. Her iki türün ortak bir üst sınıfı olmasa bile bu türler birleştirilebilir.

object Main:
  def parse(input: Int | Boolean): String =
    input match
      case n: Int     => s"number $n"
      case b: Boolean => s"flag $b"

  def main(args: Array[String]): Unit =
    println(parse(7))
    println(parse(true))

Hata Modelleme İçin Birleşimler

Birleşim türleri, sarmalayıcı bir tür kullanmadan basit hata sonuçları oluşturmak için kullanışlıdır. Numaralandırmalar veya tekil türlerle birleştirildiğinde okunaklı olur.

case object NotFound

object Main:
  def lookup(id: Int): String | NotFound.type =
    if id == 1 then "Alice" else NotFound

  def main(args: Array[String]): Unit =
    println(lookup(1))
    println(lookup(2))

Kesişim Türlerinin Temelleri

Bir kesişim türü olan A & B, hem A hem de B olan bir değeri temsil eder. Genellikle özellikleri birleştirmek için kullanılan küme kuramsal bir AND işlemidir.

trait Named:
  def name: String
trait Aged:
  def age: Int

object Main:
  def describe(p: Named & Aged): String =
    s"${p.name} is ${p.age}"

  def main(args: Array[String]): Unit =
    val person = new Named with Aged:
      def name = "Bob"
      def age = 40
    println(describe(person))

Kesişim Değişme Özelliğine Sahiptir

Kesişim türlerinde sıra önemli değildir: A & B ile B & A aynı türdür. Bu, bazı üye çözümlemelerinde sıraya duyarlı olan Scala 2 birleşik türlerinden A with B farklıdır.

trait Readable:
  def read: String
trait Writable:
  def write(s: String): Unit

object Main:
  def use(r: Readable & Writable): Unit =
    r.write("x")
    println(r.read)

  def main(args: Array[String]): Unit =
    val rw = new Readable with Writable:
      def read = "data"
      def write(s: String) = println(s"wrote $s")
    use(rw)

Birden Çok Özelliği Birleştirme

İkiden fazla türü kesiştirebilirsiniz. Sonuç, listelenen tüm yetenekleri gerektirir.

trait A: def a: Int
trait B: def b: Int
trait C: def c: Int

object Main:
  def sum(x: A & B & C): Int = x.a + x.b + x.c

  def main(args: Array[String]): Unit =
    val v = new A with B with C:
      def a = 1
      def b = 2
      def c = 3
    println(sum(v))

Birleşimler İçin Tür Takma Adları

İmza bildirimlerini okunabilir tutmak için uzun birleşim türlerine type takma adıyla ad verebilirsiniz.

type Json = Int | String | Boolean

object Main:
  def render(j: Json): String = j match
    case i: Int     => i.toString
    case s: String  => s"\"$s\""
    case b: Boolean => b.toString

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

Birleşimlerde Eksiksiz Eşleştirme

Derleyici bir birleşimin üyelerini bildiğinden eşleştirmenin eksiksiz olup olmadığını denetleyebilir. Her alternatifi ele almak, eşleştirmeyi tam hâle getirir.

type Shape = "circle" | "square"

object Main:
  def sides(s: Shape): Int = s match
    case "circle" => 0
    case "square" => 4

  def main(args: Array[String]): Unit =
    println(sides("square"))

Birleşimlerin Genişletilmesi

Birleşim değerini türü çıkarılan bir değişkene atadığınızda Scala birleşim türünü korur. Ancak bazı işlemlerin türü en küçük üst sınıra genişlettiğini unutmayın; birleşimi korumak istediğinizde tür açıklaması ekleyin.

object Main:
  def pick(flag: Boolean): Int | String =
    if flag then 1 else "one"

  def main(args: Array[String]): Unit =
    val x: Int | String = pick(false)
    println(x)

Hangisi Ne Zaman Kullanılır

Doğru aracı seçin.

Birleşim: bir değer birkaç türden biridir (OR).
Kesişim: bir değer aynı anda birkaç özelliği karşılar (AND).
Birleşimler sarmalayıcı türleri, kesişimler ise derin kalıtımı gereksiz kılar.

trait Logger: def log(s: String): Unit
trait Clock:  def now: Long

object Main:
  def run(env: Logger & Clock): Unit =
    env.log(s"time=${env.now}")

  def main(args: Array[String]): Unit =
    val env = new Logger with Clock:
      def log(s: String) = println(s)
      def now = 100L
    run(env)

Kısa Kontrol

Birleşim ve kesişim türlerini ne kadar anladığınızı test edin.

Özet

Scala 3 birleşim ve kesişim türlerini öğrendiniz.

A | B: değer A veya B'dir; sarmalayıcıya ya da ortak üst türe gerek yoktur.
A & B: değer hem A hem B'dir; değişme özelliğine sahiptir.
Birleşimleri daraltmak için örüntü eşleştirme, özellikleri birleştirmek için kesişim kullanın.
Uzun birleşimlere ad vermek için type takma adlarını kullanın.

object Main:
  def length(x: String | List[Int]): Int = x match
    case s: String    => s.length
    case l: List[Int] => l.length

  def main(args: Array[String]): Unit =
    println(length("hello"))
    println(length(List(1, 2, 3)))

Sıkça Sorulan Sorular

“Birleşim ve Kesişim Türleri” dersi ücretsiz mi?

Evet — “Birleşim ve Kesişim Türleri” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Scala for Backend Engineering & Functional Programming kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Scala for Backend Engineering & Functional Programming kursu toplamda 4 dersten oluşur.

“Birleşim ve Kesişim Türleri” dersinde ne öğreneceğim?

Yeni tür özellikleri Scala for Backend Engineering & Functional Programming ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Scala for Backend Engineering & Functional Programming öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Scala for Backend Engineering & Functional Programming, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 4. dersidir.

“Birleşim ve Kesişim Türleri” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Scala for Backend Engineering & Functional Programming dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Scala for Backend Engineering & Functional Programming dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Scala for Backend Engineering & Functional Programming Sayfasına Dön