Sepertinya kode F # sering pola cocok dengan tipe. Pasti
match opt with
| Some val -> Something(val)
| None -> Different()
sepertinya biasa.
Tapi dari perspektif OOP, yang terlihat sangat mengerikan seperti aliran kontrol berdasarkan pemeriksaan tipe runtime, yang biasanya akan disukai. Untuk mengejanya, dalam OOP Anda mungkin lebih suka menggunakan overloading:
type T =
abstract member Route : unit -> unit
type Foo() =
interface T with
member this.Route() = printfn "Go left"
type Bar() =
interface T with
member this.Route() = printfn "Go right"
Ini tentunya lebih banyak kode. OTOH, menurut pikiran saya OOP-y memiliki kelebihan struktural:
- ekstensi ke bentuk baru
T
mudah; - Saya tidak perlu khawatir menemukan duplikasi aliran kontrol pemilihan rute; dan
- Pilihan rute tidak dapat diubah dalam arti bahwa begitu saya ada
Foo
di tangan, saya tidak perlu khawatir tentangBar.Route()
implementasi rute
Apakah ada keuntungan dari pencocokan pola dengan jenis yang tidak saya lihat? Apakah itu dianggap idiomatis atau apakah itu kemampuan yang tidak umum digunakan?
But from an OOP perspective, that looks an awful lot like control-flow based on a runtime type check, which would typically be frowned on.
- terdengar terlalu dogmatis. Kadang-kadang, Anda ingin memisahkan ops Anda dari hierarki Anda: mungkin 1) Anda tidak dapat menambahkan op ke hierarki b / c Anda tidak memiliki hierarki; 2) kelas-kelas yang Anda inginkan untuk op tidak cocok dengan hierarki Anda; 3) Anda bisa menambahkan op ke hierarki Anda, tetapi tidak ingin b / c Anda tidak ingin mengacaukan API hierarki Anda dengan banyak omong kosong yang kebanyakan klien tidak gunakan.