Se tenho um monte de declarações de permissão de guarda encadeadas, como posso diagnosticar qual condição falhou, antes de separar minha guarda de várias declarações?

Dado este exemplo:

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
    }

Como posso saber qual das 4 instruções let foi a que falhou e invocou o bloco else?

A coisa mais simples em que consigo pensar é dividir as instruções em quatro instruções seqüenciais de guarda, mas isso parece errado.

 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
    }

Se eu quisesse manter todos eles em uma declaração de guarda, posso pensar em outra opção. A verificação de nil na declaração de guarda pode 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
    }

Eu nem sei se isso irá compilar, mas então eu poderia muito bem ter usado um monte deif let declarações ouguards para começar.

Qual é a maneira Swift idiomática?