Краткий ответ

Используйте joined(): он возвращает ленивое представление, которое последовательно перебирает вложенные последовательности как одну. Элементы не объединяются заранее в новый массив — очередной вложенный элемент запрашивается только во время обхода результата.

let groups = [[1, 2], [3], [4, 5]]
let flattened = groups.joined()

for value in flattened {
    print(value)
}

Здесь flattened не содержит отдельную копию всех элементов. Обход сначала проходит внешнюю последовательность, затем текущую вложенную, переходя к следующей после её завершения.

Исторический контекст

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

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

Постановка проблемы

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

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

Подробное решение

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

Объединение является ленивым: сам вызов joined() обычно только создаёт представление. Реальный запрос элемента происходит при вызове итератора результата, например в for-in, first, prefix или другом потребителе последовательности.

let groups = [[1, 2], [3, 4]]
let values = groups.joined().prefix(3)
print(Array(values)) // [1, 2, 3]

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

Важно отличать joined() от материализации результата в массив. Вызов Array(groups.joined()) действительно создаст новый массив и немедленно обойдёт все вложенные последовательности. Это может быть полезно, если нужен независимый многократно обходимый результат или требуется API, принимающий именно массив, но за это платят памятью и временем построения.

joined() не рекурсивен: он убирает один уровень вложенности. Если элементом вложенной последовательности снова является последовательность, для дальнейшего уплощения потребуется ещё один соответствующий шаг. Также ленивость не гарантирует повторяемость обхода: возможность повторного прохода определяется конкретными последовательностями и их итераторами.

Ситуация из практики

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

Вариант с предварительным объединением всех страниц прост для понимания, но создаёт массив всех записей, хотя будет использована только первая подходящая. Вложенные циклы экономят память, но дублируют логику обхода и усложняют композицию с first, prefix или последующими преобразованиями.

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

Что кандидаты часто упускают

Создаёт ли joined() новый массив?

Нет. joined() создаёт ленивый адаптер над исходной последовательностью. Новый массив появляется только при явной материализации, например через инициализацию Array.

Обойдут ли joined() все вложенные последовательности сразу?

Нет. Обход выполняется по требованию потребителя. При ограничивающей операции вроде prefix или first могут быть запрошены только часть элементов текущей вложенной последовательности и только часть внешних элементов.

Можно ли считать результат joined() многократно обходимым?

Нельзя гарантировать это только по факту вызова joined(). Повторяемость определяется исходной последовательностью и её семантикой: для обычного массива повторный обход возможен, но произвольный Sequence такой гарантии не даёт. Поэтому при необходимости стабильного повторного использования следует материализовать результат или использовать источник с подходящими гарантиями.