Коллекции и функциональный стиль

В отчёте порядок строк должен быть стабильным: можно ли полагаться на порядок элементов, который map получает от Dictionary?

При передаче замыкания в функцию без @escaping его пытаются сохранить для вызова после завершения функции. Какой механизм Swift запрещает это и почему?

Сохраняет ли partition(by:) исходный порядок элементов в каждой из двух частей?

Как начальное значение в reduce определяет тип аккумулятора?

В чём заключается принципиальное ограничение Sequence по сравнению с Collection при обращении к элементам по позиции?

На что опирается вычислительная стоимость перемещения на несколько позиций по индексу в Swift Collection?

Нужно удалить из массива все чётные элементы. Какой вызов изменит исходный массив, а какой создаст отдельный результат?

var numbers = [1, 2, 3, 4, 5]
let remaining = numbers.filter { $0 % 2 != 0 }
print(numbers)

numbers.removeAll { $0 % 2 == 0 }
print(numbers)
print(remaining)

Представьте, что две последовательности разной длины объединяют попарно через zip. Сколько пар можно получить и чем определяется момент завершения обхода?

Что обозначает первый компонент пары, которую выдаёт enumerated() для Sequence, чей первый индекс не равен нулю?

Какой компромисс определяет выбор между sorted(by:) и sort(by:) для массива?

Что обязан делать итератор Sequence при вызове next() после того, как уже вернул nil?

Чем отличается результат map от flatMap, если преобразование каждого элемента возвращает последовательность?

При преобразовании массива функция иногда возвращает nil: чем будут отличаться результаты применения map и compactMap?

Какое последствие возникает, если объект, уже помещённый в Set, изменяет поле, участвующее в его Hashable?

Нужно понять, сколько элементов реально проверит поиск первого подходящего значения. Что будет напечатано и на каком элементе завершится обход?

let numbers = [1, 2, 3, 4]
let result = numbers.first { number in
    print("проверка \(number)")
    return number % 2 == 0
}
print(result ?? -1)

В практической ситуации преобразование элементов через map может завершиться ошибкой: каким образом Swift передаёт ошибку из замыкания вызывающему коду?

В приложении из большого Array сохраняют небольшой ArraySlice: какое скрытое последствие это может иметь для памяти?

В приложении сумма элементов строится без начального значения. Как завершится выполнение этого кода и почему?

let values: [Int] = []
let total = values.reduce(+)
print(total)

При работе с изменяемой Collection сохранённый индекс используется после мутации: какое правило определяет, можно ли к нему обращаться?

Вам нужно пропустить обработку одного элемента при обходе массива. Какой вывод даст код и что именно прекращает return внутри замыкания?

let numbers = [1, 2, 3, 4]
numbers.forEach { number in
    if number == 3 {
        return
    }
    print(number)
}
print("готово")