Apa perbedaan antara sifat-sifat di Rust dan typeclasses di Haskell?

Ciri-ciri di Rust tampaknya setidaknya mirip dengan jenis kacamata di Haskell, namun saya telah melihat orang menulis bahwa ada beberapa perbedaan di antara mereka. Saya bertanya-tanya apa perbedaan-perbedaan ini.

Pada tingkat dasar, tidak ada banyak perbedaan, tetapi mereka masih ada di sana.

Haskell menjelaskan fungsi atau nilai yang didefinisikan dalam typeclass sebagai 'metode', sama seperti sifat menggambarkan metode OOP dalam objek yang mereka sertakan. Namun, Haskell berurusan dengan ini secara berbeda, memperlakukan mereka sebagai nilai-nilai individual daripada menyematkannya ke objek karena OOP akan membuat orang melakukannya. Ini adalah tentang perbedaan level permukaan yang paling jelas.

Satu hal yang tidak bisa dilakukan Rust untuk sementara waktu adalah sifat-sifat yang diketik tingkat tinggi , seperti kacamata yang terkenal Functordan Monadburuk.

Ini berarti bahwa sifat-sifat Rust hanya bisa menggambarkan apa yang sering disebut 'tipe konkret', dengan kata lain, karakter tanpa argumen umum. Haskell sejak awal bisa membuat kacamata ketik tingkat tinggi yang menggunakan tipe yang mirip dengan bagaimana fungsi tingkat tinggi menggunakan fungsi lain: menggunakan satu untuk menggambarkan yang lain. Untuk periode waktu ini tidak mungkin di Rust, tetapi karena item terkait telah diterapkan, sifat-sifat tersebut telah menjadi biasa dan idiomatis.

Jadi jika kita mengabaikan ekstensi, mereka tidak persis sama, tetapi masing-masing dapat memperkirakan apa yang dapat dilakukan oleh yang lain.

Juga disebutkan, seperti dikatakan dalam komentar, bahwa GHC (kompilator utama Haskell) mendukung opsi lebih lanjut untuk typeclasses, termasuk typeclasses multi-parameter (yaitu banyak jenis yang terlibat), dan dependensi fungsional , pilihan yang bagus yang memungkinkan untuk perhitungan tingkat-jenis. , dan mengarah ke mengetik keluarga . Sepengetahuan saya, Rust tidak memiliki funDeps atau tipe keluarga, meskipun mungkin di masa depan. †

Semua dalam semua, ciri dan kacamata memiliki perbedaan mendasar, yang karena cara mereka berinteraksi, membuat mereka bertindak dan tampak sangat mirip pada akhirnya.

† Artikel bagus tentang kacamata Haskell (termasuk yang berjenis lebih tinggi) dapat ditemukan di sini , dan bab Karat dengan Contoh tentang sifat dapat ditemukan di sini

Saya pikir jawaban saat ini mengabaikan perbedaan paling mendasar antara sifat-sifat Rust dan kelas tipe Haskell. Perbedaan-perbedaan ini berkaitan dengan cara sifat terkait dengan konstruksi bahasa berorientasi objek. Untuk informasi tentang ini, lihat buku Karat .

1. Deklarasi sifat menciptakan tipe sifat . Ini berarti bahwa Anda dapat mendeklarasikan variabel jenis tersebut (atau lebih tepatnya, referensi jenis tersebut). Anda juga dapat menggunakan tipe trait sebagai parameter pada fungsi, bidang struct, dan tipe instantiasi parameter.

   Variabel referensi sifat dapat pada saat runtime berisi objek dari tipe yang berbeda, selama tipe runtime dari objek yang direferensikan mengimplementasikan sifat tersebut.

   // 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();

   Ini bukan cara kerja kelas tipe. Tipe kelas tidak membuat tipe , jadi Anda tidak bisa mendeklarasikan variabel dengan nama kelas. Kelas tipe bertindak sebagai batas pada parameter tipe, tetapi parameter tipe harus dipakai dengan tipe beton, bukan kelas tipe itu sendiri.

   Anda tidak dapat memiliki daftar hal-hal berbeda dari tipe berbeda yang mengimplementasikan kelas tipe yang sama. (Sebaliknya, tipe eksistensial digunakan dalam Haskell untuk mengekspresikan hal yang serupa.) ^{Catatan 1}

2. Metode sifat dapat dikirim secara dinamis . Ini sangat terkait dengan hal-hal yang dijelaskan pada bagian di atas.

   Pengiriman dinamis berarti jenis runtime objek yang menjadi titik rujukan digunakan untuk menentukan metode mana yang disebut melalui referensi.

   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());

   Sekali lagi, tipe eksistensial digunakan untuk ini di Haskell.

Kesimpulannya

Sepertinya bagi saya sifat-sifat ada dalam banyak aspek konsep yang sama dengan kelas tipe. Selain itu, mereka memiliki fungsi antarmuka berorientasi objek.

Di sisi lain, kelas tipe Haskell lebih maju. Haskell misalnya memiliki tipe yang lebih tinggi dan ekstensi seperti kelas tipe multi-parameter.

Catatan 1 : Versi terbaru dari Rust memiliki pembaruan untuk membedakan penggunaan nama sifat sebagai tipe dan penggunaan nama sifat sebagai batas. Dalam jenis sifat nama diawali oleh dynkata kunci. Lihat misalnya jawaban ini untuk informasi lebih lanjut.

"Sifat" Rust adalah analog dengan kelas tipe Haskell.

Perbedaan utama dengan Haskell adalah bahwa sifat hanya mengintervensi ekspresi dengan notasi titik, yaitu dari bentuk a.foo (b).

Kelas tipe Haskell meluas ke tipe tingkat tinggi. Hanya sifat-sifat karat yang tidak mendukung tipe urutan yang lebih tinggi karena mereka hilang dari keseluruhan bahasa, artinya bukan perbedaan filosofis antara sifat-sifat dan kelas tipe