Technical Tutorials

Go 1.18'in tanıtımından bu yana, Generics dilin tarihinde en çok beklenen özelliklerden biri haline geldi. Yıllar boyunca Go geliştiricileri, tekrar eden kod yazmadan tür güvenliği sağlamak için stringer gibi kod üretme araçlarına veya manuel arayüz doğrulamalarına güveniyordu. Etkin olsalar da, bu geçici çözümler genellikle niyeti belirsizleştiriyor ve derleme sürecine karmaşıklık katıyordu.

Generics, tür güvenliğini veya performansı feda etmeden, belirli gereksinimlerle kısıtlanmış herhangi bir tür üzerinde çalışan kod yazmamıza olanak tanır. Orta ve ileri düzey geliştiriciler için bu kısıtlamaları etkili bir şekilde kullanmayı anlamak, sürdürülebilir ve DRY (Kendini Tekrar Etme) kod yazmak için hayati önem taşır. Bu yazıda, basit "Merhaba Dünya" snippet'lerinin ötesine geçerek gerçek dünya senaryolarına odaklanan pratik Go generics örneklerini keşfedeceğiz.

Generic Fonksiyonlarla Tekrar Eden Kodlardan Kurtulun

Generics'in en yaygın kullanım durumu, yalnızca türleri bakımından farklı olan tekrar eden fonksiyonları ortadan kaldırmaktır. Sayı koleksiyonlarında minimum değeri bulmanız gereken bir senaryoyu düşünün. Generics olmadan, int, float64 ve int64 için ayrı fonksiyonlara ihtiyacınız olurdu.

Generics ile, bir tür parametresi T ve bir kısıtlama kullanarak tek bir fonksiyon tanımlayabiliriz. Standart kütüphane, eşitlik kontrollerini (== ve !=) destekleyen herhangi bir türle eşleşen comparable arayüzünü sağlar. Ancak minimum değerleri bulmak için genellikle sıralamaya ihtiyaç duyarız. Go'nun standart kütüphanesi yerleşik bir sıralı kısıtlama sağlamaz, ancak kendi kısıtlamamızı oluşturabiliriz.

package main

import (
	"fmt"
)

// Sıralı, karşılaştırmayı destekleyen türler için tanımladığımız bir kısıtlamadır.
type Ordered interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
	~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
	~float32 | ~float64 | ~string
}

// FindMin, herhangi bir sıralı türden bir dilimdeki en küçük değeri döndürür.
func FindMin[T Ordered](s []T) (T, bool) {
	if len(s) == 0 {
		var zero T
		return zero, false
	}
	min := s[0]
	for _, v := range s[1:] {
		if v < min {
			min = v
		}
	}
	return min, true
}

func main() {
	ints := []int{3, 1, 4, 1, 5, 9}
	if min, ok := FindMin(ints); ok {
		fmt.Printf("Min int: %d\n", min)
	}

	floats := []float64{1.1, 2.2, 0.5}
	if min, ok := FindMin(floats); ok {
		fmt.Printf("Min float: %.1f\n", min)
	}
}

Kısıtlamada tilde (~) işaretinin kullanımına dikkat edin. Bu, tür parametresinin belirtilen türlerden birinin alt türü olabilecek herhangi bir tür olabileceğini gösterir (örneğin, int tabanlı özel bir tür). Bu esneklik, generics'in gerçekten yeniden kullanılabilir olmasını sağlayan anahtar unsurdur.

Koleksiyonlar için Generic Türler

Generics'in başka bir güçlü uygulaması, generic veri yapıları oluşturmaktır. Basit, tür güvenli bir yığın (stack) uygulayalım. Dinamik olarak büyüyebilen dilimlerin aksine, bir yığın genellikle sabit bir kapasiteye veya belirli itme/çıkarma (push/pop) mantıklarına sahiptir.

package main

import (
	"errors"
	"fmt"
)

type Stack[T any] struct {
	items []T
}

// NewStack, belirtilen kapasiteye sahip yeni bir yığın oluşturur.
func NewStack[T any](capacity int) *Stack[T] {
	return &Stack[T]{
		items: make([]T, 0, capacity),
	}
}

// Push, bir öğeyi yığının tepesine ekler.
func (s *Stack[T]) Push(item T) {
	s.items = append(s.items, item)
}

// Pop, en üstteki öğeyi kaldırır ve döndürür. Boşsa hata döndürür.
func (s *Stack[T]) Pop() (T, error) {
	if len(s.items) == 0 {
		var zero T
		return zero, errors.New("yığın boş")
	}
	index := len(s.items) - 1
	item := s.items[index]
	s.items = s.items[:index]
	return item, nil
}

func main() {
	// Bir dize yığını oluşturun
	stringStack := NewStack[string](10)
	stringStack.Push("First")
	stringStack.Push("Second")

	item, err := stringStack.Pop()
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Printf("Çıkarılan: %s\n", item) // Çıktı: Çıkarılan: Second
	}
}

Bu örnekte [T any] kullanıyoruz. any türü, interface{} için bir takma addır; yani herhangi bir türü kabul eder. Bu, önceki örnekteki Ordered arayüzüne göre daha az kısıtlayıcıdır, ancak ayrı implementasyonlara ihtiyaç duymadan tamsayılar, dizeler veya hatta özel yapıları (structs) tutabilen generic bir yığın oluşturmamıza olanak tanır.

Pratik Tavsiyeler: Generics Ne Zaman Kullanılmalı?

Generics güçlü olsa da, her soruna çözüm değildir. Dikkate almanız gereken birkaç kılavuz ilke şunlardır:

Aşırı mühendislikten kaçının: Yalnızca iki türle çalışan bir fonksiyona ihtiyacınız varsa, bunun yerine bir arayüz kullanmayı düşünün. Generics, birden fazla türünüz olduğunda veya yansıma (reflection) kullanımından kaçınmanız gerektiğinde parlar.
Okunabilirlik önemlidir: Generic kod, bazen somut koddan daha okunması zor olabilir. Kısıtlamalarınızı ve tür parametrelerinizi basit tutmaya her zaman özen gösterin. Derinlemesine iç içe geçmiş kısıtlamalardan kaçının.
Standart Kütüphaneye bağlı kalın: Mümkün olduğunda, tutarlılığı sağlamak amacıyla standart kütüphanenin kısıtlamalarını (örneğin comparable) veya iyi anlaşılan özel kısıtlamaları kullanın.

Sonuç

Go'daki Generics, dilin sadelik ve tür güvenliği felsefesini korurken kod yeniden kullanımını etkinleştirmede önemli bir adımdır. Kısıtlamaları ve tür parametrelerini ustalaşarak, ekibinizin ihtiyaçlarına göre ölçeklenebilen daha temiz ve daha sağlam uygulamalar yazabilirsiniz. Küçük başlayın: Tekrar eden bir fonksiyonu yeniden düzenleyin veya tek bir generic yardımcı tür oluşturun ve bu kalıpları projelerinize kademeli olarak entegre edin.

Go ekosistemi olgunlaştıkça, daha sofistike generic kütüphanelerin ve deyimlerin ortaya çıkması muhtemeldir. Bu yeni araçlarla bilgi sahibi kalmak ve pratik yapmak, sizi modern Go geliştirme konusunda en ön planda tutacaktır.