Memulai dengan Bahasa Pemrograman Elm

Ketika pengembang utama proyek yang sangat menarik dan inovatif menyarankan untuk beralih dari AngularJS ke Elm, pikiran pertama saya adalah: Mengapa?

Kami telah memiliki aplikasi AngularJS yang ditulis dengan baik yang dalam kondisi solid, teruji dengan baik, dan terbukti dalam produksi. Dan Angular 4, sebagai peningkatan yang layak dari AngularJS, bisa menjadi pilihan alami untuk penulisan ulang—begitu juga React atau Vue. Elm tampak seperti bahasa khusus domain yang aneh yang jarang didengar orang.

Yah, itu sebelum aku tahu apa-apa tentang Elm. Sekarang, dengan beberapa pengalaman dengannya, terutama setelah beralih dari AngularJS, saya pikir saya dapat memberikan jawaban untuk "mengapa" itu.

Pada artikel ini, kita akan membahas pro dan kontra Elm dan bagaimana beberapa konsep eksotisnya sangat sesuai dengan kebutuhan pengembang web front-end. Untuk artikel bahasa Elm yang lebih mirip tutorial, Anda dapat melihat posting blog ini.

Elm: Bahasa Pemrograman Fungsional Murni

Jika Anda terbiasa dengan pemrograman Java atau JavaScript dan merasa itu adalah cara alami menulis kode, belajar Elm bisa seperti jatuh ke lubang kelinci.

Hal pertama yang akan Anda perhatikan adalah sintaks yang aneh: tidak ada kurung kurawal, banyak panah dan segitiga.

Anda mungkin belajar hidup tanpa kurung kurawal, tetapi bagaimana Anda mendefinisikan dan menyusun blok kode? Atau, di mana for loop, atau loop lainnya, dalam hal ini? Sementara ruang lingkup eksplisit dapat didefinisikan dengan blok let , tidak ada blok dalam pengertian klasik dan tidak ada loop sama sekali.

Elm adalah bahasa klien web yang murni fungsional, sangat diketik, reaktif, dan digerakkan oleh peristiwa.

Anda mungkin mulai bertanya-tanya apakah pemrograman dimungkinkan dengan cara ini.

Pada kenyataannya, kualitas-kualitas ini bertambah untuk memberi Anda paradigma pemrograman yang luar biasa dan mengembangkan perangkat lunak yang baik.

Fungsional murni

Anda mungkin berpikir bahwa dengan menggunakan versi Java atau ECMAScript 6 yang lebih baru, Anda dapat melakukan pemrograman fungsional. Tapi, itu hanya permukaannya saja.

Dalam bahasa pemrograman itu, Anda masih memiliki akses ke gudang konstruksi bahasa dan godaan untuk menggunakan bagian yang tidak berfungsi. Di mana Anda benar-benar melihat perbedaannya adalah ketika Anda tidak dapat melakukan apa pun selain pemrograman fungsional. Pada titik itulah Anda akhirnya mulai merasakan betapa alaminya pemrograman fungsional.

Di Elm, hampir semuanya adalah fungsi. Nama rekaman adalah fungsi, nilai tipe gabungan adalah fungsi—setiap fungsi terdiri dari fungsi yang diterapkan sebagian ke argumennya. Bahkan operator seperti plus (+) dan minus (-) adalah fungsi.

Untuk mendeklarasikan bahasa pemrograman sebagai fungsional murni, daripada keberadaan konstruksi tersebut, tidak adanya segala sesuatu yang lain adalah sangat penting. Hanya dengan begitu Anda dapat mulai berpikir dengan cara yang murni fungsional.

Elm dimodelkan pada konsep matang pemrograman fungsional, dan menyerupai bahasa fungsional lainnya seperti Haskell dan OCaml.

Sangat Diketik

Jika Anda memprogram dalam Java atau TypeScript, maka Anda tahu apa artinya ini. Setiap variabel harus memiliki tepat satu jenis.

Beberapa perbedaan ada, tentu saja. Seperti halnya TypeScript, deklarasi tipe adalah opsional. Jika tidak ada, itu akan disimpulkan. Tetapi tidak ada tipe "apa pun".

Java mendukung tipe generik, tetapi dengan cara yang lebih baik. Generik di Java ditambahkan kemudian, jadi tipe tidak generik kecuali ditentukan lain. Dan, untuk menggunakannya kita membutuhkan sintaks <> yang jelek.

Di Elm, tipe bersifat generik kecuali ditentukan lain. Mari kita lihat sebuah contoh. Misalkan kita membutuhkan metode yang mengambil daftar tipe tertentu dan mengembalikan angka. Di Jawa itu akan menjadi:

 public static <T> int numFromList(List<T> list){ return list.size(); }

Dan, dalam bahasa Elm:

 numFromList list = List.length list

Meskipun opsional, saya sangat menyarankan agar Anda selalu menambahkan deklarasi tipe. Kompiler Elm tidak akan pernah mengizinkan operasi pada tipe yang salah. Untuk manusia, jauh lebih mudah untuk membuat kesalahan seperti itu, terutama saat belajar bahasa. Jadi program di atas dengan anotasi tipe adalah:

 numFromList: List a -> Int numFromList list = List.length list

Tampaknya tidak biasa pada awalnya untuk mendeklarasikan jenis pada baris yang terpisah, tetapi setelah beberapa waktu mulai terlihat alami.

Bahasa Klien Web

Artinya, Elm mengkompilasi ke JavaScript, sehingga browser dapat mengeksekusinya di halaman web.

Mengingat itu, ini bukan bahasa tujuan umum seperti Java atau JavaScript dengan Node.js tetapi bahasa khusus domain untuk menulis bagian klien dari aplikasi web. Bahkan lebih dari itu, Elm menyertakan penulisan logika bisnis (apa yang dilakukan JavaScript), dan bagian presentasi (apa yang dilakukan HTML)—semuanya dalam satu bahasa fungsional.

Semua ini dilakukan dengan cara seperti kerangka kerja yang sangat spesifik, yang disebut Arsitektur Elm.

Reaktif

Arsitektur Elm adalah kerangka kerja web reaktif. Perubahan apa pun dalam model segera ditampilkan di halaman, tanpa manipulasi DOM eksplisit.

Dengan cara itu, ini mirip dengan Angular atau React. Tapi, Elm juga melakukannya dengan caranya sendiri. Kunci untuk memahami dasar-dasarnya ada pada tanda tangan fungsi view dan update :

 view : Model -> Html Msg update : Msg -> Model -> Model

Tampilan Elm bukan hanya tampilan HTML dari model. Itu HTML yang dapat menghasilkan pesan jenis Msg , di mana Msg adalah jenis serikat yang tepat yang Anda tentukan.

Setiap acara halaman standar dapat menghasilkan pesan. Dan, ketika sebuah pesan dibuat, Elm secara internal memanggil fungsi pembaruan dengan pesan itu, yang kemudian memperbarui model berdasarkan pesan dan model saat ini, dan model yang diperbarui kembali dirender secara internal ke tampilan.

Didorong oleh peristiwa

Sangat mirip dengan JavaScript, Elm digerakkan oleh peristiwa. Namun tidak seperti, misalnya, Node.js, di mana masing-masing callback disediakan untuk tindakan asinkron, peristiwa Elm dikelompokkan dalam kumpulan pesan yang terpisah, yang ditentukan dalam satu jenis pesan. Dan, seperti halnya tipe gabungan, informasi yang dibawa oleh nilai tipe terpisah bisa berupa apa saja.

Ada tiga sumber peristiwa yang dapat menghasilkan pesan: tindakan pengguna dalam tampilan Html , eksekusi perintah, dan peristiwa luar tempat kita berlangganan. Itu sebabnya ketiga tipe, Html , Cmd , dan Sub mengandung msg sebagai argumennya. Dan, jenis msg generik harus sama di ketiga definisi—sama dengan yang dipasok ke fungsi pembaruan (dalam contoh sebelumnya, itu adalah jenis Pesan, dengan huruf kapital M), di mana semua pemrosesan Msg dipusatkan.

Kode Sumber dari Contoh Realistis

Anda dapat menemukan contoh aplikasi web Elm lengkap di repositori GitHub ini. Meskipun sederhana, ini menunjukkan sebagian besar fungsi yang digunakan dalam pemrograman klien sehari-hari: mengambil data dari titik akhir REST, mendekode dan menyandikan data JSON, menggunakan tampilan, pesan, dan struktur lainnya, berkomunikasi dengan JavaScript, dan semua yang diperlukan untuk mengompilasi dan mengemas Kode Elm dengan Webpack.

Aplikasi menampilkan daftar pengguna yang diambil dari server.

Untuk proses setup/demo yang lebih mudah, server dev Webpack digunakan untuk mengemas semuanya, termasuk Elm, dan melayani daftar pengguna.

Beberapa fungsionalitas ada di Elm, dan beberapa di JavaScript. Ini dilakukan dengan sengaja untuk satu alasan penting: Untuk menunjukkan interoperabilitas. Anda mungkin ingin mencoba Elm untuk memulai, atau secara bertahap mengganti kode JavaScript yang ada, atau menambahkan fungsionalitas baru dalam bahasa Elm. Dengan interoperabilitas, aplikasi Anda terus bekerja dengan kode Elm dan JavaScript. Ini mungkin pendekatan yang lebih baik daripada memulai seluruh aplikasi dari awal di Elm.

Bagian Elm dalam kode contoh pertama diinisialisasi dengan data konfigurasi dari JavaScript, kemudian daftar pengguna diambil dan ditampilkan dalam bahasa Elm. Katakanlah kita memiliki beberapa tindakan pengguna yang sudah diterapkan di JavaScript, jadi memanggil tindakan pengguna di Elm hanya mengirimkan panggilan kembali ke sana.

Kode juga menggunakan beberapa konsep dan teknik yang dijelaskan di bagian selanjutnya.

Penerapan Konsep Elm

Mari kita membahas beberapa konsep eksotis bahasa pemrograman Elm dalam skenario dunia nyata.

Jenis Serikat

Ini adalah emas murni dari bahasa Elm. Ingat semua situasi ketika data yang berbeda secara struktural perlu digunakan dengan algoritma yang sama? Itu selalu sulit untuk model situasi tersebut.

Berikut ini contohnya: Bayangkan Anda membuat pagination untuk daftar Anda. Di akhir setiap halaman, harus ada tautan ke halaman sebelumnya, berikutnya, dan semua halaman dengan nomornya. Bagaimana Anda menyusunnya untuk menyimpan informasi tautan mana yang diklik pengguna?

Kita dapat menggunakan beberapa panggilan balik untuk klik sebelumnya, berikutnya, dan nomor halaman, atau kita dapat menggunakan satu atau dua bidang boolean untuk menunjukkan apa yang diklik, atau memberikan arti khusus pada nilai bilangan bulat tertentu, seperti angka negatif, nol, dll. solusi ini dapat memodelkan peristiwa pengguna seperti ini.

Di Elm, ini sangat sederhana. Kami akan mendefinisikan tipe serikat pekerja:

 type NextPage = Prev | Next | ExactPage Int

Dan kami menggunakannya sebagai parameter untuk salah satu pesan:

 type Msg = ... | ChangePage NextPage

Terakhir, kami memperbarui fungsi untuk memiliki case untuk memeriksa jenis nextPage :

 update msg model = case msg of ChangePage nextPage -> case nextPage of Prev -> ... Next -> ... ExactPage newPage -> ...

Itu membuat hal-hal yang sangat elegan.

Membuat Beberapa Fungsi Peta dengan <|

Banyak modul menyertakan fungsi map , dengan beberapa varian untuk diterapkan ke sejumlah argumen yang berbeda. Misalnya List memiliki map , map2 , … , hingga map5 . Tapi, bagaimana jika kita memiliki fungsi yang membutuhkan enam argumen? Tidak ada map6 . Tapi, ada teknik untuk mengatasinya. Ini menggunakan <| berfungsi sebagai parameter, dan fungsi parsial, dengan beberapa argumen diterapkan sebagai hasil tengah.

Untuk mempermudah, misalkan List hanya memiliki map dan map2 , dan kita ingin menerapkan fungsi yang mengambil tiga argumen pada tiga daftar.

Berikut adalah tampilan implementasinya:

 map3 foo list1 list2 list3 = let partialResult = List.map2 foo list1 list2 in List.map2 (<|) partialResult list3

Misalkan kita ingin menggunakan foo , yang hanya mengalikan argumen numeriknya, yang didefinisikan seperti:

 foo abc = a * b * c

Jadi hasil dari map3 foo [1,2,3,4,5] [1,2,3,4,5] [1,2,3,4,5] adalah [1,8,27,64,125] : List number .

Mari kita mendekonstruksi apa yang terjadi di sini.

Pertama, di partialResult = List.map2 foo list1 list2 , foo diterapkan sebagian ke setiap pasangan dalam list1 dan list2 . Hasilnya adalah [foo 1 1, foo 2 2, foo 3 3, foo 4 4, foo 5 5] , daftar fungsi yang mengambil satu parameter (karena dua parameter pertama sudah diterapkan) dan mengembalikan angka.

Selanjutnya di List.map2 (<|) partialResult list3 , sebenarnya List.map2 (<|) [foo 1 1, foo 2 2, foo 3 3, foo 4 4, foo 5 5] list3 . Untuk setiap pasangan dari dua daftar ini, kita memanggil fungsi (<|) . Misalnya, untuk pasangan pertama adalah (<|) (foo 1 1) 1 , yang sama dengan foo 1 1 <| 1 foo 1 1 <| 1 , yang sama dengan foo 1 1 1 , yang menghasilkan 1 . Untuk yang kedua adalah (<|) (foo 2 2) 2 , yaitu foo 2 2 2 , yang bernilai 8 , dan seterusnya.

Metode ini bisa sangat berguna dengan fungsi mapN untuk mendekode objek JSON dengan banyak bidang, karena Json.Decode menyediakannya hingga map8 .

Hapus Semua Nilai Tidak Ada dari Daftar Mungkin

Katakanlah kita memiliki daftar nilai Maybe , dan kita hanya ingin mengekstrak nilai dari elemen yang memilikinya. Misalnya, daftarnya adalah:

 list : List (Maybe Int) list = [ Just 1, Nothing, Just 3, Nothing, Nothing, Just 6, Just 7 ]

Dan, kami ingin mendapatkan [1,3,6,7] : List Int . Solusinya adalah ekspresi satu baris ini:

 List.filterMap identity list

Mari kita lihat mengapa ini berhasil.

List.filterMap mengharapkan argumen pertama menjadi fungsi (a -> Maybe b) , yang diterapkan pada elemen daftar yang disediakan (argumen kedua), dan daftar yang dihasilkan difilter untuk menghilangkan semua nilai Nothing , dan kemudian yang asli nilai diekstraksi dari Maybe s.

Dalam kasus kami, kami memberikan identity , sehingga daftar yang dihasilkan adalah lagi [ Just 1, Nothing, Just 3, Nothing, Nothing, Just 6, Just 7 ] . Setelah memfilternya, kami mendapatkan [ Just 1, Just 3, Just 6, Just 7 ] , dan setelah ekstraksi nilai, [1,3,6,7] , seperti yang kami inginkan.

Penguraian JSON Khusus

Karena kebutuhan kita dalam decoding JSON (atau deserializing) mulai melebihi apa yang diekspos dalam modul Json.Decode , kita mungkin mengalami masalah dalam membuat decoder eksotis baru. Ini karena decoder ini dipanggil dari tengah proses decoding, misalnya, dalam metode Http , dan tidak selalu jelas apa input dan outputnya, terutama jika ada banyak kolom di JSON yang disediakan.

Berikut adalah dua contoh untuk menunjukkan bagaimana menangani kasus seperti itu.

Pada yang pertama, kami memiliki dua bidang di JSON yang masuk, a dan b , yang menunjukkan sisi dari area persegi panjang. Tapi, di objek Elm, kita hanya ingin menyimpan areanya saja.

 import Json.Decode exposing (..) areaDecoder = map2 (*) (field "a" int) (field "b" int) result = decodeString areaDecoder """{ "a":7,"b":4 }""" -- Ok 28 : Result.Result String Int

Bidang secara individual didekodekan dengan dekoder field int , dan kemudian kedua nilai diberikan ke fungsi yang disediakan di map2 . Karena perkalian ( * ) juga merupakan fungsi, dan dibutuhkan dua parameter, kita bisa menggunakannya seperti itu. areaDecoder yang dihasilkan adalah dekoder yang mengembalikan hasil fungsi saat diterapkan, dalam hal ini, a*b .

Pada contoh kedua, kita mendapatkan bidang status berantakan, yang dapat berupa null, atau string apa pun termasuk kosong, tetapi kita tahu bahwa operasi berhasil hanya jika "OK". Dalam hal ini, kami ingin menyimpannya sebagai True dan untuk semua kasus lainnya sebagai False . Dekoder kami terlihat seperti ini:

 okDecoder = nullable string |> andThen (\ms -> case ms of Nothing -> succeed False Just s -> if s == "OK" then succeed True else succeed False )

Mari kita terapkan pada beberapa JSON:

 decodeString (field "status" okDecoder) """{ "a":7, "status":"OK" }""" -- Ok True decodeString (field "status" okDecoder) """{ "a":7, "status":"NOK" }""" -- Ok False decodeString (field "status" okDecoder) """{ "a":7, "status":null }""" -- Ok False

Kuncinya di sini adalah dalam fungsi yang dipasok ke andThen , yang mengambil hasil dari dekoder string nullable sebelumnya (yang merupakan Maybe String ), mengubahnya menjadi apa pun yang kita butuhkan, dan mengembalikan hasilnya sebagai dekoder dengan bantuan succeed .

Takeaway kunci

Seperti yang dapat dilihat dari contoh-contoh ini, pemrograman dengan cara fungsional mungkin tidak terlalu intuitif untuk pengembang Java dan JavaScript. Butuh beberapa waktu untuk membiasakannya, dengan banyak coba-coba. Untuk membantu memahaminya, Anda dapat menggunakan elm-repl untuk berolahraga dan memeriksa tipe kembalian ekspresi Anda.

Contoh proyek yang ditautkan sebelumnya dalam artikel ini berisi beberapa contoh dekoder dan enkoder khusus yang mungkin juga membantu Anda memahaminya.

Tapi Tetap, Mengapa Memilih Elm?

Menjadi sangat berbeda dari kerangka kerja klien lainnya, bahasa Elm tentu saja bukan “perpustakaan JavaScript lain.” Dengan demikian, ia memiliki banyak sifat yang dapat dianggap positif atau negatif jika dibandingkan dengan mereka.

Mari kita mulai dengan sisi positif terlebih dahulu.

Pemrograman Klien Tanpa HTML dan JavaScript

Akhirnya, Anda memiliki bahasa di mana Anda dapat melakukan semuanya. Tidak ada lagi pemisahan, dan kombinasi canggung dari pencampuran mereka. Tidak ada pembuatan HTML dalam JavaScript dan tidak ada bahasa templat khusus dengan beberapa aturan logika yang disederhanakan.

Dengan Elm, Anda hanya memiliki satu sintaks dan satu bahasa, dalam kejayaannya.

Keseragaman

Karena hampir semua konsep didasarkan pada fungsi, dan beberapa struktur, sintaksnya sangat ringkas. Anda tidak perlu khawatir jika beberapa metode didefinisikan pada instance atau tingkat kelas, atau jika itu hanya sebuah fungsi. Mereka semua adalah fungsi yang didefinisikan pada level modul. Dan, tidak ada seratus cara berbeda untuk daftar iterasi.

Di sebagian besar bahasa, selalu ada argumen tentang apakah kode ditulis dengan cara bahasa tersebut. Banyak idiom yang perlu dikuasai.

Di Elm, jika dikompilasi, itu mungkin cara "Elm". Jika tidak, ya, tentu saja tidak.

Ekspresi

Meskipun ringkas, sintaks Elm sangat ekspresif.

Hal ini dicapai sebagian besar melalui penggunaan tipe serikat pekerja, deklarasi tipe formal, dan gaya fungsional. Semua ini menginspirasi penggunaan fungsi yang lebih kecil. Pada akhirnya, Anda mendapatkan kode yang cukup banyak didokumentasikan sendiri.

Tidak ada nol

Saat Anda menggunakan Java atau JavaScript untuk waktu yang sangat lama, null menjadi sesuatu yang benar-benar alami bagi Anda—bagian tak terelakkan dari pemrograman. Dan, meskipun kami terus-menerus melihat NullPointerException s dan berbagai TypeError s, kami masih tidak berpikir bahwa masalah sebenarnya adalah keberadaan null . Ini sangat alami .

Menjadi jelas dengan cepat setelah beberapa waktu dengan Elm. Tidak memiliki null tidak hanya membebaskan kita dari melihat kesalahan referensi null runtime berulang kali, tetapi juga membantu kita menulis kode yang lebih baik dengan mendefinisikan dan menangani semua situasi dengan jelas ketika kita mungkin tidak memiliki nilai aktual, sehingga juga mengurangi utang teknis dengan tidak menunda null penanganan sampai ada yang rusak.

Keyakinan Itu Akan Berhasil

Membuat program JavaScript yang benar secara sintaksis dapat dilakukan dengan sangat cepat. Tapi, apakah itu akan benar-benar berhasil? Nah, mari kita lihat setelah memuat ulang halaman dan mengujinya secara menyeluruh.

Dengan Elm, itu adalah kebalikannya. Dengan pemeriksaan tipe statis dan pemeriksaan null yang dipaksakan, diperlukan beberapa waktu untuk mengkompilasi, terutama ketika seorang pemula menulis sebuah program. Tapi, setelah dikompilasi, ada kemungkinan besar itu akan berfungsi dengan benar.

Cepat

Ini bisa menjadi faktor penting ketika memilih kerangka kerja klien. Responsivitas aplikasi web yang ekstensif seringkali penting untuk pengalaman pengguna, dan dengan demikian keberhasilan keseluruhan produk. Dan, seperti yang ditunjukkan oleh tes, Elm sangat cepat.

Kelebihan Elm vs Kerangka Tradisional

Sebagian besar kerangka kerja web tradisional menawarkan alat canggih untuk pembuatan aplikasi web. Tetapi kekuatan itu ada harganya: arsitektur yang terlalu rumit dengan banyak konsep dan aturan berbeda tentang bagaimana dan kapan menggunakannya. Butuh banyak waktu untuk menguasai semuanya. Ada pengontrol, komponen, dan arahan. Kemudian, ada fase kompilasi dan konfigurasi, dan fase run. Dan kemudian, ada layanan, pabrik, dan semua bahasa templat khusus yang digunakan dalam arahan yang disediakan—semua situasi itu ketika kita perlu memanggil $scope.$apply() secara langsung untuk membuat halaman disegarkan, dan banyak lagi.

Kompilasi Elm ke JavaScript tentu juga sangat rumit, tetapi pengembang dilindungi dari keharusan mengetahui semua mur dan bautnya. Cukup tulis beberapa Elm dan biarkan kompiler melakukan tugasnya.

Dan, Mengapa Tidak Memilih Elm?

Cukup dengan memuji Elm. Sekarang, mari kita lihat beberapa sisi yang tidak terlalu bagus.

Dokumentasi

Ini benar-benar masalah utama. Bahasa Elm tidak memiliki manual yang terperinci.

Tutorial resmi hanya membaca sekilas bahasa dan meninggalkan banyak pertanyaan yang belum terjawab.

Referensi API resmi bahkan lebih buruk. Banyak fungsi tidak memiliki penjelasan atau contoh apa pun. Dan, kemudian ada yang dengan kalimat: “Jika ini membingungkan, kerjakan Tutorial Arsitektur Elm. Itu benar-benar membantu!” Bukan baris terbaik yang ingin Anda lihat di dokumen API resmi.

Semoga, ini akan segera berubah.

Saya tidak percaya Elm dapat diadopsi secara luas dengan dokumentasi yang buruk, terutama dengan orang-orang yang berasal dari Java atau JavaScript, di mana konsep dan fungsi seperti itu tidak intuitif sama sekali. Untuk memahaminya, diperlukan dokumentasi yang jauh lebih baik dengan banyak contoh.

Format dan Spasi

Menyingkirkan kurung kurawal atau tanda kurung dan menggunakan spasi putih untuk lekukan bisa terlihat bagus. Misalnya, kode Python terlihat sangat rapi. Tetapi bagi pencipta elm-format , itu tidak cukup.

Dengan semua spasi baris ganda, dan ekspresi serta tugas dibagi menjadi beberapa baris, kode Elm terlihat lebih vertikal daripada horizontal. Apa yang akan menjadi satu-baris di C lama yang baik dapat dengan mudah meregang ke lebih dari satu layar dalam bahasa Elm.

Ini mungkin terdengar bagus jika Anda dibayar dengan baris kode yang tertulis. Tapi, jika Anda ingin menyelaraskan sesuatu dengan ekspresi mulai 150 baris sebelumnya, selamat menemukan lekukan yang tepat.

Penanganan Catatan

Sulit untuk bekerja dengan mereka. Sintaks untuk mengubah bidang catatan jelek. Tidak ada cara mudah untuk memodifikasi bidang bersarang atau merujuk bidang sewenang-wenang dengan nama. Dan jika Anda menggunakan fungsi pengakses dengan cara yang umum, ada banyak masalah dengan pengetikan yang benar.

Dalam JavaScript, catatan atau objek adalah struktur pusat yang dapat dibangun, diakses, dan dimodifikasi dalam banyak cara. Bahkan JSON hanyalah versi serial dari catatan. Pengembang terbiasa bekerja dengan catatan dalam pemrograman web, sehingga kesulitan dalam penanganannya di Elm dapat menjadi nyata jika digunakan sebagai struktur data utama.

Lebih Banyak Mengetik

Elm membutuhkan lebih banyak kode untuk ditulis daripada JavaScript.

Tidak ada konversi tipe implisit untuk operasi string dan angka, jadi banyak konversi int-float dan terutama panggilan toString diperlukan, yang kemudian memerlukan tanda kurung atau simbol aplikasi fungsi untuk mencocokkan jumlah argumen yang benar. Juga, fungsi Html.text membutuhkan string sebagai argumen. Banyak ekspresi kasus diperlukan, untuk semua Maybe s, Results , types, dll.

Alasan utama untuk ini adalah sistem tipe yang ketat, dan itu bisa menjadi harga yang pantas untuk dibayar.

Decoder dan Encoder JSON

Satu area di mana pengetikan lebih menonjol adalah penanganan JSON. Apa yang dimaksud dengan panggilan JSON.parse() dalam JavaScript dapat menjangkau ratusan baris dalam bahasa Elm.

Tentu saja, semacam pemetaan antara struktur JSON dan Elm diperlukan. Tetapi kebutuhan untuk menulis dekoder dan enkoder untuk bagian JSON yang sama adalah masalah serius. Jika REST API Anda mentransfer objek dengan ratusan bidang, ini akan membutuhkan banyak pekerjaan.

Bungkus

Kami telah melihat tentang Elm, saatnya untuk menjawab pertanyaan terkenal, mungkin setua bahasa pemrograman itu sendiri: Apakah lebih baik daripada kompetisi? Haruskah kita menggunakannya dalam proyek kita?

Jawaban atas pertanyaan pertama mungkin subjektif, karena tidak setiap alat adalah palu dan tidak semuanya adalah paku. Elm dapat bersinar dan menjadi pilihan yang lebih baik daripada kerangka kerja klien web lain dalam banyak kasus sementara gagal dalam kasus lain. Tetapi ia menawarkan beberapa nilai yang sangat unik yang dapat membuat pengembangan front-end web jauh lebih aman dan lebih mudah daripada alternatifnya.

Untuk pertanyaan kedua, untuk menghindari menjawab dengan “itu tergantung” kuno, jawaban sederhananya adalah: Ya. Bahkan dengan semua kerugian yang disebutkan, hanya keyakinan yang diberikan Elm tentang program Anda yang benar adalah alasan yang cukup untuk menggunakannya.

Coding di Elm juga menyenangkan. Ini adalah perspektif yang sama sekali baru bagi siapa saja yang terbiasa dengan paradigma pemrograman web "konvensional".

Dalam penggunaan nyata, Anda tidak perlu segera mengalihkan seluruh aplikasi ke Elm atau memulai yang baru sepenuhnya di dalamnya. Anda dapat memanfaatkan interoperabilitasnya dengan JavaScript untuk mencobanya, dimulai dengan sebagian antarmuka atau beberapa fungsi yang ditulis dalam bahasa Elm. Anda akan segera mengetahui apakah itu sesuai dengan kebutuhan Anda dan kemudian memperluas penggunaannya atau meninggalkannya. Dan siapa tahu, Anda mungkin juga jatuh cinta dengan dunia pemrograman web fungsional.