Колекції в Elixir

Списки

Що таке список у Elixir

У Elixir список — це впорядкована колекція елементів, реалізована як однозв’язний список. Це означає, що кожен елемент (вузол) зберігає посилання на наступний, але не на попередній. Така структура дозволяє швидко додавати елементи на початок списку, але повільно доступати до довільного елементу.

У Java подібну структуру представляє LinkedList — частина Java Collections Framework. Вона реалізована як двозв’язний список, що забезпечує зручне додавання/видалення елементів з початку або кінця списку.

Створення списків

У Elixir список створюється за допомогою квадратних дужок:

list = [1, 2, 3, 4] 

Додавання елементів

У Elixir новий елемент можна додати тільки на початок списку за допомогою оператора |:

# Elixir 
list = [2, 3, 4] 
new_list = [1 | list] # [1, 2, 3, 4] 

Доступ до елементів

У Elixir немає прямого доступу до елементів за індексом, але це можна зробити через Enum.at:

Enum.at([10, 20, 30], 1) # 20 

Ітерація по списку

У Elixir зручно ітерувати список через Enum.each:

Enum.each([1, 2, 3], fn x -> IO.puts(x) end) 

Pattern matching для списків

Elixir підтримує потужний механізм pattern matching, який дозволяє легко розділяти список на голову та хвіст:

# Elixir 
[head | tail] = [1, 2, 3] # head = 1, tail = [2, 3] 

Видалення елементів

У Elixir елементи видаляються за значенням за допомогою List.delete:

# Elixir 
List.delete([1, 2, 3], 2) # [1, 3] 

Сортування

Для сортування використовується Enum.sort:

Enum.sort([3, 1, 2]) # [1, 2, 3] 

Порівняння Elixir List vs Java LinkedList

Особливість	Elixir List	Java LinkedList
Тип структури	Однозв’язний список	Двозв’язний список
Доступ до елементу	Лінійний час	Лінійний час
Додавання на початок	O(1)	O(1)
Іммутабельність	Так	Ні
Pattern matching	Так	Ні

Кортежі

Що таке кортеж у Elixir

У Elixir кортеж — це структура з фіксованою кількістю елементів, що зберігається у памʼяті як послідовність значень у безперервному масиві. Елементи можуть бути різних типів, і доступ до будь-якого елемента виконується за індексом.

Кортежі схожі на масиви у Java з фіксованою довжиною, але більш гнучкі у використанні як групи значень.

Створення кортежу

Кортеж створюється за допомогою фігурних дужок {}:

# Elixir 
tuple = {:ok, "Успішно", 200} 

Доступ до елементів

Елементи кортежу доступні через модуль elem/2, де перший аргумент — це сам кортеж, другий — індекс (починається з 0):

# Elixir 
elem({:ok, "дані"}, 1) # "дані" 

Оновлення кортежу

Кортежі є іммутабельними, тому оновлення створює новий кортеж з модифікованим елементом за допомогою put_elem/3:

# Elixir 
original = {:ok, "стара відповідь"} 
updated = put_elem(original, 1, "нова відповідь") # updated = {:ok, "нова відповідь"} 

Використання в pattern matching

Кортежі широко використовуються у pattern matching, наприклад у результатах функцій:

# Elixir 
case {:error, "щось пішло не так"} do 
	{:ok, data} -> IO.puts("Все добре: #{data}") 
    {:error, reason} -> IO.puts("Помилка: #{reason}") 
end 

Застосування кортежів

Кортежі часто використовуються для повернення кількох значень з функції (наприклад, {:ok, result} або {:error, reason}), для зберігання пар ключ-значення у функціональному стилі або як тимчасові структури в логіці програми.

На відміну від списків, кортежі мають фіксовану довжину та більш ефективний доступ до елементів, але складніше оновлюються.

Порівняння: кортежі vs списки

Особливість	Кортеж	Список
Довжина	Фіксована	Змінна
Доступ до елементів	Швидкий (O(1))	Повільний (O(n))
Оновлення	Створення нового кортежу	Зазвичай через pattern matching або Enum
Часте використання	Повернення результатів функцій	Обробка та перетворення колекцій

Ключові списки

Що таке ключовий список (keyword list)

Ключовий список у Elixir — це спеціальний тип списку, де кожен елемент є парою {ключ, значення}, і ключ завжди є атомом. За суттю це список кортежів, записаний у скороченій формі.

Ключовий список зберігає порядок вставки та дозволяє дублікати ключів, на відміну від мапи. Він використовується, зокрема, для передачі параметрів у функції.

Створення ключового списку

Ключовий список можна створити явно або в скороченому синтаксисі:

# Elixir 
list = [name: "Іван", age: 30] 
# Те саме, що: 
list = [{:name, "Іван"}, {:age, 30}] 

Доступ до значень

Значення можна отримати через Keyword.get/2 або Keyword.get/3:

# Elixir 
Keyword.get([name: "Оля", age: 25], :age) # 25 
Keyword.get([name: "Оля"], :height, 160) # 160 

Оновлення ключового списку

Оскільки ключовий список — це список, оновлення відбувається шляхом створення нового списку. Якщо ключ вже існує, новий буде доданий на початок:

# Elixir 
list = [a: 1, b: 2] 
[new_value | list] = [a: 3 | list] # [a: 3, a: 1, b: 2] 

Щоб оновити значення без дублювання ключів, можна використати Keyword.put/3:

# Elixir 
Keyword.put([a: 1, b: 2], :a, 100) # [a: 100, b: 2] 

Переваги ключових списків

Ключові списки зручні для:

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

Мапи (асоційовані масиви)

Що таке мапа (Map)

Map (мапа) у Elixir — це асоціативний масив, або словник, де ключі можуть бути будь-якого типу, але найчастіше це атоми або рядки. На відміну від ключових списків, у мапі:

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

Створення мапи

# Elixir 
map = %{name: "Андрій", age: 40} 
# або з неатомними ключами: 
map = %{"city" => "Київ", "zip" => 01001} 

Доступ до значень

Мапи підтримують як динамічний, так і статичний доступ до значень:

# Elixir 
map = %{name: "Оксана", age: 28} 
map[:age] # 28 
map.name # "Оксана" (тільки якщо ключ — атом і відомий на момент компіляції) 

Оновлення мапи

Мапи є іммутабельними, але можна створити нову мапу з оновленими даними:

# Elixir 
map = %{a: 1, b: 2} 
Map.put(map, :a, 100) # %{a: 100, b: 2} 

Або за допомогою оновлення структурного запису, якщо всі ключі — атоми:

# Elixir 
%{map | b: 5} # %{a: 1, b: 5} 

Використання

Ключові списки — це зручний синтаксичний інструмент у випадках, коли потрібна послідовність пар ключ-значення з можливістю повторення та збереження порядку. Вони зручні для передачі параметрів у функції або побудови DSL у стилі Elixir.

Мапи — це повноцінні асоціативні масиви, які забезпечують високу продуктивність, унікальність ключів і зручне модифікування. Вони є рекомендованим вибором для зберігання даних, що часто оновлюються або шукаються.

Порівняння: ключові списки vs мапи

Особливість	Ключовий список	Map (мапа)
Структура	Список кортежів {:key, value}	Хеш-таблиця
Ключі можуть повторюватися	Так	Ні
Порядок зберігається	Так	Ні
Типи ключів	Тільки атоми	Будь-який тип
Швидкість доступу	Низька (O(n))	Висока (O(1))
Типове використання	Опції функцій, невеликі дані	Зберігання та маніпуляція даними

Порівняння з Java

Колекція в Elixir	Приблизний відповідник у Java	Основні відмінності
List [1, 2, 3]	LinkedList<T>	Однозв’язний список; повільний доступ до елементів за індексом, швидке додавання на початок; іммутабельний.
Tuple {:ok, "data"}	Object[], Pair<A,B>, Record	Фіксована довжина; іммутабельний; швидкий доступ за індексом; pattern matching.
Map %{key: "value"}	HashMap<K,V>	Іммутабельний; підтримує pattern matching; ключі можуть бути будь-якого типу.
Keyword List [a: 1, b: 2]	List<Map.Entry<K,V>> або List<Pair<K,V>>	Список кортежів; ключі — лише атоми; допускає дублікати; зберігає порядок.
MapSet MapSet.new([1, 2, 3])	HashSet<T>	Унікальні значення; іммутабельність; схожі операції множини (union, intersection).
Range 1..5	IntStream.rangeClosed(1, 5)	Лінива послідовність цілих чисел; використовується з Enum/Stream.
Struct %User{name: "Іван"}	POJO, record, class	На базі мапи; має визначену схему; pattern matching; іммутабельний.
Binary <<104, 101, 108, 108, 111>>	byte[]	Для роботи з низькорівневими байтами або рядками в UTF-8; ефективне зберігання.
String (рядок) "hello"	String	Під капотом — бінарне значення UTF-8; іммутабельний; підтримує pattern matching.
Charlist 'hello'	List<Character>	Список Unicode-кодів символів; рідше використовується, ніж рядки.
Stream Stream.map(1..5, &(&1 * 2))	Stream<T> (Java 8+)	Лінива обробка послідовностей; ефективна памʼять; добре комбінується з Enum.
Enum Enum.map([1,2,3], &(&1 + 1))	Collections API або Stream.map()	Жадібна обробка колекцій; повертає нову колекцію.