Wenn ich ein paar verkettete Guard Let-Anweisungen habe, wie kann ich diagnostizieren, welcher Zustand fehlgeschlagen ist, ohne meine Guard Let-Anweisung in mehrere Anweisungen aufzulösen?

Geben Sie dieses Beispiel an:

guard let keypath = dictionary["field"] as? String,
    let rule = dictionary["rule"] as? String,
    let comparator = FormFieldDisplayRuleComparator(rawValue: rule),
    let value = dictionary["value"]
    else
    {
        return nil
    }

Wie kann ich feststellen, welche der 4 let-Anweisungen fehlgeschlagen ist und den else-Block aufgerufen hat?

Das Einfachste, was ich mir vorstellen kann, ist, die Anweisungen in vier aufeinanderfolgende guard else-Anweisungen aufzuteilen, aber das fühlt sich falsch an.

 guard let keypath = dictionary["field"] as? String
    else
    {
        print("Keypath failed to load.")

        self.init()
        return nil
    }

    guard let rule = dictionary["rule"] as? String else
    {
        print("Rule failed to load.")

        self.init()
        return nil
    }

    guard let comparator = FormFieldDisplayRuleComparator(rawValue: rule) else
    {
        print("Comparator failed to load for rawValue: \(rule)")

        self.init()
        return nil
    }

    guard let value = dictionary["value"] else
    {
        print("Value failed to load.")

        self.init()
        return nil
    }

Wenn ich sie alle in einer Schutzerklärung behalten wollte, kann ich mir eine andere Option vorstellen. Das Überprüfen auf Nils in der Guard-Anweisung könnte funktionieren:

guard let keypath = dictionary["field"] as? String,
    let rule = dictionary["rule"] as? String,
    let comparator = FormFieldDisplayRuleComparator(rawValue: rule),
    let value = dictionary["value"]
    else
    {

        if let keypath = keypath {} else {
           print("Keypath failed to load.")
        }

        // ... Repeat for each let...
        return nil
    }

Ich weiß nicht einmal, ob das kompiliert wird, aber dann hätte ich genauso gut ein paar @ verwenden könneif let Anweisungen oderguards, um mit zu beginnen.

Was ist der idiomatische Swift-Weg?