Перегляд вихідного коду сторінки Erlang

{{Infobox programming language
| name = Erlang
| logo = [[Файл:Erlang logo.png|200px]]
| year = 1987
| paradigm = [[Багатопарадигмова мова програмування|мультипарадигмальна]]: [[паралельне програмування|паралельна]], [[функційне програмування|функційна]]
| developer = [[Ericsson]]
| latest_release_version = 25
| latest_release_date = {{Start date and age|2022|06|18|df=yes}}
| operating_system = [[Багатоплатформність|багатоплатформова]]
| typing = [[динамічна типізація]],[[Сильна і слабка типізація|сильна типізація]]
| genre = [[мова програмування]], [[інтерпретатор]]
| influenced_by = [[Пролог (мова програмування)|Prolog]], [[Smalltalk]] [[Lisp]], [[PLEX]]
| influenced = [[F Sharp|F#]], [[Clojure]], [[Rust (мова програмування)|Rust]], [[Scala]], [[Opa (мова програмування)|Opa]], [[Reia (мова програмування)|Reia]],[[Akka]], [[Dart]], [[Elixir (мова програмування)|Elixir]], [[Oz]],[[Go (мова програмування)|Go]]
| dialects =
| file_ext = .erl, .hrl
| license = [[Apache License|Apache 2.0]]
| website = {{url|http://www.erlang.org}}
}}'''Erlang''' (Ерла́нґ /ˈɜːrlæŋ/ ''UR-lang'') — [[мова програмування|мова]] [[функційне програмування|функційного програмування]] з [[система типізації|динамічною типізацією]], призначена для розробки програм для різного роду [[розподілені обчислення|розподілених]] і [[багатонитевість|багатониткових]] систем. Розроблена і підтримується компанією [[Ericsson]]. Мова містить в собі засоби породження паралельних [[Процес (інформатика)|процесів]] та їхньої [[взаємодія між процесами|взаємодії]] за допомогою посилання [[обмін повідомленнями|асинхронних повідомлень]], без використання блокувань.

Мова орієнтована на розробку розподілених відмовостійких [[застосунок|застосунків]], які забезпечують паралельну обробку запитів в [[Система реального часу|режимі реального часу]]. Мова набула поширення в таких областях, як [[телекомунікація|телекомунікації]], [[Банківська система|банківські системи]], [[електронна комерція]], [[IP-телефонія|комп'ютерна телефонія]] і організація [[миттєві повідомлення|миттєвого обміну повідомленнями]].

Програма транслюється в [[байт-код]], який виконується [[віртуальна машина|віртуальною машиною]], що забезпечує переносність. Одночасно розробниками випускається OTP (Open Telecom Platform)&nbsp;— супутній набір [[бібліотека програм|бібліотек]] і компонентів для розробки розподілених систем на мові Erlang. Код проєкту поширюється під модифікованою вільною ліцензією [[Mozilla Public License|MPL]].

Свій синтаксис і деякі концепції, мова Erlang успадкувала від мови логічного програмування [[Пролог (мова програмування)|Пролог]]. Мова підтримує [[зіставляння зі взірцем]], обробку виключень, спискові та бінарні генератори, [[Анонімна функція|анонімні функції]], [[Функція вищого порядку|функції вищого порядку]], обмін повідомленнями між процесами. Препроцесор підтримує роботу з [[макрос]]ами і включення заголовкових файлів.

Популярність мови Erlang зросла у зв'язку з розширенням області використання ([[Телекомунікації|телекомунікаційні системи]]) на паралельні розподілені системи з високим навантаженням, які обслуговують мільйони користувачів [[Всесвітнє павутиння|WWW]], такі як [[чат]]и, [[системи керування веб-контентом]], веб-сервери і розподілені [[База даних|бази даних]], що вимагають масштабування. Erlang використовуються в деяких [[NoSQL]]-базах даних [[Висока доступність|високої доступності]]<ref>{{Cite news|title=Programming in Constructive Set Theory|url=http://dx.doi.org/10.1145/800223.806773|publisher=ACM Press|work=Proceedings of the 1981 conference on Functional programming languages and computer architecture - FPCA '81|date=1981|accessdate=2022-08-16|doi=10.1145/800223.806773|first=Bengt|last=Nordström}}</ref>.

== Назва та історія ==

Серед малообізнаних з історією мови Erlang людей поширена думка, що назва «'''Erlang'''» розшифровується як '''ER'''icsson '''LANG'''uage. Насправді мова отримала свою назву на честь {{Нп|Агнер Краруп Ерланг|Агнера Крарупа Ерланга||Agner Krarup Erlang}}, данського математика, який працював у галузі [[телекомунікації|телекомунікацій]]. Існує одиниця вимірювання телекомунікаційного трафіку, яка також називається {{Нп|Erlang (одиниця виміру)|Erlang||Erlang (unit)}}.<ref>[http://www.rsdn.ru/article/erlang/GettingStartedWithErlang.xml#ENB Начала работы с Erlang] {{Webarchive|url=https://web.archive.org/web/20131122131040/http://www.rsdn.ru/article/erlang/GettingStartedWithErlang.xml#ENB |date=2013-11-22 }} {{ref-ru}}</ref>

На створення Erlang вплинули [[ML]], {{iw|Miranda (мова програмування)|Miranda||Miranda (programming language)}}, [[Ada]], {{iw|Модула-2|||Modula-2}}, [[CHILL (мова програмування)|CHILL]], [[Пролог (мова програмування)|Пролог]]. Окрім того, на спосіб оновлення програмного забезпечення вплинули [[Smalltalk]] і пропрієтарні мови EriPascal та PLEX, якими послуговувались в Ericson<ref name=":0">{{Cite book
|title=History of Erlang. HOPL III: Proceedings of the third ACM SIGPLAN conference on History of programming languages.
|last=Armstrong
|first=Joe
|year=2007
|language=англійська
|isbn=ISBN 978-1-59593-766-7
}}</ref>.

Мова Erlang була створена в [[1986]] році в лабораторії компанії [[Ericsson]] спільно [[Джо Армстронг (програміст)|Джо Армстронгом]] (Joe Armstrong), [[Роберт Вірдінг|Робертом Вірдінгом]] (Robert Virding) і [[Майк Вільямс|Майком Вільямсом]] (Mike Williams), і в [[1998]] році переведена в розряд [[відкрите програмне забезпечення|відкритих проєктів]]. Завдяки початковій орієнтації на створення [[застосунок|застосунків]] для [[паралельні обчислення|паралельної обробки]] запитів в режимі реального часу мова набула поширення в таких областях як [[телекомунікації]], [[банківські системи]], [[електронна комерція]], [[комп'ютерна телефонія]] і організація [[миттєві повідомлення|миттєвого обміну повідомленнями]]<ref name=":8">{{Cite web|url=http://erlang.org/course/history.html|title=Erlang.org.|website=erlang.org|language=англійська}}</ref>.
[[Файл:Robert Virding and Joe Armstrong, 2013.jpg|міні|Роберт Вірдінг та Джо Армстронг, 2013 рік]]

У 1998 році [[Вище керівництво|топ-менеджмент]] Ericsson вирішив не брати на себе зобов'язань з розробки та підтримки власної мови програмування, натомість зосередившись на [[Java]]. Використання Erlang було заборонено у нових проєктах Ericsson Radio AB у зв'язку з реалізацією плану [[аутсорсинг]]у програмної технології компанії Rational Inc.<ref>{{Cite book
|title=Concurrent Functional Programming for Telecommunications: A Case Study of Technology Introduction
|last=Däcker
|first=Bjarne
|year=2000
|publisher=Royal Institute of Technology
|pages=37
|language=англійська
}}</ref>

Це рішення дуже сильно вплинуло на майбутнє Erlang: воно призвело до відкриття коду Erlang під [[Відкрите програмне забезпечення|відкритою]] ліцензією EPL (аналог [[Mozilla Public License]]), а також послужило головною причиною початку поширення мови за межами компанії, що його створила. Основним запереченням проти відкриття вихідного коду було вирішення питань щодо патентів, але ці труднощі були подолані. Незабаром багато хто з основних розробників покинув Ericsson, щоб організувати власний бізнес&nbsp;— Bluetail AB.<ref name=":0" />

На початку 2000-х років наукові кола стали виявляти інтерес до Erlang. З 2002 року став проводитись щорічний Erlang Workshop. Ericsson продовжував спонсорувати проєкт HiPE (від {{Lang-en|High-Performance Erlang}}&nbsp;— високопродуктивний Erlang). Проєкт HiPE займався ефективною реалізацією мови та інструментами для перевірки типів, і створений у групі проєкту компілятор в машинний код, який входить у постачання версії Erlang/OTP, вільно розповсюджується з 2001 року. Роботи, пов'язані з Erlang, ведуть інші заклади вищої освіти. Інструменти для [[рефакторинг]]у створені в Кентському університеті у Великій Британії та [[Будапештський університет|університеті Лоранда Етвеша]] в Угорщині, інструменти для різних видів [[Тестування програмного забезпечення|тестування]]&nbsp;— у Мадридському політехнічному університеті, [[Технічний університет Чалмерса|технічному університеті Чалмерса]] та [[Гетеборзький університет|Гетеборгському університеті]].

Коли системи з симетричною багатопроцесорністю тільки починали завойовувати ринок серверів і настільних комп'ютерів, кидаючи виклик розробникам програмного забезпечення, вже в 2006 перша версія Erlang з підтримкою [[Симетрична мультипроцесорність|SMP]] була випущена спільними зусиллями команди OTP з Ericsson і команди HiPE. Незабаром після цього вийшла перша майже за десятиліття велика монографія з Erlang: «Programming Erlang» Джо Армстронга, після чого багато розробників «відкрили» для себе Erlang/OTP, і мова стала набирати популярності.<ref>{{Cite book
|title=Erlang – a platform for developing distributed software systems
|last=Fredlund
|first=Lars-Åke
|year=2012
|publisher=Universidad Politécnica de Madrid
|location=Madrid
|language=англійська
}}</ref>

Процес розвитку мови включає в себе розгляд пропозицій з розвитку EEP (<span lang="en" style="font-style:italic;">Erlang Enhancement Proposal</span>). За допомогою цих пропозицій Erlang-спільнота вносить зміни у стандартну подачу Erlang. З внесеними пропозиціями можна ознайомитися на веб-сторінці [https://www.erlang.org/eeps erlang.org/eeps.]

== Філософія ==
За свідченнями Майка Вільямса, Erlang створювався для вирішення трьох проблем розробки [[Розподілена система|розподілених]] [[Операційна система реального часу|систем м'якого реального часу]] з високим ступенем [[Рівночасність (інформатика)|паралелізму]]:
* можливості швидкої та ефективної розробки ПЗ;
* отримання системи, стійкої до програмних та апаратних збоїв;
* можливості оновлення системи «на льоту», без простою обладнання.

За словами Вільямса, філософія, якої дотримувались розробники Erlang, пасує і для написання [[Програмне забезпечення|програмного забезпечення]] цією мовою:<ref name=":1">{{Cite book
|title=Erlang Programming
|last=Cesarini
|first=Francesco
|year=2009
|publisher=O’Reilly Media, Inc
|pages=498
|language=англійська
|isbn=ISBN 978-0-596-51818-9.
}}</ref>

{{цитата|''
* Знайдіть правильні методи. Проєктуйте з використанням прототипів.                      
* Самих лише ідей недостатньо: треба вміти їх реалізовувати і знати, що вони працюють.
* Робіть помилки в невеликому масштабі, а не у виробничому проєкті.
''
{{oq|en|''
* Find the right methods — Design by Prototyping.
* It is not good enough to have ideas, you must also be able to implement them and know they work. 
* Make mistakes on a small scale, not in a production project.
''}}
}}

Більшість мов, створених раніше за Erlang, були розроблені без попереднього знаходження застосування, тоді як Erlang був розроблений спеціально на основі вимог до розподілених, стійких до відмов, паралельних систем реального часу. З розвитком Інтернету виявилося, що багато програм мають аналогічні вимоги, що пояснює зростання інтересу до мови.<ref name=":2">{{Cite book
|title=Introducing Erlang.
|url=https://archive.org/details/introducingerlan00laur
|last=St. Laurent
|first=Simon
|year=2013
|publisher=O’Reilly Media, Inc
|pages=[https://archive.org/details/introducingerlan00laur/page/n200 185]
|language=англійська
|isbn=ISBN 978-1-449-33176-4.
}}</ref>

Секрет високої стійкості до відмов полягає у використанні ізольованих один від одного легких процесів, пов'язаних лише механізмом обміну повідомленнями та сигналами виходу. Принципи розробників на Erlang стосовно обробки помилкових ситуацій у процесах, можна виразити у вигляді висловлювання: «[http://stratus3d.com/blog/2020/01/20/applying-the-let-it-crash-philosophy-outside-erlang/#:~:text=The%20Let%20It%20Crash%20philosophy%20is%20an%20approach%20to%20error,certain%20faults%20to%20go%20unhandled. Let it crash]»<ref>{{Cite web|title=Let It Crash|url=https://verraes.net/2014/12/erlang-let-it-crash/|website=Mathias Verraes' Blog|date=2014-12-09|accessdate=2022-10-11|language=en|first=Mathias|last=Verraes}}</ref>. Пов'язано це з тим, що в Erlang-системі легко стежити за завершенням процесу, завершувати процеси, пов'язані зі збоями, і запускати нові процеси.<ref>{{Cite book
|title=Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages
|url=https://archive.org/details/sevenlanguagesin00tate
|last=Tate
|first=Bruce A
|year=2010
|publisher=Pragmatic Bookshelf
|language=англійська
}}</ref>

== Особливості ==

Синтаксис успадкований від мови [[Prolog]]. Підтримує [[модульне програмування|модулі]], [[поліморфізм (програмування)|поліморфні функції]], зіставлення за шаблоном, [[Анонімна функція|анонімні функції]], умовні конструкції, структури, [[обробка винятків|обробку винятків]], оптимізацію [[Хвостова рекурсія|хвостової рекурсії]].

Головна риса Erlang&nbsp;— модель легких процесів. Процеси є дешевими, їхнє створення вимагає таку кількість ресурсів, що їх можна порівняти з викликом функції. Єдиним способом взаємодії процесів є асинхронний обмін повідомленнями. Процес може встановити зв'язок (link) з іншими процесами і за вибором або отримувати повідомлення про їхнє дострокове завершення з вказанням причини або розділити їхню долю. Процес має свою «поштову скриню», звідки може вибірково читати повідомлення. Мова програмування Erlang сприяє створенню великої кількості [[Конкуррентність|конкурентних]] процесів. Процеси ізольовані та не мають спільного стану.

Процес проєктування полягає в ітеративному розбитті системи на ієрархії підсистем, які конкурентно взаємодіють, доки складові не стануть достатньо простими для реалізації.

Сув'язь «Процеси + повідомлення» на відміну від сув'язі «Об'єкти + Інтерфейси + Успадкування» часто дає компактніші рішення. Відсутність потреби блокування доступу до стану процесу для синхронізації їхньої взаємодії суттєво спрощує програмування. Для конкурентного ресурсу зазвичай створюється процес-монітор, через який здійснюється взаємодія з ресурсом.

Також важливий момент полягає у формулі «let it crash» («нехай процес впаде»). Замість перехоплювати помилки і намагатися продовжувати роботу, частина програми, що містить ризикований код, відокремлюється у незалежний процес-камікадзе, який система вбиває у випадку виникнення помилки, при цьому батьківський процес отримує повідомлення про смерть нащадків і, за потреби, може перезапускати ці процеси. Такий підхід позбавляє код численних перевірок.

==== Високорівневі конструкції ====
Erlang є [[Декларативне програмування|декларативною мовою програмування]], яка використовується більше для опису того, ''що'' має бути обчислено, ніж ''як''. Наприклад, визначення функції, яке використовує [[Зіставляння зі взірцем|зіставлення зі зразком]] для вибору одного з варіантів обчислення або вилучення елемента даних зі складової структури нагадує [[рівняння]]. [[Зіставляння зі взірцем|Зіставлення зі взірцем]] поширене навіть на бітові рядки, що спрощує реалізацію телекомунікаційних протоколів.<ref name=":1" />

[[функція|Функції]] є [[Об'єкт першого класу|об'єктами першого класу]] Erlang. У мові також широко застосовуються характерні для [[Функційне програмування|функціональної парадигми]] програмування [[Спискові вирази|спискові включення]] (генератори списків).<ref name=":1" />

==== Паралельні обчислення ====
[[Файл:Обмін повідомленнями в мові Erlang.png|міні|421x421пкс|Обмін повідомленнями в мові Erlang]]
Особливістю мови Erlang є застосування '''''легковагих процесів''''' відповідно до [[Модель акторів|моделі акторів]]. Такий підхід дозволяє виконувати одночасно сотні тисяч і навіть мільйони таких процесів, кожен з яких може мати скромні вимоги до [[Оперативна пам'ять|пам'яті]]. Процеси ізольовані один від одного і не мають загального стану, але між ними можна встановити зв'язок та отримувати повідомлення про їхній стан.<ref name=":1" />

Для взаємодії процесів використовують асинхронний обмін повідомленнями. Кожен процес має свою [[Черга (структура даних)|чергу]] повідомлень, обробка якої використовує [[Зіставляння зі взірцем|зіставлення із взірцем]]. Процес, що надіслав повідомлення, не отримує повідомлення про доставку, навіть якщо ідентифікатор процесу одержувача недійсний або одержувач ігнорує повідомлення. Таким чином, відповідальність за правильно організовану взаємодію між процесами лежить на розробникові.<ref name=":2" />

Наприклад, при реалізації на Erlang мережевого [[чат]]у, структура програми може безпосередньо відображати одночасність дій користувачів щодо обміну повідомленнями шляхом запуску нових процесів. Ефективність передачі повідомлень зберігається зі збільшенням кількості процесів, а вимоги до пам'яті мінімізуються за рахунок того, що легковагими процесами керує віртуальна машина, а не засоби [[Операційна система|операційної системи]].<ref name=":1" />

==== Розподілені обчислення ====
Erlang з самого початку проєктувався для [[Розподілені обчислення|розподілених обчислень]] та [[Масштабовність|масштабованості]]. Підтримка паралелізму вбудована в [[Синтаксис (програмування)|синтаксис]] та [[Семантика мов програмування|семантику]] мови, тому побудову системи можна вести, абстрагуючись від конкретного місця обчислень. У стандартній поставці Erlang може налагодити зв'язок процесів протоколу [[TCP/IP]] незалежно від підтримуваних ним платформ ([[Операційна система|операційних систем]]).<ref name=":1" />

Запущений екземпляр емулятора Erlang називається [[Вузол (інформатика)|вузлом]] (node). Вузол має ім'я і «знає» про існування інших вузлів на цій машині або у мережі. Створення та взаємодія процесів різних вузлів не відрізняється від взаємодії процесів всередині вузла. Програми, написані на Erlang, здатні працювати на кількох вузлах. Вузлами можуть бути процесори, багато [[Ядро мікропроцесора|ядер]] одного [[процесор]]а, і навіть цілий кластер машин. Для створення процесу на іншому вузлі процесу достатньо знати його ім'я і, без особливих підстав, він може не цікавитися фізичним розташуванням процесу, що з ним взаємодіє. Синтаксис відправки повідомлення процесу на своєму вузлі та віддаленому однаковий.<ref name=":1" />

Завдяки вбудованим у мову можливостям розподілених обчислень об'єднання в [[Комп'ютерний кластер|кластер]], [[балансування навантаження]], додавання вузлів та серверів, підвищення надійності викликають лише невеликі витрати на додатковий код. За замовчуванням, вузли спроєктовані для роботи всередині відокремленого сегмента мережі ([[Демілітаризована зона (комп'ютерні мережі)|DMZ]]), але, якщо необхідно, комунікація між вузлами може відбуватися із застосуванням протоколу [[SSL]], захищеного [[Криптографія|криптографічними методами]].<ref name=":1" />

==== М'який реальний час ====
Програми високорівневою мовою Erlang можуть бути використані в системах [[Реальний час|м'якого реального часу]] (який іноді перекладають як «псевдореальний» або «квазіреальний»). Автоматизоване керування пам'яттю та [[збирання сміття]] діють у рамках одного процесу, що дає можливість створювати системи з мілісекундним [[Час відповіді|часом відгуку]] (навіть незважаючи на необхідність збирання сміття), що не відчувають погіршення [[Пропускна здатність (обчислення)|пропускної здатності]] при високому навантаженні.<ref name=":1" />

==== Гаряча заміна коду ====
Для систем, які не можуть бути зупинені для [[Оновлення програмного забезпечення|оновлення коду]], Erlang пропонує гарячу заміну коду ({{Lang-en|hot code upgrade}}). При цьому в додатку можуть одночасно працювати старі і нові версії коду. У такий спосіб програмне забезпечення на Erlang може бути модернізовано без простоїв, а виявлені помилки виправлені.<ref name=":5">{{Cite web|url=http://ftp.sunet.se/pub/lang/erlang/white_paper.html|title=Open-source Erlang — White Paper|last=Armstrong, Däcker, Lindgren, Millroth|first=Erlang product team at Ericsson.|date=2013|website=ftp.sunet.se|publisher=Ericsson AB|language=англійська|archiveurl=https://web.archive.org/web/20111025022940/http://ftp.sunet.se/pub/lang/erlang/white_paper.html}} {{Webarchive|url=https://web.archive.org/web/20111025022940/http://ftp.sunet.se/pub/lang/erlang/white_paper.html |date=2011-10-25 }}</ref>

== Опис мови ==

==== Типи даних ====
[[Сильна і слабка типізація|Типізація в Erlang є сильною]] та [[Динамічна типізація|динамічною]]. Динамічна типізація була обрана для мови Erlang через те, що перші розробники були більше з нею знайомі.<ref name=":3">{{Cite book
|title=Learn You Some Erlang for Great Good!: A Beginner's Guide
|last=Hébert
|first=Fred
|year=2013
|publisher=No Starch Press
|pages=624
|language=англійська
|isbn=ISBN 978-1593274351.
}}</ref> На думку Джо Армстронга, статична типізація вимагала б дуже великих трудовитрат, зокрема, реалізувати систему гарячого дозавантаження коду було б дуже важко. Така [[Сильна і слабка типізація|типізація]], коли можливі помилки типів виявляються лише під час виконання, не завадила можливості створювати системи з дуже [[висока доступність|високим рівнем доступності]]. Дані Erlang є ''незмінними'': операції не переписують старі значення, що знаходяться в пам'яті. Якщо необхідно, модулі на Erlang можна забезпечити описами та визначеннями нових типів (що не впливають на компіляцію програми) для автоматичної перевірки типів за допомогою утиліти Dialyzer.<ref name=":3" />

==== Числа ====
У Erlang є два типи числових [[Літерал (програмування)|літералів]]: ''цілі'' і з ''рухомою комою'', наприклад: <code>125</code>,<code>4.5e-20</code>. Крім звичайної нотації, числа можна задавати через символ [[ASCII]] (наприклад, <code>$B</code> означає <code>66</code>) або разом із зазначенням системи числення з основою від 2 до 36 (у старих версіях&nbsp;— до 16), наприклад: <code>16#3f</code>, <code>2#1010</code>. У Erlang застосовуються цілі числа [[Довга арифметика|довільної точності]] та [[Дійсне число|дійсні числа]] подвійної точності (64 [[біт]]и), у стандарті [[IEEE 754-2008|IEEE 754—1985]]. Для роботи з числами можна використовувати модуль <code>math</code>, який містить звичайний набір математичних функцій та функцію <code>math:pi/0</code>, що повертає [[Число пі|число <math>\pi</math>]].<ref name=":6">{{Cite web|url=https://www.erlang.org/doc/man/math.html|title=math, STDLIB Reference Manual Version 1.19.3|website=www.erlang.org|language=англійська}}</ref> Приклад обчислень в інтерактивній оболонці:<syntaxhighlight lang="erlang" line="1">
Erlang/OTP 23 [erts-11.2.2.4] [source] [64-bit] [smp:20:20] [ds:20:20:10] [async-threads:1] [hipe]

Eshell V11.2.2.4  (abort with ^G)
1> 123 / 23 + 12 * (2 + 3).
65.34782608695652
2> math:cos(math:pi()).
-1.0
3> random:uniform(10).
5
</syntaxhighlight>

==== Атоми ====
''Атом''&nbsp;— константа з ім'ям, що має бути взята в одинарні лапки, якщо не починається з малої літери або містить знаки, окрім літер, цифр, підкреслення, крапки та символу<code>@</code>. Поняття атома запозичене з [[Пролог (мова програмування)|Prolog]] та його можна вважати аналогом [[Перелічуваний тип даних|перерахувань]] (enum) в інших мовах програмування (без необхідності попередньої декларації).{{Sfn|Martin Logan, et al|2011|с=31—32}} Атоми використовуються майже виключно в порівняннях (та в [[Зіставляння зі взірцем|зіставленні зі взірцем]] (en: Pattern matching)), та мають Erlang дуже ефективну реалізацію. Крім того, деякі атоми мають певний сенс у значеннях, що повертаються, і описі винятків. До них відносяться, наприклад: <code>error</code>, <code>ignore</code>, <code>noreply</code>, <code>ok</code>, <code>reply</code>, <code>stop</code>, <code>undefined</code>.

==== Бітові рядки та бінарні дані ====
''Бітовий рядок'' використовується для зберігання пам'яті нетипізованих даних. Рядки, що складаються з цілої кількості [[Октет (інформатика)|октетів]], називаються ''бінарними'' (або ''двійковими'') ''даними'' ({{Lang-en|binaries}}). Синтаксис опису бітового рядка досить гнучкий, оскільки визначає значення бітів окремих діапазонів і може бути забезпечений модифікатором типу.<ref name=":1" /> Декілька прикладів в інтерактивній командній оболонці:
<syntaxhighlight lang="erlang" line="1">
1> <<23,89,120>>.
<<23,89,120>>
2> <<"ABC">>.
<<65,66,67>>
3> <<10,17,42:16>>.
<<10,17,0,42>>
4> <<$a, $b, $c>>. 
<<"abc">> 
5> <<1024/utf8>>.
<<208,128>>
</syntaxhighlight>
Конструктори бітових рядків ({{Lang-en|bitstring comprehension}}) аналогічні списковим генераторам, але працюють над бітовими рядками:
<syntaxhighlight line="1">
1> << <<bnot(X):1>> || <<X:1>> <= <<2#111011:6>> >>.
<<4:6>>
</syntaxhighlight>
У цьому прикладі змінна X послідовно отримує біти числа <code>2#111011</code>, які потім інвертуються операцією бітового заперечення <code>bnot</code> (від {{Lang-en|binary NOT}}), внаслідок чого виходить число 4.<ref name=":1" />

==== Кортеж ====
''[[Кортеж (інформатика)|Кортеж]]'' ({{Lang-en|tuple}})&nbsp;— складений тип даних з фіксованою кількістю елементів. При доступі до елементів кортежу за допомогою вбудованих функцій, нумерація елементів починається з одиниці, а не з нуля. Перший елемент кортежу (атом) можуть використовувати для опису ролі кортежу у програмі&nbsp;— його називають тегом ({{Lang-en|tag}}&nbsp;— «мітка»). В Erlang прийнято будувати різні типи даних на основі кортежів з тегами, це полегшує [[зневадження]] програми та вважається гарним стилем програмування.<ref name=":1" />

Для роботи з кортежами є декілька вбудованих функцій, наприклад:<ref name=":1" />
<syntaxhighlight lang="erlang" line="1">
1> tuple_size({a, 1, "777"}).
3
2> element(1, {b, 2, 3, 4}).
b
3> setelement(1, {c, 5}, d). 
{d,5}
</syntaxhighlight>

==== Список ====
''Список'' ({{Lang-en|list}})&nbsp;— складений тип даних зі змінною кількістю елементів. Для маніпуляції зі списками можна використовувати функції модуля <code>[https://www.erlang.org/doc/man/lists.html#all-2 lists]</code> стандартної бібліотеки. Формально список визначається як структура, яка має голову ({{Lang-en|head}}) та хвіст ({{Lang-en|tail}}), що виражається синтаксично у вигляді <code>[HEAD|TAIL]</code>, де хвіст зазвичай є списком (можливо порожнім). Порожній список позначається <code>[]</code><ref name=":1" />

Списки можна записувати і більш звичним способом. Наступні записи еквівалентні:
<syntaxhighlight line="1">
1> [a|[b|[c|[]]]].
[a,b,c]
</syntaxhighlight>
Для роботи зі списками можна використовувати конструктори списків<ref name=":3" />(генератори списків&nbsp;— en: List Comprehensions), наприклад:
<syntaxhighlight lang="erlang" line="1">
1> [X / 2 || X <- [1,2,3,4]].
[0.5,1.0,1.5,2.0]
</syntaxhighlight>
Модуль <code>[https://www.erlang.org/doc/man/lists.html#all-2 lists]</code> стандартної бібліотеки містить функції для роботи зі списками (та рядками, оскільки рядок виду «test» в Erlang є списком кодів символів)<ref name=":1" />, такі як знаходження найбільшого значення, сортування, зміни порядку елементів на протилежний, отримання суми елементів тощо. У наступному прикладі «склеюємо» два списки в один за допомогою [[Конкатенація|конкатенації]], і далі розбиваємо на два списки функцією <code>lists:split/2</code>:
<syntaxhighlight lang="erlang" line="1">
1> lists:split(2, [l,2,3] ++ [4,5,6]).
{[l,2],[3,4,5,6]}
</syntaxhighlight>
А це приклад того, що рядок виду «test» в Erlang є списком кодів символів:
<syntaxhighlight lang="erlang" line="1">
1> "test" =:= [$t, $e, $s, $t].
true
2> "test" =:= [116, 101, 115, 116].
true
3> $t.
116
</syntaxhighlight>

У модулі <code>[https://www.erlang.org/doc/man/lists.html#all-2 lists]</code> є також набір [[Функція вищого порядку|функцій вищого порядку]], таких як <code>lists:all/2</code>, <code>lists:any/2</code>, <code>lists:dropwhile/2</code>, <code>lists:filter/2</code>, <code>lists:foldl/3</code>, <code>lists:foldr/3</code>, <code>lists:map/2</code>, <code>lists:foreach/2</code>.

<code>lists:map/2</code>&nbsp;— функція вищого порядку, яка дає можливість застосувати визначену нами функцію до кожного елемента списку, в результаті отримаємо новий список:
<syntaxhighlight lang="erlang" line="1">
third_degree(R) ->
  lists:map(fun(X) -> math:pow(X, 3) end, R).
</syntaxhighlight>
В даному прикладі функція math: pow(X, 3) підносить до степеня 3 кожен елемент списку R.

<code>lists:filter/2</code>&nbsp;— дана функція вищого порядку приймає два параметри: функцію ([[предикат]]), за допомогою якої ми відфільтровуємо наш список&nbsp;— другий параметр. Повертає новий список&nbsp;— результат обробки фільтром вхідного списку.
<syntaxhighlight lang="erlang" line="1">
multiple_three(List) ->
  lists:filter(fun(X) -> X rem 3 =:= 0 end, List).
</syntaxhighlight>
В даному прикладі з вхідного списку List у новий&nbsp;— вихідний список попадуть лише елементи, кратні трьом.<code>lists:foldl/3</code>&nbsp;— функція лівої згортки ([[Англійська мова|англ]]. fold&nbsp;— згорнути, «l» від англ. left&nbsp;— лівий) приймає 3 аргументи:
* функцію згортання
* початкове значення акумулятора
* перелік
Функція згортання приймає два аргументи: поточний елемент списку та поточне значення акумулятора. І повертає нове значення акумулятора.

Класичні приклади&nbsp;— обчислення суми та добутку елементів масиву:
<syntaxhighlight lang="erlang" line="1">
1> Numberlist = [11, 12, 13, 14, 15].
[11, 12, 13, 14, 15]
2> lists:foldl(fun(Item, Acc) -> Acc + Item end, 0, Numberlist).
65
3> lists:foldl(fun(Item, Acc) -> Acc * Item end, 1, Numberlist).
360360
</syntaxhighlight>

Наступний приклад ілюструє роботу функції правої згортки lists: foldr (англ. fold&nbsp;— згорнути, «r» від англ. right&nbsp;— правий), першим параметром якої має бути функція:
<syntaxhighlight lang="erlang">
1> D = fun(V, A) -> V / A end. % функція D - ділення V на A
#Fun<erl_eval.12.82930912>
2> lists:foldr(D, 1, [1, 2, 4, 8]). 
0.25
3> 1/(2/(4/(8/1))). 
0.25
</syntaxhighlight>
Результат виконання згортки справа наліво (у рядку 2) тотожний ланцюжковому поділу (рядок 3). Другий параметр <code>foldr</code>&nbsp;— початкове значення так званого акумулятора. Для кожного елемента списку (справа ліворуч) до елемента та акумулятора застосовується функція, задана першим аргументом <code>foldr</code>, а значення записується в акумулятор. За вичерпанням списку, функція повертає значення акумулятора. Функція є досить потужним засобом, якщо врахувати, що акумулятор може бути списком або кортежем.<ref name=":2" />

Зазвичай користуються foldl&nbsp;— тому, що операція отримання елементу-голови списку виконується за константний час, а для отримання елементу з кінця списку потрібно пройтись через весь список<ref name=":9" />.

==== Рядок ====
У Erlang немає самостійного типу для ''рядків''&nbsp;— внутрішньо рядки є списками кодів символів. Рядок <code>"Привіт!"</code> рівносильний (у відповідному кодуванні) списку <code>[1055,1088,1080,1074,1077,1090,33]</code>. Для правильної інтерпретації списків кодів символів як рядків в інтерактивній консолі&nbsp;— запускайте з відповідним параметром: <code>$ erl +pc unicode</code>. Erlang підтримує [[Юнікод|Unicode]] як у рядку, так і запису окремого символу (<code>$X</code>, де X&nbsp;— деякий символ).<ref name=":2" />

Бінарні послідовності записуються та відображаються, як послідовності цілих чисел або рядків, поміщені між подвійними символами <code><nowiki><</nowiki></code> та <code><nowiki>></nowiki></code>. Для прикладу:
<syntaxhighlight lang="erlang" line="1">
1> <<5,10,20>>.
<<5,10,20>>
2> <<"hello">>.
<<"hello">>
</syntaxhighlight>
<code>term_to_binary(Term) -> Bin</code>&nbsp;— Конвертує будь-який терм Erlang у бінарну послідовність.<ref name=":9" />

Бінарна послідовність, вироблена за допомогою term_to_binary, зберігається в так званому зовнішньому форматі терму. Терми, які були конвертовані в бінарні послідовності з використанням term_to_binary, можуть бути збережені в файли, передані в повідомленнях по мережі тощо, а початковий терм, з якого вони були зроблені, може бути відновлений пізніше. Це надзвичайно корисно для збереження складних структур даних у файли або надсилання складних структур даних на віддалені машини.<ref name=":9" />
<syntaxhighlight lang="erlang" line="1">
1> B = term_to_binary("useful").
<<131,107,0,6,117,115,101,102,117,108>>
2> binary_to_term(B).
"useful"
</syntaxhighlight>
Атоми і рядки зовні досить схожі, але мають різні реалізації. Тоді як атоми можна лише порівнювати, рядки підтримують багато інших операцій, їм є безліч функцій в модулях <code>lists</code> і <code>string</code>. Рядок може виконувати функції атома, але пам'ять, яку займає рядок, пропорційна його довжині, тоді як атоми зберігаються в системній таблиці і на кожне зберігання/пересилання атома в програмі припадає лише декілька байтів, незалежно від довжини атома. Порівняння двох атомів&nbsp;— це порівняння двох внутрішніх ідентифікаторів, яке виконується за одну операцію, тоді як порівняння рядків передбачає поелементний прохід, тобто порівняння кодів символів&nbsp;— елементів списків.<ref name=":1" />

==== Логічні значення ====

Для значень булевої логіки ''істинне'' та ''хибне'' в Erlang застосовуються атоми <code>true</code> (істинне) і <code>false</code> (хибне), які використовуються операціями порівняння, логічними операціями, вбудованими функціями.<ref name=":1" /> Приклад:
<syntaxhighlight lang="erlang" line="1">
1> 2 < 3.
true
2> is_boolean(125).
false
</syntaxhighlight>

==== Функціональний об'єкт (Fun) ====
<code>Fun-вираз</code> дозволяє створити анонімну функцію (лямбда-функцію), яка використовується, наприклад, для передачі аргументом в іншу функцію. За допомогою <code>fun</code> можна також отримати функціональний об'єкт для функції модуля.<ref name=":2" /> Приклади:
<syntaxhighlight lang="erlang" line="1">
1> lists:map(fun(X) -> X + 1 end, [1, 2, 3]).
[2,3,4]
2> Belongs = fun lists:member/2.
#Fun<lists.member.2>
3> Belongs(a, [a, b]).
true
</syntaxhighlight>

==== Запис ====

Щоб позначати окремі елементи кортежів (полегшити роботу з великими кортежами) і уникнути помилок при написанні програми, в Erlang було додано синтаксичний цукор&nbsp;— синтаксис ''[[Структура (тип даних)|записів]]'' ({{Lang-en|record}}). Записів не існує в час виконання&nbsp;— на етапі компіляції записи перетворюються (транслюються) в кортежі&nbsp;— ключі губляться, відповідно, в час виконання існують лише значення записів. Для роботи з записами, необхідно спочатку дати опис запису директивою <code>-record</code>, наприклад, для запису <code>user</code> опис може бути наступним<ref name=":4">{{Cite book
|title=Erlang and OTP in Action.
|last=Logan,Merritt, Carlsson.
|first=Martin, Eric, Richard
|year=2011
|publisher=Manning
|pages=397
|isbn=ISBN 9781933988788
}}</ref>
<syntaxhighlight lang="erlang" line="1">
-record(user, {login = "anonymous", email, password}).
</syntaxhighlight>
З цього опису компілятор дізнається, що маються на увазі кортежі з чотирьох елементів, в яких елементи з другого по четвертий відповідають полям <code>login</code>, <code>nick</code>, <code>password</code> запису з ім'ям <code>user</code> (визначається атомом в першому елементі кортежу). Значенням за замовчуванням для поля <code>login</code> є рядок <code>"anon"</code>. Якщо значення за замовчуванням не вказано явно, таким є атом <code>undefined</code>.

Створення записів та вилучення елементів запису завжди вимагає явної вказівки імені запису:<ref name=":4" />
<syntaxhighlight lang="erlang" line="1">
R0 = #user{}, % всі поля отримують значення за замовчуванням
R1 = #user{login = "user1", email = "user@mail.com", password = "secret"}, % Задаємо значення для всіх полів
</syntaxhighlight>

Оновлення одного значення в наявному записі: <code>R2 = R1#user{login = "user2"},</code>

оновлення двох значень в наявному записі: <code>R2 = R1#user{login = "user2", email = "neo@matrix.org"},</code>

отримати значення по ключу з запису <code>Nick2 = R2#user.nick.</code>.

==== Карта ====
[[Карта|Асоціативний масив (словник)]] (en: map) зберігає пари виду «(ключ, значення)». І ключем, і значенням може бути будь-який терм Erlang.<ref>{{Cite web|url=http://www.erlang.org/doc/reference_manual/data_types.html|title=Data Types, Erlang Reference Manual User's Guide Version 5.10.3|date=2013|website=www.erlang.org|publisher=Ericsson AB|language=англійська}}</ref>
<syntaxhighlight lang="erlang" line="1">
Map = #{a => 2, b => 3, c=> 4, "a" => 1, "b" => 2, "hi" => 42},
Key = "hi",
maps:find(Key,Map).
{ok,42}
</syntaxhighlight>

==== Інші типи ====
У мові Erlang є інші типи даних. Тип ''посилання'' ({{Lang-en|reference}}) є унікальним у межах вузла/кластера з'єднаних вузлів в середовищі часу виконання Erlang. Посилання створюється викликом функції <code>make_ref/0</code> і може повторитися через 2<sup>82</sup> викликів цієї функції. Посилання можна порівнювати на рівність, а застосовуються вони для одноразових позначок або «[[Magic cookie|чарівного печива]]»<ref name=":4" />

''Ідентифікатор порту'' ({{Lang-en|port identifier}}) визначає порт для зв'язку із зовнішнім по відношенню до Erlang-системи світом. Порт дозволяє процесу, що його створив-власнику (так званому приєднаному процесу) обмінюватися бінарними повідомленнями зі сторонніми програмами і ОС способом, прийнятим в даній операційній системі.<ref name=":4" /><ref>{{Cite web|url=http://www.erlang.org/doc/reference_manual/ports.html|title=Ports and Port Drivers, Reference Manual User's Guide Version 5.10.3|date=2013|website=web.archive.org|publisher=Ericsson AB|language=англійська|accessdate=2022-08-16|archive-date=2013-12-03|archive-url=https://web.archive.org/web/20131203022736/http://www.erlang.org/doc/reference_manual/ports.html}}</ref>

''Ідентифікатор процесу'' ({{Lang-en|Pid}}), як і випливає з його назви, ідентифікує процес, що породжується різними функціями <code>spawn</code>. Ідентифікатор можна вважати унікальним під час роботи Erlang-системи, але в системах, що довго працюють, можуть все-таки бути використані повторно, що зазвичай не є проблемою на практиці.<ref name=":4" />

==== Вбудовані функції для роботи з типами ====
Для перетворення типів використовуються вбудовані функції (BIF,{{Lang-en|builtin function}}) виду x_to_y («з x в y»), а для перевірки належності значення того чи іншого типу&nbsp;— функції виду is_x («є_x»):
<syntaxhighlight lang="erlang" line="1">
1> atom_to_list(hello).
"hello"
2> list_to_binary("world").
<<"world">>
3> tuple_to_list({1,2,3,4}).
[1,2,3,4]
1> is_integer(3).
true
2> is_tuple("abc").
false
3> is_integer(3.0).
false
</syntaxhighlight>

== Операції ==

=== Арифметичні операції ===
Erlang надає найбільш поширені арифметичні операції для цілих чисел і [[Число з рухомою комою|чисел з плаваючою комою]]:
{| class="wikitable"
!Позначення
!Операція, що виконується
!приклад
!Результат прикладу
|-
|<code>+</code>
|Унарний плюс
|<code>+3</code>
|<code>3</code>
|-
|<code>-</code>
|Унарний мінус
|<code>-3</code>
|<code>-3</code>
|-
|<code>+</code>
|Додавання
|<code>2+3</code>
|<code>5</code>
|-
|<code>-</code>
|Віднімання
|<code>7-3</code>
|<code>4</code>
|-
|<code>*</code>
|множення
|<code>1.2*0.4</code>
|<code>0.48</code>
|-
|<code>/</code>
|Ділення
|<code>5 / 3</code>
|<code>1.6666666666666667</code>
|-
|<code>div</code>
|Цілочисельне [[ділення]]
|<code>5 div 3</code>
|<code>1</code>
|-
|<code>rem</code>
|Залишок від [[Ділення з остачею|ділення]]
|<code>5 rem 3</code>
|<code>2</code>
|}
Всі ці операції [[Асоціативність (програмування)|лівоасоціативні]]. Унарні операції мають найвищий пріоритет, потім слідує множення і ділення, найменший пріоритет у складання та віднімання. При необхідності ціле може приводитися до типу з рухомою комою.<ref name=":1" />

=== Бітові операції ===
[[Бітові операції]] працюють над цілими числами і дають в результаті [[Цілі числа|ціле число]].<ref name=":1" />
{| class="wikitable"
!Позначення
!Операція, що виконується
!приклад
!Результат прикладу
|-
|<code>bnot</code>
|[[Бітові операції|Побітове заперечення]]
|<code>bnot (2#1000)</code>
|<code>-9</code>
|-
|<code>band</code>
|[[Бітові операції|Побітове І]]
|<code>2 band 3</code>
|<code>2</code>
|-
|<code>bor</code>
|[[Бітові операції|Побітове АБО]]
|<code>1 bor 2</code>
|<code>3</code>
|-
|<code>bxor</code>
|Побітове [[Виключна диз'юнкція|виключне АБО]]
|<code>5 bxor 3</code>
|<code>6</code>
|-
|<code>bsr</code>
|[[Бітовий зсув|Побітовий зсув]] вправо
|<code>32 bsr 2</code>
|<code>8</code>
|-
|<code>bsl</code>
|[[Бітовий зсув|Побітовий зсув]] вліво
|<code>1 bsl 5</code>
|<code>32</code>
|}

=== Логічні операції ===
[[Логічний сполучник|Логічні операції]] працюють над логічними значеннями <code>true</code> (істинне) і <code>false</code> (хибне), одержуваними в результаті порівнянь та застосування функцій перевірки типу:<ref name=":1" />
{| class="wikitable"
!Позначення
!Операція, що виконується
!приклад
!Результат прикладу
|-
|<code>not</code>
|[[Заперечення]] (НЕ)
|<code>not true</code>
|<code>false</code>
|-
|<code>and</code>
|[[Кон'юнкція]] (І)
|<code>true and (1 < 5)</code>
|<code>true</code>
|-
|<code>andalso</code>
|Аналогічно <code>and</code>, але не обчислює другий операнд, якщо перший <code>false</code>
|<code>false andalso (1 < 5)</code>
|<code>false</code>
|-
|<code>or</code>
|[[Диз'юнкція (логіка)|Диз'юнкція]] (АБО)
|<code>is_atom("1") or is_atom(1)</code>
|<code>false</code>
|-
|<code>orelse</code>
|Аналогічно <code>or</code> але не обчислює другий операнд, якщо перший <code>true</code>
|<code>true orelse (1 < 5)</code>
|<code>true</code>
|-
|<code>xor</code>
|[[Виключна диз'юнкція|Виключне АБО]]
|<code>true xor true</code>
|<code>false</code>
|}

=== Операції порівняння ===
Операції порівняння отримують два операнди, а результатом операції є логічне значення <code>true</code> або <code>false</code>. У Erlang є наступні операції: <code>==</code> (рівно), <code>=:=</code> (рівно, враховуючи тип&nbsp;— використовується для порівняння чисел), <code>/=</code> (не рівно), <code>=/=</code> (не рівно, враховуючи тип&nbsp;— використовується для порівняння чисел), <code>=<</code> (менше або дорівнює), <code><</code> (менше), <code>></code> (більше), <code>>=</code> (більше або дорівнює):

<code>==</code> перевірка на рівність (не враховуючи тип):
<syntaxhighlight lang="erlang" line="1">
1> 5 == 5.
true
2> 5 == 5.0.
true
</syntaxhighlight>

<code>=:=</code> перевірка на рівність (враховуючи тип):
<syntaxhighlight lang="erlang" line="1">
4> 5 =:= 5.
true
5> 5 =:= 5.0.
false
</syntaxhighlight>

Можна порівнювати значення різних типів, але вони вважаються в Erlang впорядкованими наступним чином:<ref name=":1" />
число < атом < посилання < функція < порт < ідентифікатор процесу < кортеж < список < бінарні дані

Списки вважаються впорядкованими в [[Лексикографічний порядок|лексикографічному порядку]], а кортежі порівнюються за довжиною, і лише потім у лексикографічному порядку.<ref name=":1" />

=== Змінні ===
Змінні служать для зберігання значень простих і складових типів. Ім'я змінної починається з великої літери (у спеціальних випадках&nbsp;— з підкреслення) і може містити букви, цифри, підкреслення. Змінній можна присвоїти значення лише один раз&nbsp;— ця властивість мови програмування називається одиничним присвоєнням ({{Lang-en|single assignment}}). До переваг одиничного присвоєння можна віднести усунення необхідності в блокуваннях, а також спрощення налагодження програми<ref name=":7">{{Cite book
|title=Building Web Applications with Erlang
|last=Kessin
|first=Zachary
|year=2012
|publisher=O’Reilly Media, Inc
|pages=156 p.
|language=Англійська
|isbn=ISBN 978-1-4493-0996-1.
}}</ref>

Відбувається обчислення([[Редукція (паралельне програмування)|редукція]]) аргументів функції перед застосуванням функції до цих аргументів (вхідних параметрів).

[[Область видимості (програмування)|Область видимості]] змінної поширюється від її визначення (en: bind&nbsp;— зв'язування) до закінчення клози функції. Приклад:
<syntaxhighlight lang="erlang" line="1">
binomial(X) ->
  Y = X * X,
  X + Y.

prod([1|T]) -> prod(T);
prod([Y|T]) -> Y * prod(T);
prod([])    -> 1.
</syntaxhighlight>
У цьому прикладі область видимості <code>X</code>&nbsp;— весь опис функції <code>binomial/1</code>, а <code>Y</code>&nbsp;— від присвоєння до кінця опису. Змінна <code>Y</code> у другій клозі функції <code>prod/1</code> не має відношення до змінної <code>Y</code> з <code>binomial/1</code>: її область видимості поширюється до кінця цієї клози.<ref name=":1" />

При виході обчислень за межі області видимості змінної, пам'ять, зайнята її вмістом, може бути звільнена у процесі [[збирання сміття]], якщо значення змінної не використовується в іншій частині програми.<ref name=":4" />

=== [[Зіставляння зі взірцем|Зіставлення зі взірцем]] ===
[[Зіставляння зі взірцем|Зіставлення зі зразком]] (en: Pattern Matching) використовується в Erlang для [[Оператор присвоювання|присвоєння]] (у тому числі, при роботі з параметрами функцій), управління потоком виконання програми, отримання значень складових типів, вибору повідомлення з черги. У лівій частині порівняння (або в заголовку функції) можуть бути пов'язані (вже мають значення) і незв'язані (отримуючі значення) змінні, а також літерали (атоми, числа, рядки). В результаті виконання порівняння може виявитися успішним (у цьому випадку змінні зв'язуються зі значеннями) та неуспішним&nbsp;— змінні залишаються непов'язаними. У зразку можуть бути змінні, значення яких для зразка байдуже: їх імена записуються з підкреслення. Змінні, ім'я яких починається з підкреслення, це звичайні змінні, крім того, що компілятор не буде скаржитися, якщо вони не використані. Не можна прив'язувати до них значення більше одного разу.<ref name=":1" />

== Функції ==
Програми Erlang складаються з функцій, які викликають одне одного. Кількість вхідних аргументів (параметрів) функції називається '''''арністю'''''. При виклику функції заголовки функції зіставляються зі зразком. У разі збігу параметрів виклику формальні параметри зв'язуються з фактичними і виконується відповідна частина тіла функції. Запис варіанту обчислення функції для деякого зразка може називатися ''клозом'' від {{Lang-en|clause}}, а визначення функції&nbsp;— це набір з одного або більше клозів.

Для уточнення зіставлення зі зразком у функціях можна використовувати [[Варта (програмування)|охоронні вирази]], які випливають після ключового слова <code>when</code><ref name=":2" />. У прикладі нижче визначено функцію обчислення [[Signum-функція|знака числа]], яка розраховується в залежності від порівняння параметра з нулем:<syntaxhighlight lang="erlang" line="1">
sign(X) when X > 0 -> 1;
sign(X) when X == 0 -> 0;
sign(X) when X < 0 -> -1.
</syntaxhighlight>Erlang перебирає (матчить) клози функції в тому порядку, в якому вони записані (зверху вниз, зліва направо), доки не буде знайдено відповідний вираз (заголовок клози), який зматчиться.<ref name=":2" /> В охоронних виразах можна використовувати лише обмежений набір вбудованих функцій, оскільки ці функції не повинні мати [[Побічний ефект (програмування)|побічних ефектів]].

Функції Erlang підтримують [[Рекурсія|рекурсивні]] виклики. У разі коли визначення функції закінчується рекурсивним викликом ([[хвостова рекурсія]]), Erlang використовує оптимізацію: стек викликів не застосовується.<ref name=":2" />

Як параметром, і результатом функції може бути інша функція. У наступному прикладі функція одного аргументу повертає функцію додавання аргументу<ref name=":1" /><syntaxhighlight lang="erlang" line="1">
1> Plus = fun(X) -> fun(Y) -> X + Y end end. % Визначення функції, яка повертає функцію
#Fun<erl_eval.6.82930912>
2> Plus(2). % Функція повертає Fun-об'єкт
#Fun<erl_eval.6.82930912>
3> Plus(2)(3). % Такий синтаксис не працює
* 1 : syntax error before : '('
4> ( Plus(2) )(3). % Додаткові дужки дозволяють досягти необхідного результату
5
5> Plus2 = Plus(2), Plus2(3). % Те саме з використанням додаткової змінної
5

</syntaxhighlight>

=== Умовні вирази ===
Окрім матчингу та охоронних виразів у клозах функції, в Erlang є інші умовні вирази вибору: if та case. Вираз вибору дозволяє організувати зіставлення зі зразком усередині функції і зазвичай має наступний синтаксис:<syntaxhighlight lang="erlang" line="1">
if
 охорона1 -> вираз11, вираз12, ... ;
 охорона2 -> вираз21, вираз22, ... ;
 ...
 охоронаN -> виразN1, виразN2, ...
end
</syntaxhighlight>Тут <code>охорона1</code>— охоронний вираз (en: guards).<ref>{{Cite web|title=Syntax in functions {{!}} Learn You Some Erlang for Great Good!|url=https://learnyousomeerlang.com/syntax-in-functions#guards-guards|website=learnyousomeerlang.com|accessdate=2022-09-10}}</ref> Охоронні вирази&nbsp;— розширення зіставлення зі зразком, що додає [[Виразність (програмування)|виразності]]. Без охоронних виразів ми не можемо визначати такі речі, як діапазон значень чи певні типи даних. У Erlang if&nbsp;— це вираз, який може мати декілька гілок. Гілки скануються послідовно, зверху донизу, допоки захисна послідовність не буде оцінена як true. Якщо охорона1 (перший guard в даному прикладі) поверне true одразу почнеться виконання відповідних виразів: вираз11, вираз12,… Після виконання цих виразів відбудеться вихід з блоку і наступні умови <code>охорона2, …, охоронаN</code> перевірятися не будуть. Якщо ж <code>охорона1</code> поверне <code>false</code>, відбувається перехід до перевірки наступного охоронного виразу, і так доти, поки guard не поверне значення true, після чого будуть виконані відповідні, розділені комами вирази і вихід з блоку. Слід зауважити, що і тут в охоронному виразі можна застосовувати лише обмежений набір операцій та вбудованих функцій. Коми в охоронному вираженні працюють як операція andalso, крапка з комою — як orelse, наприклад:<ref name=":2" /><syntaxhighlight lang="erlang" line="1">
if
  X =< 0 -> io:format("менше або дорівнює нулю ~n", []), <<"менше або дорівнює нулю"/utf8>>;
  X > 0, X < 10 -> io:format("більше нуля та менше десяти ~n", []), <<"більше нуля та менше десяти"/utf8>>;
  X == 10; X == 11 -> io:format("дорівнює десяти або одинадцяти~n", []), <<"дорівнює десяти або одинадцяти"/utf8>>;
  true -> io:format("більше або дорівнює дванадцяти~n", []), <<"більше або дорівнює дванадцяти"/utf8>>
end.
</syntaxhighlight>Якщо жодна захисна послідовність не є істинною, виникає помилка виконання <code>if_clause</code>. При необхідності можна використовувати захисник <code>true</code>. В останній гілці, оскільки ця захисна послідовність завжди вірна, і вважається аналогом «інше».<ref name=":9">{{Cite web|url=https://www.erlang.org/doc/|title=Erlang/OTP 25.0.4|website=www.erlang.org|language=Англійська|accessdate=25 серпня 2022}}</ref> Компілятор Erlang стежить за безпекою зв'язування змінних усередині умовних виразів, це ми можемо побачити на наступному прикладі:<syntaxhighlight lang="erlang" line="1">
-module(badexample).
-export([broken_if/1]).

broken_if(X) ->
  if
    X < 0 -> Z = -1;
    X >= 0 -> Y = 1
  end,
  Y * Z.

</syntaxhighlight>При спробі [[Компіляція (програмування)|скомпілювати]] модуль виникають повідомлення про помилки, тому що в такому коді змінні не пов'язуються зі значенням в іншій клозі відповідно:<syntaxhighlight lang="erlang" line="1">
1> c(badexample).
badexample.erl:8: variable 'Y' unsafe in 'if' (line 4)
badexample.erl:8: variable 'Z' unsafe in 'if' (line 4)
error
</syntaxhighlight>Правильним було б визначити всі використовувані далі за кодом змінні у всіх гілках if-вирази.<ref name=":2" /><syntaxhighlight lang="erlang" line="1">
-module(if_else).
-export([compare/2, ascii/1, run/3]).

	compare(X, Y) ->
		Result = if
			X > Y -> greater;
			X =:= Y -> equal;
			X < Y -> less		
		end,
	io:format("	~p is ~p than ~p ~n", [X, Result, Y]).
		
		ascii(Letter) ->
		Code = if 
			Letter =:= 'A' -> 101;
			Letter =:= 'B' -> 102;
			true -> unknown
		end,
	io:format("	~p = ~p ~n", [Letter, Code]).
		
		run(X, Y, Letter) ->
		compare(X, Y),
		ascii(Letter).
	
</syntaxhighlight>

Можна використовувати вираз <code>case ... of</code> для порівняння послідовності патернів. На відміну від виразу <code>if, case ... of</code> дозволяє використовувати охоронні вирази в пунктах співставлення. Якщо жодний вираз case не відповідає зразку (не матчиться), система виконання викличе помилку про відсутність відповідності: «no case clause matching». Використовувати шаблон підкреслення <code>_</code> можна, щоб захопити будь-яке інше значення, яким не відповідали попередні ключі.<ref name=":8" /><syntaxhighlight lang="erlang" line="1">
case expression of
       pattern1 [when guard1] -> expr_seq1;
       pattern2 [when guard2] -> expr_seq2;
    ...
end.
</syntaxhighlight>Спочатку обчислюється expression, припустимо, що при цьому воно набуває значення Value. Далі Value співставляється з pattern1 (разом з опціональним контролером guard1), pattern2 і так далі, до першого успішного співставлення. Як тільки це станеться, виконується послідовність виразів (expr_seqN) і результат цього обчислення стає результатом всього даного виразу. Якщо жоден із патернів не підійде, то відбувається виняткова ситуація.<ref name=":9" /><syntaxhighlight lang="erlang" line="1">
-module(case_of).
-compile([export_all, nowarn_export_all]).
		
	admit(Person) ->
		case Person of
			{male, Age} when Age > 21 -> yes_with_cover;
			{female, Age} when Age > 21 -> yes_no_cover;
			{male, _} -> no_boy_admission;
			{female, _} -> no_girl_admission;
			_ -> unknown
		end.
		
	run(Person) ->
		Record = admit(Person),
		io:format("  ~p~n", [Record]).
</syntaxhighlight>

==== Приклади ====
В функціональних мовах програмування відсутні цикли, натомість використовується [[Рекурсія (програмування)|рекурсія]].

Розглянемо функції обчислення [[факторіал]]у:<syntaxhighlight lang="erlang" line="1">
-module(fact).
-export([fac/1, func/1]).

fac(0) -> 1;
fac(N) when N > 0 ->
  N * fac(N-1).
</syntaxhighlight>Це рекурсія без хвостової оптимізації, вона добре працює для невеликої глибини рекурсії. Проте, стає проблематичною у випадку великої глибини рекурсії.

Чим більше операцій рекурсії&nbsp;— тим більше займе пам'яті дана програма у стеку при виконанні, дана рекурсія розгортається у стек&nbsp;— відповідно, чим більше рекурсивних викликів&nbsp;— тим більше пам'яті займе дана програма при виконанні.<ref name=":9" />

Хвостова рекурсія&nbsp;— це рекурсія, яка викликається останньою інструкцією, таким чином стек залишається незмінним (або ж практично незмінним) і функція може працювати перманентно без зупинки.<ref name=":9" /><syntaxhighlight lang="erlang" line="1">
func(N) -> func(N,1).
func(0,A) -> A;
func(N,A) when N > 0 -> func(N-1, N*A).
</syntaxhighlight>Хвостова рекурсія незалежна від кількості рекурсивних викликів&nbsp;— в пам'яті залишаються лише два числа.

Спробуємо написати функцію обчислення N-ного [[Послідовність Фібоначчі|числа Фібоначчі]] на Erlang двома шляхами-алгоритмами. Спочатку звичайна рекурсія.<syntaxhighlight lang="erlang" line="1">
-module(fibonacci).
-export([fib_usual/1, fib_tail/1]).

fib_usual(1) -> 0;
fib_usual(2) -> 1;
fib_usual(N) when N > 0 ->
  fib_usual(N - 1) + fib_usual(N - 2).
</syntaxhighlight>Дана функція тримає всі числа-проміжні результати одночасно у памяті, і кількість рекурсивних викликів функції&nbsp;— активних процесів&nbsp;— зростає надто стрімко.

Хвостова рекурсія в даному випадку пишеться з використанням двох тимчасових змінних в якості параметрів нашої функції. Такі змінні називаються акумуляторами та використовуються для зберігання проміжних результатів наших обчислень, щоб не зберігати багато незакінчених обчислень (процесів, які очікують результат розрахунків від інших процесів) у пам'яті.<syntaxhighlight lang="erlang" line="1">
fib_tail(N) when is_integer(N), N > 0 ->
  fib_tail(N, 1, 0).
fib_tail(0, A1, _) -> A1;
fib_tail(N, A1, A2) ->
  fib_tail(N - 1, A2, A1 + A2).
</syntaxhighlight>

У памяті тримаються лише три числа та займається обчисленнями лише один процес.

Додамо декілька функцій, які працюють рекурсивно зі списком і виконують такі звичні для всіх нас завдання:

- визначення довжини масиву;

- знаходження максимального (мінімального) елемента масиву;

- обчислення суми всіх елементів масиву.

1. Визначення довжини масиву:

- спочатку звичайна рекурсія <syntaxhighlight lang="erlang" line="1">
len_list([]) -> 0;
len_list([_]) -> 1;
len_list([_H|T]) when is_list([_H|T]) ->
  1 + len_list(T).
</syntaxhighlight>- хвостова рекурсія з акумулятором<syntaxhighlight lang="erlang" line="1">
length_tail(List) when is_list(List)->
  length_tail(List, 0).
length_tail([], Acc) -> Acc;
length_tail([_|Tail], Acc) ->
  length_tail(Tail, 1 + Acc).
</syntaxhighlight>

2. Знаходимо максимальний елемент масиву:

- спочатку звичайна рекурсія<syntaxhighlight lang="erlang" line="1">
max_el([Last]) when is_number(Last) -> Last;

max_el([H | T]) when hd(T) >= H ->
  max_el(T);
max_el([H | T]) ->
  max_el([H | tl(T)]).
</syntaxhighlight>

- та сама функція, з допомогою хвостової рекурсії і акумулятора<syntaxhighlight lang="erlang" line="1">
tail_maxx([H | T]) when is_number(H)->
  tail_maxx(T, H).
tail_maxx([], Acc) when is_number(Acc) ->
  Acc;
tail_maxx([H | T], Acc) when H >= Acc ->
  tail_maxx(T, H);
tail_maxx([_ | T], Acc) ->
  tail_maxx(T, Acc).
</syntaxhighlight>

3. Підрахуємо суму елементів масиву:

- звичайна рекурсія<syntaxhighlight lang="erlang" line="1">
sumx([]) -> 0;
sumx([H | T]) -> H + sumx(T).
</syntaxhighlight>

- підрахунок суми елементів масиву з допомогою хвостової рекурсії<syntaxhighlight lang="erlang" line="1">
tail_sum(List) -> tail_sum(List, 0).

tail_sum([], Acc) -> Acc;
tail_sum([H | T], Acc) -> tail_sum(T, Acc + H).
</syntaxhighlight>

Один з алгоритмів сортування&nbsp;— [[швидке сортування]]<ref name=":5" /><syntaxhighlight line="1" lang="erlang">
-module(qsort).
-export([qsort/1]).

 qsort([]) -> [];
 qsort([Pivot|Rest]) ->
   qsort([Front || Front <- Rest, Front < Pivot]) ++ [Pivot] ++
     qsort([Back || Back <- Rest, Back >= Pivot]).
</syntaxhighlight>

У цьому прикладі функція <code>qsort</code> викликається рекурсивно до вичерпання всіх елементів. Вираз <code>[Front || Front <- Rest, Front < Pivot]</code> збирає список <code>Front</code> з елементів <code>Rest</code> таких, що елемент <code>Front</code> менший за <code>Pivot</code>. Оператор <code>++</code> [[Конкатенація|склеює]] списки.

=== Препроцесор та макроси ===
[[Препроцесор]] Erlang (EPP) дозволяє вкладати файли з вихідним кодом один в інший, визначати [[Макрокоманда|макроси]] та здійснювати прості та параметризовані макропідстановки.<ref name=":1" /> Макрос визначається за допомогою директиви <code>-define</code>, а макропідстановка здійснюється вказівкою імені макроса та можливих параметрів після знака питання (<code>?</code>). Наступний приклад показує визначення та застосування параметризованого макроса:<syntaxhighlight lang="erlang" line="1">
-define(ZERO(X), X == 0).

is_zero(T) when ?ZERO(X) -> true;
is_zero(T) -> false.
</syntaxhighlight>Ім'я макроса зазвичай пишеться великими літерами. Визначення макроса має містити [[Лексичний аналіз|лексеми]] Erlang цілком (наприклад, спроба задати частину імені змінної за допомогою макроса викликає синтаксичну помилку). Макроси можуть використовуватися для підвищення [[Прочитність|зручності читання]] коду в охоронних виразах, для операторів налагодження і&nbsp;т.&nbsp;ін. Препроцесор має декілька визначених макросів, які не можна перевизначити: <code>?MODULE</code>, <code>?MODULE_STRING</code>, <code>?FILE</code>, <code>?LINE</code>, <code>?MACHINE</code>.<ref>{{Cite book
|title=The Preprocessor, Predefined Macros, Erlang Reference Manual User's Guide Version 5.10.3
|year=2013
|publisher=Ericsson AB
|language=англійська
}}</ref>

[[Заголовний файл]] (розширення <code>.hrl</code>) з визначеннями макросів та записів можна включити за допомогою директиви <code>-include</code>.<ref name=":1" />

=== Обробка помилок ===
Для обробки [[Обробка винятків|виняткових ситуацій]] Erlang можна застосовувати конструкцію <code>try ... catch</code>, в загальному випадку записується в наступному вигляді<ref name=":1" /><syntaxhighlight lang="erlang" line="1">
try вираз для обчислення of
 зразок1 when охорона1 -> вираз1;
 зразок2 when охорона2 -> вираз2;
 ...
 зразокN when охоронаN -> виразN
catch
 класс1:зразокВикл1 when охоронаВикл1 -> виразВикл1;
 ...
 классМ:зразокВиклМ:Stacktrace when охоронаВиклМ -> виразВиклМ;
end
</syntaxhighlight>Як і у випадку case-виразу, вираз, що обчислюється, зіставляється зі зразком (частини між <code>of</code> і <code>catch</code>) для отримання результату.<ref name=":2" /> Після ключового слова <code>catch</code> слідують частини обробки винятків, у яких на додаток до зразків винятків можуть бути вказані класи винятків (перед двокрапкою): <code>error</code>, <code>throw</code> та <code>exit</code>. Stacktrace — це список викликів функцій, обчислення яких виконувала програма, коли було створено виняток. Підкреслення може використовуватись як у зразку, так і в класі виключення. Наступний простий приклад ілюструє перехоплення помилки класу <code>error</code> при обчисленні [[Квадратний корінь|квадратного кореня]].<syntaxhighlight lang="erlang" line="1">
1> try math:sqrt(-1) catch error:Error -> {error, Error} end.
{error, badarith}
2> try math:sqrt(4) catch error:Error -> {error, Error} end.
2.0
</syntaxhighlight>Для створення винятків, визначених користувачем, використовується функція <code>throw/1</code>, яка приймає кортеж з більш детальним описом помилки,<ref name=":2" /> що виникла і генерує виняток класу <code>throw</code>. Використання цієї функції небажане через погіршення зручності читання коду програми, але може знадобитися в деяких випадках при роботі з вкладеними структурами даних, наприклад, при розборі [[XML]]<ref name=":1" />. Винятки класу <code>exit</code> виникають у результаті виклику вбудованої функції <code>exit/1</code> або сигналу виходу.

До розробки Річардом Карлссоном (Richard Carlsson) з команди проєкту HiPE описаного вище нового механізму обробки винятків (з'явився у версії R10B) в Erlang використовувалися catch-вирази.<ref name=":1" />

== Модулі ==
Код програми на Erlang можна розбити на окремі [[Модульне програмування|модулі]]. Модуль&nbsp;— це ім'я для набору функцій, організованих в одному файлі. Ім'я модуля має збігатися з ім'ям файлу (якщо відкинути [[Розширення назви файлу|розширення]])<ref name=":1" />. Модуль можна відкомпілювати в байт-код як із командного рядка операційної системи, так і з командної оболонки Erlang<ref name=":3" />. У файлі модуля можна записати оголошення функцій та '''''директиви''''' (іноді називаються атрибутами). Обов'язковим атрибутом є лише <code>-module(атом_імені_модуля).</code> Інший атрибут, що часто використовується&nbsp;— <code>-export</code>&nbsp;— застосовується для опису списку експортованих функцій, тобто функцій, які можна використовувати за межами модуля.

Функції в Erlang однозначно визначаються модулем, ім'ям та [[Арність|арністю]]. Наприклад, <code>math:cos/1</code> відповідає функції <code>cos</code> з модуля <code>math</code> приймає один аргумент. Викликати функцію можна так: <code>math:cos(1.2)</code><ref name=":1" />

[[Початковий код|Вихідний текст]] модуля компілюється в BEAM-файл&nbsp;— файл, що містить байт-код віртуальної машини '''''BEAM''''' ({{Lang-en|Bogdan’s/Björn's Erlang Abstract Machine}}<span lang="en" style="font-style:italic;">Bogdan's/Björn's Erlang Abstract Machine</span>{{sfn|Hebert|2013|місце=Modules}}). У свою чергу, '''''ERTS''''' ({{Lang-en|Erlang Runtime System}}<span lang="en" style="font-style:italic;">Erlang Runtime System</span>&nbsp;— система часу виконання Erlang) виконує цей код.<ref name=":2" />

=== Процеси ===
Основною абстракцією [[Паралельний алгоритм|паралельного програмування]] в Erlang є ''процес''. Процеси можуть породжувати інші процеси, виконуватися одночасно, обмінюватися повідомленнями, реагувати на завершення один одного.

=== Створення процесів ===
Erlang має невеликий, але потужний набір примітивів для створення процесів і спілкування між ними.

Міжпроцесовий зв'язок працює за допомогою асинхронної системи передачі повідомлень, яка не має спільного доступу: кожен процес має «поштову скриньку»&nbsp;— чергу повідомлень, які були надіслані іншими процесами та ще не використані. Для отримання повідомлень, які відповідають бажаним паттернам, процес використовує примітив <code>receive</code>. Процедура обробки повідомлень перевіряє повідомлення по черзі на відповідність кожному паттерну, поки один з них не збігається. Коли повідомлення використано та видалено з поштової скриньки, процес відновлює виконання. Повідомлення може містити будь-яку структуру Erlang, включаючи примітиви (цілі числа, числа з плаваючою точкою, символи, атоми), кортежі, списки та функції.

Для створення нового процесу служить декілька вбудованих функцій (<code>spawn</code> та її аналоги){{sfn|Martin Logan, et al|2011|с=75}}. Функції повертають ідентифікатор процесу, який може використовуватися, наприклад, для надсилання повідомлень новоствореному процесу. В інтерактивній консолі erl можна отримати список процесів та іншу інформацію за допомогою функцій <code>processes().</code> та <code>i().</code> відповідно.<ref name=":1" />

Наведений нижче приклад коду показує вбудовану підтримку розподілених процесів:
<syntaxhighlight lang="erlang" line="1">
%% Створимо процес та викличемо функцію web:start_server(Port, MaxConnections)
ServerProcess = spawn(web, start_server, [Port, MaxConnections]),

%% Створимо віддалений процес та викличемо функцію
%% web:start_server(Port, MaxConnections) на віддаленій ноді RemoteNode
RemoteProcess = spawn(RemoteNode, web, start_server, [Port, MaxConnections]),

%% Відправимо повідомлення процесу ServerProcess (асинхронно).
%% Повідомлення складається з кортежа з атомом "pause" та числом "10".
ServerProcess ! {pause, 10},

%% Отримаємо повідомлення, надіслані цьому процесу
receive
  a_message -> do_something;
  {data, DataContent} -> handle(DataContent);
  {hello, Text} -> io:format("Got hello message: ~s", [Text]);
  {goodbye, Text} -> io:format("Got goodbye message: ~s", [Text])
end.
</syntaxhighlight>
Як показує приклад, процеси можуть бути створені у віддалених вузлах, і взаємодія з ними є прозорою у тому сенсі, що взаємодія з віддаленими процесами працює точно так само, як взаємодія з локальними процесами.

Розподіленість (en: Concurrency) підтримує основний метод обробки помилок в Erlang. Коли процес аварійно завершується, він акуратно завершує роботу та надсилає повідомлення керуючому процесу, який потім може вжити заходів, наприклад запустити новий процес, який бере на себе завдання старого процесу.

=== Передача та прийом повідомлень ===
Як і мова [[Occam]], Erlang використовує для відправки повідомлення синтаксис зі знаком оклику: <code>Process_ID ! Message</code>.
Прийом повідомлення&nbsp;— тобто вилучення його з черги («поштової скриньки») процесу&nbsp;— виконується за допомогою receive-виразів, які зазвичай записуються таким чином<ref name=":1" />:
<syntaxhighlight lang="erlang" line="1">
receive
  зразок1 when охорона1 -> вираз11, вираз12, ...;
  зразок2 when охорона2 -> вираз21, вираз22, ...;
  ...
  зразокN when охоронаN -> виразN1, виразN2, ...;
  Непов'язанаЗміннаДляІншихПовідомлень -> вираз1, вираз2, ...
end
</syntaxhighlight>
Зустрівши такий вираз, інтерпретатор послідовно переглядає повідомлення з черги. Кожне повідомлення інтерпретатор зіставляє зі зразком і, якщо воно відповідає зразку, то обчислюються відповідні вирази. Коли всі повідомлення перебрані, і потрібного не виявилося, процес очікує нових повідомлень, після чого перебір черги повторюється. Якщо в receive-виразі відсутній зразок, якому задовольняє будь-яке повідомлення, такий вираз називається вибірковим receive-виразом.<ref name=":1" />

=== Обробка помилок та завершення процесів ===
Процес можна зв'язати з іншим, у результаті між процесами встановлюється ''двонаправлене з'єднання'' ({{Lang-en|link}}). Якщо один із процесів завершується ненормально, всім пов'язаним з ним процесам передається ''сигнал виходу'' ({{Lang-en|exit signal}}). Процеси, що отримали сигнал, завершуються, поширюючи сигнал далі. Сигнал виходу є кортежем, елементами якого є атом <code>'EXIT'</code> (вихід), ідентифікатор процесу, що завершився, і причину завершення процесу. Причина завершення передається ланцюжком процесів, що завершуються.<ref name=":1" />

Процес може здійснити ''перехоплення помилки'' ({{Lang-en|trapping errors}}), якщо він має прапорець перехоплення виходу. Такий процес отримує сигнали виходу пов'язаних з ним процесів у вигляді звичайних повідомлень з аналогічною структурою кортежу. Перехоплений сигнал виходу більше не передається пов'язаним з процесом-перехоплювачем процесам. Сигнал виходу з причиною&nbsp;— атомом <code>normal</code> (нормальне завершення процесу) не викликає завершення пов'язаного процесу. Якщо ж причина&nbsp;— атом <code>kill</code>, процес завершується беззастережно (незалежно від прапорець перехоплення виходу), а пов'язаним з ним процесам як причина відправляється атом <code>killed</code>, що дає їм можливість зреагувати.<ref name=":1" />

Erlang має можливість встановити і однонаправлене з'єднання. При завершенні процесу, що спостерігається, процес-спостерігач отримує повідомлення із зазначенням причини завершення. Процес може зупинити себе сам чи зупинити інший процес, викликавши функцію <code>exit.</code><ref name=":1" />

=== Ввід-вивід ===
У [[Планувальник завдань|планувальнику]] процесів Erlang-системи проблема [[Ввід/вивід|вводу-виводу]], властива багатьом іншим мовам паралельного програмування, вирішена достатньо елегантно. Управління вводом-виводом, інтегроване з планувальником, вже на нижньому рівні здійснюється на основі подій, що дозволяє програмі обробляти вхідні та вихідні дані без зайвих блокувань. Такий підхід вимагає меншого числа випадків установлення та розриву з'єднань, а також прибирає необхідність блокування та [[перемикання контексту]]. Спосіб частіше застосовується в системах з явними вимогами високої доступності та низького часу відгуку. Реалізація подієво-орієнтованого вводу-виводу вбудована в Erlang-систему. Це є перевагою при проєктуванні паралельних додатків.<ref name=":4" />

Стандартна бібліотека містить модуль <code>io</code> з функціями вводу-виводу. Такі функції містять в собі [[Побічний ефект (програмування)|побічні ефекти]]. Вони полягають, наприклад, у появі виведеної інформації в консолі або у записуванні даних у файл на диску. Наприклад, функція <code>io:format</code> для форматованого виводу виводить рядок із підстановкою параметрів, повертаючи у разі успіху атом <code>ok.</code><ref name=":1" /><syntaxhighlight line="1" lang="erlang">
1> io:format("приклад виводу : ~p~n", [1]). 
приклад виводу : 1
ok
</syntaxhighlight>Функції модуля <code>io</code> передбачають стандартний серверний [[Інтерфейс (об'єктно-орієнтоване програмування)|інтерфейс]] вводу-виводу. Протокол вводу-виводу Erlang ({{Lang-en|The Erlang I/O-protocol}}) детально визначає зв'язок клієнта і сервера, забезпечує двонаправлений зв'язок між клієнтами та серверами. Сервер вводу/виводу&nbsp;— це процес, який обробляє запити та виконує потрібне завдання, наприклад, на пристрої введення/виведення. Клієнт&nbsp;— це будь-який процес Erlang, який бажає читати або писати дані з/на пристрій введення/виведення.<ref>{{Cite web|url=https://www.erlang.org/doc/apps/stdlib/io_protocol.html|title=The Erlang I/O-protocol, STDLIB User's Guide Version 1.19.4|date=24 грудня 2013|publisher=Ericsson AB|language=англійська}}</ref>

== Бібліотеки ==

==== Стандартна бібліотека модулів ====
Згідно з офіційною документацією, стандартна бібліотека модулів STDLIB<ref name=":6" /> є обов'язковою для включення до мінімальної системи Erlang/OTP<ref name=":10">{{Cite web|url=http://www.erlang.org/doc/man/STDLIB_app.html|title=STDLIB, STDLIB Reference Manual Version 1.19.3|date=2013|publisher=Ericsson AB|accessdate=2013-12-01|language=en|archivedate=2013-11-07|archiveurl=https://web.archive.org/web/20131107140904/http://www.erlang.org/doc/man/STDLIB_app.html|deadurl=no}}</ref> разом з ядром Erlang. Бібліотека містить модулі, що надають різноманітні функції для роботи з вбудованими типами та іншими структурами даних, вводу-виводу, звернення до середовища, для роботи з [[Файлова система|файловою системою]], процесами тощо.

Згідно з офіційною документацією, стандартна бібліотека модулів STDLIB є обов'язковою для включення до мінімальної системи Erlang/OTP<ref name=":10"/> разом з ядром Erlang. Бібліотека містить модулі, що надають різноманітні функції для роботи з вбудованими типами та іншими структурами даних, вводу-виводу, звернення до середовища, для роботи з файловою системою, процесами тощо.

Модуль <u><code>[https://www.erlang.org/doc/man/array array]</code></u> :

* визначає (функціональний) [[абстрактний тип даних]] для [[Динамічний масив|динамічного масиву.]]
* містить функції вилучення та оновлення елементів масиву, рекурсивні функції для роботи з масивами.
Модуль <u><code>[https://www.erlang.org/doc/man/string string]</code></u> розширює можливості модуля <code>[https://www.erlang.org/doc/man/lists.html#all-2 lists]</code> функціями для роботи безпосередньо зі списками символів, якими є рядки в мові Erlang.

Модуль <u><code>[https://www.erlang.org/doc/man/dict dict]</code></u> (від {{Lang-en|dictionary}}&nbsp;— словник) містить функції для [[Асоціативний масив|асоціативного масиву]]. Наприклад, збереження, вилучення та видалення значення за ключем, з'єднання масивів тощо.

Модуль <u><code>[https://www.erlang.org/doc/man/math math]</code></u> містить математичні функції.

Модуль <u><code>[https://www.erlang.org/doc/man/random random]</code></u> містить функції для генерації псевдовипадкових чисел.

Модуль <u><code>[https://www.erlang.org/doc/man/calendar calendar]</code></u> забезпечує обчислення місцевого та універсального часу, дня тижня та багатьох функцій перетворення часу. Час є місцевим, коли він налаштований відповідно до поточного часового поясу та літнього часу. Час є універсальним, коли він відображає час на нульовій довготі без будь-яких поправок на літній час.

Модуль <u><code>[https://www.erlang.org/doc/man/timer timer]</code></u> містить функції переведення інтервалів часу до мілісекунд, запуску подій за таймером та інші, пов'язані з часом, функції.

Модуль <u><code>[https://www.erlang.org/doc/man/erlang erlang]</code></u> містить вбудовані функції Erlang; по замовчуванню, функції з цього модуля є імпортованими в кожен модуль.

Модуль <u><code>[https://www.erlang.org/doc/man/file.html file]</code></u> забезпечує інтерфейс до файлової системи. Функції для відкриття, закриття, читання та запису файлів; перегляду директорій і&nbsp;т.&nbsp;д.

Модуль <u><code>[https://www.erlang.org/doc/man/filelib.html filelib]</code></u> містить утиліти вищого рівня, ніж модуль <u><code>[https://www.erlang.org/doc/man/file.html file]</code></u>. Цей модуль не підтримує «необроблені» імена файлів (тобто файли, імена яких не відповідають очікуваному кодуванню). Такі файли ігноруються функціями цього модуля. Допоміжні функції для маніпуляцій з файлами:

* <code>ensure_dir(Name) -> ok | {error, Reason}</code>&nbsp;— Переконується, що всі батьківські каталоги для вказаного файлу або імені каталогу існують, намагаючись створити їх, якщо необхідно. Повертає OK, якщо всі батьківські каталоги вже існують або можуть бути створені. Повертає {error, Reason}, якщо якийсь батьківський каталог не існує та не може бути створений.
* <code>ensure_path(Path) -> ok | {error, Reason}</code>&nbsp;— Переконується, що всі батьківські каталоги для вказаного шляху Path існують, намагаючись створити їх, якщо необхідно. На відміну від secure_dir/1, ця функція намагатиметься створити всі сегменти шляху як каталог, включаючи останній сегмент. Повертає OK, якщо всі батьківські каталоги вже існують або можуть бути створені. Повертає <code>{error, Reason}</code>, якщо якийсь батьківський каталог не існує та не може бути створений.

Модуль <u><code>[https://www.erlang.org/doc/man/filename filename]</code></u> містить функції для аналізу та обробки імен файлів. Ці функції створені таким чином, щоб код Erlang міг працювати на багатьох різних платформах із різними форматами імен файлів. Назва файлу може бути короткою відносною назвою, наприклад foo.erl, довгою абсолютною назвою, включаючи позначення диска, назвою каталогу, як-от D:\usr/local\bin\erl/lib\tools\foo.erl, або будь-якими варіаціями між ними. Допоміжні функції для маніпуляцій з файлами:

* <code>absname(Filename) -> file:filename_all()</code>&nbsp;— Перетворює відносне ім'я файлу та повертає абсолютне ім'я. Не робить спроб створити найкоротшу абсолютну назву, оскільки це може дати неправильні результати у файлових системах, які дозволяють посилання.
* <code>absname(Filename, Dir) -> file:filename_all()</code>&nbsp;— Те саме, що absname/1, за винятком того, що каталог, до якого має бути віднесене ім'я файлу, вказано в аргументі Dir.

Модуль <u><code>[https://www.erlang.org/doc/man/io.html io]</code></u> забезпечує інтерфейс до стандартних серверів введення/виведення Erlang. Усі функції виведення повертають ОК, якщо вони успішні, або завершують роботу, якщо це не так. Функції в цьому модулі мають додатковий параметр IoDevice. Якщо він включений, це буде pid процесу, який обробляє протоколи введення/виведення. Зазвичай&nbsp;— IoDevice, який повертає file: open/2. Якщо IoDevice не вказано, використовується standard_io. Опис протоколів вводу-виводу є у розділі «Протокол вводу-виводу Erlang» у посібнику користувача.

Модуль <u><code>[https://www.erlang.org/doc/man/io_lib io_lib]</code></u>&nbsp;— функції бібліотеки введення/виведення. Містить функції для перетворення в / і з рядків (списків символів). Вони використовуються для реалізації функцій в модулі [https://www.erlang.org/doc/man/io.html io].

Модуль <u><code>[https://www.erlang.org/doc/man/crypto.html crypto]</code></u> забезпечує набір криптографічних функцій. Наявні хеш-функції:

* SHA1, SHA2&nbsp;— Secure Hash Standard [FIPS PUB 180-4].
* SHA3&nbsp;— Standard: Permutation-Based Hash and Extendable-Output Functions [FIPS PUB 202].
* BLAKE2&nbsp;— fast secure hashing.
* MD5&nbsp;— Message Digest Algorithm [<nowiki>RFC 1321</nowiki>].
* MD4&nbsp;— Message Digest Algorithm [<nowiki>RFC 1320</nowiki>].
Модуль [https://www.erlang.org/doc/man/crypto_app <code><u>crypto_app</u></code>]&nbsp;— додаток [https://www.erlang.org/doc/man/crypto.html <u><code>crypto</code></u>]. Метою програми crypto є надання Erlang API для криптографічних функцій. API знаходиться на досить низькому рівні, і є деякі відповідні функції API, доступні в public_key(3), на вищому рівні абстракції, який використовує криптододаток у своїй реалізації. Поточна реалізація крипто використовує nifs для інтерфейсу криптобібліотеки OpenSSL і може працювати з обмеженою функціональністю зі старими версіями, як OpenSSL 0.9.8c. Підтримка режиму FIPS вимагає принаймні версії 1.0.1 і встановлення OpenSSL із підтримкою FIPS. Рекомендується використовувати версію, яка офіційно підтримується проєктом OpenSSL. API-сумісні серверні модулі, такі як LibreSSL, також повинні працювати. Криптододаток щодня тестується принаймні з однією версією OpenSSL 1.0.1, 1.0.2, 1.1.0, 1.1.1 і 3.0. Режим FIPS також перевірено для 1.0.1 і 1.0.2. Використання OpenSSL 3.0 із механізмами або в режимі FIPS ще не підтримується програмою OTP/crypto. Вихідні версії OpenSSL можна завантажити з домашньої сторінки проєкту OpenSSL або з перелічених там сайтів-дзеркал.

Окрім цих найбільш важливих модулів, стандартна бібліотека містить багато інших, з якими можна познайомитися за документацією.<ref name=":1" />

=== Таблиці ETS та DETS ===
Для організації [[Колекція (програмування)|колекцій]] в оперативній пам'яті в Erlang є модуль ETS ({{Lang-en|Erlang Term Storage}}&nbsp;— «сховище термів Erlang»). ETS може зберігати чотири види колекцій: [[Множина (тип даних)|множина]] ({{Lang-en|set}}), [[впорядкована множина]] ({{Lang-en|ordered set}}), [[мультимножина]] ({{Lang-en|bag}}), [[Множина (тип даних)|мультимножина з повтореннями]] ({{Lang-en|duplicate bag}}).<ref name=":2" /> Доступ до елементів колекцій відбувається ключовим полем кортежу(ключі, як і значення, можуть бути будь-яких типів). Упорядковані множини зреалізовані у вигляді бінарних збалансованих [[АВЛ-дерево|АВЛ-дерев]], а інші колекції&nbsp;— з використанням [[Геш-таблиця|хеш-таблиць]].<ref name=":1" />

DETS-таблиці доповнюють функціональність ETS-таблиць (за винятком впорядкованих множин), дозволяючи зберігати дані у файлах.

=== Фреймворк OTP ===
[[Файл:Дерево процесів.png|альт=|праворуч|безрамки|Дерево процесів Erlang]]
OTP ({{Lang-en|Open Telecom Platform}}) є налагодженим набором корисних поведінок ({{Lang-en|behaviours}}) процесів. Він використовується для створення серверних програм. OTP формалізує дії процесів та дозволяє будувати на їх основі [https://www.erlang.org/doc/applications.html <u>OTP-додатки</u>]. У [https://www.erlang.org/doc/man_index.html модулях ОТР] визначено загальні, стандартизовані шаблони для конструювання паралельних додатків. <u>[https://www.erlang.org/doc/man/gen_server.html <code>Gen_server</code>]</u>&nbsp;— інтерфейсний модуль для реалізації клієнт-серверної архітектури.<ref>{{Cite web|title=Erlang -- gen_server|url=https://www.erlang.org/doc/man/gen_server.html|website=www.erlang.org|accessdate=2022-09-16}}</ref> Загальний серверний процес ([https://www.erlang.org/doc/man/gen_server.html <code>gen_server</code>]), реалізований за допомогою цього модуля, має стандартний набір інтерфейсних функцій і включає функції відстеження та звітування про помилки. Він вписується в дерево нагляду OTP. Найпопулярнішими поведінками є узагальнений сервер та спостерігач ({{Lang-en|supervisor}})<ref>{{Cite web|title=Erlang -- supervisor|url=https://www.erlang.org/doc/man/supervisor.html|website=www.erlang.org|accessdate=2022-09-16}}</ref>. Є й інші поведінки: [[Скінченний автомат|кінцевий автомат]], обробник [https://www.erlang.org/doc/man/gen_event.htm подій]<ref>{{Cite web|title=Erlang -- gen_statem|url=https://www.erlang.org/doc/man/gen_statem.html|website=www.erlang.org|accessdate=2022-09-16}}</ref>.<ref name=":2" /> OTP містить і інше [[Проміжне програмне забезпечення|сполучне програмне забезпечення]] ({{Lang-en|middleware}}), наприклад, [[Система управління базами даних|СУБД]] [[Mnesia]].

OTP-поведінки поділяються на робочі процеси ({{Lang-en|worker processes}}):

* Що виконують власне обробку запитів,
* Процеси-спостерігачі ({{Lang-en|supervisors}}).

У завдання процесів спостерігачів входить стеження за робочими процесами та іншими процесами спостерігачами&nbsp;— нащадками. Дерева спостерігачів складають OTP-додаток ({{Lang-en|application}}). Документація Erlang визначає OTP-додаток компонентом, який реалізує деяку функціональність, яка може бути незалежно запущена на виконання і зупинена як ціле, а також [[Повторне використання коду|повторно використана]] в інших системах.<ref>{{Cite web|url=https://www.erlang.org/doc/apps/kernel/application.html|title=application, Kernel Reference Manual Version 2.16.3|date=1 листопада 2013|website=www.erlang.org|publisher=Ericsson AB|language=англійська|accessdate=2013}}</ref> Розробник програми пише код '''''модулів функцій зворотного виклику''''' ({{Lang-en|call-back module}}), в яких і знаходиться специфічна для цієї програми частина функціональності.<ref name=":1" />

Строго кажучи, OTP не є частиною мови Erlang. Однак, він настільки увійшов у культуру та практику розробників на Erlang, що часом між ними складно провести межу.<ref name=":2" />

=== Розробка графічного інтерфейсу користувача ===
Розробка додатків з [[Графічний інтерфейс користувача|графічним інтерфейсом користувача]] (крім [[Вебінтерфейс|веб-інтерфейсів]]) може вестись за допомогою бібліотеки wxErlang&nbsp;— бібліотеки [[wxWidgets]], портованої для Erlang. В стандартну поставку Erlang/OTP входить WxErlang. WxWidgets написаний на [[C++]], тому перед розробниками wxErlang стояло завдання виразити засобами Erlang ієрархію [[Об'єкт (програмування)|об'єктів]]. Спрощуючи, у wxErlang [[Клас (програмування)|класам]] відповідають модулі, а об'єктам&nbsp;— посилання, макросам на C ++ відповідають макроси Erlang. Деякі типи даних, для яких у C++ були використані класи, подаються в Erlang за допомогою інших типів даних, наприклад wxPoint задається у вигляді кортежу з двох елементів. Події wxErlang можна оброблити в Erlang або через функцію зворотнього виклику ({{Lang-en|call-back functions}}), або в більш природному середовищі Erlang передачею повідомлень.<ref name=":1" />

== Програмування на Erlang ==

=== Інтерактивна оболонка ===
[[Файл:Інтерактивна оболонка erl в окремому вікні.png|міні|333x333пкс|Інтерактивна оболонка erl в окремому вікні]]
Інтерактивна оболонка ({{Lang-en|shell}}) для Erlang може бути викликана в [[UNIX-подібні операційні системи|Unix-подібних системах]] командою <code>erl</code>, у Windows&nbsp;— <code>werl</code>.

Оболонка дозволяє:

* вводити вирази та отримувати результат їх виконання, випробувати новий код,
* займатися інтерактивним налагодженням,
* керувати системою, що знаходиться в промисловій експлуатації, тощо.<ref name=":4" />

Також, оболонка дозволяє використовувати додаткові функції (команди), доступні тільки в ній. До прикладу, команда <code>q().</code> здійснює вихід із оболонки із завершенням всього, що робить Erlang-система.<ref name=":4" />

В оболонці можна викликати BREAK-меню за допомогою {{Клавіша|Ctrl|C}} (у Unix-подібних ОС) або {{Клавіша|Ctrl|Break}} (у Windows). Це меню має різні команди, у тому числі {{Клавіша|a}}&nbsp;— негайна зупинка, {{Клавіша|c}}&nbsp;— продовження роботи в оболонці та інші інформаційні та допоміжні команди для роботи з Erlang-системою. Комбінація клавіш {{Клавіша|Ctrl|G}} викликає ще командне меню, яким можна, за необхідності, зупинити процес, що «завісив» оболонку, і повернутися в оболонку ({{Клавіша|i}} і потім {{Клавіша|c}})<ref name=":3" />

=== Документування та оформлення коду ===
Система EDoc може генерувати документацію з вихідного коду. Для документування коду модуля достатньо додати певним чином розмічений текст, а також файл <code>overview.edoc</code> для документації рівня проєкту (в останньому необов'язково використовувати знаки коментаря)<ref name=":2" />. Інструменти для роботи з кодом на Erlang, наприклад, erlang-режим в [[Emacs]], мають на увазі деякі особливості щодо вживання символів коментаря. Коментарем вважається текст від знака відсотка (<code>%</code>) до кінця рядка в Erlang. Так, потрійний знак відсотка викликає вирівнювання лівим краєм, подвоєний&nbsp;— вирівнювання на рівні навколишнього коду, а одиночний знак відсотка використовується для позначення коментаря після коду, в кінці рядка<ref name=":2" />. Розробники Erlang виробили певні [[Стандарт оформлення коду|стильові угоди]] щодо організації та оформлення вихідного коду. Наприклад, хорошим стилем вважається зниження вкладеності синтаксичних структур, написання коротких модулів (менше 400 рядків коду) та функцій (не довше 15-20 рядків коду), використання осмислених імен для змінних та функцій тощо.<ref>{{Cite web|url=http://erlang.se/doc/programming_rules.shtml|title=. Programming Rules and Conventions|last=Klas Eriksson, M. Williams, J. Armstrong|date=2 грудня 2013|website=erlang.se|publisher=Ericsson AB|language=англійська|accessdate=2022-08-16|archive-date=2013-11-30|archive-url=https://web.archive.org/web/20131130121046/http://www.erlang.se/doc/programming_rules.shtml}} {{Webarchive|url=https://web.archive.org/web/20131130121046/http://www.erlang.se/doc/programming_rules.shtml |date=2013-11-30 }}</ref>

=== Типи та аналіз коду ===
Програма Dialyzer, розроблена в рамках проєкту HiPE. Вона входить до стандартної поставки і дозволяє виявити помилки (у тому числі помилки типізації) шляхом [[Статичний аналіз коду|статичного аналізу коду]]. Програма TypEr, написана Тобіасом Ліндалом (Tobias Lindahl) та Костісом Сагонасом (Kostis Sagonas), є частиною Dialyzer. TypEr дозволяє перевіряти визначення типів функцій, звіряти вказаний у директиві <code>-spec</code> тип функції з її визначенням, виконати виведення типів. Програма виводить всі типи, що відповідають успішному застосуванню функції, в загальному випадку лише приблизно, в більш грубий бік. Використання функції будь-яким іншим чином обов'язково призведе до помилки часу виконання. У наступному прикладі показаний синтаксис визначення типу (директива <code>-type</code>), оголошення типу полів запису та директива <code>-spec</code> разом з визначенням функції<ref name=":1" />:<syntaxhighlight lang="erlang" line="1">
-type(user_status() :: disabled | enabled). % статус - один з двох атомів

-record(user, {login="anon" ::string(), % типи полів запису
               password ::string(),
               status :: user_status(),
               nickname ::string()}).

-spec(check_password(string(), #user{}) -> ok | {error, string()}). % декларація функції

check_password(Password, User) -> % визначення функції
    ...
</syntaxhighlight>
Dialyzer (від {{Lang-en|DIscrepancy AnaLYZer for ERlang Programs}}&nbsp;— «аналізатор суперечностей для Erlang-програм») програма для виявлення в коді окремих модулів і в окремих додатках, помилок типів, [[Недосяжний код|недосяжного коду]] та надлишкових перевірок. Усі виявлені Dialyzer дефекти вимагають усунення, бо інструмент не дає помилкових спрацьовувань. Для кожної функції всіх модулів, що перевіряються, Dialyzer, встановлює тип, використовуючи заснований на обмеженнях вивід типів і аналіз потоків даних. Після визначення типів функцій проводиться аналіз протиріч у програмі.<ref>{{Cite book
|title=A Scalability Benchmark Suite for Erlang/OTP
|last=Aronis, Stavros and Papaspyrou, Nikolaos and Roukounaki, Katerina and Sagonas, Konstantinos and Tsiouris, Yiannis and Venetis, Ioannis E.
|year=2012
|publisher=Proceedings of the Eleventh ACM SIGPLAN Workshop on Erlang Workshop. Erlang '12.
|location=Copenhagen, Denmark: ACM.
|pages=pp. 33—42
|language=англійська
|isbn=978-1-59593-766-7.
}}</ref>

=== Тестування, профілювання, рефакторинг ===
Для [[Модульне тестування|модульного тестування]] Erlang надає EUnit. Для [[Системне тестування|системного тестування]] Erlang надає фреймворк Common Test. EUnit містить засоби для опису тестів, в тому числі необхідний для цього набір макросів, а також виводить звіт по закінченню тестування. Тестування модулів відбувається шляхом підключення заголовного файлу з EUnit, а функції з тестами можуть бути як включені в сам модуль, що тестується, так і винесені в окремий модуль.<ref name=":1" />

Тестування паралельних програм можна виконати за допомогою Quviq Quick Check (версія Mini безкоштовно). Крім тестування, можна здійснити перевірку всіх можливих варіантів вихідних даних за допомогою методу [[Перевірка моделі|перевірки моделей]]. Для цього є, створена в Мадридському політехнічному університеті, утиліта McErlang. [https://github.com/fredlund/McErlang]<ref name=":1" />

Щоб [[Профілювання (програмування)|профілювати]] код та виявити ступінь [[Тестування програмного забезпечення|покриття коду тестами]] можна звернутися до модулів <code>eprof</code>, <code>fprof</code>, <code>cover</code> та [[Утиліта|утиліти]] cprof.<ref name=":2" />

Для Erlang розроблена низка інструментів [[рефакторинг]]у вихідного коду (список не є вичерпним):

* RefactorErl,
* Wrangler,
* автоматична, незалежна від [[Інтегроване середовище розробки|IDE]] утиліта tidier.

Утиліта tidier дозволяє автоматично знаходити та виробляти еквівалентні перетворення коду, наприклад, замінює<syntaxhighlight lang="erlang" line="1">
lists:filter(fun (X) -> is_something(X) end, L)
</syntaxhighlight>на<syntaxhighlight lang="erlang" line="1">
[X || X <- L, is_something(X)]
</syntaxhighlight><ref>{{Cite book
|title=Cleaning Up Erlang Code is a Dirty Job but Somebody's Gotta Do It
|last=Avgerinos, Thanassis and Sagonas, Konstantinos.
|year=2009
|publisher=Proceedings of the 8th ACM SIGPLAN Workshop on ERLANG ACM,
|location=Edinburgh, Scotland:
|language=англійська
|deadurl=https://dl.acm.org/doi/10.1145/1596600.1596602
}}</ref>

=== Ефективність ===
Erlang має свої секрети написання ефективного коду. Удосконалення мови робить деякі з трюків застарілими, тому документація є найкращим посібником у питаннях оптимізації, у сукупності з профілюванням та [[Стрес-тестування програмного забезпечення|стрес-тестуванням]].

Наприклад, при роботі зі списками не бажано додавати елемент до кінця довгого списку за допомогою конкатенації або функції додавання елемента до списку. Зате можна додати елемент до початку списку, а кінцевий результат обробити функцією звернення порядку елементів списку.<syntaxhighlight lang="erlang" line="1">
L1 = [New_Elem | List].
L2 = lists:reverse(L1).
</syntaxhighlight>Є свої рекомендації і для підвищення ефективності паралельних програм. До прикладу, дії, що вимагають багато пам'яті, найкраще виділяти в окремий процес, бо при цьому зменшуються витрати на збирання сміття. Тоді пам'ять швидше буде звільнено після завершення процесу.<ref name=":1" />

== Erlang та інші мови програмування ==

=== Інтеграція та гібридні мови ===
Erlang-система дозволяє виконувати інтеграцію з системами на інших мовах програмування. Є механізми для мережевої взаємодії з [[C (мова програмування)|С]], [[Java]], [[Lisp|Лісп]], [[Perl]], [[Python]], [[Ruby]]. До прикладу, для ефективнішого синхронного виклику невеликих функцій на C можна використовувати платформно-залежні функції ({{Lang-en|NIF, natively implemented function}}). Високорівневі бібліотеки дозволяють Erlang-системі представляти C або Java-вузли як звичайні Erlang-вузли. Інші мови можна пов'язати з середовищем виконання Erlang за допомогою [[драйвер]]ів або мережевих [[Сокет (програмний інтерфейс)|сокетів]] за допомогою протоколів на кшталт [[HTTP]], [[SNMP]], IIOP. До прикладу, Ruby взаємодіє з Erlang за допомогою пакета erlectricity, а для Python розроблена реалізація Erlang-вузла у вигляді пакету py-interface.<ref name=":7" />

Віртуальна машина Erlang знаходить застосування і в інших мовах програмування. До прикладу, [[Elixir (мова програмування)|Elixir]] та проєкт Erl2 Джо Армстронга. Крім того, Роберт Вірдінг підтримує проєкт Lisp Flavored Erlang («Erlang, приправлений Ліспом»), у якому синтаксис [[Lisp|Ліспа]] використовується з компілятором<ref>{{Cite web|url=https://lfe.github.io/|title=Lisp Flavored Erlang|language=англійська|website=lfe.github.io}}</ref> Erlang. Є й інші BEAM-мови: Efene, Joxa, Reia<ref>{{Cite web|url=http://www.unlimitednovelty.com/2011/06/why-im-stopping-work-on-reia.html|title=Why I’m stopping work on Reia|date=JUNE 29, 2011|website=www.unlimitednovelty.com|language=англійська}}</ref>, Luerl, Erlog<ref>{{Cite web|url=http://spawnedshelter.com/|title=Federico Carrone, et al Spawned Shelter!|date=15 вересня 2013|website=spawnedshelter.com|language=Англійська}}</ref>.

На офіційному сайті мови є [http://www.erlang.org/faq/academic.html згадка] проєкт про [https://github.com/trifork/erjang/wiki Erjang,] в якому використовується віртуальна машина Java.

=== Порівняння Erlang та C++ за продуктивністю ===
Практика показує, що для вивчених телекомунікаційних додатків код на Erlang був на 70—85&nbsp;% коротшим, ніж на [[C++]], а продуктивність системи при переписуванні коду з C++ на Erlang зросла майже на 100&nbsp;%{{sfn|Nyström, Trinder, King|2008}}. Для одного із використаних у дослідженні проєктів різниця була пояснена написанням додаткового C++ коду в рамках [[Defensive computing|захисного програмування]], управління пам'яттю та коду для високорівневої комунікації, тобто можливостями, які є частиною мови Erlang та бібліотек OTP.<ref name=":1" />

=== Порівняння взаємодії процесів у Erlang та Go ===
Вплив [[Комунікуючі послідовні процеси|теорії послідовних процесів, що взаємодіють,]] [[Тоні Гоар|Чарльза Е.Хоара]] відчувається як у [[Go (мова програмування)|Go]], так і в Erlang.

'''Erlang і Go'''

<u>Спільне</u> : процеси відправляють одне одному повідомлення.

<u>Відмінне</u>:

* В Erlang це відбувається безпосередньо.
* В Go за допомогою каналів ({{Lang-en|channels}})<ref name="chisnall2">{{Cite web|url=http://www.informit.com/articles/article.aspx?p=1768317|last=David Chisnall|title=A Tale of Two Concurrency Models: Comparing the Go and Erlang Programming Languages|date=2011-11-14|publisher=Pearson Education, Informit|accessdate=2013-12-01|language=en|archivedate=2013-12-03|archiveurl=https://web.archive.org/web/20131203213648/http://www.informit.com/articles/article.aspx?p=1768317|deadurl=no}}</ref> Ці канали мають типи.<ref>{{Cite web|url=https://www.informit.com/articles/|title=A Tale of Two Concurrency Models: Comparing the Go and Erlang Programming Languages|last=Chisnall|first=David|date=14 листопада 2011|website=www.informit.com|language=англійська|accessdate=1 грудня 2013}}</ref>

'''Організація взаємодії з повідомленнями'''

У Erlang немає типізації часу [[Компілятор|компіляції]] за винятком охоронних виразів, що дозволяє посилати процесам повідомлення будь-якого типу. «Незрозуміле» повідомлення буде проігноровано, або назавжди залишиться в черзі<ref name="chisnall2"/>.

Go дозволяє легко організувати групу «go-програм» ({{Lang-en|goroutine}}&nbsp;— натяк на {{Lang-en|co-routine}}&nbsp;— [[співпрограма]]) для отримання повідомлень з деякого каналу (такий підхід відомий як [[пул потоків]]).

'''Реалізація робочого пулу'''

В Erlang, при проєктуванні якого приділялася особлива увага [[Детермінізм (інформатика)|детермінізму]] та часу затримки ({{Lang-en|latency}}), реалізація робочого пулу можлива, але потребує додаткових зусиль. Численні відправники тривіально реалізуються в обох мовах.<ref name="chisnall2"/> Erlang-процес може надіслати повідомлення і чекати на нього відповідь (відповідно до деякого зразка), ігноруючи інші повідомлення в черзі.

В Go таке неможливо, але подібна функціональність може бути досягнута створенням (у тому числі динамічним) нових вводів, тобто поділом каналів за призначенням.<ref name="chisnall2"/>

'''Розділення між процесами'''

В Erlang відсутній стан, що розділяється між процесами ({{Lang-en|shared mutable state}}) і тому ізольований процес дуже рідко представляє інтерес<ref name="chisnall2"/>

Go вимагає явної вказівки того, які go-програми будуть взаємодіяти з іншими передачею повідомлень.

Абстракції взаємодіючих процесів схожі в Erlang і Go. Щоб уникнути помилок при переході з однієї мови на іншу, слід враховувати тонкощі і особливості обох мов: шаблони, які хороші в одній мові, можуть не підходити для іншої.<ref name="chisnall2"/>

== Критика ==

В Erlang є недоліки<ref name="Katz" />:

* Недоліки синтаксису: символ закінчення виразу залежить від контексту (це або символи <code>. ,</code> або <code>;</code>). Це вимагає додаткової уваги при зміні місця виразу.
* Надлишкове багатослів'я записів (record).
* Завжди потрібно прописувати повний перелік альтернатив, або вказати останньою клозою true в if-виразі, для уникнення видачі [[Обробка винятків|винятку]], якщо ні одна з умов не виконується.
* Суворо обмежений набір функцій, які можна використовувати в if-виразах (цей недолік можна оминути використанням case-виразів).
* Функціональний стиль і незмінювані змінні призводять у деяких додатках (наприклад, тести) до більшої кількості правок, ніж в інших мовах програмування, так як вставка деякої проміжної обробки може вимагати нових імен змінних, що може призвести до змін у коді, наступного далі за текстом.
* З недоліків системи типів можна вказати відсутність [[Рядок (програмування)|рядкового типу]], і неможливість динамічно додавати у записи нові члени.
* Існують проблеми з організацією вихідного коду, яка можлива тільки через створення нового файлу.
* Відсутність просторів імен, класів або інших засобів для організації коду.
* Рівень якості модулів, за винятком основних, та документації є далеко не найкращим<ref name="Katz">{{Cite web|url=http://damienkatz.net/2008/03/what_sucks_about.html|title=What Sucks About Erlang|last=Katz|date=2008-03-09|language=en|accessdate=2013-11-24|archivedate=2013-12-05|archiveurl=https://web.archive.org/web/20131205040258/http://damienkatz.net/2008/03/what_sucks_abou.html|deadurl=no|first=Damien|website=damienkatz.net}}</ref>.
Джо Армстронг, один з творців мови, у своєму виступі на конференції з історії мов програмування в 2007 році перерахував список зон зростання для мови:{{Sfn|Armstrong, A History of Erlang|2007|місце=6-19,6-20}}

* Використання збирання сміття для атомів.
* Поліпшення засобів сполучення із зовнішнім кодом ({{Lang-en|foreign code}}).
* Посилення ізоляції між процесами.
* Більш виборча система безпеки серед вузлів Erlang, заснована на різному ступені довіри.
* Окремі позначення для протоколів та систем.
* Модулі мають бути [[Об'єкт першого класу|об'єктами першого класу]].

Масове поширення Erlang може стримувати незвичний для більшості програмістів [[Синтаксис (програмування)|синтаксис]], використання [[Функційне програмування|функціональної парадигми]], а також те, що найкраща на 2022 рік реалізація мови використовує віртуальну машину BEAM, а не більш поширену [[Віртуальна машина Java|JVM]].{{Sfn|Tate|2010|с=221}}

=== Сфера застосування ===
[[Файл:ErlangStack.png|міні|288x288пкс|Типова архітектура системи, яка використовує Erlang/OTP. Програми Erlang користуються службами Mnesia, [[SASL]], агентами SNMP-моніторингу та іншими на базі фреймворку OTP, який у свою чергу використовує ERTS. Програми інших систем програмування підтримуються меншою мірою{{sfn|Dan McCreary, Ann Kelly|2013}}.]]
Erlang підходить для:

* Створення мережевих [[сервер]]ів, розподілених систем, програм з [[Графічний інтерфейс користувача|GUI]] та подібних до них інтерактивних програм.
* Створення інструментів для тестування, управління та стеження,
* Створення додатків з нерегулярним паралелізмом, у яких розпаралелювані завдання досить різноманітні.

Erlang погано підходить для: Написання коду, що містить інтенсивні обчислення з плаваючою комою, який вимагає включення [[Машинний код|нативного коду]] конкретної платформи чи сильної оптимізації і для створення додатків, які потребують синхронного виконання завдань.

Для проєктів, в яких код повинен виконуватися на [[Віртуальна машина Java|JVM]] або [[Common Language Runtime|CLR]], або проєктів, що вимагають безлічі бібліотек з інших систем програмування{{sfn|Larson, Erlang for Concurrent Programming|2008}}.

Крім того, Erlang став застосовуватися для :

* Розробки [[Хмарні обчислення|систем]] хмари ще до того, як сформувалося саме поняття хмарних обчислень.<ref name="гифт">{{Cite web|url=http://www.ibm.com/developerworks/en/library/cl-bigdata/index.html|title=Робота з великими обсягами даних в хмарі за допомогою MapReduce|date=2012-03-01|publisher=IBM|accessdate=2013-12-07|archivedate=2013-12-11|archiveurl=https://web.archive.org/web/20131211043500/http://www.ibm.com/developerworks/en/library/cl-bigdata/index.html|deadurl=no|language=англійська}}</ref>
* Використовується в масштабних телекомунікаційних та Інтернет-додатках багатьма компаніями, включаючи [[Amazon Elastic Compute Cloud|Amazon EC2]] з реалізацією [[SimpleDB]].
* Сервіс соціальних закладок [[Delicious]], [[Facebook]] (бекенд для чату), зроблений на Erlang.
* [[T-Mobile]] (сервіс [[SMS]] та системи аутентифікації){{sfn|Ericsson| 4 December 2014|місце="Ericsson". Ericsson.com. 4 December 2014. Retrieved 7 April 2018.}}.
* Серверне програмне забезпечення [[WhatsApp]] написане на Erlang.
* У січні 2012 року сервери WhatsApp під [[FreeBSD]] з 96 ГБ оперативної пам'яті змогли обробляти від 1 до 2,8 мільйонів з'єднань<ref>[http://www.erlang-factory.com/upload/presentations/558/efsf2012-whatsapp-scaling.pdf Scaling to Millions of Simultaneous Connections] {{Wayback}}, Rick Reed (WhatsApp) // Erlang Factory SF, March 30, 2012</ref><ref>[http://blog.whatsapp.com/index.php/2012/01/1-million-is-so-2011/ 1 million is so 2011] {{Wayback}} // WhatsApp Blog, January 6, 2012</ref>.

Erlang часто ставлять у заслугу легендарну надійність ATM-комутатора AXD301 у мережі [[British Telecom]].

За даними Ericsson, з січня 2002 року за декілька років трапилася лише одна незначна несправність, на підставі чого надійність системи згідно з розрахунками була 99,9999999&nbsp;%{{sfn|Томпсон|2012|с=33}}. Хоча більш реальні оцінки, що враховують багато інших факторів, говорять все-таки про «п'ять дев'яток», успіх маршрутизатора пов'язують з доступними засобами розробки надійних паралельних обчислень, вбудованими в Erlang{{sfn|Томпсон|2012|с=33}}.

Ще Erlang використовується в додатках [[Відкрите програмне забезпечення|з відкритим вихідним кодом]], наприклад:

* [[Apache CouchDB|CouchDB]]&nbsp;— документоорієнтована [[База даних|БД]] з [[REST]]&nbsp;— інтерфейсом,
* [https://github.com/disco-framework/disco Disco]&nbsp;— фреймворк для [[Розподілені обчислення|розподілених обчислень]] на основі парадигми [[MapReduce]]<ref name="гифт2">{{Cite web|url=http://discoproject.org/#:~:text=Disco%20is%20a%20lightweight%2C%20open,and%20schedules%20your%20jobs%20efficiently.|title=Робота з великими обсягами даних в хмарі за допомогою Map Reduce|last=http://discoproject.org/|date=2012-03-01|accessdate=2013-12-07|archivedate=2013-12-11|archiveurl=https://web.archive.org/web/20131211043500/http://www.ibm.com/developerworks/ru/library/cl-bigdata/index.html|deadurl=no|website=discoproject.org|language=Англійська}}</ref><ref>{{Cite web|url=http://discoproject.org/|title=Disco (сторінка проєкту)|accessdate=2013-12-07|archivedate=2010-09-16|archiveurl=https://web.archive.org/web/20100916105505/http://discoproject.org/|deadurl=no|website=discoproject.org}}</ref>,
* [[Ejabberd]]&nbsp;— вільний (GNU GPL), розподілений та відмовостійкий Jabber-сервер, написаний на Erlang,
* [[RabbitMQ]]&nbsp;— [[Message-oriented middleware|платформа, орієнтована на обробку повідомлень]] (реалізує [[AMQP]], [[MQTT]]<ref>{{Cite web|last=Pivotal Software, Inc.|title=RabbitMQ MQTT Adapter|url=https://www.rabbitmq.com/mqtt.html|accessdate=2015-12-10|archivedate=2015-12-01|archiveurl=https://web.archive.org/web/20151201005325/http://www.rabbitmq.com/mqtt.html|deadurl=no}}</ref>),
* [[Wings 3D]]&nbsp;— програма 3D-моделювання.{{sfn|Томпсон|2012|с=23—25}}

Для Erlang було написано декілька [[Вебсервер|веб-серверів]]:

* [https://github.com/ninenines/cowboy Cowboy]<ref>{{Citation|title=Cowboy|url=https://github.com/ninenines/cowboy|publisher=Nine Nines|date=2022-09-15|accessdate=2022-09-16}}</ref>
* [[Yaws]] ({{Lang-en|Yet Another Web Server}}),
* [[MochiWeb]]&nbsp;— бібліотека для створення HTTP-серверів<ref>{{Cite web|url=http://www.ibm.com/developerworks/xml/library/os-erlang2/|title=Introduction to programming in Erlang, Part 2: Use advanced features and functionality|date=2013|last=Martin Brown|publisher=[[IBM]]|accessdate=2013-12-01|language=en|archivedate=2013-12-03|archiveurl=https://web.archive.org/web/20131203133348/http://www.ibm.com/developerworks/xml/library/os-erlang2/|deadurl=no}}</ref>.

Ще були створені декілька [[Каркас вебзастосунків|веб-фреймворків]] і [[Система керування вмістом|систем управління вмістом]], таких як:

* [https://github.com/synrc/n2o N2O]<ref>{{Cite web|url=https://github.com/synrc/n2o|title=N2O|accessdate=2014-12-13|archiveurl=https://web.archive.org/web/20150818181301/https://github.com/synrc/n2o|deadurl=no|archive-date=2015-08-18}}</ref>,
* [[Nitrogen (програмний каркас)|Nitrogen]]
* [[Chicago Boss]]
* [https://zotonic.com/ Zotonic]
* BeepBeep
* Erlang Web
* ErlyWeb{{sfn|Zachary Kessin|2012|с=121—123}}
* [https://github.com/novaframework/nova Novaframework]<ref>{{Cite web|url=https://github.com/novaframework/nova|title=Novaframework|date=24 травня 2022|website=github.com|language=англійська|accessdate=22.08.2022}}</ref>

Серед відомого програмного забезпечення, написаного Erlang, яке не увійшло в категорії вище виділяють:

* Розподілену [[NoSQL]] базу даних [[Riak]], яка спроєктована за принципами [[Amazon DynamoDB]]{{sfn|Simon St. Laurent|2013|с=167}}.
* [[Flussonic]] (раніше відомий як [[Erlyvideo]])&nbsp;— відеострімінговий сервер, що підтримує декілька протоколів<ref>{{Cite web|url=https://flussonic.com/|title=Flussonic — live streaming software|accessdate=2012-05-07|archivedate=2012-06-16|archiveurl=https://web.archive.org/web/20120616192637/http://erlyvideo.com|deadurl=no}}</ref>.

Крім того, написаний на Erlang інструмент [[Tsung]], який дозволяє емулювати тисячі (за достатньої кількості тестових серверів&nbsp;— мільйони) одночасних користувачів, застосовується у стрес-тестуваннях розподілених систем<ref>{{Книга
|автор = Bradley Holt
|частина = Chapter 6. Distributed Load Testing
|заголовок = Scaling CouchDB
|посилання = https://archive.org/details/scalingcouchdb00holt
|видавництво = O'Reilly Media, Inc.
|рік = 2011
|pages = [https://archive.org/details/scalingcouchdb00holt/page/n52 39]
|allpages = 72
|ISBN = 978-1-4493-0343-3
|ref = Holt
}}</ref>.

Erlang підходить для завдань [[Штучний інтелект|штучного інтелекту]] (особливо [[Обчислювальний інтелект|обчислювального інтелекту]], [[Нейроеволюція|нейроеволюції]]), заснованих на [[Штучна нейронна мережа|нейронних мережах]]. Таке застосування можливе завдяки п'ятьом ключовими властивостями «мови програмування нейронних мереж», що є у Erlang:

* ізольовані процеси-нейрони ({{Lang-en|encapsulation}}),
* паралелізм ({{Lang-en|concurrency}}, одночасність),
* механізм виявлення збоїв,
* незалежність від розташування ({{Lang-en|location transparency}})
* гаряча заміна коду.

Прикладом такого застосування є реалізація одного з підходів до нейроеволюції&nbsp;— DXNN{{sfn|Sher|2013|місце=Chapter 5 The Unintentional Neural Network Programming Language|сторінки=144—150}}.

=== Спільнота ===
Навколо технологій Erlang утворилась спільнота розробників, яка підтримує новачків.

[[Початковий код|Вихідний код]] Erlang доступний через сервіс спільної розробки [[GitHub]]. Розробники та користувачі Erlang можуть спілкуватися через список розсилки Erlang-questions (питання Erlang) або на IRC-каналі #erlang на [[Freenode]].

[https://www.erlang-factory.com/ Erlang Factory] влаштовує у всьому світі заходи та конференції, серед яких конференція користувачів Erlang (Erlang User Conference).

Спеціальна група SIGPLAN [[Асоціація обчислювальних машин|ACM]] регулярно проводить Erlang-майстерню (Erlang Workshop), а конференція [[O'Reilly Open Source Convention|OSCON]] включає секцію з Erlang{{sfn|Simon St. Laurent|2013|с=168—169}}.

В Україні [https://t.me/erlang_club Erlang спільнота] порівняно невелика.

== Див. також ==
* [[.erl]]
* [[Elixir (мова програмування)]]

== Виноски ==
{{reflist}}

== Посилання ==
* http://www.erlang.org/ — реалізація з відкритими вихідними текстами {{Webarchive|url=https://web.archive.org/web/20060613061633/http://erlang.org/white_paper.html |date=13 червня 2006 }}
* http://groups.google.com/group/erlang-in-ukraine — група україномовної Erlang-спільноти
* https://archive.today/20030224125715/http://www.erlang-projects.org/ — репозиторій проєктів на Erlang
* https://web.archive.org/web/20111026040038/http://cean.process-one.net/ — Comprehensive Erlang Archive Network, репозиторій проєктів на Erlang
* https://web.archive.org/web/20130806160118/http://www.trapexit.org/ — форум, [[вікі]], рішення, підручники, довідкові матеріали
* http://erlide.sourceforge.net/ — плагін для середовища розробки [[Eclipse]] {{Webarchive|url=https://web.archive.org/web/20070905210102/http://erlide.sourceforge.net/ |date=5 вересня 2007 }} з підтримкою мови Erlang
* http://www.learnyousomeerlang.com — англомовний онлайн-підручник з програмування мовою Erlang {{Webarchive|url=https://web.archive.org/web/20220408140344/https://learnyousomeerlang.com/ |date=8 квітня 2022 }}
* 2007. Programming Erlang: Software for a Concurrent World. Pragmatic Bookshelf ISBN 978-1934356005.
* 2013. Programming Erlang: Software for a Concurrent World. Second edition. Pragmatic Bookshelf ISBN 978-1937785536.

{{Мови програмування}}


{{Compu-lang-stub}}

[[Категорія:Функційні мови програмування]]
[[Категорія:Багатоплатформне вільне програмне забезпечення]]
[[Категорія:Мови програмування зі співставленням з шаблоном]]