Si tengo un montón de declaraciones de guardia encadenadas, ¿cómo puedo diagnosticar qué condición falló, salvo romper mi guardia en múltiples declaraciones?

Dado este ejemplo:

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
    }

¿Cómo puedo saber cuál de las 4 declaraciones let fue la que falló e invocó el bloque else?

Lo más simple que se me ocurre es dividir las declaraciones en 4 declaraciones secuenciales de guardia, pero eso se siente mal.

 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
    }

Si quisiera mantenerlos a todos en una declaración de guardia, puedo pensar en otra opción. La comprobación de nulos dentro de la declaración de protección podría funcionar:

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
    }

Ni siquiera sé si eso se compilará, pero también podría haber usado un montón deif let declaraciones oguards para empezar.

¿Cuál es la forma idiomática de Swift?