Not sure about the syntax to create two guard statement cases for each throw instance

Hi Kyler,

I did as you suggested, but I still have 3 errors and I'm unsure of how to complete it.. it truly is one of the hardest questions I've tried. My code has 3 errors currently looks like this:

swift_lint.swift:8:12: error: argument for generic parameter 'Key' could not be inferred let keys = Dictionary.keys ^ swift_lint.swift:17:46: error: cannot call value of non-function type 'ParserError' throw ParserError.EmptyDictionary("the data in the array dict has a nil value. I.E, the value is nil, not the key") ~~~~~~~~~~~~~~~~~~~~~~~~~^ swift_lint.swift:21:41: error: cannot call value of non-function type 'ParserError' throw ParserError.InvalidKey("the key is invalid since it itself does not exist in dictionary, so therefore the value cannot either") ~~~~~~~~~~~~~~~~~~~~^

Am I using the syntax correctly? Which dictionary am I supposed to refer to in order to callback the key?

Paul, If you could please post your code so I can better assist you. The format is to use three backticks followed by the name of the language on the first line by itself and then three backticks on the last line by itself. You can also reference the Markdown Cheatsheat on the hyperlink just above the post comment button. Thank you!

Hi Kyler! I have finally wrapped my head around this exercise and wanted to share my findings with you. I think perhaps you might be mistaken about this exercise.

While the == nil comparison does pass (maybe because the case successfully evaluates, it just evaluates to false), no matter what value is placed in the key for the var data, your parser as written will always throw the InvalidKey error.

However, if we use the below code:

struct Parser {
    var data: [String : String?]?

    func parse() throws {
        guard let dict = data else {
            throw ParserError.EmptyDictionary
        }
        guard dict.keys.contains("someKey") == true else {
            throw ParserError.InvalidKey
        }
/// The print statement is not part of the exercise but I used it to test when both error checks had passed
        print("No Errors have been found.")

    }
}

We can actually trigger the EmptyDictionary, the InvalidKey, or just pass all checks and perform some other work (like printing a success message to console).

We can test this in a playground too! Just set up the following variables:

let data: [String : String?]? = ["someKey": nil]
let nilData: [String : String?]? = nil
let otherData: [String: String?]? = ["otherKey": nil]

Then initialize a Parse struct using any of the above variables you like.

let parser = Parser(data: nilData)

The parse method along with a pattern matching Do catch combo like listed below, will print an error for each type of error we created with our variables. Otherwise, if we use the valid "data" we print the success line to the console.

do {
    try parser.parse()

} catch ParserError.EmptyDictionary() {

    print("The Dictionary does not exist")

} catch ParserError.InvalidKey() {

    print("Key 'someKey' doesn't exist in this Dictionary")

}

If you already knew all this, then ignore me. But I finally understand all of this section!

Sidenote: we can be more terse with "guard dict.keys.contains("someKey") == true" . Since the "contains()" method actually returns a Bool value, we could drop the "== true" altogether. I think the "== true" is slightly more readable but that is my opinon!

Hi Paul!

Yes, one you delete my Print Statement that I added inside of the struct (the one with the commented text above it), all the above code should get you through the challenge. Let me know if there is something specific which you aren't understanding as I feel like I've firmly grasped this specific challenge after banging my head against it.