Elm изменил мое представление о непопулярных языках | by Sergey Ufocoder | devSchacht | Medium

Elm изменил мое представление о непопулярных языках | by Sergey Ufocoder | devSchacht | Medium ОБД2

A quick sample

Here is a little program that lets you increment and decrement a number:

import Browser
import Html exposing (Html, button, div, text)
import Html.Events exposing (onClick)

main =
  Browser.sandbox { init = , update = update, view = view }

typeMsg = Increment | Decrementupdate msg model =
  case msg ofIncrement ->
      model   1Decrement ->
      model - 1view model =
  div []
    [ button [ onClick Decrement ] [ text "-" ]
    , div [] [ text (String.fromInt model) ]
    , button [ onClick Increment ] [ text " " ]
    ]

Try it out in the online editor here.

The code can definitely look unfamiliar at first, so we will get into how this example works soon!

Elm — функциональный язык программирования / хабр

Elm изменил мое представление о непопулярных языках | by Sergey Ufocoder | devSchacht | Medium

Model-Updater-View — функциональный паттерн, успешно применяемый в языке Elm в основном для разработки пользовательских интерфейсов. Что бы им воспользоваться надо создать тип Model, представляющий полное состояние программы, тип Message, описывающий события внешней среды, на которые программа должна реагировать, меняя свое состояние, функцию updater, которая из старого состояния и сообщения создает новое состояние прораммы и функции view, которая вычисляет по состоянию программы требуемые воздействия на внешнюю среду, которые порождают события типа Message. Паттерн очень удобный, но у него есть маленький недостаток — он не позволяет описать какие события имеют смысл для конкретных состояний программы.

Схожая проблема возникает (и решается) и при использовании ОО-паттерна State.

Язык Elm простой, но очень строгий — он проверяет, что функция updater хоть как-то обрабатывает все возможные сочетания модели-состояние и сообщения-события. По этому приходится писать лишний, пусть и тривиальный — как правило оставляющий модель без изменений, код. Я хочу продемонстрировать, как этого можно избежать в более сложных языках — Idris, Scala, C и Haskell.

Elm изменил мое представление о непопулярных языках

Перевод статьи Alexander Campbell: Elm changed my mind about unpopular languages

Вы когда-нибудь обращались к программному обеспечению так, чтобы это выходило за рамки обыденного? Возможно, вы пытались сделать программное обеспечение для своего графического калькулятора Fx-9860GX и понимали, что вы были одним из тех пяти человек, которые когда-либо пытались это сделать вообще, при том, что документации не было. Опыт отстойный. Или возможно вы относитесь к такому типу людей, которые получают удовольствие посредством мудреных ошибок и полного отсутствия документации (к коим иногда отношусь и я), но я решил, что в профессиональной разработке программного обеспечения, где важен вопрос его поставки на рынок, я буду придерживаться только самых широко используемых инструментов.

Для себя я сделал твердое и решительное правило: если я найду две технологии, которые могут решить какую-то проблему, то я предпочту ту, которой пользуется больше людей. К слову, я не хотел бы включать в проект неясный API для работы с графикой, а затем искать в коде, чтобы никто не вызывал функцию set_color() после функции resize_window() (да, изменение размеров окна это тяжело), ведь последовательное выполнение этих двух функций является причиной ошибки сегментации памяти. Я не хочу быть парнем, который найдет ошибку в компиляторе. Мне просто нужно разработать программный продукт.

Частично мое сомнение по поводу использования новых платформ связано с двухлетним опытом написание на языке Go, до того как произошла история с управлением зависимостей. Сообщество было разбито на множеством болезненных или посредственных решений: gopkg.in, godep, glide, gb и так далее. Потребовалось годы, чтобы разработчики «успокоились» (да, я легко бросаюсь этим словом) и остановилось на godep, а ведь это было не так недавно, когда сообщество Go его полностью приняло, это был относительно безболезненный опыт. И недавно я узнал, что разработчики языка Go могут представить официальное решение: golang/dep.

Со своим новым правилом я чувствовал себя уверенным в выборе своего стека. Когда я искал инструменты для создания веб-приложения, то рассматривал только массово используемые и популярные инструменты, такие как Bootstrap и jQuery. У каждой из этих библиотек несметное число пользователей каждый месяц, поэтому все возможные ошибки проработаны, не так ли? Даже если, у меня возникнет проблема, уверен, кто-то уже получал ответ на нее на StackOverflow. Все как по маслу. И вуаля, все уже работает. Вы можете пройтись по всему жизненному циклу веб-приложения, и вы редко столкнетесь с ситуацией, когда вы не можете найти решение проблемы в течение 5 секунд в сети. Кто-то уже исправил это. Моя стратегия была безупречной.

Но когда я присоединился к Real Kinetic, я узнал, что мы разрабатываем клиентское веб-приложение на Elm. Elm? Серьезно? Это же экспериментальный язык, созданный для Haskell-снобов, которые не могут справиться с обычным языком для синих воротничков, таким как JavaScript? Я представлял поклонников языка Elm так, словно вокруг меня стояли хипстеры, говорящие о том, что побочные эффекты в веб-приложениях — это же 2008 год, бро. Определенно, я не представлял их как людей, которые поставляют приложения на рынок программного обеспечения. На мой взгляд, Elm не соответствовал производственной среде.

Поэтому в течение первых нескольких недель я был настроен скептически. Но затем, когда я в третий раз изучал руководство по архитектуре Elm, наконец, что-то щелкнуло у меня в голове. Я понял. Вот это да! Да это же намного лучше, чем JavaScript. Я могу посмотреть на код и с уверенностью предсказывать его поведение, его пограничные случаи и все остальное.

Во-первых, Elm имеет естественную для чистого функционального языка предсказуемость; когда вы пишете Elm, компилятор заставляет вас обдумывать каждый случай. Рассмотрим следующий пример: для своего друга вы пишете некоторое приложение для учета книг в библиотеке. Он хочет возможность получать отчет, в котором бы отображалось, сколько книг находится в каталоге, дата издания самой ранней и самой поздней книги в библиотеке и количество уникальных авторов.

Я могу более подробно рассмотреть этот код. Например, вот этот фрагмент:

Здесь мы используем две библиотечные функции: List.maximum и Maybe.withDefault. Назначение и использовании функции List.maximum очевидны, также его сигнатура типа является показательной.

В данном случае, поскольку наш список имеет тип «List Int», функция возвращает «Maybe Int». Концепция использования Maybe знакома людям пришедшим из Haskell (Maybe), из Rust (Option) или из Java (Optional). Maybe — это контейнер с нулевым (Nothing) или одним (Just x) элементом. Мы можем использовать функцию Maybe.withDefault для «распаковки» значения Maybe, заменяя на значение по умолчанию, если контейнер Maybe пуст.

Таким образом, этот фрагмент кода извлекает максимальное значение в списке copyrightYears, если оно существует. Если же нет, мы просто возвращаем ноль. Elm требует, чтобы вы продумали все пограничные случаи. Вы должны рассмотреть и указать, что произойдет в каждом случае. Именно по этой причине Elm может реально обещать отсутствие исключений во времени выполнения.

Вторая причина, почему Elm лучше, чем JavaScript — это то, что Elm естественно подходит для работы с DOM. Это настолько естественное чувство, что кажется, что HTML был разработан специально для Elm, но не наоборот. Отчасти причина заключается в том, что Elm использует концепцию виртуального DOM, с которой вы можете быть знакомы, если сталкивались с React (именно виртуальный DOM является причиной, почему представление может быть автоматически обновлено с помощью измененной модели приложения. Примечание редактора : В данном случае кажется, что автор заблуждается. Виртуальный DOM нужен для снижения стоимости таких обновлений). Здесь показано то, как мы можем отобразить тип LibraryReport в HTML:

Обратите внимание на то, как мы составили функцию renderRow включающую viewReport. Отображаемый результат:

Разработка с Elm — это сплошная череда приятных сюрпризов: элегантный интерфейс командной строки, полезный при разработке компилятор, интуитивно понятный отладчик.

К числу этих неожиданностей относятся (спойлеры):

Сообщение компилятора, когда вы удалите поле из структуры без обновления связанных с ней функций.

Самыми большими минусами Elm являются то, что:

  1. Это функциональный язык, и поэтому кривая обучения круче для тех программистов, кто пришел из императивных языков.
  2. Вероятно, вы не сможете использовать его на стороне сервера (язык не такой универсальный, как JavaScript).
  3. В нем отсутствуют некоторые высокоуровневые возможности других функциональных языков, таких как в Haskell.
  4. Строгая семантика зависимостей накладывает ограничение на разработчиков библиотек для Elm по немедленному их обновлению, когда зависимости изменились, чтобы не блокировать последующие обновления.
Код ошибки:  Телефоны Sony Ericsson Elm и Hazel расширяют линейку GreenHeart -

Вам кажется, что здесь чего-то не хватает? Даже несмотря на то, что Elm — небольшой язык с небольшим сообществом, это никак не влияет заметным образом на опыт разработки на Elm.

Теперь я решительно отдаю предпочтение Elm для любого нового клиентского веб-приложения. Elm обладает и другими преимуществами, которые лежат на поверхности, такими как высокая производительность, достойная поддержка библиотек, а также продуманный дизайн взаимодействия с JavaScript, но для меня преимущество в Elm — это то, что он дает мне уверенность в моем коде.

Elm компилятор

Заслуживает отдельного пункта. Так как в процессе написания программы в терминале вы видите подробный текст ошибки и «предложения» по исправлению.

Данный инструмент невероятно упрощает рефакторинг. Вы можете исправить модель данных (сердце вашей программы) и затем следовать сообщения компилятора об ошибках, исправляя код везде, где нужно. В конце работы, вы откроете браузер и с удивлением обнаружите, что все работает!

Когда ваша кодовая база растет, возможность удобного наращивания функционала в приложении (разработки новых фич) выходит на первое место. Elm предоставляет для этого удобнейший инструментарий, состоящий из компилятора и … достаточно :)

Причем, речь не только про проверку передан ли тип строка в аргумент функции, который ожидает строку (это и TypeScript умеет). Elm компилятор умеет гораздо больше, так как система типов в Elm гораздо сильнее. Это нужно попробовать.

Elm открывает интересные вакансии

Если вы решили «запрыгнуть в IT» с минимумом знаний, то данная опция для вас сейчас недоступна. Легче выучить что-то популярное и начать битву на выживание среди других, кто поступил так же.

Если вы еще учитесь и вам необходимо выполнить курсовую / диплом с визуальной состовляющей в web — я очень рекомендую присмотреться к Elm.

Если же вы уже умеете программировать и присматриваетесь к тому, чтобы разрабатывать стабильные SPA, которые легко поддерживать — вновь я призываю вас посмотреть на Elm. Что вы получите?

Помимо уже упомянутого выше «расширения кругозора» и стабильной работы приложения, вам станут доступны немногочисленные вакансии в зарубежных компаниях. В СНГ есть люди, кто работает с Elm, но открытых вакансий я не нашел. На сегодня (19 ноября 2021) есть как минимум две (смешно!?) вакансии с релокейтом — в Мюнхен и в Мельбурн. Не так давно, была закрыта вакансия с релокейтом (то есть, переездом с помощью от компании) в США.

На stackoverflow можно найти 4 вакансии на elm (из которых чистый фронтенд — одна).

Не густо, согласен, но позиции предполагают удаленную работу или переезд, что придется по нраву многим.

К тому же, я думаю Elm коммьюнити продолжит расти и со временем будет доступно больше позиций.

Elm позволит вам выделиться на рынке труда. Так же, если вы можете выбирать стэк технологий на работе, вы можете использовать новые знания, для создания бронебойного приложения с любовью к расширению функционала.

Map, filter, reduce

Ramda также имеет свои собственные версии map, filter и reduce. Несмотря на то, что эти функции находятся в Array.prototype в нативном JavaScript, их версии в Ramda каррированные:

Why a functional language?

You can get some benefits from programming in a functional style, but there are some things you can only get from a functional language like Elm:

  • No runtime errors in practice.
  • Friendly error messages.
  • Reliable refactoring.
  • Automatically enforced semantic versioning for all Elm packages.

No combination of JS libraries can give you all of these guarantees. They come from the design of the language itself! And thanks to these guarantees, it is quite common for Elm programmers to say they never felt so confident while programming.

I have put a huge emphasis on making Elm easy to learn and use, so all I ask is that you give Elm a shot and see what you think. I hope you will be pleasantly surprised!

Безопасности

Другая большая выгода вяза — безопасность, которую это обеспечивает. Полностью избегая возможности значения NULL, это заставляет нас обрабатывать все альтернативные пути в приложении.

Например, в JavaScript (и многих других языках) вы можете получить ошибки времени выполнения, выполнив что-то вроде:

var list =[] list[1]*2

Это вернет NaN в JavaScript, который вы должны обработать, чтобы избежать ошибки во время выполнения.

Если вы попробуете нечто подобное в Elm:

list =[](List.head list)*2

Компилятор отклонит это, сообщив, что List.head list возвращает тип Maybe . Тип Maybe может содержать или не содержать значение, мы должны обработать случай, когда значением является Nothing .

(Maybe.withDefault1(List.head list))*2

Это дает нам большую уверенность в наших приложениях. Очень редко можно увидеть ошибки времени выполнения в приложениях Elm.

Будущее

Невозможно предугадать, что принесёт с собой завтрашний день, но мы можем произвести некоторые грамотные предположения. Вот некоторые из моих:

Произойдёт окончательный переход к языкам, компилируемым в JavaScript.

Идеи функционального программирования, витающие вокруг да около на протяжении сорока лет, заново откроют себя, чтобы решить наши насущные проблемы сложности программного обеспечения.

Состояние аппаратного обеспечения, в частности гигабайты дешёвой памяти и быстрые процессоры, сделает функциональные методы жизнеспособными.

Центральные процессоры не станут работать быстрее, но количество ядер будет продолжать расти.

Изменяющееся состояние будет осмысленно, как одна из основных проблем сложных систем.

Я написал эту серию статей, потому что верю, что за функциональным программированием будущее и потому что последнюю пару лет прикладывал все усилия, чтобы освоить его (и я всё ещё учусь).

Моей целью являлось помочь другим освоить все эти концепты легче и быстрее, чем мне самому, и помочь другим поднять их уровень в программировании, чтобы они стали более востребованными специалистами.

Даже если мой тезис о том, что Elm станет весомым языком в будущем, неверен, я могу сказать с достаточной уверенностью, что функциональное программирование и Elm находятся на одной траектории с движением будущего.

Я надеюсь, что после прочтения этих статей, вы чувствуете себя более уверенными в своих способностях и понимаете эти идеи.

Желаю вам удачи в ваших будущих начинаниях.

Бэкэнд

Elm официально не поддерживает разработку на стороне сервера. Основная команда разработчиков не считает это своей основной целью и предпочитает сосредоточить разработку на улучшении опыта фронтенд-разработки. Тем не менее, есть несколько независимых проектов, которые пытаются изучить возможности использования Elm в качестве серверной части.

Проекты в основном застряли на Elm версии 0.18.0, так как более новые не поддерживают «родной» код и некоторые другие используемые функции. Есть две попытки использовать Elm с BEAM (виртуальная машина Erlang). Один из проектов выполняет Elm непосредственно в среде, а другой компилирует его в Elixir.

В elm нет runtime exception

То есть, ошибок, которые возникли во время работы вашей программы. Прощайте undefined is not a function. Еще раз — никаких undefined! В Elm, так же нет null, типа, который считается «большой ошибкой» в дизайне языка. Есть противники и сторонники данного подхода, мне хватает и того, что нет undefined;)

Как это обстоит на практике? Вы пишите код на elm, затем запускается компилятор, который проверяет ваш код (привет, Turbo Pascal), затем если проверка прошла успешно — программа выполняется. Такая программа (в нашем случае это js файл) не должна «неожиданно упасть», так как прошла проверку. На деле, все так и есть. Наше приложение стабильно.

Заметьте, здесь нет гарантии, что все будет работать так как вы задумали. Код по прежнему пишите вы. Вы можете ошибиться в логике, но при этом, ваше приложение будет работать. Вы не увидите в консоли красный текст: Uncaught error exception….

Я знаю, таким образом вам Elm «не продать», но поверьте, если вы начнете писать на Elm, то первым делом, когда привыкнете и вам нужно будет написать js — вы испытаете шок от давно забытой в консоли ошибки про то, что undefined — не функция и «все упало».

Вернуться к вязу

Все это отличные шаблоны, которые делают приложение более надежным, предсказуемым и обслуживаемым. Однако, чтобы правильно использовать их в JavaScript, мы должны быть осторожны, чтобы не делать некоторые вещи в неправильных местах (например, изменять состояние внутри компонента).

Код ошибки:  Цифровая приборная панель на автомобиль своими руками | «Автофил» — автомобильный журнал

Elm — это язык программирования, который был создан с самого начала с учетом многих из этих шаблонов. Это делает естественным принятие и использование их, не беспокоясь о неправильных действиях.

В Elm мы создаем приложения, используя:

  • Неизменные данные
  • Чистые взгляды, которые описывают DOM
  • Однонаправленный поток данных
  • Централизованное государство
  • Централизованное место, где описаны мутации данных
  • Содержатся побочные эффекты

Веселье в elm

Elm — функциональный язык программирования. Разобравшись с данным подходом в рамках elm, вы сможете лучше использовать «функциональщину» в ваших текущих javascript приложениях или же продолжите изучать другие языки программирования в поисках того инструмента, который позволит разрабатывать приложения с азартом.

Elm учит новой парадигме: думать о модели данных в первую очередь, подбирать такую модель, которая изначально покроет только возможные состояния приложения, не больше ни меньше. Больше о подобном подходе можно узнать из доклада «Делайте невозможное состояние не возможным«, от Elm-евангелиста Richard Feldman.

Elm — это новый вызов, если вы «подустали» от стабильности или от того, что вы как рыба в воде, не видите новых вершин для покорения в js коде.

Если вы пишите на elm, то вам не нужно настраивать много инструментов для форматирования и проверки (типа eslint и prettier). В elm мире, есть один пакет elm-format, который не имеет настроек. Код у всех выглядит одинаково, не о чем спорить.

Так или иначе, знакомство с языком не пройдет бесследно, а внедрение его на ваш рабочий проект можно провести по частям, монтируя elm-приложение в определенный div, как это было с реактом, когда переписывались старые приложения.

Вяз архитектура

Elm Architecture — это шаблон для создания интерактивных веб-приложений. Приложения Elm естественно строятся таким образом, но другие проекты могут найти эту концепцию полезной.

Программа Elm всегда делится на три части:

  • Модель — состояние приложения
  • Просмотр — функция, которая превращает модель в HTML
  • Обновление — функция, обновляющая модель на основе сообщений

Это ядро ​​Elm Architecture.

Например, представьте себе приложение, которое отображает число и кнопку, увеличивающую число при нажатии. В этом случае все, что нам нужно сохранить, — это одно число, поэтому наша модель может быть такой же простой, как type alias Model = Int. viewФункция будет определена с Htmlбиблиотекой и отображение номера и кнопки.

Чтобы номер обновлялся, нам нужно иметь возможность отправлять сообщение updateфункции, что осуществляется с помощью настраиваемого типа, например type Msg = Increase. IncreaseЗначение прикрепили его к кнопке , определенной в viewфункции таким образом, что при нажатии кнопки пользователем, Increaseпередается в updateфункцию, которая может обновить модель за счет увеличения числа.

В архитектуре Elm отправка сообщений update- единственный способ изменить состояние. В более сложных приложениях сообщения могут поступать из различных источников: взаимодействие с пользователем, инициализация модели, внутренние вызовы update, подписки на внешние события (изменение размера окна, системные часы, взаимодействие JavaScript …), а также изменения и запросы URL-адресов.

Вяз синтаксис

Синтаксис Elm напоминает Haskell , так как оба являются языками семейства ML.

greeting :String->String greeting name ="Hello"   name

Это функция, которая принимает String и возвращает другую String .

Если заинтересовались:

Все материалы на английском:

Материалы на русском тоже имеются, но маловато (я помогу с этим :D). Пока что можно поискать на хабре.

Зачем использовать вяз?

Чтобы понять, почему вы должны заботиться о Elm, давайте поговорим о некоторых тенденциях внешнего интерфейса в последние пару лет:

История

Изначально Elm был разработан Эваном Чаплицки в качестве его диссертации в 2021 году. Первый выпуск Elm сопровождался множеством примеров и онлайн-редактором, который упростил работу в веб-браузере . Эван присоединился к Prezi в 2021 году, чтобы работать над Elm, а в 2021 году перешел в NoRedInk в качестве инженера с открытым исходным кодом, также основав Elm Software Foundation.

Первоначальная реализация компилятора Elm нацелена на HTML , CSS и JavaScript . Набор основных инструментов продолжал расширяться, теперь он включает REPL , диспетчер пакетов , отладчик, путешествующий во времени, и установщики для macOS и Windows.

Каррирование и композиция

Раннее, в одной из предыдущих частей, мы научились писать каррированные функции. Вот более сложный пример по этому поводу:

Обратите внимание, что нам пришлось написать каррированный фрагмент функции вручную.

И, чтобы вызвать f, мы должны написать:

Но круглых скобок здесь достаточно, чтобы заставить плакать Lisp-программиста.

Существует множество библиотек, облегчающих задачу каррирования. Одна из моих любимых — Ramda.

Использование Ramda теперь позволяет нам написать:

Определение функции стало выглядеть не намного лучше, зато теперь нам удалось избавиться от нужды во всех этих круглых скобках. Заметьте, что мы можем применять угодное нам количество параметров, когда вызываем f: столько же или всего несколько.

Используя Ramda, мы можем переписать функцию mult5AfterAdd10 из Части 3 и Части 4:

Модульная система

У Elm есть модульная система, которая позволяет пользователям разбивать свой код на более мелкие части, называемые модулями. Модули могут скрывать детали реализации, такие как вспомогательные функции, и группировать связанный код вместе.

Модули служат пространством имен для импортированного кода, например Bitwise.and. Сторонние библиотеки (или пакеты) состоят из одного или нескольких модулей и доступны в публичной библиотеке Elm . Все библиотеки версируются в соответствии с semver , который обеспечивается компилятором и другими инструментами. То есть удалить функцию или изменить ее тип можно только в основной версии.

Недостатки javascript

Со всеми библиотеками и расширенными средствами языка, которые получил JavaScript, он остаётся страдать из-за того факта, что является императивным языком программирования, пытающимся быть всем и для всех.

Большинство фронтенд-разработчиков застряли на одном месте, используя JavaScript для браузера, потому что он долгое время оставался единственным вариантом. Но сейчас многие разработчики уходят от написания JavaScript-кода напрямую.

Вместо этого они пишут на других языках и компилируют или, выражаясь точнее, транспилируют их в JavaScript.

Одним из первым таких языков был CoffeeScript. Сейчас на вооружение Angular 2 (прим. пер., «сейчас» актуально для Angular 5) был принят TypeScript. Транспилятором для JavaScript является Babel.

Всё больше и больше людей прибегают к такому подходу в продакшене.

Но все эти языки начинали с JavaScript и только сделали его немного лучше. Почему бы не пойти до конца и не транспилировать JavaScript из чистого функционального языка?

Неизменность

Все значения в Elm неизменяемы , что означает, что значение не может быть изменено после его создания. Elm использует постоянные структуры данных для реализации своих массивов, наборов и словарей в стандартной библиотеке.

Неизменные данные

Изменчивые данные сильно затрудняют ограничение места их изменения, поскольку любой компонент, имеющий к ним доступ, может что-то добавить или удалить. Это приводит к непредсказуемости, так как состояние может измениться где угодно.

Используя неизменные данные, мы можем избежать этого, строго контролируя, где изменяется состояние приложения. Объединение неизменяемых данных с функциями, описывающими преобразования, дает нам очень надежный рабочий процесс, а неизменные данные помогают нам обеспечивать однонаправленный поток, не позволяя нам изменять состояние в неожиданных местах.

Неизменяемость

Первая вещь, принимаемая во внимание — это неизменяемость. В ES2021 или ES6, как он ещё называется, появилось новое ключевое слово для объявления переменных — const. Оно означает, что если переменная была установлена однажды, она не может быть переопределена:

Здесь a определена как константа и по этой причине не может быть изменена после установки. Вот почему выражение a = 2 выбрасывает ошибку.

Проблема const в том, что в JavaScript она не заходит в своей идее так далеко, как должна. Следующий пример проиллюстрирует её предел:

Заметьте, что a.x = 2 НЕ выбрасывает исключения. Единственное значение, остающееся неизменяемым с const – это сама переменная a. Всё, что a в себе определяет, может быть изменено.

Это ужасное разочарование, потому что отсутствие такого недостатка сделало бы JavaScript гораздо лучше.

Как же мы можем достичь полной неизменяемости в JavaScript?

К сожалению, это возможно только с помощью библиотеки Immutable.js. Она должна дать нам должный уровень неизменяемости, но, увы, её использование также сделает наш код больше похожим на Java, чем на JavaScript.

Код ошибки:  Проект ОБД-56

Немного деталей про elm

Elm шустрый. По тестам — работает быстрее. Размер билда меньше. Данные об этом есть на главной странице elm-lang.

На практике — писать получается с комфортом, так как компилятор в терминале висит и ругается (причем, очень тактично, об этом еще поговорим), если что-то пошло не так. В браузер стоит переключиться, если стадия компиляции прошла успешно и настал момент увидеть результат.

Конечно, в начале писать получается, не то чтобы медленно. Не получается, вообще. Мне было трудно понять новый язык. Однако, бытует мнение, что в Elm не так уж и сложно «въехать», особенно если вы проходите стажировку в компании, что подтверждено в нескольких компаниях, если верить подкасту Elm Town.

Ограничения

Elm не поддерживает полиморфизм более высокого порядка , который предлагают родственные языки Haskell и PureScript , а также не поддерживает создание классов типов .

Это означает, что, например, у Elm нет универсальной mapфункции, которая работает с несколькими структурами данных, такими как Listи Set. В Elm такие функции обычно вызываются с указанием имени модуля, например, вызывая List.mapи Set.map.

Другим результатом является большой объем шаблонного кода в проектах среднего и большого размера, как показано автором «Вяза в действии» в их примере одностраничного приложения, при этом почти идентичные фрагменты повторяются в функциях обновления, просмотра, подписок, синтаксического анализа маршрута и построения. .

Однонаправленный поток данных

Еще одна интересная тенденция — однонаправленный поток событий всех наших приложений. Вместо того, чтобы позволить любому компоненту общаться с любым другим компонентом, мы отправляем сообщение через центральный конвейер сообщений.

Делая это, мы получаем больше видимости всех взаимодействий, которые происходят в нашем приложении.

Опишите состояние вместо преобразования dom

Недавно мы создавали приложения, изменяя DOM вручную (например, используя jQuery). По мере роста нашего приложения мы вводим больше состояний. Необходимость кодирования преобразований между ними экспоненциально увеличивает сложность нашего приложения, усложняя его обслуживание.

Вместо того чтобы делать это, такие библиотеки, как React , популяризировали идею сосредоточения внимания на описании определенного состояния DOM, а затем позволяли библиотеке обрабатывать преобразования DOM для нас. Мы сосредоточены только на описании дискретных состояний DOM, а не на том, как мы туда доберемся.

Это приводит к существенно меньшему количеству кода для написания и поддержки.

События и преобразование данных

Когда дело доходит до состояния приложения, обычным делом является изменение состояния самостоятельно, например, добавление комментариев в массив.

Вместо того, чтобы делать это, мы можем только описать, как состояние приложения должно меняться в зависимости от событий, и позволить другому применить эти преобразования для нас. В JavaScript Redux сделал популярным этот способ создания приложений.

Преимущество этого состоит в том, что мы можем написать «чистые» функции для описания этих преобразований. Эти функции легче понять и проверить. Дополнительным преимуществом является то, что мы можем контролировать, где изменяется состояние нашего приложения, что делает наши приложения более удобными в обслуживании.

Другое преимущество заключается в том, что нашим представлениям не нужно знать, как изменять состояние, им нужно только знать, какие события отправлять.

Совместимость с html, css и javascript

Elm использует абстракцию, называемую портами, для связи с JavaScript . Он позволяет значениям поступать в программы Elm и исходить из них, что делает возможным взаимодействие между Elm и JavaScript.

У Elm есть библиотека elm / html, которую программист может использовать для написания HTML и CSS в Elm. Он использует подход виртуальной DOM для повышения эффективности обновлений.

Ссылки

Как только страница обновилась в Википедии она обновляется в Вики 2.Обычно почти сразу, изредка в течении часа.

Статические типы

Вяз статически типизирован. Аннотации типов не являются обязательными (из-за вывода типов), но настоятельно рекомендуется. Аннотации находятся в строке над определением (в отличие от языков семейства C, где типы и имена перемежаются). Elm использует единственное двоеточие для обозначения «имеет тип».

Типы включают примитивы, такие как целые числа и строки, и базовые структуры данных, такие как списки, кортежи и записи. Например, функции имеют типы, написанные стрелками round : Float -> Int. Настраиваемые типы позволяют программисту создавать настраиваемые типы для представления данных в соответствии с предметной областью.

Типы могут относиться к другим типам, например к файлу List Int. Типы всегда пишутся с заглавной буквы; Имена в нижнем регистре — это переменные типа. Например, a List a- это список значений неизвестного типа. Это тип пустого списка и аргумента List.length, который не зависит от элементов списка.

Есть несколько специальных типов, которые программисты создают для взаимодействия со средой выполнения Elm. Например, Html Msgпредставляет (виртуальное) дерево DOM, все обработчики событий которого создают сообщения определенного типа Msg.

Вместо того, чтобы разрешать любому значению быть неявно допускающим значение NULL (например, JavaScript undefinedили нулевой указатель ), стандартная библиотека Elm определяет Maybe aтип. Код, который создает или обрабатывает необязательное значение, делает это явно с использованием этого типа, а для всего остального кода гарантируется, что значение заявленного типа действительно присутствует.

Elm предоставляет ограниченное количество встроенных классов типов : numberчто включает в себя Intи Floatдля облегчения использования числовых операторов, таких как ( )или (*), comparableкоторый включает числа, символы, строки, списки сопоставимых объектов и кортежи сопоставимых объектов для облегчения использования сравнения. операторы, и appendableкоторый включает строки и списки для облегчения конкатенации с ( ).

Типы в elm

Помимо того, что нам привычно: строки, числа, объекты, массивы, в Elm можно создать свой тип данных.

WAT?

В начале — непонятно, что это такое и зачем. Но, когда втянешься…

Расскажу вам любимый пример из «интернетов»:

Стандартный запрос за списком новостей в redux:

В чем здесь проблема? В том, что у нас изначально в data — пустой массив. То есть, на этапе загрузки приложения мы увидим: «нет новостей», а затем прелоадер и затем новости.

Если же новостей на сервере нет — вновь увидим «нет новостей».

Проблема на данный момент в том, что мы плохо спроектировали модель данных, в которой нет разницы для ситуаций: «мы еще не запросили новости», и «запрос вернулся, новостей нет».

Проблема легко решаема, конечно. Можно установить data в null на начальном этапе, можно добавить дополнительный флаг в стиле «был ли запрос за данными» и т.д.

А можно, сделать свой тип! В котором мы модель данных новостей укажем следующую:

При таком раскладе отрисовать текущее состояние приложения становится заметно проще.

Функции

Elm имеет небольшой набор языковых конструкций, включая традиционные if-выражения, let-выражения для локального состояния и case-выражения для сопоставления с образцом . Как функциональный язык, он по умолчанию поддерживает анонимные функции , функции в качестве аргументов и частичное приложение.

Его семантика включает неизменяемые значения, функции без состояния и статическую типизацию с выводом типа. Программы Elm визуализируют HTML через виртуальную модель DOM и могут взаимодействовать с другим кодом, используя «JavaScript как услугу».

Функциональный javascript

JavaScript имеет множество фич, позволяющих вам программировать на более функциональный манер. Полной чистоты не будет, но вы можете добиться некоторой неизменяемости с помощью самого языка и ещё большей с помощью библиотек.

Идеально не будет, но если вам нужно использовать функциональные возможности, тогда почему бы не привлечь некоторые преимущества языка?

Централизованное государство

Еще одной тенденцией в развитии внешнего интерфейса является использование централизованного «атома» для сохранения всего состояния. Это означает, что мы помещаем все состояния в одно большое дерево, а не разбрасываем его по компонентам.

В типичном приложении мы обычно имеем глобальное состояние приложения (например, совокупность пользователей) и специфическое состояние компонента (например, состояние видимости конкретного компонента). Это является спорным ли хранить оба вида состояния в одном месте выгодно или нет.

Чистые компоненты

Еще одной тенденцией является использование чистых компонентов. Это означает, что при одинаковых входных данных компонент всегда будет отображать одинаковые выходные данные. Внутри этих компонентов не происходит побочных эффектов.

Это делает понимание и тестирование наших компонентов намного проще, чем раньше, поскольку они более предсказуемы.

Вывод

Elm — это захватывающий язык программирования, который включает в себя отличные шаблоны для создания надежных приложений. Он имеет краткий синтаксис, с большой встроенной безопасностью, которая позволяет избежать ошибок во время выполнения.

Кривая обучения тому, как структурировать приложение Elm, не тривиальна, поскольку приложения, использующие функциональное реактивное программирование, отличаются от того, к чему мы привыкли, но они того стоят.

Оцените статью
OBD
Добавить комментарий