Swift 3：使用具体的使用者类型键入泛型委托类型的错误

Question

I have a problem with a generic delegate ProducerDelegate , which will have an argument ( Int ) with the same type as the consumer IntConsumer method needs it ( Int )

If the delegate methods will be called and I want to use the received value element

func didProduce<Int>(from: Producer<Int>, element: Int) {
    output(element: element)
}

to call an other method I got the error:

Cannot convert value of type 'Int' to expected argument type 'Int'

And my question is why?

I explain my case (and here is a playground file with the same source: http://tuvalu.s3.amazonaws.com/so/generic-delegate.playground.zip )

I have a generic producer class Producer with a protocol for produced elements ProducerDelegate :

import Foundation

/// Delegate for produced elements
protocol ProducerDelegate : class {

    /// Called if a new element is produced
    ///
    /// - Parameters:
    ///     - from: producer
    ///     - element: produced element
    func didProduce<T>(from: Producer<T>, element: T)
}

/// Produces new element
class Producer<T> {

    /// The object that acts as consumer of produced element
    weak var delegate: ProducerDelegate?

    /// The producing element
    let element: T

    /// Initializes and returns a `Producer` producing the given element
    ///
    /// - Parameters:
    ///     - element: An element which will be produced
    init(element: T) {
        self.element = element
    }

    /// Produces the object given element
    func produce() {
        delegate?.didProduce(from: self, element: element)
    }
}

In a consumer, the producer is injected:

/// Consumes produced `Int` elements and work with it
class IntConsumer {

    /// Producer of the `Int`s
    let producer: Producer<Int>

    /// Initializes and returns a `IntConsumer` having the given producer
    ///
    /// - Parameters:
    ///     - producer: `Int` producer
    init(producer: Producer<Int>) {
        self.producer = producer
        self.producer.delegate = self
    }

    /// outputs the produced element
    fileprivate func output(element: Int) {
        print(element)
    }
}

Now, I wanted add the extension for the delegate like this:

extension IntConsumer: ProducerDelegate {
    func didProduce<Int>(from: Producer<Int>, element: Int) {
        output(element: element)
    }
}

But, it fails with: Cannot convert value of type 'Int' to expected argument type 'Int'

The Swift compiler says I should cast the element to Int , like:

func didProduce<Int>(from: Producer<Int>, element: Int) {
    output(element: element as! Int)
}

but it fails, too

But, if the generic type has an other concrete type, like String , I can cast and it works:

func didProduce<String>(from: Producer<String>, element: String) {
    guard let element2 = element as? Int else { return }

    output(element: element2)
}

So, my current solution is to work with a typealias, that I don't have to put wrong types in the delegate method:

extension IntConsumer: ProducerDelegate {
    typealias T = Int

    func didProduce<T>(from: Producer<T>, element: T) {
        guard let element = element as? Int else { return }

        output(element: element)
    }
}

I hope someone can explain me my error and give me a better solution.

Answer 1

Your protocol requirement

func didProduce<T>(from: Producer<T>, element: T)

says "I can be called with any type of element and a producer of the same type of element". But that's not what you want to express – an IntConsumer can only consume Int elements.

You then implement this requirement as:

func didProduce<Int>(from: Producer<Int>, element: Int) {...}

which defines a new generic placeholder called " Int " – which will shadow the standard library's Int inside the method. Because your " Int " could represent any type, the compiler rightly tells you that you cannot pass it to a parameter that expects an actual Int .

You don't want generics here – you want an associated type instead:

/// Delegate for produced elements
protocol ProducerDelegate : class {

    associatedtype Element

    /// Called if a new element is produced
    ///
    /// - Parameters:
    ///     - from: producer
    ///     - element: produced element
    func didProduce(from: Producer<Element>, element: Element)
}

This protocol requirement now says "I can be called with only a specific type of element, which the conforming type will decide".

You can then simply implement the requirement as:

extension IntConsumer : ProducerDelegate {

    // Satisfy the ProducerDelegate requirement – Swift will infer that
    // the associated type "Element" is of type Int.
    func didProduce(from: Producer<Int>, element: Int) {
        output(element: element)
    }
}

(Note the removal of the <Int> generic placeholder).

However, because we're now using an associated type, you cannot use ProducerDelegate as an actual type – only a generic placeholder. This is because the compiler now has no idea what the associated type is if you talk only in terms of ProducerDelegate , so you cannot possibly use protocol requirements that depend on that associated type.

One possible solution to this problem is to define a type erasure in order to wrap the delegate method, and allowing us to express the associated type in terms of a generic placeholder:

// A wrapper for a ProducerDelegate that expects an element of a given type.
// Could be implemented as a struct if you remove the 'class' requirement from 
// the ProducerDelegate.
// NOTE: The wrapper will hold a weak reference to the base.
class AnyProducerDelegate<Element> : ProducerDelegate {

    private let _didProduce : (Producer<Element>, Element) -> Void

    init<Delegate : ProducerDelegate>(_ base: Delegate) where Delegate.Element == Element {
        _didProduce = { [weak base] in base?.didProduce(from: $0, element: $1) }
    }

    func didProduce(from: Producer<Element>, element: Element) {
        _didProduce(from, element)
    }
}

In order to prevent retain cycles, base is captured weakly by the type-erasure.

You'll then want to change your Producer 's delegate property to use this type-erased wrapper:

var delegate: AnyProducerDelegate<Element>?

and then use the wrapper when assigning the delegate in IntConsumer :

/// Consumes produced `Int` elements and work with it
class IntConsumer {

    // ...        

    init(producer: Producer<Int>) {
        self.producer = producer
        self.producer.delegate = AnyProducerDelegate(self)
    }

    // ...

}

Although, one downside to this approach is that the delegate won't be set to nil if the consumer is deallocated, instead calling didProduce on it will just silently fail. Unfortunately, I'm not aware of a better way of achieving this – would certainly be interested if anyone else has a better idea.