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

Это стандартные протоколы не соответствуют вопросам протоколов. Контракт — это протокол, который требует, чтобы соответствующие типы также соответствовали Initializable. Он сам по себе не может быть инициализирован. По сути, это канонический пример того, почему протоколы не могут соответствовать сами себе в самом общем случае. Если бы это было так, я мог бы написать Contract.init() и получить в ответ... что? Невозможно выделить память для абстрактного контракта.

Поскольку Contract не соответствует Initializable, он не может быть напрямую Option. Сегодня в Swift также отсутствует какой-либо механизм, позволяющий говорить о наследовании протоколов. Вы не можете сказать, что Option должен быть протоколом, требующим Initializable. Это просто за пределами системы типов Swift.

Тем не менее, это довольно негибкий подход. Это требует, чтобы каждый тип принимал тривиальное init, что очень ограничивает типы, которые могут соответствовать. Есть гораздо лучшие способы IMO реализовать этот вид фабрики.

Избавьтесь от Initializable, избавьтесь от требования static (позже вы поймете, почему) и замените тип функцией-строителем.

protocol OptionListFactory {
    associatedtype Option
    var availableOptions: [() -> Option] { get }
}

Это приводит к тому, что расширение настраивается следующим образом:

extension OptionListFactory {
    // Remove `static`
    func build(code: Int) -> Option? {
        if code >= 0 && code < availableOptions.count {
            return availableOptions[code]()  // Call the builder function
        }
        else {
            return nil
        }
    }
}

И простая фабрика:

protocol Contract {}

struct Contract01 : Contract {}
struct Contract02 : Contract {}

struct ContractFactory : OptionListFactory {
    let availableOptions: [() -> Contract] = [
        Contract01.init,   // init rather than self
        Contract02.init,
    ]
}

Но что, если у вас есть какой-то тип, который вы хотите продать, и для его создания требуется дополнительная информация? Выполнение этого таким образом делает это простым.

// Elements need a name
protocol Element {
    var name: String { get }
}

struct Element01 : Element { let name: String }
struct Element02 : Element { let name: String }
struct Element20 : Element { let name: String }

struct ElementFactory : OptionListFactory {
    let availableOptions: [() -> Element]

    // And now we can assign that name
    init(prefix: String) {
        availableOptions = [
            { Element01(name: prefix + "01") },
            { Element02(name: prefix + "02") },
            { Element20(name: prefix + "20") },
        ]
    }
}

let ef = ElementFactory(prefix: "local")
let e20 = ef.build(code: 2)
// e20?.name == "local20"

Делая экземпляры фабрик вместо использования static, они становятся более гибкими и могут быть настроены. А используя функции, вы можете создавать композиции способами, о которых вы, возможно, и не подозревали. Например, вы можете добавлять оператор отладочной печати каждый раз, когда создается параметр:

struct DebugFactory<Base: OptionListFactory>: OptionListFactory {
    let availableOptions: [() -> Base.Option]

    init(base: Base) {
        availableOptions = base.availableOptions.map { f in
            return {
                print("Creating object")
                return f()
            }
        }
    }
}

// Works exactly the same as `ef`, just prints.
let debugFactory = DebugFactory(base: ef)
debugFactory.build(code: 2)