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

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

Функция: sequencep object

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

Функция: length sequence

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

Функция: length< sequence length

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

Функция: length> sequence length

Возвращает не-nil, если sequence длиннее, чем length.

Функция: length= sequence length

Возвращает не-nil, если длина sequence равна length.

Функция: elt sequence index

Эта функция возвращает элемент 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

;; 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 в разделе Создание 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

;; 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 sequence

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

Функция: nreverse sequence

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

Например:

(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 sequence &rest keyword-args

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

:key keyfunc

Использовать keyfunc — функцию, которая принимает один элемент из sequence и возвращает его ключ, чтобы получить ключи, используемые при сравнении. Если этот аргумент не задан или если keyfunc равен nil, предполагается identity; то есть в качестве ключей сортировки используются сами элементы.

:lessp predicate

Использовать predicate для упорядочивания ключей. predicate — функция, принимающая два ключа сортировки и возвращающая не-nil, если первый должен предшествовать второму. Если этот аргумент не задан или predicate равен nil, используется value<, применимый ко многим различным типам Lisp и обычно выполняющий сортировку по возрастанию (см. определение value< ниже).

Для согласованной работы любой предикат должен соблюдать следующие правила:

• Он должен быть антисимметричным: нельзя одновременно ставить a перед b и b перед a.
• Он должен быть транзитивным: если он ставит a перед b и b перед c, то он также должен ставить a перед c.

: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. При использовании этой формы сортировка всегда выполняется на месте.

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

Функция: value< a b

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

Аргументы a и b должны иметь один и тот же тип. В частности:

• Числа сравниваются с помощью < (см. определение <).
• Строки сравниваются с помощью string-lessp (см. определение string-lessp), а символы — путём сравнения их имён как строк.
• Cons-ячейки, списки, векторы и записи сравниваются лексикографически. Это означает, что две последовательности сравниваются поэлементно слева направо до первого различия, после чего результат определяется вызовом 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 для добавления расширений см. в разделе Обобщённые функции.

Функция: seq-elt sequence index

Эта функция возвращает элемент 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]

Функция: seq-length sequence

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

Функция: seqp object

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

(seqp [1 2])
⇒ t

(seqp 2)
⇒ nil

Функция: seq-drop sequence n

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

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

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

Функция: seq-take sequence n

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

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

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

Функция: seq-take-while predicate sequence

Эта функция возвращает элементы 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])
⇒ []

Функция: seq-drop-while predicate sequence

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

Функция: seq-split sequence length

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

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

Функция: seq-do function sequence

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

Функция: seq-map function sequence

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

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

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

Функция: seq-map-indexed function sequence

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

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

Функция: seq-mapn function &rest sequences

Эта функция возвращает результат применения 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")

Функция: seq-filter predicate sequence

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

Функция: seq-remove predicate sequence

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

Функция: seq-remove-at-position sequence n

Эта функция возвращает копию 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]

Функция: seq-keep function sequence

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

(seq-keep #'cl-digit-char-p '(?6 ?a ?7))
⇒ (6 7)

Функция: seq-reduce function sequence initial-value

Эта функция возвращает результат вызова 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

Функция: seq-some predicate sequence

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

Функция: seq-find predicate sequence &optional default

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

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

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

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

Функция: seq-every-p predicate sequence

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

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

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

Функция: seq-empty-p sequence

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

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

(seq-empty-p "")
⇒ t

Функция: seq-count predicate sequence

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

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

Функция: seq-sort function sequence

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

Функция: seq-sort-by function predicate sequence

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

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

Функция: seq-contains-p sequence elt &optional function

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

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

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

Функция: seq-set-equal-p sequence1 sequence2 &optional testfn

Эта функция проверяет, содержат ли 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

Функция: seq-position sequence elt &optional function

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

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

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

Функция: seq-positions sequence elt &optional testfn

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

Функция: seq-uniq sequence &optional function

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

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

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

Функция: seq-subseq sequence start &optional end

Эта функция возвращает подмножество 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]

Функция: seq-concatenate type &rest sequences

Эта функция возвращает последовательность типа 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-mapcat function sequence &optional type

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

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

Функция: seq-partition sequence n

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

Функция: seq-union sequence1 sequence2 &optional function

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

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

Функция: seq-intersection sequence1 sequence2 &optional function

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

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

Функция: seq-difference sequence1 sequence2 &optional function

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

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

Функция: seq-group-by function sequence

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

Функция: seq-into sequence type

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

Функция: seq-min sequence

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

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

(seq-min "Hello")
⇒ 72

Функция: seq-max sequence

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

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

(seq-max "Hello")
⇒ 111

Макрос: seq-doseq (var sequence) body…

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

Макрос: seq-let var-sequence val-sequence body…

Этот макрос связывает переменные, определённые в 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-setq var-sequence val-sequence

Этот макрос работает аналогично 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 sequence

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