Apakah pemrograman GUI fungsional dimungkinkan? [Tutup]


404

Saya baru-baru ini menangkap bug FP (mencoba mempelajari Haskell), dan saya benar-benar terkesan dengan apa yang saya lihat sejauh ini (fungsi kelas satu, evaluasi malas, dan semua barang lainnya). Saya belum ahli, tapi saya sudah mulai merasa lebih mudah untuk alasan "fungsional" daripada keharusan untuk algoritma dasar (dan saya mengalami kesulitan untuk kembali ke tempat saya harus).

Satu-satunya area di mana FP saat ini tampaknya gagal, adalah pemrograman GUI. Pendekatan Haskell tampaknya hanya membungkus toolkit GUI imperatif (seperti GTK + atau wxWidgets) dan menggunakan blok "do" untuk mensimulasikan gaya imperatif. Saya belum pernah menggunakan F #, tetapi pemahaman saya adalah bahwa ia melakukan sesuatu yang mirip menggunakan OOP dengan kelas .NET. Jelas, ada alasan bagus untuk ini - pemrograman GUI saat ini adalah semua tentang IO dan efek samping, jadi pemrograman murni fungsional tidak mungkin dilakukan dengan sebagian besar kerangka kerja saat ini.

Pertanyaan saya adalah, apakah mungkin untuk memiliki pendekatan fungsional untuk pemrograman GUI? Saya mengalami kesulitan membayangkan seperti apa ini dalam praktiknya. Adakah yang tahu kerangka kerja, eksperimental atau lainnya, yang mencoba hal semacam ini (atau bahkan kerangka kerja yang dirancang dari bawah ke atas untuk bahasa fungsional)? Atau solusi untuk hanya menggunakan pendekatan hybrid, dengan OOP untuk bagian-bagian GUI dan FP untuk logika? (Saya hanya bertanya karena penasaran - Saya ingin berpikir bahwa FP adalah "masa depan," tetapi pemrograman GUI sepertinya lubang yang cukup besar untuk diisi.)


7
Setelah melihat GUI di Common Lisp dan OCaml, saya akan mengatakan bahwa, kemungkinan besar, kemalasan Haskell-lah yang menyebabkan masalah ini.
new123456

5
@ new123456 Common Lisp bukan bahasa fungsional, ia bekerja dengan data yang bisa berubah dan mencakup efek samping
Electric Coffee

3
@ElectricCoffee Lisp adalah bahasa yang sangat fleksibel yang dapat digunakan dalam banyak gaya berbeda, dan banyak orang memilih untuk menggunakan Lisp dalam gaya fungsional.
chrismamo1

8
Dari pengalaman saya (walaupun saya masih mencoba untuk mempercayainya dan belajar lebih banyak) FRP benar-benar mencapai batasnya dengan pemrograman GUI; itu bagus dan elegan untuk 80% kasus penggunaan tetapi widget kaya membutuhkan kontrol yang sangat tepat dari keadaan internal mereka (misalnya kotak pencarian kombo, dll) dan FRP hanya menghalangi. Imperatif tidak selalu jahat; mencoba meminimalkan jumlah kode imperatif yang baik tetapi menghapusnya 100%? Belum melihatnya berfungsi untuk pengembangan UI non-sepele.
AlexG

8
@ElectricCoffee "Lisp umum bukan bahasa fungsional". Lisp adalah ibu dari semua bahasa fungsional. Maksudmu Lisp tidak murni.
Jon Harrop

Jawaban:


184

Pendekatan Haskell tampaknya hanya membungkus toolkit GUI imperatif (seperti GTK + atau wxWidgets) dan menggunakan blok "do" untuk mensimulasikan gaya imperatif

Itu tidak benar-benar "pendekatan Haskell" - itu hanya bagaimana Anda mengikat toolkit GUI imperatif paling langsung - melalui antarmuka imperatif. Haskell kebetulan memiliki ikatan yang cukup menonjol.

Ada beberapa pendekatan yang cukup matang, atau lebih eksperimental fungsional / deklaratif murni untuk GUI, kebanyakan di Haskell, dan terutama menggunakan pemrograman reaktif fungsional.

Beberapa contoh adalah:

Bagi Anda yang tidak terbiasa dengan Haskell, Flapjax, http://www.flapjax-lang.org/ adalah implementasi pemrograman reaktif fungsional di atas JavaScript.


32
Lihat makalah Conal Elliott tentang buah untuk penjelasan mendalam tentang teknik dan keputusan: conal.net/papers/genuinely-functional-guis.pdf Saya telah melakukan pemrograman GUI murni fungsional dalam gaya ini selama beberapa bulan sekarang. . SAYA SUKA, itu adalah bantuan yang sangat menyenangkan dari neraka spageti pemrograman imperatif UI, yang tampaknya lebih buruk dalam hal ini daripada pemrograman yang paling penting.
luqui

44
Saya 100% setuju dengan ini. Untuk membuatnya lebih jelas: alasan mengapa toolkit GUI yang ada sering digunakan adalah karena ada. Alasan mengapa antarmuka mereka cenderung imperatif dan tidak murni adalah karena toolkit cenderung imperatif dan tidak murni. Alasan mengapa toolkit cenderung imperatif dan tidak murni adalah karena sistem operasi yang mereka andalkan cenderung imperatif dan tidak murni. Namun, tidak ada yang secara mendasar mengharuskan semua ini tidak murni: ada binding fungsional untuk toolkit tersebut, ada toolkit fungsional, bahkan ada sistem operasi fungsional.
Jörg W Mittag

16
Itu semua hanya masalah kemalasan. (Kata buruk dimaksudkan.)
Jörg W Mittag

10
Suatu hari semua desain GUI akan diimplementasikan melalui WYSIWYG, dengan logika diimplementasikan secara fungsional. Ini prediksi saya.
BlueRaja - Danny Pflughoeft

24
Makalah luqui menyebutkan sepertinya sudah mati. Ada tautan yang berfungsi di situs Conal Elliott, meskipun: conal.net/papers/genuinely-functional-guis.pdf
aganders3

74

Pertanyaan saya adalah, apakah mungkin untuk memiliki pendekatan fungsional untuk pemrograman GUI?

Kata-kata kunci yang Anda cari adalah "pemrograman reaktif fungsional" (FRP).

Conal Elliott dan beberapa yang lain telah membuat sedikit industri rumahan karena berusaha menemukan abstraksi yang tepat untuk FRP. Ada beberapa implementasi konsep FRP di Haskell.

Anda dapat mempertimbangkan untuk memulai dengan makalah "Pemrograman Reaktif Fungsional Reaktif" terbaru dari Conal , tetapi ada beberapa implementasi (lama) lainnya, beberapa di antaranya terhubung dari situs haskell.org . Conal memiliki kemampuan untuk mencakup seluruh domain, dan makalahnya dapat dibaca tanpa mengacu pada apa yang datang sebelumnya.

Untuk mengetahui bagaimana pendekatan ini dapat digunakan untuk pengembangan GUI, Anda mungkin ingin melihat Fudgets , yang saat ini semakin lama, yang dirancang pada pertengahan 90-an, memang menghadirkan pendekatan FRP yang solid untuk desain GUI.


Saya ingin menambahkan peningkatan penggunaan "Ekstensi Reaktif" (Perpustakaan FRP; namun, bukan FP) yang awalnya ditulis untuk C # dan kemudian dipindahkan ke Jawa (RxJava) dan JavaScript (RxJS) dan berbagai bahasa. Lihat reactivex.ioPada intinya, Angular 2 menggunakan RxJS secara ekstensif.
srph

63

Windows Presentation Foundation adalah bukti bahwa pendekatan fungsional berfungsi sangat baik untuk pemrograman GUI. Ini memiliki banyak aspek fungsional dan kode WPF "baik" (mencari pola MVVM) menekankan pendekatan fungsional lebih dari keharusan. Saya berani mengklaim bahwa WPF adalah toolkit GUI fungsional dunia nyata yang paling sukses :-)

WPF menjelaskan antarmuka pengguna dalam XAML (meskipun Anda dapat menulis ulang untuk secara fungsional mencari C # atau F # juga), jadi untuk membuat beberapa antarmuka pengguna Anda akan menulis:

<!-- Declarative user interface in WPF and XAML --> 
<Canvas Background="Black">
   <Ellipse x:Name="greenEllipse" Width="75" Height="75" 
      Canvas.Left="0" Canvas.Top="0" Fill="LightGreen" />
</Canvas>

Selain itu, WPF juga memungkinkan Anda untuk mendeskripsikan secara animasi dan reaksi terhadap peristiwa menggunakan serangkaian tag deklaratif lain (sekali lagi, hal yang sama dapat ditulis sebagai kode C # / F #):

<DoubleAnimation
   Storyboard.TargetName="greenEllipse" 
   Storyboard.TargetProperty="(Canvas.Left)"
   From="0.0" To="100.0" Duration="0:0:5" />

Sebenarnya, saya berpikir bahwa WPF memiliki banyak kesamaan dengan Haskell's FRP (meskipun saya percaya bahwa desainer WPF tidak tahu tentang FRP dan itu agak disayangkan - WPF kadang-kadang terasa agak aneh dan tidak jelas jika Anda menggunakan fungsional sudut pandang).


12
Sementara XAML sangat deklaratif, apakah MVVM benar-benar mendorong gaya fungsional pemrograman? Seluruh gagasan model tampilan, yang tugasnya melacak status tampilan (dan mengimplementasikan antarmuka yang disebut INotifyPropertyChangedsemua hal), tampaknya bertentangan dengan FP bagi saya. Saya jelas bukan ahli FP, dan mungkin saya terlalu fokus pada aspek immutabilitas dibandingkan dengan aspek deklaratif, tapi saya kesulitan melihat bagaimana pola MVVM (seperti yang biasanya digunakan) adalah contoh FP.
devuxer

1
@ Duxuxer Saya berpendapat bahwa itu terjadi. Saya tidak berpikir ada orang yang secara realistis akan menggunakan FP untuk kode ketat yang tidak dapat diubah. Alih-alih, Anda memutuskan di mana batas-batas mutabilitas Anda berada, dan bekerja tidak berubah pada semua level lainnya - dalam hal ini, semua orang dapat menganggap negara tidak dapat diubah, kecuali untuk satu bagian kecil yang benar-benar mengubah negara. Ini mirip dengan cara kerja HTML - ya, Anda memiliki DOM yang tidak dapat diubah, tetapi setiap kali Anda menavigasi, Anda masih harus membangun yang baru. INotifyPropertyChangedhanyalah fungsi pembaruan yang Anda berikan ke mana pun Anda perlu menangani pembaruan GUI - ini adalah perbaikan latensi.
Luaan

3
Steven Pemberton menulis 2 posting hebat tentang F # dan WPF, Pikirannya tentang pengembangan WPF dengan F # menjelang akhir posting kedua menambah diskusi ini. 2 contoh lain yang juga membuat saya penasaran adalah penggunaan pengontrol fungsional dalam acara yang didorong MVVM dan penggunaan serikat yang didiskriminasi dan rekursi untuk membangun antarmuka sederhana dalam demo kontrol WPF oleh Flying Frog Consultancy.
Funk

29

Saya benar-benar akan mengatakan bahwa pemrograman fungsional (F #) adalah alat yang jauh lebih baik untuk pemrograman antarmuka pengguna daripada misalnya C #. Anda hanya perlu memikirkan masalahnya sedikit berbeda.

Saya membahas topik ini dalam buku pemrograman fungsional saya di Bab 16, tetapi ada kutipan gratis yang tersedia , yang menunjukkan (IMHO) pola paling menarik yang dapat Anda gunakan di F #. Katakanlah Anda ingin menerapkan menggambar persegi panjang (pengguna menekan tombol, menggerakkan mouse dan melepaskan tombol). Di F #, Anda dapat menulis sesuatu seperti ini:

let rec drawingLoop(clr, from) = async { 
   // Wait for the first MouseMove occurrence 
   let! move = Async.AwaitObservable(form.MouseMove) 
   if (move.Button &&& MouseButtons.Left) = MouseButtons.Left then 
      // Refresh the window & continue looping 
      drawRectangle(clr, from, (move.X, move.Y)) 
      return! drawingLoop(clr, from) 
   else
      // Return the end position of rectangle 
      return (move.X, move.Y) } 

let waitingLoop() = async { 
   while true do
      // Wait until the user starts drawing next rectangle
      let! down = Async.AwaitObservable(form.MouseDown) 
      let downPos = (down.X, down.Y) 
      if (down.Button &&& MouseButtons.Left) = MouseButtons.Left then 
         // Wait for the end point of the rectangle
         let! upPos = drawingLoop(Color.IndianRed, downPos) 
         do printfn "Drawn rectangle (%A, %A)" downPos upPos }

Ini adalah pendekatan yang sangat penting (dalam gaya F # pragmatis yang biasa), tetapi ia menghindari penggunaan keadaan yang bisa berubah untuk menyimpan keadaan gambar saat ini dan untuk menyimpan lokasi inital. Meskipun dapat dibuat lebih fungsional, saya menulis perpustakaan yang melakukan itu sebagai bagian dari tesis Master saya, yang seharusnya tersedia di blog saya dalam beberapa hari ke depan.

Pemrograman Reaktif Fungsional adalah pendekatan yang lebih fungsional, tetapi saya merasa agak sulit untuk digunakan karena mengandalkan fitur Haskell yang cukup canggih (seperti panah). Namun, sangat elegan dalam banyak kasus. Keterbatasannya adalah bahwa Anda tidak dapat dengan mudah menyandikan mesin negara (yang merupakan model mental yang berguna untuk program reaktif). Ini sangat mudah menggunakan teknik F # di atas.


7
+1 Ini mencerminkan pengalaman kami, setelah menulis beberapa GUI produksi di F # menggunakan perpustakaan kombinator dan IObservable.
Jon Harrop

Apakah komentar tentang FRP berubah sejak diperkenalkannya ekstensi reaktif ke perpustakaan .NET?
Fsharp Pete

1
Berikut ini beberapa penelitian tentang FRP Arrowized dan bagaimana efek dan mutasi dapat tertanam dalam Arrowized FRP tanpa melanggar hukum: haskell.cs.yale.edu/wp-content/uploads/2015/10/10/… (karena sebagian besar perpustakaan FRP menggunakan Monads atau bahkan Berlaku, jadi tidak benar bahwa Panah diharuskan).
Erik Kaplun

17

Apakah Anda menggunakan bahasa fungsional / hibrid OO seperti F # atau OCaml, atau dalam bahasa yang murni fungsional seperti Haskell di mana efek samping diturunkan ke IO monad, biasanya diperlukan satu ton pekerjaan yang diperlukan untuk mengelola GUI lebih seperti "efek samping" daripada seperti algoritma yang murni fungsional.

Yang mengatakan, telah ada beberapa penelitian yang sangat solid dimasukkan ke dalam GUI fungsional . Bahkan ada beberapa (kebanyakan) toolkit fungsional seperti Fudgets atau FranTk .


6
Tautan "GUI fungsional" rusak :( di-cache: webcache.googleusercontent.com/search?q=cache:http://…
Dan Burton


12

Salah satu ide yang membuka pikiran di balik Pemrograman Fungsional Reaktif adalah memiliki fungsi penanganan peristiwa yang menghasilkan KEDUA reaksi terhadap peristiwa DAN fungsi penanganan acara berikutnya. Dengan demikian sistem yang berkembang direpresentasikan sebagai urutan fungsi penanganan acara.

Bagi saya, belajar tentang Yampa menjadi hal penting untuk mendapatkan fungsi yang menghasilkan fungsi dengan benar. Ada beberapa surat kabar bagus tentang Yampa. Saya merekomendasikan The Yampa Arcade:

http://www.cs.nott.ac.uk/~nhn/Talks/HW2003-YampaArcade.pdf (slide, PDF) http://www.cs.nott.ac.uk/~nhn/Publications/hw2003. pdf (artikel lengkap, PDF)

Ada halaman wiki di Yampa di Haskell.org

http://www.haskell.org/haskellwiki/Yampa

Halaman muka Yampa asli:

http://www.haskell.org/yampa (sayangnya saat ini rusak)


1
Tautan itu rusak untuk waktu yang lama. Coba Yampa
CoR

7

Sejak pertanyaan ini pertama kali diajukan, pemrograman reaktif fungsional telah dibuat sedikit lebih utama oleh Elm.

Saya sarankan memeriksanya di http://elm-lang.org , yang juga memiliki beberapa tutorial interaktif yang sangat bagus tentang cara membuat GUI dalam peramban yang berfungsi penuh.

Hal ini memungkinkan Anda untuk membuat GUI berfungsi penuh di mana kode yang Anda butuhkan untuk memasok sendiri hanya terdiri dari fungsi-fungsi murni. Saya pribadi merasa jauh lebih mudah untuk masuk daripada berbagai kerangka kerja GUI Haskell.


Inilah tesis FRP asli di belakang Elm . Tetapi juga sejak Mei 2016 Elm bukan bahasa FRP lagi .
icc97

6

Pembicaraan Elliot tentang FRP dapat ditemukan di sini .

Selain itu, bukan benar-benar jawaban tetapi komentar dan beberapa pemikiran : entah bagaimana istilah "GUI fungsional" tampaknya sedikit seperti sebuah oxymoron (kemurnian dan IO dalam istilah yang sama).

Tetapi pemahaman saya yang kabur adalah bahwa pemrograman GUI fungsional adalah tentang mendefinisikan secara deklaratif fungsi tergantung waktu yang mengambil input pengguna (nyata) bergantung waktu dan menghasilkan output GUI yang tergantung waktu.

Dengan kata lain, fungsi ini didefinisikan seperti persamaan diferensial secara deklaratif, alih-alih oleh suatu algoritma yang secara imperatif menggunakan keadaan bisa berubah-ubah.

Jadi dalam FP konvensional seseorang menggunakan fungsi waktu independen, sedangkan di FRP orang menggunakan fungsi tergantung waktu sebagai blok bangunan untuk menggambarkan suatu program.

Mari kita berpikir tentang mensimulasikan bola pada pegas yang dengannya pengguna dapat berinteraksi. Posisi bola adalah output grafis (di layar), pengguna mendorong bola adalah penekanan tombol (input).

Mendeskripsikan program simulasi ini dalam FRP (menurut pemahaman saya) dilakukan oleh persamaan diferensial tunggal (secara deklaratif): akselerasi * massa = - rentangan pegas * konstanta pegas + Gaya yang diberikan oleh pengguna.

Berikut adalah video tentang ELM yang menggambarkan sudut pandang ini.


5

Pada 2016, ada beberapa kerangka kerja FRP yang relatif lebih matang untuk Haskell seperti Sodium dan Reflex (tetapi juga Netwire).

The Manning buku tentang Pemrograman Fungsional Reaktif showcase versi Java dari Sodium, untuk contoh bekerja, dan menggambarkan bagaimana sebuah FRP GUI berperilaku basis kode dan skala dibandingkan dengan imperatif serta pendekatan berbasis Aktor.

Ada juga makalah baru-baru ini tentang Arrowized FRP dan prospek menggabungkan efek samping, IO, dan mutasi dalam pengaturan FRP murni yang taat hukum: http://haskell.cs.yale.edu/wp-content/uploads/2015/10/ dwc-yale-diformat-disertasi.pdf .

Juga perlu dicatat adalah bahwa kerangka kerja JavaScript seperti ReactJS dan Angular dan banyak lainnya sudah atau sedang bergerak ke arah menggunakan FRP atau pendekatan fungsional untuk mencapai komponen GUI yang skalabel dan komposer.


Sodium telah ditinggalkan demi pisang reaktif menurut
Sith


3

Untuk mengatasi ini saya memposting beberapa pemikiran saya dalam menggunakan F #,

http://fadsworld.wordpress.com/2011/04/13/f-in-the-enterprise-i/ http://fadsworld.wordpress.com/2011/04/17/fin-the-enterprise-ii- 2 /

Saya juga berencana melakukan tutorial video untuk menyelesaikan seri dan menunjukkan bagaimana F # dapat berkontribusi dalam pemrograman UX.

Saya hanya berbicara dalam konteks F # di sini.

-Fahad


2

Semua jawaban lain ini dibangun di atas pemrograman fungsional, tetapi membuat banyak keputusan desain sendiri. Salah satu perpustakaan yang dibangun pada dasarnya sepenuhnya dari fungsi dan tipe data abstrak sederhana adalah gloss. Ini adalah tipe untuk playfungsinya dari sumber

-- | Play a game in a window. Like `simulate`, but you manage your own input events.
play    :: Display              -- ^ Display mode.
        -> Color                -- ^ Background color.
        -> Int                  -- ^ Number of simulation steps to take for each second of real time.
        -> world                -- ^ The initial world.
        -> (world -> Picture)   -- ^ A function to convert the world a picture.
        -> (Event -> world -> world)    
                -- ^ A function to handle input events.
        -> (Float -> world -> world)
                -- ^ A function to step the world one iteration.
                --   It is passed the period of time (in seconds) needing to be advanced.
        -> IO ()

Seperti yang Anda lihat, ini berfungsi sepenuhnya dengan memasok fungsi murni dengan tipe abstrak sederhana, yang perpustakaan lain bantu.


1

Inovasi yang paling jelas diperhatikan oleh orang-orang yang baru mengenal Haskell adalah bahwa ada pemisahan antara dunia yang tidak murni yang berkaitan dengan komunikasi dengan dunia luar, dan dunia murni dari komputasi dan algoritma. Pertanyaan pemula yang sering muncul adalah "Bagaimana saya bisa menyingkirkan IO, yaitu, dikonversi IO amenjadi a?" Cara untuk itu adalah dengan menggunakan monads (atau abstraksi lainnya) untuk menulis kode yang melakukan efek IO dan rantai. Kode ini mengumpulkan data dari dunia luar, membuat modelnya, melakukan perhitungan, mungkin dengan menggunakan kode murni, dan menampilkan hasilnya.

Sejauh menyangkut model di atas, saya tidak melihat ada yang sangat salah dengan memanipulasi GUI di IOmonad. Masalah terbesar yang muncul dari gaya ini adalah bahwa modul tidak dapat dikomposisikan lagi, yaitu, saya kehilangan sebagian besar pengetahuan saya tentang urutan eksekusi pernyataan di program saya. Untuk memulihkannya, saya harus menerapkan alasan yang sama seperti pada kode GUI imperatif. Sementara itu, untuk kode non-GUI yang tidak murni, urutan eksekusi jelas karena definisi operator IOmonad >==(setidaknya selama hanya ada satu utas). Untuk kode murni, tidak masalah sama sekali, kecuali dalam kasus sudut untuk meningkatkan kinerja atau untuk menghindari evaluasi yang mengakibatkan .

Perbedaan filosofis terbesar antara konsol dan IO grafis adalah bahwa program yang menerapkan biasanya ditulis dalam gaya sinkron. Hal ini dimungkinkan karena ada (mengabaikan sinyal dan deskriptor file terbuka lainnya) hanya satu sumber peristiwa: aliran byte yang biasa disebut stdin. GUI pada dasarnya asinkron, dan harus bereaksi terhadap kejadian keyboard dan klik mouse.

Filosofi populer melakukan asynchronous IO dengan cara fungsional disebut Functional Reactive Programming (FRP). Ini mendapat banyak daya tarik baru-baru ini dalam bahasa yang tidak murni, non-fungsional berkat perpustakaan seperti ReactiveX , dan kerangka kerja seperti Elm. Singkatnya, ini seperti melihat elemen GUI dan hal-hal lain (seperti file, jam, alarm, keyboard, mouse) sebagai sumber acara, yang disebut "dapat diamati", yang memancarkan aliran peristiwa. Peristiwa ini digabungkan dengan menggunakan operator akrab seperti map, foldl, zip, filter, concat, join, dll, untuk menghasilkan aliran baru. Ini berguna karena status program itu sendiri dapat dilihat sebagai scanl . map reactToEvents $ zipN <eventStreams>program, di mana Nsama dengan jumlah yang dapat diamati yang pernah dipertimbangkan oleh program.

Bekerja dengan FRP yang dapat diamati memungkinkan untuk memulihkan kompabilitas karena peristiwa dalam aliran diperintahkan dalam waktu. Alasannya adalah bahwa abstraksi aliran peristiwa memungkinkan untuk melihat semua yang dapat diamati sebagai kotak hitam. Pada akhirnya, menggabungkan aliran acara menggunakan operator memberikan kembali beberapa pemesanan lokal pada eksekusi. Ini memaksa saya untuk menjadi lebih jujur ​​tentang invarian mana yang benar-benar diandalkan oleh program saya, mirip dengan cara semua fungsi di Haskell harus transparan transparan: jika saya ingin menarik data dari bagian lain dari program saya, saya harus eksplisit. iklan menyatakan jenis yang sesuai untuk fungsi saya. (The IO monad, menjadi bahasa Domain-Khusus untuk menulis kode tidak murni, secara efektif menghindari ini)


-22

Pemrograman fungsional mungkin telah pindah dari ketika saya masih di universitas, tetapi seingat saya poin utama dari sistem pemrograman fungsional adalah untuk menghentikan programmer membuat "efek samping". Namun pengguna membeli perangkat lunak karena efek samping yang dibuat, misalnya memperbarui UI.


25
Saya pikir Anda salah paham intinya: bukan itu pemrograman fungsional tidak memiliki efek luar pada dunia - yang akan membuat semua program sama sekali tidak berguna! Sebaliknya, pemrograman fungsional memungkinkan Anda mengkarantina IO sehingga Anda tahu bit mana yang menggunakannya dan bit mana yang tidak.
Tikhon Jelvis

Whoooooooosh x20
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.