AnyProtocol.swift

protocol Example {
    associatedtype Value
    func value() -> Value
}

struct AnyExample<Value> {
    private class Container<Value> {
        func value() -> Value {
            fatalError()
        }
    }
    private final class _Container<ExampleType: Example>: Container<ExampleType.Value> {
        override func value() -> ExampleType.Value {
            example.value()
        }
        private let example: ExampleType
        init(example: ExampleType) {
            self.example = example
        }
    }
    private let upstream: Container<Value>
    init<ExampleType: Example>(upstream: ExampleType) where ExampleType.Value == Value {
        self.upstream = _Container(example: upstream)
    }
    func value() -> Value {
        upstream.value()
    }
}

extension Example {
    func eraseToAnyExample() -> AnyExample<Value> {
        AnyExample(upstream: self)
    }
}

struct AnExample: Example {
    typealias Value = String
    func value() -> String {
        "hello"
    }
}

struct ExampleMember {
    // Want to do this:
    //let example1: Example<String>
    // or
    //let example2: Example where Value == String
    // maybe an opaque return type plus where clause?
    //let example3: some Example where Value == String

    // Instead have to do this
    let example4 = AnyExample(upstream: AnExample())
    // or
    let example5 = AnExample().eraseToAnyExample()
}