Гетерогенный универсальный контейнер в Swift

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

protocol ItemProtocol: CustomStringConvertible {
    var id: String { get }
}

enum ItemType {
    case book(title: String)
    case car(brand: String)
}

struct Item: ItemProtocol {
    let id: String
    let type: ItemType

    var description: String {
        switch self.type {
        case .car(let brand):
            return "Car brand: \(brand)"
        case .book(let title):
            return "Book title: \(title)"
        }
    }
}

let book1 = Item(id: "1", type: .book(title: "Title1"))
let book2 = Item(id: "2", type: .book(title: "Title2"))

let car1 = Item(id: "1", type: .car(brand: "Brand1"))
let car2 = Item(id: "2", type: .car(brand: "Brand2"))


struct Section {
    let items: [Item]
}

let section1 = Section(items: [book1, book2])
let section2 = Section(items: [car1, car2])

let sections = [section1, section2]

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

Создайте любую оболочку ItemProtocol:

protocol ItemProtocol {
    var id: String { get }
}

struct AnyItem : ItemProtocol {

    private let item: ItemProtocol

    init(_ item: ItemProtocol) {
        self.item = item
    }

    // MARK: ItemProtocol
    var id: String { return item.id }
}

И типа стертый Раздел, Любой раздел:

protocol SectionProtocol {
    associatedtype T
    var items: [T] { get }
    var renderer: Renderer<T> { get }
}

struct Section<Item: ItemProtocol>: SectionProtocol {
    typealias T = Item
    var items: [Item]
    var renderer: Renderer<Item>

    var asAny: AnySection {
        return AnySection(self)
    }
}

struct AnySection : SectionProtocol {
    typealias T = AnyItem

    private let _items: () -> [T]
    private let _renderer: () -> Renderer<T>

    var items: [T] { return _items() }
    var renderer: Renderer<T> { return _renderer() }

    init<Section : SectionProtocol>(_ section: Section) {
        self._items = { section.items as! [AnySection.T] }
        self._renderer = { section.renderer as! Renderer<AnySection.T>}
    }
} 

Теперь у вас может быть коллекция AnySection:

let sections: [AnySection] = [bookSection.asAny, carSection.asAny]

Проблема в том, что нет общего (за исключением Any) между разными типами Section (с разными универсальными аргументами). Одним из возможных решений было бы объединить все типы Section в один протокол и использовать этот протокол для построения массива:

protocol SectionProtocol {
    var genericItems: [ItemProtocol] { get }
    var renderedTitles: [String] { get }
}

extension Section: SectionProtocol {
    var genericItems: [ItemProtocol] { return items }
    var renderedTitles: [String] {
        return items.map { renderer.title($0) }
    }
}

let sections: [SectionProtocol] = [bookSection, carSection]

sections.forEach { section in
    section.renderedTitles.forEach { renderedTitle in
        print("\(renderedTitle)")
    }
}

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

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