Converting types when decoding about argo

[tonyd256]

In your case, we would recommend you use the extension just like you did. However, I can see how this breaks down with different NSDate formatters. The reason you are seeing the compiler hang is because the types aren't aligning and making JSONParseUtils.parseURL take a String? fixes that.

The expression j <|? "full" in your code above returns a String?? and the flatMap operator >>- will only unwrap one level of context. You would have to write that line as <^> j <| "full" >>- JSONParseUtils.parseURL. The issue now is that you loose your "nil is ok" decoding. To fix that, wrap your entire expression in pure. This will wrap the result in another optional context and allow for nil being ok.

<^> pure(j <| "full" >>- JSONParseUtils.parseURL)

I'm going to keep this issue open to make sure an example of this gets added to the docs and/or a test. I think this will change with Argo 1.0.

[marcelofabri]

Thanks for the feedback. I'll take a closer look at pure.

[tonyd256]

@marcelofabri any update on this? did pure work out for you?

[marcelofabri]

I justed tested this, but I couldn't make it work:

struct JSONParseUtils {
    static func parseURL(URLString: String?) -> NSURL? {
        return flatMap(URLString) { NSURL(string: $0) }
    }
}


extension ImagesURLs: Decodable {
    static func create(fullImageURL: NSURL?)(mediumImageURL: NSURL?)(thumbImageURL: NSURL?) -> ImagesURLs {
        return ImagesURLs(fullImageURL: fullImageURL, mediumImageURL: mediumImageURL, thumbImageURL: thumbImageURL)
    }

    public static func decode(j: JSON) -> Decoded<ImagesURLs> {
        return ImagesURLs.create
            <^> pure((j <| "full") >>- JSONParseUtils.parseURL)
            <*> pure((j <| "medium") >>- JSONParseUtils.parseURL)
            <*> pure((j <| "thumb") >>- JSONParseUtils.parseURL)
    }
}

The compiler just gives up:

Expression was too complex to be solved in reasonable time; consider breaking up the expression into distinct sub-expressions

I also didn't understand why you suggested <| and not <|?.

[tonyd256]

@marcelofabri Using Argo 1.0+, those operators return a Decoded<T> now instead of a T?.
This means that j <| "full" returns Decoded<String>. You can use j <|? "full" to return a Decoded<String?>.
Then you use flatMap which expects the type signature to be String? -> Decoded<NSURL?>.

If you change parseURL to return a Decoded<NSURL?> by puring the return and remove the pure calls in the decode function, it should align for you.

[marcelofabri]

I finally got it! Thanks for the patience and your help.

Here's the final code for future reference:

struct JSONParseUtils {
    static func parseURL(URLString: String?) -> Decoded<NSURL?> {
        return pure(flatMap(URLString) { NSURL(string: $0) })
    }
}

extension ImagesURLs: Decodable {
    static func create(fullImageURL: NSURL?)(mediumImageURL: NSURL?)(thumbImageURL: NSURL?) -> ImagesURLs {
        return ImagesURLs(fullImageURL: fullImageURL, mediumImageURL: mediumImageURL, thumbImageURL: thumbImageURL)
    }

    public static func decode(j: JSON) -> Decoded<ImagesURLs> {
        return ImagesURLs.create
            <^> j <|? "full" >>- JSONParseUtils.parseURL
            <*> j <|? "medium" >>- JSONParseUtils.parseURL
            <*> j <|? "thumb" >>- JSONParseUtils.parseURL
    }
}

[tonyd256]

Awesome! Glad we were able to figure it out! Feel free to comment on here again if a similar thing happens or make new issues if you run into other problems!