В этом разделе описаны функции, которые принимают последовательности любого вида.
Эта функция возвращает t, если object является списком, вектором,
строкой, булевым вектором или символьной таблицей, и nil в противном случае. Смотрите также
seqp ниже.
Эта функция возвращает количество элементов в sequence. Функция
выдаёт ошибку wrong-type-argument, если аргумент
не является последовательностью или является точечным списком; она выдаёт ошибку
circular-list, если аргумент является циклическим списком. Для
символьной таблицы возвращаемое значение всегда на единицу больше максимального
кода символа Emacs.
Смотрите Определение safe-length о родственной функции safe-length.
(length '(1 2 3))
⇒ 3
(length ())
⇒ 0
(length "foobar")
⇒ 6
(length [1 2 3])
⇒ 3
(length (make-bool-vector 5 nil))
⇒ 5
Смотрите также string-bytes в Текстовые представления.
Если вам нужно вычислить ширину строки при отображении, вам следует использовать
string-width (см. Размер отображаемого текста), а не length,
поскольку length подсчитывает только количество символов, но не
учитывает ширину отображения каждого символа.
Возвращает не-nil, если sequence короче, чем length.
Это может быть эффективнее, чем вычисление длины sequence,
если sequence является длинным списком.
Возвращает не-nil, если sequence длиннее, чем length.
Возвращает не-nil, если длина sequence равна
length.
Эта функция возвращает элемент sequence по индексу
index. Допустимые значения index — целые числа от
0 до длины sequence минус один. Если
sequence является списком, значения вне диапазона ведут себя как
для nth. См. Определение nth. В противном случае значения вне диапазона
вызывают ошибку args-out-of-range.
(elt [1 2 3 4] 2)
⇒ 3
(elt '(1 2 3 4) 2)
⇒ 3
;; Мы используем string, чтобы наглядно показать, какой символ возвращает elt.
(string (elt "1234" 2))
⇒ "3"
(elt [1 2 3 4] 4)
error→ Args out of range: [1 2 3 4], 4
(elt [1 2 3 4] -1)
error→ Args out of range: [1 2 3 4], -1
Эта функция обобщает aref (см. Функции, работающие с массивами) и
nth (см. Определение nth).
Эта функция возвращает копию seqr, которая должна быть либо последовательностью, либо записью. Копия имеет тот же тип, что и оригинал, и содержит те же элементы в том же порядке. Однако, если seqr пуста, например, строка или вектор нулевой длины, значение, возвращаемое этой функцией, может не быть копией, а пустым объектом того же типа, идентичным seqr.
Сохранение нового элемента в копии не влияет на исходный
seqr и наоборот. Однако элементы копии
не являются копиями; они идентичны (eq) элементам
оригинала. Поэтому изменения, вносимые в эти элементы,
обнаруживаемые через копию, также видны в оригинале.
Если аргументом является строка с текстовыми свойствами, список свойств в копии является отдельной копией, а не общей с исходным списком свойств. Однако фактические значения свойств являются общими. См. Текстовые свойства.
Эта функция не работает для точечных списков. Попытка скопировать циклический список может привести к бесконечному циклу.
Смотрите также append в Построение ячеек cons и списков, concat в
Создание строк и vconcat в Функции для векторов
для других способов копирования последовательностей.
(setq bar (list 1 2))
⇒ (1 2)
(setq x (vector 'foo bar))
⇒ [foo (1 2)]
(setq y (copy-sequence x))
⇒ [foo (1 2)]
(eq x y)
⇒ nil
(equal x y)
⇒ t
(eq (elt x 1) (elt y 1))
⇒ t
;; Замена элемента одной последовательности.
(aset x 0 'quux)
x ⇒ [quux (1 2)]
y ⇒ [foo (1 2)]
;; Изменение внутренней части общего элемента.
(setcar (aref x 1) 69)
x ⇒ [quux (69 2)]
y ⇒ [foo (69 2)]
Эта функция создаёт новую последовательность, элементы которой являются элементами sequence, но в обратном порядке. Исходный аргумент sequence не изменяется. Обратите внимание, что символьные таблицы не могут быть обращены.
(setq x '(1 2 3 4))
⇒ (1 2 3 4)
(reverse x)
⇒ (4 3 2 1)
x
⇒ (1 2 3 4)
(setq x [1 2 3 4])
⇒ [1 2 3 4]
(reverse x)
⇒ [4 3 2 1]
x
⇒ [1 2 3 4]
(setq x "xyzzy")
⇒ "xyzzy"
(reverse x)
⇒ "yzzyx"
x
⇒ "xyzzy"
Эта функция изменяет порядок элементов sequence на обратный.
В отличие от reverse, исходная sequence может быть изменена.
Например:
(setq x (list 'a 'b 'c))
⇒ (a b c)
x
⇒ (a b c)
(nreverse x)
⇒ (c b a)
;; Ячейка cons, которая была первой, теперь последняя.
x
⇒ (a)
Чтобы избежать путаницы, мы обычно сохраняем результат nreverse
обратно в ту же переменную, которая содержала исходный список:
(setq x (nreverse x))
Вот nreverse нашего любимого примера (a b c),
представленный графически:
Голова исходного списка: Перевёрнутый список: ------------- ------------- ------------ | car | cdr | | car | cdr | | car | cdr | | a | nil |<-- | b | o |<-- | c | o | | | | | | | | | | | | | | ------------- | --------- | - | -------- | - | | | | ------------- ------------
Для вектора это ещё проще, потому что не нужен setq:
(setq x (copy-sequence [1 2 3 4]))
⇒ [1 2 3 4]
(nreverse x)
⇒ [4 3 2 1]
x
⇒ [4 3 2 1]
Обратите внимание, что в отличие от reverse, эта функция не работает со строками.
Хотя вы можете изменять данные строки с помощью aset, настоятельно
рекомендуется рассматривать строки как неизменяемые, даже если они изменяемы.
См. Изменяемость.
Эта функция сортирует sequence, которая должна быть списком или вектором, и возвращает отсортированную последовательность того же типа. Сортировка устойчива, что означает, что элементы с равными ключами сохраняют свой относительный порядок. Она принимает следующие необязательные именованные аргументы:
:key keyfuncИспользует keyfunc — функцию, которая принимает один элемент из
sequence и возвращает его ключевое значение, для генерации ключей, используемых при
сравнении. Если этот аргумент отсутствует или keyfunc равен
nil, то предполагается identity; то есть сами элементы
используются в качестве ключей сортировки.
:lessp predicateИспользует predicate для упорядочивания ключей. predicate — это функция,
которая принимает два ключа сортировки в качестве аргументов и возвращает не-nil, если
первый должен идти перед вторым. Если этот аргумент отсутствует или
predicate равен nil, то используется value<,
что применимо ко многим различным типам Lisp и обычно сортирует в
порядке возрастания (см. определение value< ниже).
Для согласованности любой предикат должен подчиняться следующим правилам:
:reverse flagЕсли flag не равен nil, порядок сортировки меняется на обратный. При
стандартном предикате :lessp это означает сортировку в порядке убывания.
:in-place flagЕсли flag не равен nil, то sequence сортируется на месте
(деструктивно) и возвращается. Если nil или если этот аргумент не указан,
возвращается отсортированная копия входных данных, а сама sequence
остаётся неизменной. Сортировка на месте немного быстрее, но
исходная последовательность теряется.
Если поведение по умолчанию не подходит для ваших нужд, обычно
проще и быстрее указать новую функцию :key, чем другой
предикат :lessp. Например, рассмотрим сортировку этих строк:
(setq numbers '("one" "two" "three" "four" "five" "six"))
(sort numbers)
⇒ ("five" "four" "one" "six" "three" "two")
Вы можете отсортировать строки по длине, указав другую ключевую функцию:
(sort numbers :key #'length)
⇒ ("one" "two" "six" "four" "five" "three")
Обратите внимание, как строки одинаковой длины сохраняют исходный порядок благодаря
устойчивости сортировки. Теперь предположим, что вы хотите отсортировать по длине, но
использовать содержимое строк для разрешения совпадений. Самый простой способ — указать ключевую
функцию, которая преобразует элемент в значение, сортируемое таким образом.
Поскольку value< упорядочивает составные объекты (cons, списки,
векторы и записи) лексикографически, вы можете сделать:
(sort numbers :key (lambda (x) (cons (length x) x)))
⇒ ("one" "six" "two" "five" "four" "three")
потому что (3 . "six") упорядочивается перед (3 . "two") и так далее.
Для совместимости с предыдущими версиями Emacs функция sort
также может вызываться в фиксированной двухаргументной форме:
(sort sequence predicate)
где predicate является аргументом :lessp. При использовании этой
формы сортировка всегда выполняется на месте.
Смотрите Сортировка текста о дополнительных функциях сортировки. Смотрите
documentation в Доступ к строкам документации о полезном
примере использования sort.
Эта функция возвращает не-nil, если a предшествует b в
стандартном порядке сортировки; это означает, что она возвращает nil, когда
b предшествует a, или если они равны или неупорядочены.
Аргументы a и b должны быть одного типа. В частности:
< (см. определение <).
string-lessp (см. определение string-lessp), а символы сравниваются путём сравнения их имён как
строк.
value< для
первой пары различающихся элементов. Если одна последовательность заканчивается раньше
другой, более короткая последовательность идёт перед более длинной.
nil) будут сравниваться раньше любого живого
буфера.
nil.
Примеры:
(value< -4 3.5) ⇒ t (value< "dog" "cat") ⇒ nil (value< 'yip 'yip) ⇒ nil (value< '(3 2) '(3 2 0)) ⇒ t (value< [3 2 "a"] [3 2 "b"]) ⇒ t
Обратите внимание, что nil рассматривается либо как символ, либо как пустой список,
в зависимости от того, с чем он сравнивается:
(value< nil '(0)) ⇒ t (value< 'nib nil) ⇒ t
Нет ограничения на длину последовательностей (списков, векторов и т. д.),
которые могут сравниваться, но value< может завершиться ошибкой при попытке
сравнить циклические или глубоко вложенные структуры данных.
Библиотека seq.el предоставляет следующие дополнительные макросы и
функции для работы с последовательностями, с префиксом seq-.
Все функции, определённые в этой библиотеке, не имеют побочных эффектов; т.е. они не изменяют никакую последовательность (список, вектор или строку), которую вы передаёте в качестве аргумента. Если не указано иное, результатом является последовательность того же типа, что и входная. Для функций, которые принимают предикат, это должна быть функция одного аргумента.
Библиотека seq.el может быть расширена для работы с дополнительными типами
последовательных структур данных. Для этой цели все функции
определены с использованием cl-defgeneric. См. Обобщённые функции для
получения более подробной информации об использовании cl-defgeneric для добавления расширений.
Эта функция возвращает элемент sequence по указанному
индексу index, который является целым числом, допустимый диапазон значений которого — от нуля до
длины sequence минус один. Для значений вне диапазона
для встроенных типов последовательностей seq-elt ведёт себя как elt.
Подробности см. в Определение elt.
(seq-elt [1 2 3 4] 2) ⇒ 3
seq-elt возвращает места, доступные для установки с помощью setf
(см. Макрос setf).
(setq vec [1 2 3 4]) (setf (seq-elt vec 2) 5) vec ⇒ [1 2 5 4]
Эта функция возвращает количество элементов в sequence. Для
встроенных типов последовательностей seq-length ведёт себя как length.
См. Определение length.
Эта функция возвращает не-nil, если object является последовательностью
(списком или массивом) или любым дополнительным типом последовательности, определённым через
обобщённые функции seq.el. Это расширяемый вариант
sequencep.
(seqp [1 2]) ⇒ t
(seqp 2) ⇒ nil
Эта функция возвращает все элементы sequence, кроме первых n (целое число) элементов. Если n отрицательно или равно нулю, результатом является sequence.
(seq-drop [1 2 3 4 5 6] 3) ⇒ [4 5 6]
(seq-drop "hello world" -4) ⇒ "hello world"
Эта функция возвращает первые n (целое число) элементов
sequence. Если n отрицательно или равно нулю, результатом
является nil.
(seq-take '(1 2 3 4) 3) ⇒ (1 2 3)
(seq-take [1 2 3 4] 0) ⇒ []
Эта функция возвращает элементы sequence по порядку,
останавливаясь перед первым, для которого predicate возвращает nil.
(seq-take-while (lambda (elt) (> elt 0)) '(1 2 3 -1 -2)) ⇒ (1 2 3)
(seq-take-while (lambda (elt) (> elt 0)) [-1 4 6]) ⇒ []
Эта функция возвращает элементы sequence по порядку,
начиная с первого, для которого predicate возвращает nil.
(seq-drop-while (lambda (elt) (> elt 0)) '(1 2 3 -1 -2)) ⇒ (-1 -2)
(seq-drop-while (lambda (elt) (< elt 0)) [1 4 6]) ⇒ [1 4 6]
Эта функция возвращает список, состоящий из подпоследовательностей sequence длиной (не более) length. (Последний элемент может быть короче length, если длина sequence не кратна length.)
(seq-split [0 1 2 3 4] 2) ⇒ ([0 1] [2 3] [4])
Эта функция применяет function к каждому элементу sequence по очереди (предположительно для побочных эффектов) и возвращает sequence.
Эта функция возвращает результат применения function к каждому элементу sequence. Возвращаемое значение является списком.
(seq-map #'1+ '(2 4 6)) ⇒ (3 5 7)
(seq-map #'symbol-name [foo bar])
⇒ ("foo" "bar")
Эта функция возвращает результат применения function к каждому элементу sequence и его индексу внутри seq. Возвращаемое значение является списком.
(seq-map-indexed (lambda (elt idx)
(list idx elt))
'(a b c))
⇒ ((0 a) (1 b) (2 c))
Эта функция возвращает результат применения function к каждому элементу sequences. Арность (см. subr-arity) function должна соответствовать количеству последовательностей. Отображение останавливается в конце самой короткой последовательности, а возвращаемое значение является списком.
(seq-mapn #'+ '(2 4 6) '(20 40 60)) ⇒ (22 44 66)
(seq-mapn #'concat '("moskito" "bite") ["bee" "sting"])
⇒ ("moskitobee" "bitesting")
Эта функция возвращает список всех элементов sequence,
для которых predicate возвращает не-nil.
(seq-filter (lambda (elt) (> elt 0)) [1 -1 3 -3 5]) ⇒ (1 3 5)
(seq-filter (lambda (elt) (> elt 0)) '(-1 -3 -5)) ⇒ nil
Эта функция возвращает список всех элементов sequence,
для которых predicate возвращает nil.
(seq-remove (lambda (elt) (> elt 0)) [1 -1 3 -3 5]) ⇒ (-1 -3)
(seq-remove (lambda (elt) (< elt 0)) '(-1 -3 -5)) ⇒ nil
Эта функция возвращает копию sequence, из которой удалён элемент по (начиная с нуля) индексу n. Результатом является последовательность того же типа, что и sequence.
(seq-remove-at-position [1 -1 3 -3 5] 0) ⇒ [-1 3 -3 5]
(seq-remove-at-position [1 -1 3 -3 5] 3) ⇒ [1 -1 3 5]
Эта функция возвращает список всех не-nil результатов вызова
function для элементов sequence.
(seq-keep #'cl-digit-char-p '(?6 ?a ?7)) ⇒ (6 7)
Эта функция возвращает результат вызова function с initial-value и первым элементом sequence, затем вызова function с этим результатом и вторым элементом sequence, затем с этим результатом и третьим элементом sequence и т. д. function должна быть функцией двух аргументов.
function вызывается с двумя аргументами. initial-value (а затем накопленное значение) используется в качестве первого аргумента, а элементы sequence — в качестве второго аргумента.
Если sequence пуста, эта функция возвращает initial-value без вызова function.
(seq-reduce #'+ [1 2 3 4] 0) ⇒ 10
(seq-reduce #'+ '(1 2 3 4) 5) ⇒ 15
(seq-reduce #'+ '() 3) ⇒ 3
Эта функция возвращает первое не-nil значение, возвращённое
применением predicate к каждому элементу sequence по очереди.
(seq-some #'numberp ["abc" 1 nil]) ⇒ t
(seq-some #'numberp ["abc" "def"]) ⇒ nil
(seq-some #'null ["abc" 1 nil]) ⇒ t
(seq-some #'1+ [2 4 6]) ⇒ 3
Эта функция возвращает первый элемент sequence, для которого
predicate возвращает не-nil. Если ни один элемент не соответствует
predicate, функция возвращает default.
Обратите внимание, что эта функция неоднозначна, если найденный элемент идентичен default, поскольку в этом случае невозможно определить, был ли найден элемент или нет.
(seq-find #'numberp ["abc" 1 nil]) ⇒ 1
(seq-find #'numberp ["abc" "def"]) ⇒ nil
Эта функция возвращает не-nil, если применение predicate
к каждому элементу sequence возвращает не-nil.
(seq-every-p #'numberp [2 4 6]) ⇒ t
(seq-every-p #'numberp [2 4 "6"]) ⇒ nil
Эта функция возвращает не-nil, если sequence пуста.
(seq-empty-p "not empty") ⇒ nil
(seq-empty-p "") ⇒ t
Эта функция возвращает количество элементов sequence, для которых
predicate возвращает не-nil.
(seq-count (lambda (elt) (> elt 0)) [-1 2 0 3 -2]) ⇒ 2
Эта функция возвращает копию sequence, отсортированную
согласно function — функции двух аргументов, которая возвращает
не-nil, если первый аргумент должен следовать перед вторым.
Эта функция аналогична seq-sort, но элементы
sequence преобразуются применением function к ним
перед сортировкой. function — это функция одного аргумента.
(seq-sort-by #'seq-length #'> ["a" "ab" "abc"]) ⇒ ["abc" "ab" "a"]
Эта функция возвращает не-nil, если хотя бы один элемент в
sequence равен elt. Если необязательный аргумент
function не равен nil, это функция двух аргументов,
используемая вместо equal по умолчанию.
(seq-contains-p '(symbol1 symbol2) 'symbol1) ⇒ t
(seq-contains-p '(symbol1 symbol2) 'symbol3) ⇒ nil
Эта функция проверяет, содержат ли sequence1 и sequence2
одинаковые элементы, независимо от порядка. Если необязательный
аргумент testfn не равен nil, это функция двух
аргументов, используемая вместо equal по умолчанию.
(seq-set-equal-p '(a b c) '(c b a)) ⇒ t
(seq-set-equal-p '(a b c) '(c b)) ⇒ nil
(seq-set-equal-p '("a" "b" "c") '("c" "b" "a"))
⇒ t
(seq-set-equal-p '("a" "b" "c") '("c" "b" "a") #'eq)
⇒ nil
Эта функция возвращает индекс (начиная с нуля) первого элемента в
sequence, который равен elt. Если необязательный аргумент
function не равен nil, это функция двух аргументов,
используемая вместо equal по умолчанию.
(seq-position '(a b c) 'b) ⇒ 1
(seq-position '(a b c) 'd) ⇒ nil
Эта функция возвращает список индексов (начиная с нуля) элементов
в sequence, для которых testfn возвращает
не-nil при передаче элемента и elt в качестве
аргументов. testfn по умолчанию равен equal.
(seq-positions '(a b c a d) 'a) ⇒ (0 3)
(seq-positions '(a b c a d) 'z) ⇒ nil
(seq-positions '(11 5 7 12 9 15) 10 #'>=) ⇒ (0 3 5)
Эта функция возвращает список элементов sequence с
удалёнными дубликатами. Если необязательный аргумент function не равен nil,
это функция двух аргументов, используемая вместо equal по умолчанию.
(seq-uniq '(1 2 2 1 3)) ⇒ (1 2 3)
(seq-uniq '(1 2 2.0 1.0) #'=) ⇒ (1 2)
Эта функция возвращает подмножество sequence от start до end, оба целые числа (end по умолчанию равен последнему элементу). Если start или end отрицательны, они отсчитываются от конца sequence.
(seq-subseq '(1 2 3 4 5) 1) ⇒ (2 3 4 5)
(seq-subseq '[1 2 3 4 5] 1 3) ⇒ [2 3]
(seq-subseq '[1 2 3 4 5] -3 -1) ⇒ [3 4]
Эта функция возвращает последовательность типа type, состоящую из
объединения sequences. type может быть: vector,
list или string.
(seq-concatenate 'list '(1 2) '(3 4) [5 6]) ⇒ (1 2 3 4 5 6)
(seq-concatenate 'string "Hello " "world") ⇒ "Hello world"
Эта функция возвращает результат применения seq-concatenate
к результату применения function к каждому элементу
sequence. Результатом является последовательность типа type или
список, если type равен nil.
(seq-mapcat #'seq-reverse '((3 2 1) (6 5 4))) ⇒ (1 2 3 4 5 6)
Эта функция возвращает список элементов sequence,
сгруппированных в подпоследовательности длины n. Последняя последовательность может
содержать меньше элементов, чем n. n должно быть целым числом. Если
n — отрицательное целое число или 0, возвращаемое значение равно nil.
(seq-partition '(0 1 2 3 4 5 6 7) 3) ⇒ ((0 1 2) (3 4 5) (6 7))
Эта функция возвращает список элементов, которые присутствуют либо в
sequence1, либо в sequence2. Все элементы возвращаемого списка
уникальны в том смысле, что никакие два элемента не сравниваются как равные.
Если необязательный аргумент function не равен nil, он
должен быть функцией двух аргументов для сравнения элементов
вместо equal по умолчанию.
(seq-union [1 2 3] [3 5]) ⇒ (1 2 3 5)
Эта функция возвращает список элементов, которые присутствуют как в
sequence1, так и в sequence2. Если необязательный аргумент
function не равен nil, это функция двух аргументов для
сравнения элементов вместо equal по умолчанию.
(seq-intersection [2 3 4 5] [1 3 5 6 7]) ⇒ (3 5)
Эта функция возвращает список элементов, которые присутствуют в
sequence1, но отсутствуют в sequence2. Если необязательный аргумент
function не равен nil, это функция двух аргументов для
сравнения элементов вместо equal по умолчанию.
(seq-difference '(2 3 4 5) [1 3 5 6 7]) ⇒ (2 4)
Эта функция разделяет элементы sequence на ассоциативный список,
ключи которого являются результатом применения function к каждому элементу
sequence. Ключи сравниваются с помощью equal.
(seq-group-by #'integerp '(1 2.1 3 2 3.2)) ⇒ ((t 1 3 2) (nil 2.1 3.2))
(seq-group-by #'car '((a 1) (b 2) (a 3) (c 4))) ⇒ ((b (b 2)) (a (a 1) (a 3)) (c (c 4)))
Эта функция преобразует последовательность sequence в последовательность
типа type. type может быть одним из следующих символов:
vector, string или list.
(seq-into [1 2 3] 'list) ⇒ (1 2 3)
(seq-into nil 'vector) ⇒ []
(seq-into "hello" 'vector) ⇒ [104 101 108 108 111]
Эта функция возвращает наименьший элемент sequence. Элементы sequence должны быть числами или маркерами (см. Маркеры).
(seq-min [3 1 2]) ⇒ 1
(seq-min "Hello") ⇒ 72
Эта функция возвращает наибольший элемент sequence. Элементы sequence должны быть числами или маркерами.
(seq-max [1 3 2]) ⇒ 3
(seq-max "Hello") ⇒ 111
Этот макрос подобен dolist (см. dolist), за исключением
того, что sequence может быть списком, вектором или строкой. Это
прежде всего полезно для побочных эффектов.
Этот макрос связывает переменные, определённые в var-sequence, со значениями, которые являются соответствующими элементами val-sequence. Это известно как деструктурирующее связывание. Элементы var-sequence сами могут содержать последовательности, что позволяет осуществлять вложенную деструктуризацию.
Последовательность var-sequence может также содержать маркер &rest,
за которым следует имя переменной для связывания с остатком
val-sequence.
(seq-let [first second] [1 2 3 4] (list first second)) ⇒ (1 2)
(seq-let (_ a _ b) '(1 2 3 4) (list a b)) ⇒ (2 4)
(seq-let [a [b [c]]] [1 [2 [3]]] (list a b c)) ⇒ (1 2 3)
(seq-let [a b &rest others] [1 2 3 4] others)
⇒ [3 4]
Шаблоны pcase предоставляют альтернативное средство для
деструктурирующего связывания, см. Деструктуризация с помощью шаблонов pcase.
Этот макрос работает аналогично seq-let, за исключением того, что значения
присваиваются переменным, как если бы setq, а не в
связывании let.
(let ((a nil)
(b nil))
(seq-setq (_ a _ b) '(1 2 3 4))
(list a b))
⇒ (2 4)
Эта функция возвращает элемент sequence, выбранный случайным образом.
(seq-random-elt [1 2 3 4]) ⇒ 3 (seq-random-elt [1 2 3 4]) ⇒ 2 (seq-random-elt [1 2 3 4]) ⇒ 4 (seq-random-elt [1 2 3 4]) ⇒ 2 (seq-random-elt [1 2 3 4]) ⇒ 1
Если sequence пуста, эта функция выдаёт ошибку.