Noțiuni introductive cu limbajul de programare Elm

Când dezvoltatorul principal al unui proiect foarte interesant și inovator a sugerat trecerea de la AngularJS la Elm, primul meu gând a fost: De ce?

Aveam deja o aplicație AngularJS bine scrisă, care era într-o stare solidă, bine testată și dovedită în producție. Iar Angular 4, fiind o actualizare demnă de la AngularJS, ar fi putut fi o alegere naturală pentru rescriere - la fel ar fi putut React sau Vue. Elm părea un limbaj ciudat specific unui domeniu de care oamenii abia au auzit.

Ei bine, asta a fost înainte să știu ceva despre Elm. Acum, cu ceva experiență cu el, mai ales după trecerea la el de la AngularJS, cred că pot da un răspuns la acel „de ce”.

În acest articol, vom analiza avantajele și dezavantajele lui Elm și cum unele dintre conceptele sale exotice se potrivesc perfect nevoilor unui dezvoltator web front-end. Pentru un articol în limbajul Elm mai asemănător unui tutorial, puteți arunca o privire la această postare de blog.

Elm: Un limbaj de programare pur funcțional

Dacă sunteți obișnuit cu programarea în Java sau JavaScript și simțiți că este modalitatea naturală de a scrie cod, învățarea Elm poate fi ca și cum ați cădea în groapa iepurelui.

Primul lucru pe care îl veți observa este sintaxa ciudată: fără acolade, multe săgeți și triunghiuri.

S-ar putea să înveți să trăiești fără bretele, dar cum definiți și cuibărați blocurile de cod? Sau, unde este bucla for , sau orice altă buclă, de fapt? În timp ce domeniul de aplicare explicit poate fi definit cu un bloc let , nu există blocuri în sensul clasic și nici bucle.

Elm este un limbaj de client web pur funcțional, puternic tipat, reactiv și bazat pe evenimente.

S-ar putea să începeți să vă întrebați dacă programarea este posibilă chiar în acest fel.

În realitate, aceste calități se adună pentru a vă oferi o paradigmă uimitoare de programare și dezvoltare de software bun.

Pur funcțional

S-ar putea să credeți că, folosind versiunea mai nouă de Java sau ECMAScript 6, puteți face programare funcțională. Dar asta este doar suprafața.

În acele limbaje de programare, mai aveți acces la un arsenal de constructe de limbaj și tentația de a recurge la părțile nefuncționale ale acestuia. Unde observați cu adevărat diferența este atunci când nu puteți face altceva decât programare funcțională. Este în acel moment în care în cele din urmă începi să simți cât de naturală poate fi programarea funcțională.

În Elm, aproape totul este o funcție. Numele înregistrării este o funcție, valoarea tipului de uniune este o funcție — fiecare funcție este compusă din funcții aplicate parțial argumentelor sale. Chiar și operatorii precum plus (+) și minus (-) sunt funcții.

Pentru a declara un limbaj de programare ca fiind pur funcțional, mai degrabă decât existența unor astfel de constructe, absența tuturor celorlalte este de o importanță capitală. Abia atunci poți începe să gândești într-un mod pur funcțional.

Elm este modelat pe concepte mature de programare funcțională și seamănă cu alte limbaje funcționale precum Haskell și OCaml.

Tastat puternic

Dacă programezi în Java sau TypeScript, atunci știi ce înseamnă asta. Fiecare variabilă trebuie să aibă exact un tip.

Există unele diferențe, desigur. Ca și în cazul TypeScript, declarația de tip este opțională. Dacă nu este prezent, se va deduce. Dar nu există „orice” tip.

Java acceptă tipuri generice, dar într-un mod mai bun. Genericele în Java au fost adăugate mai târziu, astfel încât tipurile nu sunt generice dacă nu se specifică altfel. Și, pentru a le folosi, avem nevoie de sintaxa urâtă <> .

În Elm, tipurile sunt generice, dacă nu se specifică altfel. Să ne uităm la un exemplu. Să presupunem că avem nevoie de o metodă care preia o listă de un anumit tip și returnează un număr. În Java ar fi:

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

Și, în limba Elm:

 numFromList list = List.length list

Deși opțional, vă sugerez să adăugați întotdeauna declarații de tip. Compilatorul Elm nu ar permite niciodată operații pe tipuri greșite. Pentru un om, este mult mai ușor să faci o astfel de greșeală, mai ales în timp ce învață limba. Deci, programul de mai sus cu adnotări de tip ar fi:

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

Poate părea neobișnuit la început să declari tipurile pe o linie separată, dar după ceva timp începe să pară natural.

Limba clientului web

Ceea ce înseamnă, pur și simplu, este că Elm se compilează în JavaScript, astfel încât browserele să îl poată executa pe o pagină web.

Având în vedere asta, nu este un limbaj de uz general precum Java sau JavaScript cu Node.js, ci un limbaj specific domeniului pentru a scrie partea client a aplicațiilor web. Mai mult decât atât, Elm include atât scrierea logicii de afaceri (ce face JavaScript), cât și partea de prezentare (ce face HTML), toate într-un singur limbaj funcțional.

Toate acestea sunt realizate într-un mod foarte specific asemănător unui cadru, care se numește Arhitectura Elm.

Reactiv

Arhitectura Elm este un cadru web reactiv. Orice modificări ale modelelor sunt redate imediat pe pagină, fără manipulare explicită a DOM.

În acest fel, este similar cu Angular sau React. Dar, Elm o face și în felul său. Cheia pentru înțelegerea elementelor de bază este în semnătura funcțiilor de view și update :

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

O vizualizare Elm nu este doar vizualizarea HTML a modelului. Este HTML care poate produce mesaje de tip Msg , unde Msg este un tip de uniune exact pe care îl definiți.

Orice eveniment de pagină standard poate produce un mesaj. Și, atunci când este produs un mesaj, Elm apelează intern funcția de actualizare cu acel mesaj, care apoi actualizează modelul pe baza mesajului și modelului curent, iar modelul actualizat este din nou redat intern în vizualizare.

Condus de evenimente

La fel ca JavaScript, Elm este bazat pe evenimente. Dar, spre deosebire de, de exemplu, Node.js, unde sunt furnizate apeluri inverse individuale pentru acțiunile asincrone, evenimentele Elm sunt grupate în seturi discrete de mesaje, definite într-un singur tip de mesaj. Și, ca în cazul oricărui tip de uniune, informațiile pe care le poartă valorile de tip separate ar putea fi orice.

Există trei surse de evenimente care pot produce mesaje: acțiunile utilizatorului în vizualizarea Html , execuția comenzilor și evenimentele exterioare la care ne-am abonat. De aceea, toate cele trei tipuri, Html , Cmd și Sub conțin ca argument msg . Și, tipul generic msg trebuie să fie același în toate cele trei definiții — același furnizat funcției de actualizare (în exemplul anterior, era tipul Msg , cu M majuscule), unde toată procesarea mesajelor este centralizată.

Codul sursă al unui exemplu realist

Puteți găsi un exemplu complet de aplicație web Elm în acest depozit GitHub. Deși simplu, arată cea mai mare parte a funcționalității utilizate în programarea clientului de zi cu zi: preluarea datelor de la un punct final REST, decodarea și codificarea datelor JSON, utilizarea vizualizărilor, mesajelor și a altor structuri, comunicarea cu JavaScript și tot ceea ce este necesar pentru compilare și pachet. Cod Elm cu Webpack.

Aplicația afișează o listă de utilizatori preluați de pe un server.

Pentru un proces de configurare/demo mai ușor, serverul de dezvoltare Webpack este folosit atât pentru ambalarea tuturor, inclusiv pentru Elm, cât și pentru a servi lista utilizatorilor.

Unele funcționalități sunt în Elm, iar altele în JavaScript. Acest lucru se face în mod intenționat dintr-un motiv important: pentru a arăta interoperabilitatea. Probabil că doriți să încercați Elm să pornească sau să comutați treptat codul JavaScript existent la acesta sau să adăugați o nouă funcționalitate în limbajul Elm. Cu interoperabilitatea, aplicația dvs. continuă să funcționeze atât cu codul Elm, cât și cu JavaScript. Aceasta este probabil o abordare mai bună decât să porniți întreaga aplicație de la zero în Elm.

Partea Elm din codul exemplu este mai întâi inițializată cu date de configurare din JavaScript, apoi lista de utilizatori este preluată și afișată în limbajul Elm. Să presupunem că avem deja unele acțiuni ale utilizatorului implementate în JavaScript, așa că invocarea unei acțiuni utilizator în Elm trimite apelul înapoi către acesta.

Codul folosește, de asemenea, unele dintre conceptele și tehnicile explicate în secțiunea următoare.

Aplicarea conceptelor Elm

Să trecem prin câteva dintre conceptele exotice ale limbajului de programare Elm în scenariile din lumea reală.

Tip de uniune

Acesta este aurul pur al limbii ulmului. Vă amintiți toate acele situații în care date structural diferite trebuiau utilizate cu același algoritm? Este întotdeauna dificil să modelezi acele situații.

Iată un exemplu: Imaginează-ți că creezi o paginare pentru lista ta. La sfârșitul fiecărei pagini, ar trebui să existe link-uri către paginile anterioare, următoare și către toate paginile după numerele lor. Cum îl structurați pentru a păstra informațiile despre linkul pe care a făcut clic utilizatorul?

Putem folosi mai multe apeluri inverse pentru clicurile anterioare, următoare și pe numărul paginii, sau putem folosi unul sau două câmpuri booleene pentru a indica ceea ce sa făcut clic sau pentru a da o semnificație specială unor anumite valori întregi, cum ar fi numere negative, zero etc. Dar niciunul dintre aceste soluții pot modela exact acest tip de eveniment utilizator.

În Elm, este foarte simplu. Am defini un tip de uniune:

 type NextPage = Prev | Next | ExactPage Int

Și îl folosim ca parametru pentru unul dintre mesaje:

 type Msg = ... | ChangePage NextPage

În cele din urmă, actualizăm funcția pentru a avea un case pentru a verifica tipul următoarei nextPage :

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

Face lucrurile foarte elegante.

Crearea mai multor funcții pentru hărți cu <|

Multe module includ o funcție de map , cu mai multe variante de aplicat unui număr diferit de argumente. De exemplu, List are map , map2 , … , până la map5 . Dar, ce se întâmplă dacă avem o funcție care ia șase argumente? Nu există map6 . Dar, există o tehnică pentru a depăși asta. Utilizează <| funcția ca parametru și funcții parțiale, cu unele dintre argumente aplicate ca rezultate medii.

Pentru simplitate, să presupunem că o List are doar map și map2 și dorim să aplicăm o funcție care ia trei argumente pe trei liste.

Iată cum arată implementarea:

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

Să presupunem că vrem să folosim foo , care doar își înmulțește argumentele numerice, definite ca:

 foo abc = a * b * c

Deci rezultatul map3 foo [1,2,3,4,5] [1,2,3,4,5] [1,2,3,4,5] este [1,8,27,64,125] : List number .

Să deconstruim ceea ce se întâmplă aici.

În primul rând, în partialResult = List.map2 foo list1 list2 , foo este parțial aplicat fiecărei perechi din list1 și list2 . Rezultatul este [foo 1 1, foo 2 2, foo 3 3, foo 4 4, foo 5 5] , o listă de funcții care ia un parametru (deoarece primii doi sunt deja aplicați) și returnează un număr.

Următorul în List.map2 (<|) partialResult list3 , este de fapt List.map2 (<|) [foo 1 1, foo 2 2, foo 3 3, foo 4 4, foo 5 5] list3 . Pentru fiecare pereche din aceste două liste, numim funcția (<|) . De exemplu, pentru prima pereche, este (<|) (foo 1 1) 1 , care este același cu foo 1 1 <| 1 foo 1 1 <| 1 , care este la fel cu foo 1 1 1 , care produce 1 . Pentru al doilea, va fi (<|) (foo 2 2) 2 , care este foo 2 2 2 , care evaluează la 8 și așa mai departe.

Această metodă poate fi deosebit de utilă cu funcțiile mapN pentru decodarea obiectelor JSON cu multe câmpuri, deoarece Json.Decode le oferă până la map8 .

Eliminați toate valorile Nimic dintr-o listă de poate

Să presupunem că avem o listă de valori Maybe și dorim să extragem doar valorile din elementele care au una. De exemplu, lista este:

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

Și, vrem să obținem [1,3,6,7] : List Int . Soluția este această expresie cu o singură linie:

 List.filterMap identity list

Să vedem de ce funcționează.

List.filterMap se așteaptă ca primul argument să fie o funcție (a -> Maybe b) , care este aplicată pe elementele unei liste furnizate (al doilea argument), iar lista rezultată este filtrată pentru a omite toate valorile Nothing și apoi valoarea reală. valorile sunt extrase din Maybe s.

În cazul nostru, am furnizat identity , astfel încât lista rezultată este din nou [ Just 1, Nothing, Just 3, Nothing, Nothing, Just 6, Just 7 ] . După filtrare, obținem [ Just 1, Just 3, Just 6, Just 7 ] , iar după extragerea valorii, este [1,3,6,7] , așa cum ne-am dorit.

Decodare JSON personalizată

Pe măsură ce nevoile noastre în decodarea (sau deserializarea) JSON încep să depășească ceea ce este expus în modulul Json.Decode , este posibil să avem probleme la crearea de noi decodore exotice. Acest lucru se datorează faptului că aceste decodoare sunt invocate de la mijlocul procesului de decodare, de exemplu, în cadrul metodelor Http , și nu este întotdeauna clar care sunt intrările și ieșirile lor, mai ales dacă există o mulțime de câmpuri în JSON furnizat.

Iată două exemple pentru a arăta cum să tratați astfel de cazuri.

În primul, avem două câmpuri în JSON de intrare, a și b , care indică laturile unei zone dreptunghiulare. Dar, într-un obiect Elm, vrem doar să-i stocăm zona.

 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

Câmpurile sunt decodificate individual cu decodorul field int și apoi ambele valori sunt furnizate funcției furnizate în map2 . Deoarece înmulțirea ( * ) este, de asemenea, o funcție și necesită doi parametri, o putem folosi doar așa. areaDecoder rezultat este un decodor care returnează rezultatul funcției atunci când este aplicat, în acest caz, a*b .

În al doilea exemplu, obținem un câmp de stare dezordonat, care poate fi nul sau orice șir, inclusiv gol, dar știm că operația a reușit doar dacă este „OK”. În acest caz, dorim să-l stocăm ca True și pentru toate celelalte cazuri ca False . Decodorul nostru arată astfel:

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

Să-l aplicăm unor JSON-uri:

 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

Cheia aici se află în funcția furnizată către andThen , care preia rezultatul unui decodor de șiruri nullabile anterior (care este un Maybe String ), îl transformă în orice avem nevoie și returnează rezultatul ca decodor cu ajutorul succeed .

Cheie la pachet

După cum se poate vedea din aceste exemple, programarea în mod funcțional poate să nu fie foarte intuitivă pentru dezvoltatorii Java și JavaScript. Este nevoie de ceva timp pentru a te obișnui, cu multe încercări și erori. Pentru a vă ajuta să înțelegeți, puteți utiliza elm-repl pentru a exercita și a verifica tipurile de returnare ale expresiilor dvs.

Proiectul exemplu la care se face legătura mai devreme în acest articol conține mai multe exemple de decodoare și codificatoare personalizate care vă pot ajuta, de asemenea, să le înțelegeți.

Dar totuși, de ce să alegi Elm?

Fiind atât de diferit de alte framework-uri client, limbajul Elm nu este cu siguranță „o altă bibliotecă JavaScript”. Ca atare, are o mulțime de trăsături care pot fi considerate pozitive sau negative în comparație cu acestea.

Să începem mai întâi cu partea pozitivă.

Programare client fără HTML și JavaScript

În cele din urmă, ai o limbă în care poți face totul. Gata cu separarea și combinațiile incomode ale amestecării lor. Fără generare de HTML în JavaScript și nici limbaje de șabloane personalizate cu unele reguli logice reduse.

Cu Elm, ai o singură sintaxă și o singură limbă, în toată gloria sa.

Uniformitate

Deoarece aproape toate conceptele se bazează pe funcții și câteva structuri, sintaxa este foarte concisă. Nu trebuie să vă faceți griji dacă o metodă este definită la nivel de instanță sau de clasă sau dacă este doar o funcție. Toate sunt funcții definite la nivel de modul. Și, nu există o sută de moduri diferite de a repeta listele.

În majoritatea limbilor, există întotdeauna acest argument despre dacă codul este scris în felul limbii. O mulțime de idiomuri trebuie stăpânite.

În Elm, dacă se compilează, probabil că este modul „Elm”. Dacă nu, ei bine, cu siguranță nu este.

Expresivitate

Deși concisă, sintaxa Elm este foarte expresivă.

Acest lucru se realizează în principal prin utilizarea tipurilor de uniuni, declarațiilor de tip formale și stilului funcțional. Toate acestea inspiră utilizarea unor funcții mai mici. La sfârșit, obțineți un cod care se auto-documentează.

Nu Null

Când utilizați Java sau JavaScript pentru o perioadă foarte lungă de timp, null devine ceva complet natural pentru dvs. - o parte inevitabilă a programării. Și, deși vedem constant NullPointerException și diverse TypeError , încă nu credem că adevărata problemă este existența null . Este atât de natural .

Devine clar după ceva timp cu Elm. A nu avea null nu numai că ne scutește de a vedea erorile de referință nul de execuție din nou și din nou, ci ne ajută, de asemenea, să scriem un cod mai bun, definind și gestionând clar toate situațiile în care este posibil să nu avem valoarea reală, reducând astfel și datoria tehnică prin neamânarea null . manipulare până când ceva se sparge.

Încrederea că va funcționa

Crearea de programe JavaScript corecte din punct de vedere sintactic se poate face foarte rapid. Dar, chiar va funcționa? Ei bine, să vedem după ce am reîncărcat pagina și am testat-o ​​temeinic.

Cu Elm, este invers. Cu verificarea tipului static și verificările null impuse, este nevoie de ceva timp pentru compilare, mai ales când un începător scrie un program. Dar, odată ce este compilat, există șanse mari să funcționeze corect.

Rapid

Acesta poate fi un factor important atunci când alegeți un cadru client. Capacitatea de răspuns a unei aplicații web extinse este adesea crucială pentru experiența utilizatorului și, prin urmare, pentru succesul întregului produs. Și, după cum arată testele, Elm este foarte rapid.

Avantajele Elm vs Framework-uri tradiționale

Cele mai multe dintre cadrele web tradiționale oferă instrumente puternice pentru crearea de aplicații web. Dar această putere are un preț: arhitectură prea complicată, cu o mulțime de concepte și reguli diferite despre cum și când să le folosești. Este nevoie de mult timp pentru a stăpâni totul. Există controlere, componente și directive. Apoi, sunt fazele de compilare și configurare și faza de rulare. Și apoi, există servicii, fabrici și tot limbajul de șablon personalizat folosit în directivele furnizate - toate acele situații în care trebuie să apelăm direct $scope.$apply() pentru a reîmprospăta pagina și multe altele.

Compilarea Elm la JavaScript este, de asemenea, foarte complicată, dar dezvoltatorul este protejat de a fi nevoit să cunoască toate piulițele și șuruburile acesteia. Doar scrieți niște Elm și lăsați compilatorul să-și facă treaba.

Și de ce să nu alegi Elm?

Ajunge cu lăudarea lui Elm. Acum, să vedem câteva dintre laturile sale nu atât de grozave.

Documentație

Aceasta este într-adevăr o problemă majoră. Limbajul Elm nu are un manual detaliat.

Tutorialele oficiale parcurg limba și lasă o mulțime de întrebări fără răspuns.

Referința oficială API este și mai proastă. Multe funcții nu au niciun fel de explicații sau exemple. Și, apoi, sunt cei cu propoziția: „Dacă acest lucru este confuz, lucrați prin Tutorialul Arhitectura Elm. Chiar ajută!” Nu este cea mai grozavă linie pe care doriți să o vedeți în documentele oficiale API.

Sperăm că acest lucru se va schimba în curând.

Nu cred că Elm poate fi adoptat pe scară largă cu o documentație atât de slabă, mai ales cu oameni care vin din Java sau JavaScript, unde astfel de concepte și funcții nu sunt deloc intuitive. Pentru a le înțelege, este nevoie de o documentare mult mai bună, cu o mulțime de exemple.

Format și spațiu alb

A scăpa de bretele sau parantezele și utilizarea spațiului alb pentru indentare ar putea arăta bine. De exemplu, codul Python arată foarte bine. Dar pentru creatorii de elm-format , nu a fost suficient.

Cu toate spațiile de linii duble și expresiile și atribuțiile împărțite în mai multe linii, codul Elm arată mai mult vertical decât orizontal. Ceea ce ar fi o singură linie în vechiul C bun se poate extinde cu ușurință la mai mult de un ecran în limba Elm.

Acest lucru poate suna bine dacă sunteți plătit cu linii de cod scrise. Dar, dacă doriți să aliniați ceva cu o expresie începută cu 150 de rânduri mai devreme, mult succes în găsirea indentației potrivite.

Manipularea înregistrărilor

Este greu să lucrezi cu ei. Sintaxa de modificare a câmpului unei înregistrări este urâtă. Nu există o modalitate ușoară de a modifica câmpurile imbricate sau de a face referire în mod arbitrar la câmpuri după nume. Și dacă utilizați funcțiile accesorii într-un mod generic, există multe probleme cu tastarea corectă.

În JavaScript, o înregistrare sau un obiect este structura centrală care poate fi construită, accesată și modificată în multe moduri. Chiar și JSON este doar o versiune serializată a unei înregistrări. Dezvoltatorii sunt obișnuiți să lucreze cu înregistrări în programarea web, așa că dificultățile în manipularea lor în Elm pot deveni vizibile dacă sunt folosite ca structură de date primară.

Mai multe tastare

Elm necesită mai mult cod pentru a fi scris decât JavaScript.

Nu există o conversie implicită de tip pentru operațiile cu șir și numere, așa că sunt necesare o mulțime de conversii int-float și mai ales apeluri toString , care necesită apoi paranteze sau simboluri ale aplicației de funcție pentru a se potrivi cu numărul corect de argumente. De asemenea, funcția Html.text necesită un șir ca argument. Sunt necesare o mulțime de expresii de caz, pentru toate acele Maybe s, Results , tipuri etc.

Motivul principal pentru aceasta este sistemul de tip strict și acesta poate fi un preț corect de plătit.

Decodoare și codificatoare JSON

Un domeniu în care mai mult tastarea iese în evidență este manipularea JSON. Ceea ce este pur și simplu un apel JSON.parse() în JavaScript poate cuprinde sute de linii în limbajul Elm.

Desigur, este nevoie de un fel de mapare între structurile JSON și Elm. Dar necesitatea de a scrie atât decodoare, cât și codificatoare pentru aceeași bucată de JSON este o problemă serioasă. Dacă API-urile dvs. REST transferă obiecte cu sute de câmpuri, aceasta va fi multă muncă.

Învelire

Am văzut despre Elm că este timpul să răspundem la întrebările binecunoscute, probabil la fel de vechi ca limbajele de programare în sine: Este mai bun decât concurența? Ar trebui să-l folosim în proiectul nostru?

Răspunsul la prima întrebare poate fi subiectiv, deoarece nu orice unealtă este un ciocan și nu totul este un cui. Elm poate străluci și poate fi o alegere mai bună față de alte framework-uri de client web în multe cazuri, în timp ce nu se încadrează în altele. Dar oferă o valoare cu adevărat unică, care poate face dezvoltarea web front-end mult mai sigură și mai ușoară decât alternativele.

Pentru a doua întrebare, pentru a evita să răspunzi și cu vechiul „depinde”, răspunsul simplu este: da. Chiar și cu toate dezavantajele menționate, doar încrederea pe care ți-o oferă Elm că programul tău este corect este un motiv suficient pentru a-l folosi.

Codarea în Elm este, de asemenea, distractivă. Este o perspectivă complet nouă pentru oricine este obișnuit cu paradigmele de programare web „convenționale”.

În uz real, nu trebuie să treceți imediat întreaga aplicație la Elm sau să începeți una nouă complet în ea. Puteți profita de interoperabilitatea sa cu JavaScript pentru a-l încerca, începând cu o porțiune a interfeței sau o anumită funcționalitate scrisă în limbajul Elm. Vei afla rapid dacă se potrivește nevoilor tale și apoi îi vei extinde utilizarea sau îl vei lăsa. Și cine știe, s-ar putea să te îndrăgostești și de lumea programării web funcționale.