Parse multiple kind of structs in same array about argo

[tonyd256]

If this is truely the response that you are trying to decode then it's not too hard. You actually only have one type in your array and it's an object of an item and a collection. I would make an in-between struct ItemCollection say, and implement JSONDecodable like so:

struct ItemCollection {
  let item: Item
  let collection: Collection
}

extension ItemCollection: JSONDecodable {
  static func create(item: Item)(collection: Collection) -> ItemCollection {
    return ItemCollection(item: item, collection: collection)
  }

  static func decode(j: JSONValue) -> ItemCollection {
    return ItemCollection.create
      <^> j <| "item"
      <*> j <| "collection"
  }
}

Then you can decode your array and use map to get the separate arrays like so:

let results: [ItemCollection] = json <|| "result"
let items: [Item] = results.map { $0.item }
let collections: [Collection] = results.map { $0.collection }

where json is the initial JSONValue.

Or if you want them in the same array you can use reduce

let array: [SomeProtocol] = results.reduce([]) { $0 + [$1.item, $1.collection] }

[piercifani]

After reading @tonyd256 's answer, I realized that my approach was too Objective C like, so I ended up defining an enum with associated objects:

public enum ResultKind {
    case ItemKind(Item)
    case CollectionKind(Collection)
    case UnknownKind
}

extension ResultKind : JSONDecodable {
    static func create(item : Item?)(collection : Collection?) -> ResultKind {
        if let item = item {
            return ResultKind.ItemKind(item)
        } else if let collection = collection {
            return ResultKind.CollectionItem(collection)
        } else {
            return ResultKind.UnknownItem
        }
    }

    public static func decode(j: JSON) -> ResultKind? {
        let ItemKey = "item"
        let CollectionKey = "collection"

        return ResultKind.create
            <^> j <|? ItemKey
            <*> j <|? CollectionKey
    }
}

Definitely a more Swift-y way of doing things of doing things, I like it!

[nvh]

What would be the type of the resulting array? You can't store structs of type Item and Collection in the same array, unless they implement the same protocol.

[piercifani]

That's exactly the case, they implement the same protocol (a domain-specific one, not just JSONDecodable)

[nvh]

Hmmm, this is were default implementations in protocols would really help in Swift :)
You could of course make it a class and subclass Item and Collection from that, but I guess you much rather have value types, right?

[piercifani]

This sound solid, let me try this out!