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

У произвольной Collection позиция элемента не обязана быть целым числом: коллекция использует собственный тип Index. Попытка обращаться к элементам через целые смещения либо ограничивает код массивами, либо приводит к ошибкам, потере обобщённости и неоправданным затратам на поиск позиции.

Для перехода к элементу по смещению следует использовать операции коллекции, например index(_:offsetBy:), а затем обращаться к элементу через полученный индекс.

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

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

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

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

Код, рассчитанный на целочисленные индексы, фактически зависит от конкретного типа коллекции, обычно от Array. При передаче String, Set или другой коллекции такой подход может не скомпилироваться, потому что их Index имеет другой тип или вообще не поддерживает прямой доступ по позиции.

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

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

У Collection есть startIndex, endIndex и операции перемещения индексов. Индекс нужно получать средствами самой коллекции, поскольку только она знает, как перейти к следующему элементу и где заканчивается допустимый диапазон.

Минимальный обобщённый пример:

func element<C: Collection>(at offset: Int, in collection: C) -> C.Element? {
    guard offset >= 0 else { return nil }
    guard let index = collection.index(
        collection.startIndex,
        offsetBy: offset,
        limitedBy: collection.endIndex
    ), index != collection.endIndex else {
        return nil
    }
    return collection[index]
}

let character = element(at: 1, in: "Swift")

offset здесь означает количество переходов от startIndex, а не смещение в байтах или обязательное значение индекса. Для String результатом будет второй Character, тогда как внутреннее представление строки может использовать несколько кодовых единиц для одного символа.

Если алгоритму нужен последовательный обход, обычно лучше использовать for-in, map, filter или другой метод над последовательностью. Если нужны частые обращения по позиции, следует учитывать гарантии конкретного типа: RandomAccessCollection обеспечивает эффективное перемещение индексов, а обычная Collection этого не обещает.

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

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

Команда пишет обобщённую функцию, которая берёт элемент по номеру позиции. Первый вариант использует целое число непосредственно как индекс. Он прост для Array, но не работает с String и не может быть применён к произвольной Collection.

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

Выбранное решение — принимать целевую коллекцию и получать её Index через index(_:offsetBy:limitedBy:). Такой вариант сохраняет обобщённость и корректность, а стоимость перехода явно определяется моделью коллекции. Если операция вызывается много раз, коллекцию дополнительно ограничивают требованием RandomAccessCollection либо меняют алгоритм на последовательный обход.

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

Почему String.Index нельзя заменять индексом байта?

String хранит текст в кодировке Unicode, где один пользовательский символ может состоять из нескольких кодовых единиц и даже нескольких Unicode-скаляров. Позиция внутри строки должна учитывать границы расширенных графем, поэтому произвольный байтовый offset не является корректным индексом String.
Одинакова ли стоимость index(_:offsetBy:) для всех коллекций?

Нет. Для коллекции с последовательным доступом переход на расстояние n может требовать O(n) шагов. Для RandomAccessCollection эта операция гарантированно выполняется за O(1), поэтому обобщённый алгоритм не должен молча предполагать постоянную стоимость.
Можно ли безопасно использовать сохранённый индекс после изменения коллекции?

Не в общем случае. Мутация может изменить структуру коллекции и инвалидировать индекс; правила зависят от конкретного типа и операции. Надёжная стратегия — не переносить индекс через потенциально инвалидирующую мутацию или заново получать его после изменения коллекции.