扩展使用的具有通用类型别名的协议

Question

I am running into an issue with the json parsing portion of an application I am writing. I wrote a quick example in a playground shown below to illustrate the issue. I have a parser type protocol and a collection of parser objects that conform to it. Everything works flawlessly except for the final line. The compiler is having an issue figuring what class a generic should be, and I am not sure whether it's a mistake I have made or a bug with the compiler itself.

The error is produced by the final line of the example and reads:

For this example I made the extension on Dictionary in the final few lines, but in my actual application I am using RxSwift, and the extension is on Observable as I am trying to write:

API.someNetworkRequest().parsed().subscribeNext() { thing in } 

This error has no relation to RxSwift though.

Also to note, I have tried using 'as!' and a few other approaches to try and get the compiler understanding what type I want the generic constraint to be. If I could just write parsed() and feed that the generic constraint directly it would work, but I can't as it is a function and produces the error 'Cannot explicitly specialize a generic function'.

  protocol ParserType {
      typealias ParsedObjectType

      init()

      func parse(object: AnyObject) throws -> ParsedObjectType
  }    

  struct Dog {
      var name: String?
  }    

  class DogParser: ParserType {
      required init() { }

      func parse(object: AnyObject) throws -> Dog {
          return Dog()
      }
  }    

  struct PaginationContext {
      var nextPageLink: String?
  }    

  class PaginatedParser<T where T: ParserType>: ParserType {
      required init() { }

      func parse(object: AnyObject) throws -> ([T.ParsedObjectType], PaginationContext?) {
          // some array from json object
          let jsonArray = ["test", "test", "test"]

          let childParser = T()
          let parsedDogs: [T.ParsedObjectType] = jsonArray.flatMap() {
              do {
                  return try childParser.parse($0 as! AnyObject)
              } catch {
                  return nil
              }
          }

          let pagination = PaginationContext()

          return (parsedDogs, pagination)
      }
  }    


  // This works perfectly
  let paginatedParser = PaginatedParser<DogParser>()
  let thing = [String: AnyObject]()
  let parsedData = try! paginatedParser.parse(thing as! AnyObject)    



  extension Dictionary {
      func parsed<T where T: ParserType>() -> ([T.ParsedObjectType], PaginationContext?) {
          let paginatedParser = PaginatedParser<T>()
          return try! paginatedParser.parse(self as! AnyObject)
      }
  }    

  // This won't. The compiler can't figure out that it needs to use DogParser.
  let thing2 = [String: AnyObject]()
  let result: ([DogParser.ParsedObjectType], PaginationContext?) = thing2.parsed()

Answer 1

The extension method parsed() cannot infer that the generic type T is the same type as the immutable that you assign the result of the call to.

You can solve this by supplying the parsed(..) method with the actual parser type as a parameter. You needn't actually make explicit use of this parameter (hence internal name omitted using _ ), and its sole purpose in this context is to infer the type of the generic T .

// ...

extension Dictionary where Key: StringLiteralConvertible, Value: AnyObject {
    func parsed<T: ParserType>(_: T.Type) -> ([T.ParsedObjectType], PaginationContext?) {
        let paginatedParser = PaginatedParser<T>()
        return try! paginatedParser.parse(self as! AnyObject)
    }
}

With this, you needn't explicitly supply the type of result as it can be inferred from the return of parsed(..) . Note that I've also added a limitation in the extension for keys that conform to StringLiteralConvertible ( String , among others, see language ref. ) and for AnyObject values. You shouldn't make extensions more general than they need to be.

Example usage:

let thing2 = [String: AnyObject]()
let result = thing2.parsed(DogParser)

print(result.dynamicType)
    /* (Array<Dog>, Optional<PaginationContext>), OK */