Rust'daki özellikler ile Haskell'deki typeclasses arasındaki fark nedir?

Rust'daki özellikler en azından Yüzeysel olarak Haskell'deki tipik örneklere benziyor , ancak insanların aralarında bazı farklılıklar olduğunu yazdıklarını gördüm. Bu farklılıkların tam olarak ne olduğunu merak ediyordum.

Temel düzeyde, çok fazla fark yok, ama hala oradalar.

Haskell, tıpkı özellikler içerdikleri nesnelerdeki OOP yöntemlerini tanımladığı gibi, bir tip sınıfında tanımlanan işlevleri veya değerleri 'yöntemler' olarak tanımlar. Bununla birlikte, Haskell bunlarla farklı şekilde ilgilenir, onlara OOP gibi bir nesneye sabitlemek yerine bireysel değerler olarak davranır. Bu, en belirgin yüzey seviyesi farkı ile ilgilidir.

Rust'un bir süre yapamayacağı tek şey , rezil ve tipik sınıflar gibi daha üst düzey tip özelliklerdi .FunctorMonad

Bu, Rust özelliklerinin genellikle 'somut tip' olarak adlandırılan şeyi, başka bir deyişle, genel bir argüman olmadan tanımlayabileceği anlamına gelir. Başlangıçtan itibaren Haskell, üst düzey işlevlerin diğer işlevleri nasıl kullandığına benzer türler kullanan daha üst düzey tipler yapabilir: birini diğerini tanımlamak için kullanma. Bir süre için bu Rust'da mümkün değildi, ancak ilişkili öğeler uygulandığından, bu tür özellikler yaygın ve deyimsel hale geldi.

Dolayısıyla, uzantıları görmezden gelirsek, bunlar tam olarak aynı değildir, ancak her biri diğerinin neler yapabileceğini yaklaşık olarak tahmin edebilir.

Yorumlarda da belirtildiği gibi, GHC'nin (Haskell'in ana derleyicisi), çok parametreli (yani birçok tür dahil) daktilolar ve tip bağımlılıklarına izin veren hoş bir seçenek de dahil olmak üzere, tipik sınıflar için diğer seçenekleri desteklediği de belirtilmelidir. ve tip ailelere götürür . Bildiğim kadarıyla, Rust gelecekte ne de olsa eğlenceliDeps veya tip aileleri yok. †

Sonuç olarak, özellikler ve tipik sınıflar, etkileşim biçimleri nedeniyle, hareket etmelerini ve sonunda oldukça benzer görünmelerini sağlayan temel farklılıklara sahiptir.

† Haskell'in tip sınıfları hakkında güzel bir makale (daha yüksek tipler de dahil olmak üzere) burada bulunabilir ve özelliklerle ilgili Örnek bölümüyle Rust'ı burada bulabilirsiniz.

Bence mevcut cevaplar Rust özellikleri ile Haskell tipi sınıflar arasındaki en temel farklılıkları görmezden geliyor. Bu farklılıklar, özelliklerin nesne yönelimli dil yapılarıyla ilişkilendirilme şekliyle ilgilidir. Bununla ilgili bilgi için Rust kitabına bakınız .

1. Özellik bildirimi bir özellik türü oluşturur . Bu, böyle bir türün (veya daha doğrusu türün referanslarının) değişkenlerini bildirebileceğiniz anlamına gelir. Özellik türlerini işlev, yapı alanları ve tür parametresi örneklerinde parametre olarak da kullanabilirsiniz.

   Bir sürekli başvuru değişkeni, çalışma zamanında başvurulan nesnenin çalışma zamanı türü özelliği uyguladığı sürece farklı türdeki nesneleri içerebilir.

   // The shape variable might contain a Square or a Circle, 
   // we don't know until runtime
   let shape: &Shape = get_unknown_shape();
   
   // Might contain different kinds of shapes at the same time
   let shapes: Vec<&Shape> = get_shapes();

   Tür sınıfları bu şekilde çalışmaz. Tür sınıfları tür oluşturmaz , bu nedenle sınıf adıyla değişken bildiremezsiniz. Tür sınıfları , tür parametreleri üzerinde sınır görevi görür , ancak tür parametreleri tür sınıfının kendisi ile değil somut bir türle başlatılmalıdır.

   Aynı tür sınıfını uygulayan farklı türde farklı şeylerin bir listesi olamaz. (Bunun yerine, Haskell'de benzer bir şeyi ifade etmek için varoluşçu türler kullanılır.) ^{Not 1}

2. Özellik yöntemleri dinamik olarak gönderilebilir . Bu, yukarıdaki bölümde açıklananlarla güçlü bir şekilde ilişkilidir.

   Dinamik gönderme, başvuru noktasından hangi yöntemin çağrıldığını belirlemek için bir başvuru noktası olan nesnenin çalışma zamanı türünün kullanıldığı anlamına gelir.

   let shape: &Shape = get_unknown_shape();
   
   // This calls a method, which might be Square.area or
   // Circle.area depending on the runtime type of shape
   print!("Area: {}", shape.area());

   Yine, bunun için Haskell'de varoluşçu türler kullanılır.

Sonuç olarak

Bana öyle geliyor ki, özellikler birçok açıdan tip sınıflarıyla aynı kavramdır. Ek olarak, nesne yönelimli arayüzlerin işlevselliğine sahiptirler.

Diğer yandan Haskell'in tip sınıfları daha ileridir. Haskell, örneğin çok parametreli tip sınıfları gibi daha yüksek türlü tiplere ve uzantılara sahiptir.

Not 1 : Rust'un son sürümlerinde, özellik adlarının tür olarak kullanımını ve özellik adlarının sınır olarak kullanımını ayırt etmek için bir güncelleme vardır. Bir özellik türünde, adın başına dynanahtar kelime gelir. Daha fazla bilgi için örneğin bu cevaba bakınız .

Rust'un “özellikleri” Haskell'in tip sınıflarına benzer.

Haskell ile temel fark, özelliklerin yalnızca nokta gösterimine sahip ifadelere, yani a.foo (b) formuna müdahale etmesidir.

Haskell tipi sınıflar daha üst düzey tiplere uzanır. Rust özellikleri yalnızca yüksek sıra türlerini desteklemez, çünkü tüm dilde eksiktirler, yani özellikler ve tip sınıfları arasında felsefi bir fark değildir