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

Код нарушает правило эксклюзивного доступа: во время обхода values замыкание одновременно пытается изменить тот же массив. Сначала нужно завершить чтение исходных элементов, а затем выполнить изменения, например обойти копию или накопить новые значения отдельно.

var values = [1, 2, 3]

values.forEach { value in
    values.append(value * 2)
}

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

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

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

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

forEach читает элементы values во время вызова. Внутри замыкания values.append требует эксклюзивного доступа для записи, поэтому чтение и запись пересекаются по времени.

Кроме ошибки компиляции, изменение коллекции во время её обхода было бы концептуально неоднозначным: непонятно, должны ли добавленные элементы участвовать в текущей итерации. Разные стратегии обхода могли бы приводить к пропуску элементов, повторной обработке или бесконечному росту коллекции.

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

Безопасный вариант — обойти неизменяемый снимок, а изменять исходный массив отдельно:

var values = [1, 2, 3]
let original = values

original.forEach { value in
    values.append(value * 2)
}

print(values) // [1, 2, 3, 2, 4, 6]

Во время обхода original доступ к исходным элементам не пересекается с записью в values. Благодаря copy-on-write создание original обычно не копирует буфер немедленно; отдельная копия появляется, когда один из массивов должен быть изменён.

Другой вариант — сначала вычислить добавляемые элементы, а затем выполнить одну модификацию:

var values = [1, 2, 3]
let additions = values.map { $0 * 2 }
values.append(contentsOf: additions)

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

Важно, что проблема не специфична для forEach. Аналогичное пересечение возникает при попытке изменить массив непосредственно внутри for value in values. Само по себе замыкание не делает коллекцию неизменяемой; конфликт создаётся одновременным чтением коллекции и изменением той же переменной.

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

В приложении нужно добавить к списку загруженных идентификаторов производные идентификаторы. Разработчик написал обход массива с append внутри замыкания и получил ошибку эксклюзивного доступа.

Рассматривались два решения. Обход копии прост и сохраняет исходный порядок, но удерживает дополнительную ссылку на буфер и может привести к копированию при записи. Предварительное построение результата через map требует временной памяти для нового массива, зато разделяет операции и обычно лучше выражает преобразование данных.

Был выбран вариант с map и append(contentsOf:): исходный массив читается только на этапе построения additions, после чего изменяется одной отдельной операцией. Результат стал детерминированным, а риск случайно начать обрабатывать вновь добавленные элементы исчез.

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

Обязательно ли forEach изменяет коллекцию во время обхода?

Нет. forEach сам по себе только последовательно передаёт элементы замыканию. Ошибка появляется из-за дополнительной записи в ту же переменную внутри замыкания; если замыкание только читает или изменяет другую коллекцию, эксклюзивный доступ к исходной коллекции не нарушается.

Почему создание let original = values обычно не копирует весь массив сразу?

Array — значимый тип с оптимизацией copy-on-write. До первой записи несколько переменных могут совместно ссылаться на один буфер, потому что это не меняет наблюдаемое значение. Когда values.append требует модификации, Swift обеспечивает уникальность изменяемого буфера: при необходимости создаётся копия, а original сохраняет прежнее содержимое.

Можно ли обойти проблему, добавляя элементы через индексный цикл?

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