Parse nested array failed about argo

[gfontenot]

I think you can do this without a custom decode function, actually. This is going to be so much easier with Swift 4.1 and conditional conformance, but the gist now is that you'll want to move from JSON to [JSON] then to [[Reference]]:

extension Exercise: Argo.Decodable {
  static func decode(_ json: JSON) -> Decoded<Exercise> {
    let djs: Decoded<[JSON]> = json <|| "analyses"
    let ans: Decoded<[[Reference]]> = djs.flatMap { js in
      sequence(js.map([Reference].decode))
    }

    return curry(Exercise.init)
      <^> .optional(ans)
  }
}

This can be reduced to single expressions if you prefer. Alternatively, if you do this kind of thing frequently you can add a generic global function like so:

func decodeNested<T: Argo.Decodable>(_ json: JSON, key: String) -> Decoded<[[T]]> where T.DecodedType == T {
  return (json <|| key)
    >>- { sequence($0.map([T].decode)) }
}

extension Exercise: Argo.Decodable {
  static func decode(_ json: JSON) -> Decoded<Exercise> {
    let ans: Decoded<[[Reference]]> = decodeNested(json, key: "analyses")

    return curry(Exercise.init)
      <^> .optional(ans)
  }
}

Once we implement conditional conformance this will simplify to what you have now:

extension Exercise: Argo.Decodable {
  static func decode(_ json: JSON) -> Decoded<Exercise> {
    return curry(Exercise.init)
      <^> json <||? "analyses"
  }
}

FWIW, I don't think you should need to explicitly make ReferenceType conform to Decodable either. I believe our default implementation should handle that if you just declare the conformance:

extension Exercise.ReferenceType: Argo.Decodable { }

[wongzigii]

If would appreciate if you can take a look at this issue. :D

[jshier]

Argo doesn't actually support decoding arrays of arrays by default. Perhaps with Swift 4.1's conditional conformances, but for now you'll need to do it manually and define a decode method within an extension on Array. Something like extension Array where Element == [Reference].

[wongzigii]

@jshier Thanks for your reply.

extension Array where Element == [Exercise.Reference] {
    func decode() -> Decoded<[Decoded<Exercise.Reference>]> {
        var result: [Decoded<Exercise.Reference>] = []
        self.forEach { inner in
	    let r = Exercise.Reference.decode(JSON(inner))
            result.append(r)
        }
        return .success(result)
    }
}

If I understand you correctly, I finally get this code, however, I don't know how to call this method on extension Exercise.Analyse: Argo.Decodable

extension Exercise.Analyse: Argo.Decodable {

    static func decode(_ json: JSON) -> Decoded<Exercise.Analyse> {
        // How?
    }
}

Can you guide me a little bit more? Thanks

[gfontenot]

Good news! This will Just Work in the next release! I'm going to close this now in anticipation of that release, but feel free to re-open this if you have any other questions.