在Argo中解码泛型类型

Question

I'm using Thoughtbot's Argo framework for parsing JSON objects into models.

I'm running into an issue where I have a protocol and its extension like so

protocol SomeProtocol {
    associatedtype Model
    func foo()     
}

extension SomeProtocol where Model: Decodable {
    func foo() -> Model? {
        // someJSON is AnyObject in this case, say, from a network call
        guard let model: Model = decode(someJSON) else { return nil }
        return model
    }
}

and the class that conforms to this protocol looks something like this

class SomeClass: SomeProtocol {
    typealias Model = ArgoModel

    func bar() {
        print(foo())
    }
}

and the model like this

struct ArgoModel {
    let id: String
}

extension ArgoModel: Decodable {
    static func decode(j: AnyObject) -> Decoded<ArgoModel> {
        return curry(self.init)
            <^> j <| "id"
    }
}

(I'm also using their Curry library as well to curry the init method)

The problem I'm having is that, in the SomeProtocol extension, the associatedtype, Model, can't be decoded by Argo. The error I get is

No 'decode' candidates produced the expected contextual result type 'Self.Model?'

Is this a limitation of the Swift type system? Or is there something I'm missing?

Answer 1

After researching some more it seems like this is a limitation of the Swift type system as of Swift 2.3. The exact reason for the issue is that contextual types such as collections and monads can't conform to Decodable in Argo. So my models would work as long as they were not contained in a collection. With Swift 3.0, the goal is to allow

the ability to make a constrained extension conform to a new protocol (ie, an array of Equatable elements is Equatable)

as seen in this issue: https://github.com/thoughtbot/Argo/issues/334

My current workaround is to make a plural model which contains the array of models and decode that in the SomeProtocol extension. So now my model would look like this:

struct ArgoModels {
    let models: [ArgoModel]
}

extension ArgoModels: Decodable {
    static func decode(j: JSON) -> Decoded<ArgoModels> {
        switch j {
            case .Array(let a):
                return curry(self.init) <^> sequence(a.map(ArgoModel.decode))
            default:
                return .typeMismatch("Array", actual: j)
        }
    }
}

struct ArgoModel {
    let id: String
}

extension ArgoModel: Decodable {
    static func decode(j: AnyObject) -> Decoded<ArgoModel> {
        return curry(self.init)
            <^> j <| "id"
    }
}

Then in the implementing class, I can make a typealias, Model that can either be a single object or a collection of them in a generic way.