Swift type erasure type puzzler

puzzler.swift

import Foundation

// ——— The Setup ———

protocol Foo
    {
    associatedtype Bar
    func modify(bar: Bar) -> Bar
    }

struct Greeter: Foo
    {
    func modify(bar: String) -> String
        { return "Hi, \(bar)" }
    }

struct Multiplier: Foo
    {
    var factor: Int
    
    func modify(bar: Int) -> Int
        { return bar * factor }
    }

struct FooBarPair<F, B where F: Foo, B == F.Bar>
    {
    var foo: F
    var bar: B
    
    func apply()
        { print(foo.modify(bar)) }
    }

let a = FooBarPair(foo: Greeter(), bar: "ih")
let b = FooBarPair(foo: Multiplier(factor: 6), bar: 7)

// ——— The Puzzle ———

// Suppose I have an array of [a,b], and I want to call apply() on every element.
//
// Note that a caller doesn’t need to know the generic types F, B to call apply().
// If Swift allowed the existential type [FooBarPair], then this would be easy!
// But Swift doesn’t, and it isn’t.
//
// The approach below is the best I’ve found. Is there a simplier way?

protocol AnnoyingTypeErasingProtocol
    {
    func apply()
    }

extension FooBarPair: AnnoyingTypeErasingProtocol { }

let pairs: [AnnoyingTypeErasingProtocol] = [a,b]

for pair in pairs
    { pair.apply() }