Apakah kontrak semantik antarmuka (OOP) lebih informatif daripada tanda tangan fungsi (FP)?

Dikatakan oleh beberapa orang bahwa jika Anda mengambil prinsip-prinsip SOLID secara ekstrem, Anda berakhir pada pemrograman fungsional . Saya setuju dengan artikel ini, tetapi saya berpikir bahwa beberapa semantik hilang dalam transisi dari antarmuka / objek ke fungsi / penutupan, dan saya ingin tahu bagaimana Pemrograman Fungsional dapat mengurangi kerugian.

Dari artikel:

Selain itu, jika Anda menerapkan Prinsip Segregasi Antarmuka (ISP) dengan teliti, Anda akan memahami bahwa Anda harus memilih Antarmuka Peran daripada Antarmuka Header.

Jika Anda terus mengarahkan desain ke antarmuka yang lebih kecil dan lebih kecil, pada akhirnya Anda akan tiba di Antarmuka Peran utama: antarmuka dengan metode tunggal. Ini sering terjadi pada saya. Ini sebuah contoh:

public interface IMessageQuery
{
    string Read(int id);
}

Jika saya mengambil ketergantungan pada IMessageQuery, bagian dari kontrak implisit adalah bahwa panggilan Read(id)akan mencari dan mengembalikan pesan dengan ID yang diberikan.

Bandingkan ini dengan mengambil ketergantungan pada tanda tangan fungsional yang setara int -> string,. Tanpa isyarat tambahan, fungsi ini bisa menjadi sederhana ToString(). Jika Anda menerapkan IMessageQuery.Read(int id)dengan ToString()saya dapat menuduh Anda sengaja subversif!

Jadi, apa yang bisa dilakukan programmer fungsional untuk menjaga semantik antarmuka yang bernama baik? Apakah konvensional untuk, misalnya, membuat tipe rekaman dengan satu anggota?

type MessageQuery = {
    Read: int -> string
}

Seperti kata Telastyn, membandingkan definisi fungsi statis:

public string Read(int id) { /*...*/ }

untuk

let read (id:int) = //...

Anda belum benar-benar kehilangan apa pun mulai dari OOP ke FP.

Namun, ini hanya sebagian dari cerita, karena fungsi dan antarmuka tidak hanya disebut dalam definisi statisnya. Mereka juga melewati . Jadi misalkan kita MessageQuerydibaca oleh kode lain, a MessageProcessor. Maka kita memiliki:

public void ProcessMessage(int messageId, IMessageQuery messageReader) { /*...*/ }

Sekarang kita tidak bisa secara langsung melihat nama metode IMessageQuery.Readatau parameternya int id, tetapi kita bisa sampai di sana dengan sangat mudah melalui IDE kita. Secara umum, fakta bahwa kita melewatkan IMessageQueryantarmuka daripada sembarang antarmuka dengan metode fungsi dari int ke string berarti kita menjaga idmetadata nama parameter yang terkait dengan fungsi ini.

Di sisi lain, untuk versi fungsional kami memiliki:

let read (id:int) (messageReader : int -> string) = // ...

Jadi apa yang kita simpan dan hilangkan? Yah, kami masih memiliki nama parameter messageReader, yang mungkin membuat nama jenis (yang setara dengan IMessageQuery) tidak perlu. Tapi sekarang kami telah kehilangan nama parameter iddalam fungsi kami.

Ada dua cara utama dalam hal ini:

• Pertama, dari membaca tanda tangan itu, Anda sudah dapat menebak dengan baik apa yang akan terjadi. Dengan menjaga fungsi tetap singkat, sederhana, dan kohesif serta menggunakan penamaan yang baik, Anda membuatnya lebih mudah untuk berkomunikasi atau menemukan informasi ini. Setelah kita membaca fungsi yang sebenarnya, itu akan menjadi lebih sederhana.

• Kedua, itu dianggap desain idiomatik dalam banyak bahasa fungsional untuk membuat tipe kecil untuk membungkus primitif. Dalam hal ini, yang terjadi adalah sebaliknya - alih-alih mengganti nama tipe dengan nama parameter ( IMessageQueryke messageReader) kita dapat mengganti nama parameter dengan nama tipe. Misalnya, intbisa dibungkus dengan tipe yang disebut Id:

  type Id = Id of int
  

  Sekarang readtanda tangan kami menjadi:

  let read (id:int) (messageReader : Id -> string) = // ...
  

  Yang sama informatif seperti apa yang kita miliki sebelumnya.

  Sebagai catatan, ini juga memberi kami beberapa perlindungan kompiler yang kami miliki di OOP. Sementara versi OOP memastikan bahwa kami mengambil secara khusus fungsi yang IMessageQuerylama int -> string, di sini kami memiliki perlindungan yang serupa (namun berbeda) yang kami Id -> stringgunakan daripada yang lama int -> string.

Saya akan enggan mengatakan dengan keyakinan 100% bahwa teknik-teknik ini akan selalu sama baiknya dan informatif seperti memiliki informasi lengkap yang tersedia pada sebuah antarmuka, tetapi saya pikir dari contoh di atas, Anda dapat mengatakan bahwa sebagian besar waktu, kami mungkin bisa melakukan pekerjaan yang sama baiknya.

Saat melakukan FP saya cenderung menggunakan jenis semantik yang lebih spesifik.

Misalnya, metode Anda untuk saya akan menjadi seperti:

read: MessageId -> Message

Ini berkomunikasi lebih banyak daripada gaya ThingDoer.doThing()gaya OO (/ java)

Jadi, apa yang bisa dilakukan programmer fungsional untuk menjaga semantik antarmuka yang bernama baik?

Gunakan fungsi yang bernama baik.

IMessageQuery::Read: int -> stringhanya menjadi ReadMessageQuery: int -> stringatau sesuatu yang serupa.

Hal utama yang perlu diperhatikan adalah bahwa nama hanya kontrak dalam arti kata yang paling longgar. Mereka hanya bekerja jika Anda dan programmer lain menyimpulkan implikasi yang sama dari namanya, dan mematuhinya. Karena itu, Anda benar-benar dapat menggunakan nama apa pun yang berkomunikasi dengan perilaku tersirat itu. OO dan pemrograman fungsional memiliki nama mereka di tempat yang sedikit berbeda dan dalam bentuk yang sedikit berbeda, tetapi fungsinya sama.

Apakah kontrak semantik antarmuka (OOP) lebih informatif daripada tanda tangan fungsi (FP)?

Tidak dalam contoh ini. Seperti yang saya jelaskan di atas, satu kelas / antarmuka dengan fungsi tunggal tidak bermakna lebih informatif daripada fungsi mandiri yang bernama sama.

Setelah Anda mendapatkan lebih dari satu fungsi / bidang / properti di kelas, Anda dapat menyimpulkan lebih banyak informasi tentang mereka karena Anda dapat melihat hubungannya. Dapat diperdebatkan jika itu lebih informatif daripada fungsi mandiri yang mengambil parameter yang sama / mirip atau fungsi mandiri yang diatur oleh namespace atau modul.

Secara pribadi, saya tidak berpikir bahwa OO secara signifikan lebih informatif, bahkan dalam contoh yang lebih kompleks.

Saya tidak setuju bahwa fungsi tunggal tidak dapat memiliki 'kontrak semantik'. Pertimbangkan undang-undang ini untuk foldr:

foldr f z nil = z
foldr f z (singleton x) = f x z
foldr f z (xn <> ys) = foldr f (foldr f z ys) xn

Dalam arti apa itu bukan semantik, atau bukan kontrak? Anda tidak perlu mendefinisikan tipe untuk 'folder', terutama karena foldrsecara unik ditentukan oleh undang-undang tersebut. Anda tahu persis apa yang akan dilakukan.

Jika Anda ingin mengambil fungsi dari beberapa jenis, Anda dapat melakukan hal yang sama:

-- The first argument `f` must satisfy for all x, y, z
-- > f x x = true
-- > f x y = true and f y x = true implies x = y
-- > f x y = true and f y z = true implies f x z = true
sort :: forall 'a. (a -> a -> bool.t) -> list.t a -> list.t a;

Anda hanya perlu memberi nama dan menangkap jenis itu jika Anda perlu kontrak yang sama beberapa kali:

-- Type of functions `f` satisfying, for all x, y, z
-- > f x x = true
-- > f x y = true and f y x = true implies x = y
-- > f x y = true and f y z = true implies f x z = true
type comparison.t 'a = a -> a -> bool.t;

Pemeriksa tipe tidak akan memberlakukan semantik apa pun yang Anda tetapkan untuk suatu tipe, jadi membuat tipe baru untuk setiap kontrak hanyalah boilerplate.

Hampir semua bahasa fungsional yang diketik secara statis memiliki cara untuk alias tipe dasar dengan cara yang mengharuskan Anda untuk secara eksplisit menyatakan maksud semantik Anda. Beberapa jawaban lain telah memberikan contoh. Dalam praktiknya, pemrogram fungsional yang berpengalaman perlu alasan yang sangat baik untuk menggunakan jenis pembungkus itu, karena mereka merusak kemampuan kompilasi dan penggunaan kembali.

Misalnya, klien ingin implementasi kueri pesan yang didukung oleh daftar. Di Haskell, implementasinya bisa sesederhana ini:

messages = ["Message 0", "Message 1", "Message 2"]
messageQuery = (messages !!)

Menggunakan newtype Message = Message Stringini akan jauh lebih mudah, meninggalkan implementasi ini terlihat seperti:

messages = map Message ["Message 0", "Message 1", "Message 2"]
messageQuery (Id index) = messages !! index

Itu mungkin tidak tampak seperti masalah besar, tetapi Anda harus melakukan konversi jenis itu bolak-balik di mana - mana , atau mengatur lapisan batas dalam kode Anda di mana segala sesuatu di atas Int -> Stringmaka Anda mengonversinya Id -> Messageuntuk lulus ke lapisan di bawah ini. Katakanlah saya ingin menambahkan internasionalisasi, atau memformatnya dalam semua huruf besar, atau menambahkan konteks logging, atau apa pun. Semua operasi itu semuanya sederhana untuk dikomposisi dengan Int -> String, dan menjengkelkan dengan Id -> Message. Bukan berarti tidak pernah ada kasus di mana pembatasan jenis yang ditingkatkan diinginkan, tetapi gangguan sebaiknya sebanding dengan trade off.

Anda dapat menggunakan sinonim jenis alih-alih pembungkus (dalam Haskell typebukan newtype), yang jauh lebih umum dan tidak memerlukan konversi di semua tempat, tetapi itu tidak memberikan jaminan tipe statis baik seperti versi OOP Anda, hanya sedikit enapsulasi. Jenis pembungkus sebagian besar digunakan di mana klien tidak diharapkan untuk memanipulasi nilai sama sekali, simpan saja dan kirimkan kembali. Misalnya, pegangan file.

Tidak ada yang dapat mencegah klien menjadi "subversif." Anda hanya membuat lingkaran untuk dilewati, untuk setiap klien. Mock sederhana untuk unit test umum sering kali memerlukan perilaku aneh yang tidak masuk akal dalam produksi. Antarmuka Anda harus ditulis sehingga mereka tidak peduli, jika memungkinkan.