Sorumluluk reddi: Go ile yalnızca bir gündür oynadım, bu yüzden çok şey kaçırmış olma ihtimalim çok yüksek.

Go'da jenerikler / şablonlar / whatsInAName için neden gerçek bir destek olmadığını bilen var mı? Yani bir jenerik var map, ancak bu derleyici tarafından sağlanırken bir Go programcısı kendi uygulamasını yazamaz. Go'yu olabildiğince ortogonal yapmakla ilgili tüm konuşmalarla birlikte, neden genel bir tür kullanıp yeni bir tane OLUŞTURMAYIYORUM?

Özellikle işlevsel programlama söz konusu olduğunda, lambdalar, hatta kapanışlar vardır, ancak jenerikten yoksun statik tip bir sistemle, nasıl, iyi, genel yüksek dereceli fonksiyonları gibi yazabilirim filter(predicate, list)? Tamam, Bağlantılı listeler ve benzerleri interface{}tür güvenliğinden ödün vererek yapılabilir .

SO / Google üzerinde hızlı bir arama herhangi bir içgörü ortaya koymadığından, jenerikler Go'ya sonradan eklenecek gibi görünüyor. Java çalışanlarından çok daha iyisini yapacağına dair Thompson'a güveniyorum, ama neden jenerik ilaçları dışarıda tutalım? Yoksa planlandılar ve henüz uygulanmadı mı?

bu cevabı burada bulacaksınız: http://golang.org/doc/faq#generics

Go'nun neden genel türleri yok?

Jenerikler bir noktada eklenebilir. Bazı programcıların bunu yaptığını bilsek de, onlar için bir aciliyet hissetmiyoruz.

Jenerikler kullanışlıdır, ancak tip sistem ve çalışma süresinde karmaşıklık açısından bir maliyete sahiptirler. Karmaşıklığa orantılı değer veren bir tasarım henüz bulamadık, ancak üzerinde düşünmeye devam ediyoruz. Bu arada, Go'nun yerleşik haritaları ve dilimlerinin yanı sıra, kaplar oluşturmak için boş arabirimi kullanma yeteneği (açık kutudan çıkarma ile), çoğu durumda jeneriklerin daha az sorunsuz olsa da etkinleştireceği şeyi yapan kod yazmanın mümkün olduğu anlamına gelir.

Bu açık bir sorun olmaya devam ediyor.

2 gidin

Https://blog.golang.org/go2draft adresinde jenerikler için bir taslak tasarım bulunmaktadır .

1 gidin

Go gazilerinden biri olan Russ Cox, The Generic Dilemma adlı bir blog yazısı yazdı ve burada

… Yavaş programcılar, yavaş derleyiciler ve şişirilmiş ikili dosyalar mı yoksa yavaş yürütme süreleri mi istiyorsunuz?

Yavaş programcılar jenerik olmamasının sonucu değildir, yavaş derleyiciler C ++ benzeri jeneriklerden kaynaklanır ve yavaş yürütme süreleri Java'nın kullandığı kutudan çıkarma yaklaşımından kaynaklanır.

Blogda belirtilmeyen dördüncü olasılık C # yoluna gitmektir. Özel kodu C ++ 'da olduğu gibi, ancak gerektiğinde çalışma zamanında üretmek. Gerçekten beğendim, ancak Go, C # 'den çok farklıdır, bu yüzden bu muhtemelen hiç uygulanamaz ...

Ben tekniği gibi popüler Java 1.4 kullanarak bahsetmeliyiz seferde jenerik programlama buna atmalarını interface{}tamamen aynı sorunlardan muzdarip boks-kutudan çıkarma derleme zamanı tür güvenliği kaybının yanı sıra, (yani ne yapıyoruz çünkü). Küçük türler için (ints gibi) Go, interface{}türü, arabirime dönüştürülen girişlerin listesi {} bitişik bir bellek alanını kaplayacak ve normal inçlere göre yalnızca iki kat daha fazla yer kaplayacak şekilde optimize eder . Yine de, içinden yayın yaparken çalışma zamanı kontrollerinin ek yükü var interface{}. Referans .

Gitmek için genel destek ekleyen tüm projeler (bunlardan birkaçı var ve hepsi ilginç) tek tip olarak derleme zamanı kodu oluşturmanın C ++ yoluna gider.

Jenerikler halihazırda yerleşik olmasa da, kod üreten küçük yardımcı programlarla kombinasyonlar halinde yorum kullanan go için birkaç harici jenerik uygulaması vardır.

İşte böyle bir uygulama: http://clipperhouse.github.io/gen/

Aslında bu gönderiye göre :

Pek çok kişi (yanlış bir şekilde) Go ekibinin pozisyonunun "Git hiçbir zaman jeneriklere sahip olmayacağı" sonucuna varmıştır. Aksine, hem Go'yu çok daha esnek ve güçlü kılmak hem de Go'yu çok daha karmaşık hale getirmek için potansiyel jeneriklerin sahip olduğunu anlıyoruz. Jenerik ekleyeceksek, bunu olabildiğince az karmaşıklıkla daha fazla esneklik ve güç elde edecek şekilde yapmak istiyoruz.

Parametrik polimorfizmi (jenerikler) olduğu için göz altında Go 2 .

Bu yaklaşım , tür parametreleri üzerindeki kısıtlamaları ifade etmek için kullanılabilecek bir sözleşme kavramını ortaya koyacaktır:

contract Addable(a T) {
  a + a // Could be += also
}

Böyle bir sözleşme daha sonra şu şekilde kullanılabilir:

func Sum(type T Addable)(l []T) (total T) {
  for _, e := range l {
    total += e
  }
  return total
}

Bu, bu aşamada bir tekliftir .

Sizin filter(predicate, list)fonksiyonu böyle bir tip parametresi ile uygulanabilir:

func Filter(type T)(f func(T) bool, l []T) (result []T) {
  for _, e := range l {
    if f(e) {
      result = append(result, e)
    }
  }
  return result
}

Bu durumda sınırlamaya gerek yoktur T.