Обработка динамических выходных данных в функциях Swift без ущерба для безопасности типов (любая)

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

Однако я столкнулся с необходимостью вернуть Any из таких функций, как vectorAssoc, особенно в случаях, когда тип возвращаемого значения может быть кортежем или логическим значением. Вот пример функций Vector и vectorAssoc:

struct Vector<Element>: ExpressibleByArrayLiteral {
    private var storage: [Element] = []
    
    public init(arrayLiteral elements: Element...) {
        storage = elements
    }
    
    func count() -> Int {
        return storage.count
    }
    
    subscript(index: Int) -> Element {
        return storage[index]
    }
}

func vectorAssoc(_ v: Int, _ vec: Vector<(Int, Int)>) -> Any {
    func helper(_ i: Int) -> Any {
        if i >= vec.count() {
            return false
        } else {
            let elem = vec[i]
            
            if elem.0 == v {
                return elem
            } else {
                return helper(i + 1)
            }
        }
    }
    
    return helper(0)
}

let vec: Vector = [(2, 1), (3, 1), (4, 1), (5, 1)]

// Example usage
let a = vectorAssoc(4, vec) // prints (4, 1)
let b = vectorAssoc(12, vec) // prints false

Поскольку выходные данные vectorAssoc могут использоваться в качестве входных данных для другой функции, я ищу предложения о том, как более эффективно обрабатывать возвращаемый тип Any. В идеале я ищу способ указать, что тип возвращаемого значения может быть только одним из двух конкретных типов (кортеж или логическое значение), не прибегая к пользовательским типам или дополнительным параметрам.

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

Итак, очень простое объяснение нового вопроса:

Any в данном случае — это ТОЛЬКО 2 типа (кортеж и логический), его не может быть больше двух. Если бы был способ вернуть Any (только два конкретных типа) и каким-то образом Any стал бы примитивным типом (одним из этих двух), который мог бы воспользоваться преимуществами безопасности типов. Есть ли способ заставить это работать?

Редактировать:

Но было бы неплохо иметь новый тип, что-то вроде:

func foo(_ param: in Type) -> out Type { ... }

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

Другой подход может быть:

func foo(_ param: Int) -> out Type { ... }

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

Таким образом (-> out Type) он может быть одним примитивным типом при передаче в другую функцию. Тип будет работать по тем же принципам, что и примитивные типы, но если вы все же хотите, чтобы тип имел несколько типов, используйте (_ param: in Type), но только два типа, а не Any.

Хорошее объяснение здесь: Обработка динамических выходных данных в функциях Swift без ущерба для безопасности типов