Что такое opaque types (some)?

Opaque types, представленные в Swift 5.1 с ключевым словом some, позволяют функции или свойству возвращать значение, тип которого является непрозрачным — то есть конкретный тип скрыт от вызывающей стороны, но гарантированно соответствует определённому протоколу или набору ограничений. Это похоже на обратные дженерики (reverse generics), где тип определяется внутри функции, а не передаётся извне.

Как это работает

Когда вы объявляете возвращаемый тип как some Protocol, вы говорите компилятору: "Я верну некоторый конкретный тип, который реализует этот протокол, но я не буду раскрывать, какой именно". Компилятор знает конкретный тип и проверяет его соответствие на этапе компиляции, обеспечивая безопасность типов. Снаружи же виден только протокол, что создаёт абстракцию.

Пример использования

Представьте, что у вас есть протокол Shape с методом для вычисления площади. Вы можете создать функцию, которая возвращает some Shape, скрывая, является ли это квадратом или кругом:

protocol Shape {
    func area() -> Double
}

struct Square: Shape {
    var side: Double
    func area() -> Double { side * side }
}

struct Circle: Shape {
    var radius: Double
    func area() -> Double { .pi * radius * radius }
}

func createShape(isCircle: Bool) -> some Shape {
    if isCircle {
        return Circle(radius: 5.0)  // Компилятор знает, что это Circle
    } else {
        return Square(side: 4.0)    // Но здесь ошибка: все пути должны возвращать один тип!
    }
}

В этом примере функция createShape должна возвращать один и тот же конкретный тип (например, только Circle или только Square), потому что some требует статической определённости. Для динамического выбора типов можно использовать возврат просто протокола Shape (с потерей некоторых оптимизаций).

Где применяется

• В SwiftUI для модификаторов, которые возвращают some View, скрывая сложные иерархии типов.
• В библиотеках для предоставления абстрактных API, где детали реализации не должны быть видны пользователю.
• Для улучшения производительности, позволяя компилятору статически анализировать типы, в отличие от экзистенциальных типов (протоколов).

Практический пример

Рассмотрим более реалистичный случай — фабрика, создающая конфигурации:

protocol Configuration {
    var timeout: Int { get }
}

struct ProductionConfig: Configuration {
    var timeout: Int { 30 }
}

struct DebugConfig: Configuration {
    var timeout: Int { 300 }
}

func makeConfig() -> some Configuration {
    #if DEBUG
    return DebugConfig()
    #else
    return ProductionConfig()
    #endif
}

let config = makeConfig() // Тип config — some Configuration (скрыт)
print(config.timeout)

Здесь makeConfig возвращает непрозрачный тип, и вызывающий код не знает, это DebugConfig или ProductionConfig, но может использовать свойства протокола.

Вывод: Opaque types с some полезны, когда нужно скрыть конкретный тип возвращаемого значения, но сохранить безопасность типов и производительность, особенно в библиотеках и фреймворках вроде SwiftUI, где важно абстрагировать сложные детали.