LIST

ВСТУП

Модуль роботи зі списками. Перелік підмножини фунцій, що використовуються в ERP.UNO.

map(fun((A) -> B), [A]) -> [B]

Бере функцію від As до Bs, а також список As і створює список B, застосовуючи функцію до кожного елемента в списку. Ця функція використовується для отримання повернених значень. Порядок оцінки залежить від реалізації.

> :lists.map(fn x -> x * x end, [1,2,3]) [1, 4, 9]

all(fun((Elem :: T) -> boolean()), [T]) -> boolean()

Повертає true при умові, що fun(Elem :: T) -> true для всіх елементів у списку [T], в іншому випадку повертає false. Результатом fun(Elem :: T) повинно бути повернено логічне значення.

> :lists.all(fn x -> rem(x, 2) == 0 end, [2, 4, 6]) true

any(fun((Elem :: T) -> boolean()), [T]) -> boolean()

Повертає true при умові, що fun(Elem :: T) -> true принаймні для одного елемента у списку [T]. Результатом fun(Elem :: T) повинно бути повернено логічне значення.

> :lists.any(fn x -> rem(x, 2) == 1 end, [2, 3, 4]) true

droplast([T, ...]) -> [T]

Викидає останній елемент у списку [T, ...]. Якщо список порожній, тоді функція аварійно завершує роботу з пропозицією function_clause.

> :lists.droplast([1,2,3,4,5]) [1, 2, 3, 4]

duplicate(integer() >= 0, T) -> [T]

Повертає список, який містить N-копій терму T.

> :lists.duplicate(3, [1, 2]) [[1, 2], [1, 2], [1, 2]]

filter(fun((Elem :: T) -> boolean()), [T1]) -> [T2]

Повертає у список [T2] лише ті елементи, для яких fun(Elem :: T) -> true. Результатом fun(Elem :: T) повинно бути повернено логічне значення. Зверніть увагу, що filter не може фільтрувати та перетворювати елемент одночасно. Для даних дій використовують метод flat_map/2.

> :lists.filter(fn x -> rem(x, 2) == 0 end, [1, 2, 3, 4]) [2, 4]

filtermap(fun((Elem) -> boolean() | {true, Value}), [Elem]) -> [Elem | Value]

Викликає fun(Elem) для послідовних елементів у списку [Elem]. Fun/1 має повертати логічне значення або кортеж {true, Value}. Функція повертає список елементів, для яких Fun повертає нове значення, де значення true є синонімом {true, Elem}.

> :lists.filtermap(fun(X) -> case X rem 2 of 0 -> {true, X div 2}; _ -> false end end, [1,2,3,4,5]) [1,2]

flatten([term() | DeepList]) -> [term()]

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

> :lists.flatten([1, [[2], 3]]) [1, 2, 3]

flatten([term() | DeepList], [term()]) -> [term()]

Повертає зведену версію DeepList із доданим Tail=[term()]. Порожні елементи списку відкидаються

> :lists.flatten([1, [[2], 3]], [4, 5]) [1, 2, 3, 4, 5]

foldl(fun((Elem :: T, AccIn) -> AccOut), Acc0, [T]) -> Acc1

Викликає Fun(Elem, AccIn) для послідовних елементів A з [T], починаючи з AccIn == Acc0. Fun/2 має повернути новий акумулятор, який передається наступному виклику. Функцію повертає кінцеве значення акумулятора. Acc0 повертається, якщо список порожній.

> :lists.foldl(fn x, acc -> x + acc end, 10, [5, 5]) 20

foldr(fun((Elem :: T, AccIn) -> AccOut), Acc0, [T]) -> Acc1

Подібно до foldl/3, але список перміщується справа наліво. Згортає (зменшує) заданий список справа за допомогою функції. Потрібен акумулятор, який може бути будь-яким значенням.

> :lists.foldr(fn x, acc -> x - acc end, 0, [1, 2, 3, 4]) -2

foreach(fun((Elem :: T) -> term()), [T]) -> ok

Викликає Fun(Elem) для кожного елемента у [T]. Ця функція використовується для її побічних ефектів, і порядок оцінювання визначається таким самим, як і порядок елементів у списку.

> :lists.foreach(fn a -> IO.puts a + a end, [1,2,3]) 2 4 6 :ok

join(T, [T1]) -> [T2]

Об'єднує список шляхів. Вставляє Sep, (Sep=T) між кожним елементом у [T1]. На порожній список та на список одиночних елементів не впливає.

> :lists.join(" = ", [1, 2, 3]) [1, " = ", 2, " = ", 3]

keydelete(term(), integer() >= 1, [Tuple1]) -> [Tuple2]

Метод .keydelete отримує ключ, значення та список кортежів, після шукає кортеж, який має задане значення за вказаним ключем кортежу. Коли кортеж знайдено, цей кортеж видаляється зі списку. Буде видалено лише перший відповідний кортеж.

> :lists.keydelete(:a, 1, [a: 1, b: 2]) [b: 2]

keyfind(term(), integer() >= 1, [Tuple]) -> Tuple | false

Отримує список кортежів та повертає перший кортеж, у якому N-й елемент відповідає заданому key. Якщо такий кортеж знайдено, повертає Tuple, інакше повертає false.

> :lists.keyfind(:a, 1, [a: 1, b: 2]) {:a, 1}

keyreplace(term(), integer() >= 1, [Tuple1], NewTuple) -> [Tuple2]

Повертає копію [Tuple1], де перше входження кортежу T, N-й елемент якого порівнюється з Key, замінюється на NewTuple, якщо такий кортеж T існує.

> :lists.keyreplace(:b, 2, [a: 1, b: 2], {:a, 3}) [a: 1, b: 2]

keystore(term(), integer() >= 1, [Tuple1], tuple()) -> [Tuple, ...]

Повертає копію [Tuple1], де перше входження кортежу T, N-й елемент якого порівнюється з Key, замінюється на NewTuple, якщо такий кортеж T існує. Якщо такого кортежу T немає, копія [Tuple1], де [tuple()] має бути додано до кінця повертається.

> :lists.keystore(:a, 1, [a: 1, b: 2], {:a, 3}) [a: 3, b: 2]

keytake(term(), integer() >= 1, [tuple1()]) -> {value, tuple(), [tuple2()]} | false

Шукає в списку кортежів [tuple1()] кортеж, N-й елемент якого порівнюється з Key. Повертає {value, Tuple, [tuple2()]}, якщо такий кортеж знайдено, інакше повертає false. [tuple2()] — це копія [tuple1()], де перше входження Tuple було видалено.

> :lists.keytake(:a, 1, [a: 1, b: 2]) {:value, {:a, 1}, [b: 2]}

member(T, [T]) -> boolean()

Повертає true, якщо елемент T відповідає будь-якому елементу [T], інакше false.

> :lists.member(2, [1.0, 2.0, 3.0]) false

partition(fun((Elem :: T) -> boolean()), List) -> {Satisfying, NotSatisfying}
List = Satisfying = NotSatisfying = [T]

Розбийте List на два списки, де перший список містить усі елементи, для яких fun((Elem :: T) повертає true, а другий список містить усі елементи, для яких fun((Elem :: T) повертає false. Щоб дізнатися про інший спосіб розділення списку, див. splitwith/2.

> :lists.partition(fn a -> rem(a, 3) == 1 end, [1,2,3,4,5,6,7]) {[1, 4, 7], [2, 3, 5, 6]}

prefix([term1()], [term2()]) -> boolean()

Повертає true, якщо [term1()] є префіксом [term2()], інакше false.

> :lists.prefix([1,2,3], [5,6,7]) false

reverse([term1()]) -> [term2()]

Повертає список з елементами в [term1()] у зворотному порядку.

> :lists.reverse([1, 2, 3, 4]) [4, 3, 2, 1]

reverse([term1()], term()) -> [term2()]

Повертає список із елементами зі списку [term1()] у зворотному порядку, із доданим term().

> :lists.reverse([1, 2, 3, 4], [5, 6, 7]) [4, 3, 2, 1, 5, 6, 7]

search(fun((T) -> boolean()), [T]) -> {value, Value} | false

Якщо у списку є таке Value, що Pred(Value) повертає true, повертає {value, Value} для першого такого значення, інакше повертає false. Функція Pred має повертати логічне значення.

> :lists.search(fn(x) -> rem(x, 2) == 0 end, [1, 2, 3, 4]) {:value, 2}
:lists.search(fn(x) -> rem(x, 2) == 0 end, [a: 1, b: 2]) [a: 1, b: 2]

seq(From, To) -> [integer()]
From = To = Incr = integer()

Повертає послідовність цілих чисел, яка починається з From і містить послідовні результати додавання Incr до попереднього елемента, доки To не буде досягнуто або пройдено (в останньому випадку To не є елементом послідовності). Incr за замовчуванням дорівнює 1. Невдачі: - If To < From - Incr and Incr > 0. - If To > From - Incr and Incr < 0. - If Incr =:= 0 and From =/= To.

Для всіх послідовностей виконуються такі рівності: length(lists:seq(From, To)) =:= To - From + 1 length(lists:seq(From, To, Incr)) =:= (To - From + Incr) div Incr
> :lists.seq(1, 10) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

seq(integer(), integer(), integer()) -> [integer()]

> :lists.seq(1, 20, 3) [1, 4, 7, 10, 13, 16, 19]

sort[term1()] -> [term2()]

Повертає список, що містить відсортовані елементи [term1()].

> :lists.sort([3, 2, 1]) [1, 2, 3]

sort(fun((A :: T, B :: T) -> boolean()), [term1()]) -> [term2()]

Повертає список, що містить відсортовані елементи [term1()] відповідно до функції ordering function Fun. Fun(A, B) має повертати true, якщо A порівнюється менше або дорівнює B у порядку, інакше false.

> :lists.sort(&(&1 >= &2), [1, 2, 3]) [3, 2, 1]

split(integer() >= 0, [term1()]) -> {[term2()], [term3()]}

Розділяє [term1()] на [term2()] і [term3()]. До частини [term2()] входить N-кількість елементів, решта від елементів належить до [term3()].

> :lists.split(2, [1, 2, 3]) {[1, 2], [3]}

unzip([{A, B}]) -> {[A], [B]}

«Розпаковує» список двох кортежів на два списки, де перший список містить перший елемент кожного кортежу, а другий список містить другий елемент кожного кортежу.

> :lists.unzip([{:a, 1}, {:b, 2}, {:c, 3}]) {[:a, :b, :c], [1, 2, 3]}

zip([term1()], [term2()]) -> [term3()]

"Архівує" два списки однакової довжини в один список двох кортежів, де перший елемент кожного кортежу береться з першого списку, а другий елемент береться з відповідного елемента другого списку.

> :lists.zip([1, 2], [5, 6]) [{1, 5}, {2, 6}]