Zero Generics: Fonksiyonlar ve Shape'lerde Type Parametreleri

Neden Generic'ler

Birden fazla element tipi için çalışması gereken tiplerle hızlıca karşılaşırsınız. İki değerin "pair"ı, değerlerin integer mı, string mi, yoksa kullanıcı tanımlı bir shape mi olduğunu umursamamalı. Generic'ler tipi bir kez yazıp çağıranın ihtiyacına göre istediği element tipleriyle instantiate etmenize olanak verir.

Alternatif — IntPair, StringPair, BytePair ve benzerlerini ayrı ayrı yazmak — hızla sıkıcı hale gelir ve compose etmez. Zero'da generic'ler bu iş için standart araçtır.

Generic Fonksiyonlar

Type parametrelerini fonksiyon adı ile parametre listesi arasında angle bracket'ler içinde bildirin:

fun makePair<T, U>(left: T, right: U) -> Pair<T, U> {
    return Pair { left: left, right: right }
}

T ve U placeholder tipleridir — çağıran ne olduklarına karar verir.

Çağrılar genellikle bunları hecelemeniz gerekmez; compiler argüman tiplerinden çıkarır:

let pair = makePair(40, 2_u8)

Burada T, i32 (suffix'siz bir integer literal için varsayılan) olarak ve U, u8 (_u8 suffix'inden) olarak çıkarılır. Sonuç pair bağlamasının tipi Pair<i32, u8> olur.

Inference yanlış tipleri seçeceği — örneğin literal'ler belirsiz olduğu için — durumda, parametreleri çağrı yerinde sabitleyebilirsiniz:

let pair = makePair<u8, u8>(1, 2)

(Angle-bracket çağrı söz diziminin tam olarak gösterildiği gibi olup olmadığı Zero sürümleri arasında değişebilir; kesin yazım için güncel dokümanlara bakın. Inference-first davranışı kararlı kısımdır.)

Generic Shape'ler

Shape'ler de type parametrelerini aynı şekilde alır:

shape Pair<T, U> {
    left: T,
    right: U,
}

Her alanın tipi parametrelerden söz edebilir. Instance'lar bunları sabitler:

let intBytes: Pair<i32, u8> = Pair { left: 40, right: 2_u8 }
let words:    Pair<String, String> = Pair { left: "hi", right: "there" }

Generic shape ve generic fonksiyonu birleştiren işlenmiş bir örnek — inference'ı iş başında görmek için Run'a tıklayın:

shape Pair<T, U> {
    left: T,
    right: U,
}

fun makePair<T, U>(left: T, right: U) -> Pair<T, U> {
    return Pair { left: left, right: right }
}

pub fun main(world: World) -> Void raises {
    let pair: Pair<i32, u8> = makePair(40, 2_u8)
    if pair.left == 40 && pair.right == 2_u8 {
        check world.out.write("generic pair ok\n")
    } else {
        check world.out.write("generic pair broke\n")
    }
}

Bir generic shape bildirimi, bir generic fonksiyon, sıkı tiplendirilmiş bir çağrı yeri. IntBytePair boilerplate'i yok.

Type Alias'ları

Aynı parametrelendirilmiş tip tekrar tekrar geldiğinde, ona type ile bir isim verin:

type BytePair = Pair<u8, u8>

Artık BytePair, bir tip yazabileceğiniz her yerde Pair<u8, u8> ile değiştirilebilir:

type BytePair = Pair<u8, u8>

shape Pair<T, U> {
    left: T,
    right: U,
}

pub fun main(world: World) -> Void raises {
    let pair: BytePair = Pair { left: 1_u8, right: 2_u8 }
    if pair.left == 1_u8 && pair.right == 2_u8 {
        check world.out.write("type alias ok\n")
    } else {
        check world.out.write("type alias broke\n")
    }
}

Bir alias yalnızca bir adlandırma özelliğidir — ayrı bir tip yaratmaz. BytePair alan bir fonksiyon, Pair<u8, u8> tipinde bir değeri seve seve kabul eder (ve tersi).

Standart Kütüphanede Generic'ler

Aynı mekanizma standart kütüphanenin büyük bir kısmını güçlendirir. Gerçek Zero kodunda göreceğiniz birkaçı:

• Maybe<T> — bir T veya hiçbir şey tutan opsiyonel bir değer.
• Span<T> — T değerleri üzerinde ödünç alınmış bir dilim. Span<u8>, bir byte buffer üzerinde kanonik görünümdür.
• ref<T> ve mutref<T> — kopyalamadan veri paylaşmanız gereken durumlar için explicit referans tipleri.

Bunların hepsini bir kerede öğrenmek zorunda değilsiniz. Generic'lerin önemi, aynı shape'in elinizdeki hangi element tipi için de çalışmasıdır.

Generic'ler Ne Zaman Karşılığını Verir (ve Ne Zaman Vermez)

Aynı fonksiyonu ya da shape'i iki kez farklı element tipleriyle yazdığınızı fark ettiğinizde generic'lere başvurun. Şu durumlarda somut bir tipe geçin:

• Fonksiyonun mantığı yalnızca belirli bir tip için anlamlıdır (örneğin String'ler için bir parser).
• Tipin hata mesajlarında görünmesini istiyorsunuz, böylece debug etmek kolaylaşır.
• Performans karakteristikleri memory'de belirli bir boyuta bağlıdır.

Generic'lerin maliyeti gerçektir — daha büyük binary'ler (her instantiation yeni kod üretir) ve biraz daha yavaş compile süreleri. Çoğu uygulama kodu için bu maliyet ihmal edilebilir, ama binary boyutunun önemli olduğu sıkı, embedded tarzı kod yazıyorsanız bilmekte fayda var.

Constraint'ler Üzerine Bir Not

Bazı generic sistemleri bir type parametresini sınırlandırmanıza olanak verir ("T =='i desteklemeli", "T Iterator implement etmeli"). Zero'nun pre-1.0'daki constraint hikayesi hâlâ gelişiyor — resmi repo'daki örnekler generic'leri ayrıntılı bounds olmadan düz formda kullanıyor. Dil oturdukça, constraint söz diziminin dilin geri kalanıyla tutarlı küçük ve düzenli bir formda gelmesini bekleyin. Şimdilik, gerçekten geçirdiğiniz her T için çalışan generic'ler yazın ve bir işlemin desteklenmediği durumlarda compiler'ın size söylemesine izin verin.

Sırada: Enum'lar

Generic'ler size tipler üzerinde parametrelendirme imkanı verir. Bir sonraki yapı taşı yelpazenin diğer ucunda — Zero'nun variant'ları ekstra veri taşımayan durumlar için sade enumeration tipi olan enum'lar.