If you have object[first] = nil it will crash (fatal error: unexpectedly found nil while unwrapping an Optional value), as of left we have non-optional type. You should change AnyObject to optional or remove it (but it will raise warning)

When I checked Himotoki's perfomance by JSONShootout with Himotoki, the result was very slow. It was very sad... 😢 so I inspect the issue and I found reason.

It was caused by occured swift_dynamicCast by cast to [String: Any] in valueFor. So I fixed it to use NSDictionary for this cast, and the benchmark result changed very fast. 😄

I want to review and merge this fix.

:+1: for this project! I'm going to add to my https://github.com/loretoparisi/ios-json-benchmark JSON comparison project. I have a question. In terms of pure swift language, using Apple's Foundation creates a dependency from Cocoa. Any way to get rid of it (no Cocoa dependencies at all). Thank you.

Hi, I have an issue decoding array of arrays, how would you write a decode function which decode a JSON like this:

"summary": {
  "items": [[0], [1], [2]]
}

I've tried writing a struct like this:

struct Summary {
  let items: [[Int]]
}

and an extension:

extension Summary: Decodable {
  static func decode(_ e: Extractor) throws -> Summary {
    return try Summary(items: e <|| "items")
  }
}

but I'm getting an error: Type '[Int]' does not conform to protocol 'Decodable'

I know the JSON could be built better but this is what I'm getting from the server and this is what I have to decode.

Thanks, Oron

I have an object Song

struct Song {
    ...
    let frequencies: [[Int]]
}

and right now I'm parsing it so:

guard let arrayOfFrequencies = e.rawValue.valueForKeyPath("frequencies") as? [AnyObject] else {
    throw customError("frequency parsing failed")
}       
guard let twoD = arrayOfFrequencies.map({ $0 as? [Int] }) as? [[Int]] else {        
    throw customError("frequency parsing failed")
}       

Is this the way I should be decoding it? Can I use Himotoki to make my life easier?

I have an issue since i last updated my pods and Himotoki got upgraded to 2.0.0.

I no longer can use DecodedType and I have the following scenario I'd appreciate if you can help me fix.

I am subclassing a class which I need to be decodable like such:

class A: Decodable {
    var type : Int = 0
    var title: String = ""

    init (e: Extractor) {
        type = try! e <| "type"
        title = try! e <| "title"
    }

    static func decode(e: Extractor) throws -> A {
        let type : Int = try e <| "type"
        switch type {
        case 0:
            return B(e: e)
        case 1:
            return C(e: e)
        case 2:
            return A(e: e)
        }
    }
}

class B: A {
    var total : Double = 0.0
    override init(e: Extractor) {
        total = try! e <| "total"
        super.init(e: e)
    }
}

class C: A {
    var link : String = ""
    override init(e: Extractor) {
        link = try! e <| "link"
        super.init(e: e)
    }
}

I now have a compiler error on this line static func decode(e: Extractor) throws -> A which says Method 'decode' in non-final class 'A' must return 'Self' to conform to protocol 'Decodable'

Thank you for your help in advance! Great library :+1: !

In generic decodable type, Swift can't infer the type of initializer. For example:

struct PaginatedResponse<T: Decodable where T == T.DecodedType> {
    let id: Int
    let content: T

    static func decode(e: Extractor) -> PaginatedResponse? {
        let create = { PaginatedResponse($0) } // <- Missing argument for parameter 'content' in call

        return build(
            e <| "id",
            e <| "content"
        ).map(create)
    }
}

FYI, the code below passes build successfully.

struct PaginatedResponse<T: Decodable where T == T.DecodedType> {
    let id: Int
    let content: T

    static func decode(e: Extractor) -> PaginatedResponse? {
        let create = { id, content in
            PaginatedResponse(id: id, content: content)
        }

        return build(
            e <| "id",
            e <| "content"
        ).map(create)
    }
}

Do you have any idea to infer the type of initializer in the regular way?

Why Class in Swift can not decode by Himotoki? such as : class Hello: Decodable { var text: String? }

static func decode(_ e: Extractor) throws -> UserModel { return try UserModel ( text : e <| "text", ) }

Thank you so much for making Himotoki! I am using this library and think its Awesome so I wanted to make the README just a little more awesome!

The original english is fine, but I thought I would phrase just a few sentences to sound a little more inviting, hopefully encouraging more developers to try this library!

~ Nick

I have some JSON where one key path returns an Array<Dictionary<String,Any>>, that is an array of [String:Any] and I want to pass this to a Transformer for manipulation into a different structure.

The issue I have is that Extractor's array and arrayOptional methods expect to return an array of Decodable T. I can see why this works for Transformer<String, URL> and the like thanks to the extensions in StandardLib.swift, but [String:Any] does not conform to Decodable.

The only way I can get this to work is by adding an extension on Dictionary as follows:

extension Dictionary: Decodable {
    public static func decode(_ e: Extractor) throws -> Dictionary<Key, Value> {
        return try castOrFail(e.rawValue)
    }
}

Is this correct? Should this be part of StandardLib.swift, or am I approaching this in the wrong way?

It unclear from the README.md if Himotoki runs on Linux.

I have browsed around in the code and it mentions Linux several places.

Perhaps make it more clear that Linux is supported.

I am trying to decode a JSON like this one with Himotoki in Swift 3

next: [
          {
            question: 'Fréquence',
            condition: { '==': ['answer', 'Actions'] },
          },
          {
            question: 'Fréquence',
            condition: { '>=': ['answer', 'Stop'] },
          },
          {
            question: 'Risque',
            condition: { '<=': ['answer', 'nul'] }
          }
        ]

In the condition, there is an object that looks like a dictionary, since the field name changes ('==', '<=', '>=, ...). The value is then an array of string

I have tried to decode like this

typealias ConditionType = [String]

extension ConditionType: Decodable {}

struct NextItem {
    let question: String?
    let condition: [String : ConditionType]?
}

extension NextItem: Decodable {
    static func decode(_ e: Extractor) throws -> NextItem {

        return try NextItem(
            question:  e <|? "question",
            condition: e <|-|? "condition"
        )
    }
}

I do not not how to decode the ConditionType since there is no field name for the array

Maybe this is a rare case, but building inside xcworkspace ends-up with runtime crash. See: https://github.com/toshi0383/TVMLKitchen/issues/142 I confirmed this happens with Himotoki, too.

I wonder if anybody have alternative work-around for this? Rather than adding ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES = YES on library side?