Ahhhh saya sudah boleh mendengar anda menjerit dan mengeluh: “Lebih banyak siaran tentang Pengaturcaraan Fungsian, apakah masalah besarnya? Mengapa saya perlu mengubah cara berfikir saya sekarang?”
Cuba ubah soalan itu dan tanya diri anda: kita bercakap tentang pengaturcaraan di sini, mungkin kerana ia akan membantu anda?
Mungkin ia boleh menjadikan kod anda lebih mudah dibaca dan lebih boleh diselenggara?
Adakah anda sejuk, sekarang? Baiklah, mari kita selesaikan beberapa "ketakutan" (walaupun tidak sepatutnya) tentang Pengaturcaraan Fungsian (FP), ya?
Memandangkan Javascript semakin berubah menjadi bahasa Assembly untuk penyemak imbas, terdapat beberapa perpustakaan/rangka kerja yang menggunakan prinsipal FP, ditambah dengan kod yang ditulis dalam bahasa tersebut disusun kepada JS untuk boleh digunakan dalam semua penyemak imbas.
Kami akan menggunakannya Skrip murni dalam contoh kami kerana ia lebih ringkas dan lebih mudah dibaca daripada JS tulen.
Pengenalan asas kepada istilah dan paradigma FP (Menggunakan Purescript VS Pure JS)
Pertama, saya ingin membiasakan anda dengan beberapa konsep asas tentang FP. Pengaturcaraan Berfungsi, seperti namanya,
adalah berdasarkan Paradigma Fungsional (Anda tidak mengatakan?) di mana segala-galanya adalah a fungsi, fungsi-fungsi yang kita suka daripada matematik (perkataan pencetus), ingat? Dari A ke B, atau dari Integer ke Integer anda namakannya.
Contoh:
addMeFive::Int -> Int addMeFive x = x + 5
vs
function addMeFive(x) {
return x + 5
}
Jika anda ingat dengan betul, berfungsi, mengikut definisi, apabila menerima input yang sama berulang kali akan
kembalikan hasil yang sama setiap kali (Tulen fungsi).
addMeFive 5 = 10 -- dan tiada cara untuk mendapatkan sebarang jawapan lain daripada panggilan ini.
Anak-anak kecil ini mempunyai ciri-ciri keren seperti komposisi yang menjadi asas untuk mencipta program yang lebih kompleks dalam FP.
Komposisi bukan satu-satunya cara untuk melekatkan fungsi bersama
Kandungan bagi fungsi f dan g.
g::a -> b f::b -> c
Jika terdapat fungsi dari a ke b dan satu lagi dari b ke c maka terdapat juga fungsi dari a ke c dan boleh ditakrifkan oleh komposisi dua fungsi yang terakhir.
-- f <<< g dibaca - f selepas g f <<< g :: a -> c
Pembolehubah ialah tidak berubah, secara lalai atau jika tidak, ia mesti dinyatakan dengan jelas.
a=5 a=8 -- tidak dibenarkan.
Seperti yang mungkin anda lihat, jika pembolehubah tidak berubah, maka keadaan perlumbaan tidak menjadi masalah kerana ia adalah akibatnya
keadaan boleh ubah. Jadi, dalam FP, concurrency dan operasi selari lebih mudah untuk ditangani.
jenis amat penting dalam Pengaturcaraan Fungsian.
Tidak semua bahasa pengaturcaraan berfungsi ditaip dengan kuat, jenis menggalakkan kita, walau bagaimanapun untuk memikirkan dahulu tentang hubungan dalam Perisian kami dan bukannya berlari dan mengekod tanpa mengira.
Jenis jenis istimewa ialah jenis polimorfik. Polimorfisme membolehkan kami menggunakan fungsi yang sama tetapi dengan Jenis Input yang berbeza, jenis ini membina asas untuk jenis generik yang dikenali dalam bahasa OOP seperti Java, C# dan sebagainya.
length::[a] -> Int -- mengembalikan panjang Senarai jenis a
Selepas asas, salah satu aspek penting pengaturcaraan berfungsi ialah Fungsi Pesanan Tinggi (HOF).
Di sinilah fungsi menjadi menarik, kita tahu fungsi menerima input dan mengembalikan output, sehingga kini ia hanya Integer, Strings, jenis rawak a, dll.
Bagaimana jika kita memberikan fungsi sebagai hujah? Itu sahaja, anda baru sahaja meningkatkan fungsi anda.
Contoh:
peta:: (a->b) -> [a] -> [b]
map ialah fungsi yang mengembalikan senarai di mana fungsi yang diberikan sebagai hujah telah digunakan pada setiap elemen senarai yang diberikan.
mapadalah fungsi yang agak penting, jadi ingatlah ia.
Abstraksi: OOP lwn. FP
Definisi Abstraksi (yang lebih sesuai dengan Sains Komputer): "Kualiti menangani idea dan bukannya acara."
Kami tidak mahu berurusan dengan peristiwa konkrit, atau terperinci, kerana terdapat terlalu banyak faktor yang akan menghalang cara pemikiran kita, jadi kita abstrak, kehilangan beberapa butiran tetapi mengekalkan fokus masalah (idea definisi) .
Tunggu apa?
Untuk menjadi lebih ringkas, kami memilih sendiri bahagian paling penting dalam masalah kami dan butiran yang selebihnya dilupakan, bukan sahaja struktur untuk jenis/objek kami tetapi juga keseluruhan program kami.
Dalam OOP, abstraksi cukup mudah dicapai dengan mewakili "Perkara", walaupun, tidak dalam semua kerumitannya,
hanya sifat-sifat penting. Kemudian anda boleh melakukan "Stuff" dengan entiti yang diabstrakkan, dan hampir sama dengannya.
By the way, "Perkara" dipanggil Objek dan "Stuff" ialah kaedah.
Dalam FP, kami cuba memaksimumkan abstraksi, kami memotong masalah kami kepada fungsi mudah yang selepas itu akan digubah untuk mencipta fungsi yang lebih kompleks yang menghasilkan program yang melakukan perkara yang kami mahu. Ia bukan sahaja tertumpu pada perwakilan "Perkara", ia lebih kepada hubungan antara mereka, yang akhirnya menjadi tumpuan kami. Kami mencipta jenis asas kami dan kemudian, jika kami perlu mempunyai jenis yang lebih kompleks, kami boleh menggabungkannya dengan pelbagai pengendali cth A + B (Sama ada A atau B atau Jenis Kesatuan), A x B (A darab B, Atau pasangan jenis) dan beberapa yang lain.
Corak FP 101
Di sinilah kita, titik sebenar semua kekacauan ini, Corak FP, jangan dikelirukan dengan Corak Reka Bentuk daripada OOP, corak FP adalah tentang mengenali pengulangan, anda tahu, maksud sebenar corak (anda perlu berusaha lebih keras OOP).
Mari kita bincangkan tentang Kari, Fungsi, Katamorfisme dan Anamorfisme (atau masing-masing, Karipap, Peta, Lipat dan Terbongkar). Demi kesederhanaan, saya akan menggunakan Senarai untuk menerangkan tiga yang terakhir:
Karipap
kari (bukan hidangan) ialah apa yang kita lakukan apabila kita mengubah fungsi dengan lebih daripada satu hujah kepada fungsi yang menerima satu hujah dan kemudian mengembalikan fungsi yang bertanggungjawab untuk menerima hujah yang tinggal. Ini memudahkan kemungkinan komposisi/Chaining.
kari :: ((a,b)->c) -> a -> b -> c
Peta aka Functor
Peta aka Fungsi ialah aplikasi fungsi dalam struktur kompleks. Untuk senarai, ia kelihatan seperti:
peta:: (a->b) -> [a] -> [b]
cth Apabila anda ingin menggandakan elemen senarai, bukannya gelung lama yang baik, mengapa tidak:
peta((elem)=> elem*2)[1,2,3]=peta(*2)[1,2,3]=[2,4,6]
Kurangkan aka Catamorphism aka Lipat
Katamorfisme daripada bahasa Yunani: κατά "ke bawah" dan μορφή "bentuk, bentuk" atau juga dikenali Lipat adalah keupayaan untuk mengurangkan struktur menjadi struktur lain, juga dikenali sebagai menakluk yang diadakan pada Bahagikan dan Conquer.
lipat::forall abc . (a->b->b) -> b -> [a] -> b
cth Ingin mengira penjumlahan senarai integer? Tiada masalah
lipat ((elem,acc)=> acc + elem) 0 [1,2,3] = 6
Untuk menjadi lebih jelas, lipat ialah fungsi rekursif dengan senarai jenis input dan output apa sahaja jenis yang anda mahukan. Jika kita menyahbina contoh kita dalam fungsi yang sepadan:
sum::[int] -> int sum[] = 0 -- hujah kedua jumlah lipatan kami (x:xs) = x + sum xs -- kelakuan yang sama seperti fungsi yang diterima sebagai hujah dalam contoh lipatan kami
Hasilkan aka Anamorphism aka Unfold
Anamorfisme daripada bahasa Yunani ἀνά "ke atas" dan μορφή "bentuk, bentuk" atau juga dikenali sebagai Terbongkar adalah keupayaan untuk menjana struktur daripada struktur lain, iaitu Jurang daripada Perpecahan dan Penaklukan.
terungkap :: (b->Mungkin (Tuple ab)) -> b -> [a]
Ini kelihatan lebih rumit namun fungsinya (b->(Tuple a b)) bertanggungjawab untuk menjana elemen senarai output.
cth jana senarai dari 10 hingga 1
unfold(benih -> jika benih == 0 maka Tiada yang lain Hanya(benih,benih-1)) 10 = [10,9,8,7,6,5,4,3,2,1] generateList::Int - > [Int] generateList seed = jika seed == 0 maka [] else seed:(generateList seed-1)
Anjakan ke arah FP
Selepas menganalisis beberapa corak FP, soalan yang anda tanya dalam kepala anda pada permulaan artikel (ingat). Mengapakah setiap bahasa, termasuk JavaScript, bergerak ke arah pengaturcaraan berfungsi? Saya fikir jika anda membaca sehingga tahap ini anda memahami hakikat bahawa fungsi adalah abstraksi yang kuat. Terdapat mudah untuk dibaca dan dikodkan dan kerana kami bergerak ke arah pengekodan fungsi kecil ini membolehkan kami melekatkannya bersama-sama seperti Legos untuk membina program yang lebih besar.
Ditulis oleh Yoan Ribeiro
PS: Anda boleh lihat ceramah saya dan ceramah BloodyOwl (dalam bahasa Perancis). Skrip Tulen dan Sebab untuk menjual di sana:
http://blog.js-republic.com/meetup-js-star-reason-purescript-programmation-fp/
