Последовательности

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

Функция: sequencep объект

Эта функция возвращает t если объект является списком, вектором, строкой, bool-вектором или таблицей символов, nil в противном случае. См. также seqp ниже.

Функция: length последовательность

Эта функция возвращает количество элементов в последовательности. Функция сигнализирует об ошибке 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 подсчитывает только количество символов, но не учитывает ширину отображения каждого символа.

Функция: length< последовательность длина

Возвращает не-nil если последовательность короче длины. Это может быть более эффективным, чем вычисление длины последовательности, если последовательность является длинным списком.

Функция: length> последовательность длина

Возвращает не-nil если последовательность длиннее длины.

Функция: length= последовательность длина

Возвращает не-nil если длина последовательности равна длине.

Функция: elt последовательность индекс

Эта функция возвращает элемент последовательности с индексом индекс. Допустимые значения индекс — целые числа от 0 до на единицу меньше длины последовательности. Если последовательность является списком, значения, выходящие за пределы диапазона, ведут себя так же, как для nth. См. Определение nth. В противном случае значения, выходящие за пределы диапазона, вызывают ошибку args-out-of-range.

(elt [1 2 3 4] 2)
     ⇒ 3

(elt '(1 2 3 4) 2)
     ⇒ 3

;; We use string to show clearly which character elt returns.
(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).

Функция: copy-sequence seqr

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

Сохранение нового элемента в копию не влияет на исходное seqr, и наоборот. Однако элементы копии не являются копиями; они идентичны (eq) элементам оригинала. Следовательно, изменения, внесенные в эти элементы, как обнаруженные через копию, также видны в оригинале.

Если аргумент является строкой с текстовыми свойствами, список свойств в копии сам является копией, не совмещенной со списком свойств оригинала. Однако фактические значения свойств совмещены. См. Текстовые свойства.

Эта функция не работает для точечных списков. Попытка копирования циклического списка может привести к бесконечному циклу.

См. также append в Создание списков, 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

;; Replacing an element of one sequence.
(aset x 0 'quux)
x ⇒ [quux (1 2)]
y ⇒ [foo (1 2)]

;; Modifying the inside of a shared element.
(setcar (aref x 1) 69)
x ⇒ [quux (69 2)]
y ⇒ [foo (69 2)]

Функция: reverse последовательность

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

(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"

Функция: nreverse последовательность

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

Например:

(setq x (list 'a 'b 'c))
     ⇒ (a b c)

x
     ⇒ (a b c)
(nreverse x)
     ⇒ (c b a)

;; The cons cell that was first is now last.
x
     ⇒ (a)

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

(setq x (nreverse x))

Вот графическое представление nreverse нашего любимого примера, (a b c).

Original list head:                       Reversed list:
 -------------        -------------        ------------
| 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, настоятельно рекомендуется рассматривать строки как неизменяемые, даже когда они изменяемы. См. Изменяемость.

Функция: sort последовательность предикат

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

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

Функция сравнения предикат должна давать надежные результаты для любой пары аргументов, по крайней мере, в рамках одного вызова sort. Она должна быть антисимметричной; то есть, если a меньше b, b не должно быть меньше a. Она должна быть транзитивной — то есть, если a меньше b, а b меньше c, то a должно быть меньше c. Если вы используете функцию сравнения, которая не соответствует этим требованиям, результат sort непредсказуем.

Деструктивный аспект sort для списков заключается в том, что он переупорядочивает ячейки cons, образующие последовательность, изменяя CDRs. Недеструктивная функция сортировки создавала бы новые ячейки cons для хранения элементов в отсортированном порядке. Если вы хотите сделать отсортированную копию, не уничтожая оригинал, сначала скопируйте ее с помощью copy-sequence и затем отсортируйте.

Сортировка не изменяет CARs ячеек cons в последовательности; ячейка cons, которая изначально содержала элемент a в последовательности, по-прежнему содержит a в своем CAR после сортировки, но теперь она появляется в другом месте в списке из-за изменения CDRs. Например:

(setq nums (list 1 3 2 6 5 4 0))
     ⇒ (1 3 2 6 5 4 0)

(sort nums #'<)
     ⇒ (0 1 2 3 4 5 6)

nums
     ⇒ (1 2 3 4 5 6)

Предупреждение: Обратите внимание, что список в nums больше не содержит 0; это та же ячейка cons, что и раньше, но она больше не первая в списке. Не предполагайте, что переменная, которая ранее содержала аргумент, теперь содержит весь отсортированный список! Вместо этого сохраните результат sort и используйте его. Чаще всего мы сохраняем результат обратно в переменную, которая содержала исходный список:

(setq nums (sort nums #'<))

Для лучшего понимания того, что такое стабильная сортировка, рассмотрим следующий пример с вектором. После сортировки все элементы, чьи car равны 8, сгруппированы в начале vector, но их относительный порядок сохраняется. Все элементы, чьи car равны 9, сгруппированы в конце vector, но их относительный порядок также сохраняется:

(setq
  vector
  (vector '(8 . "xxx") '(9 . "aaa") '(8 . "bbb") '(9 . "zzz")
          '(9 . "ppp") '(8 . "ttt") '(8 . "eee") '(9 . "fff")))
     ⇒ [(8 . "xxx") (9 . "aaa") (8 . "bbb") (9 . "zzz")
         (9 . "ppp") (8 . "ttt") (8 . "eee") (9 . "fff")]

(sort vector (lambda (x y) (< (car x) (car y))))
     ⇒ [(8 . "xxx") (8 . "bbb") (8 . "ttt") (8 . "eee")
         (9 . "aaa") (9 . "zzz") (9 . "ppp") (9 . "fff")]

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

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

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

Библиотека seq.el может быть расширена для работы с дополнительными типами последовательных структур данных. Для этой цели все функции определяются с использованием cl-defgeneric. См. Общие функции для получения дополнительной информации об использовании cl-defgeneric для добавления расширений.

Функция: seq-elt индекс последовательности

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

(seq-elt [1 2 3 4] 2)
⇒ 3

seq-elt возвращает места, которые можно установить с помощью setf (см. Установление обобщенных переменных).

(setq vec [1 2 3 4])
(setf (seq-elt vec 2) 5)
vec
⇒ [1 2 5 4]

Функция: seq-length последовательность

Эта функция возвращает количество элементов в последовательности. Для встроенных типов последовательностей seq-length ведет себя как length. См. Определение length.

Функция: seqp объект

Эта функция возвращает не-nil , если объект является последовательностью (списком или массивом), или любым другим типом последовательности, определенным с помощью универсальных функций seq.el. Это расширяемый вариант sequencep.

(seqp [1 2])
⇒ t

(seqp 2)
⇒ nil

Функция: seq-drop последовательность n

Эта функция возвращает все, кроме первых n (целое число) элементов последовательности. Если n отрицательное или равно нулю, результат — последовательность.

(seq-drop [1 2 3 4 5 6] 3)
⇒ [4 5 6]

(seq-drop "hello world" -4)
⇒ "hello world"

Функция: seq-take последовательность n

Эта функция возвращает первые n (целое число) элементов последовательности. Если n отрицательное или равно нулю, результат — nil.

(seq-take '(1 2 3 4) 3)
⇒ (1 2 3)

(seq-take [1 2 3 4] 0)
⇒ []

Функция: seq-take-while предикат последовательность

Эта функция возвращает члены последовательности в порядке, останавливаясь перед первым, для которого предикат возвращает 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])
⇒ []

Функция: seq-drop-while предикат последовательность

Эта функция возвращает члены последовательности в порядке, начиная с первого, для которого предикат возвращает 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]

Функция: seq-do функция последовательность

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

Функция: seq-map функция последовательность

Эта функция возвращает результат применения функции к каждому элементу последовательности. Возвращаемое значение — список.

(seq-map #'1+ '(2 4 6))
⇒ (3 5 7)

(seq-map #'symbol-name [foo bar])
⇒ ("foo" "bar")

Функция: seq-map-indexed функция последовательность

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

(seq-map-indexed (lambda (elt idx)
                   (list idx elt))
                 '(a b c))
⇒ ((0 a) (1 b) (2 c))

Функция: seq-mapn функция &rest последовательности

Эта функция возвращает результат применения функции к каждому элементу последовательностей. Арность (см. subr-arity) функции должна соответствовать количеству последовательностей. Картирование останавливается в конце самой короткой последовательности, и возвращаемое значение — список.

(seq-mapn #'+ '(2 4 6) '(20 40 60))
⇒ (22 44 66)

(seq-mapn #'concat '("moskito" "bite") ["bee" "sting"])
⇒ ("moskitobee" "bitesting")

Функция: seq-filter предикат последовательность

Эта функция возвращает список всех элементов в последовательности, для которых предикат возвращает не-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

Функция: seq-remove предикат последовательность

Эта функция возвращает список всех элементов в последовательности, для которых предикат возвращает nil.

(seq-remove (lambda (elt) (> elt 0)) [1 -1 3 -3 5])
⇒ (-1 -3)

(seq-remove (lambda (elt) (< elt 0)) '(-1 -3 -5))
⇒ nil

Функция: seq-reduce функция последовательность начальное-значение

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

Функция вызывается с двумя аргументами. начальное-значение (а затем накопленное значение) используется в качестве первого аргумента, а элементы в последовательности — в качестве второго аргумента.

Если последовательность пуста, возвращается начальное-значение без вызова функции.

(seq-reduce #'+ [1 2 3 4] 0)
⇒ 10

(seq-reduce #'+ '(1 2 3 4) 5)
⇒ 15

(seq-reduce #'+ '() 3)
⇒ 3

Функция: seq-some предикат последовательность

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

(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

Функция: seq-find предикат последовательность &optional значение-по-умолчанию

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

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

(seq-find #'numberp ["abc" 1 nil])
⇒ 1

(seq-find #'numberp ["abc" "def"])
⇒ nil

Функция: seq-every-p предикат последовательность

Эта функция возвращает не-nil , если применение предиката ко всем элементам последовательности возвращает не-nil.

(seq-every-p #'numberp [2 4 6])
⇒ t

(seq-every-p #'numberp [2 4 "6"])
⇒ nil

Функция: seq-empty-p последовательность

Эта функция возвращает не-nil , если последовательность пуста.

(seq-empty-p "not empty")
⇒ nil

(seq-empty-p "")
⇒ t

Функция: seq-count предикат последовательность

Эта функция возвращает количество элементов в последовательности, для которых предикат возвращает не-nil.

(seq-count (lambda (elt) (> elt 0)) [-1 2 0 3 -2])
⇒ 2

Функция: seq-sort функция последовательность

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

Функция: seq-sort-by функция предикат последовательность

Эта функция похожа на seq-sort, но элементы последовательности преобразуются с помощью применения функции к ним перед сортировкой. Функция — функция от одного аргумента.

(seq-sort-by #'seq-length #'> ["a" "ab" "abc"])
⇒ ["abc" "ab" "a"]

Функция: seq-contains-p последовательность элемент &optional функция

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

(seq-contains-p '(symbol1 symbol2) 'symbol1)
⇒ t

(seq-contains-p '(symbol1 symbol2) 'symbol3)
⇒ nil

Функция: seq-set-equal-p последовательность1 последовательность2 &optional testfn

Эта функция проверяет, содержат ли последовательность1 и последовательность2 одинаковые элементы, независимо от порядка. Если необязательный аргумент 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

Функция: seq-position последовательность элемент &optional функция

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

(seq-position '(a b c) 'b)
⇒ 1

(seq-position '(a b c) 'd)
⇒ nil

Функция: seq-uniq последовательность &optional функция

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

(seq-uniq '(1 2 2 1 3))
⇒ (1 2 3)

(seq-uniq '(1 2 2.0 1.0) #'=)
⇒ (1 2)

Функция: seq-subseq последовательность начало &optional конец

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

(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]

Функция: seq-concatenate тип &rest последовательности

Эта функция возвращает последовательность типа тип, составленную из конкатенации последовательностей. Тип может быть: 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-mapcat последовательность &опционально тип

Эта функция возвращает результат применения seq-concatenate к результату применения функции к каждому элементу последовательности. Результатом является последовательность типа тип, или список, если тип равен nil.

(seq-mapcat #'seq-reverse '((3 2 1) (6 5 4)))
⇒ (1 2 3 4 5 6)

Функция: seq-partition последовательность n

Эта функция возвращает список элементов последовательности, сгруппированных в подпоследовательности длиной 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))

Функция: seq-union последовательность1 последовательность2 &опционально функция

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

(seq-union [1 2 3] [3 5])
⇒ (1 2 3 5)

Функция: seq-intersection последовательность1 последовательность2 &опционально функция

Эта функция возвращает список элементов, присутствующих как в последовательности1, так и в последовательности2. Если необязательный аргумент функция не равен nil, он является функцией двух аргументов для сравнения элементов вместо стандартного equal.

(seq-intersection [2 3 4 5] [1 3 5 6 7])
⇒ (3 5)

Функция: seq-difference последовательность1 последовательность2 &опционально функция

Эта функция возвращает список элементов, присутствующих в последовательности1, но не в последовательности2. Если необязательный аргумент функция не равен nil, он является функцией двух аргументов для сравнения элементов вместо стандартного equal.

(seq-difference '(2 3 4 5) [1 3 5 6 7])
⇒ (2 4)

Функция: seq-group-by функция последовательность

Эта функция разделяет элементы последовательности на список ассоциаций, ключами которых являются результаты применения функции к каждому элементу последовательности. Ключи сравниваются с помощью 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)))

Функция: seq-into последовательность тип

Эта функция преобразует последовательность последовательность в последовательность типа тип. Тип может быть одним из следующих символов: 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]

Функция: seq-min последовательность

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

(seq-min [3 1 2])
⇒ 1

(seq-min "Hello")
⇒ 72

Функция: seq-max последовательность

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

(seq-max [1 3 2])
⇒ 3

(seq-max "Hello")
⇒ 111

Макрос: seq-doseq (переменная последовательность) тело…

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

Макрос: seq-let последовательность-переменных последовательность-значений тело…

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

Последовательность последовательность-переменных также может содержать маркер &rest за которым следует имя переменной, которая будет связана со всем остальным содержимым последовательность-значений.

(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-setq последовательность-переменных последовательность-значений

Этот макрос работает аналогично seq-let, за исключением того, что значения присваиваются переменным, как если бы это происходило с помощью setq вместо привязки let.

(let ((a nil)
      (b nil))
  (seq-setq (_ a _ b) '(1 2 3 4))
  (list a b))
⇒ (2 4)

Функция: seq-random-elt последовательность

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

(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

Если последовательность пуста, эта функция сигнализирует об ошибке.