How can I write a custom contract that adds a note to another contract in case of error?

[NicholasPini]

I'm trying to write a Nickel contract that adds a custom error note to whatever contract it is applied to. I've come up with this:

let WithMsg = fun msg Contract =>
  (
    std.contract.custom (fun label value =>
      std.contract.check Contract label value
      |> match {
        'Ok v => 'Ok v,
        'Error e =>
          let r = std.record.map (fun s x => if s == "notes" then x @ msg else x) e in
          'Error (if std.record.has_field "notes" r then r else r & { notes = [msg] })
      }
    )
  )
in
# ...

The problem is that this is very inconsistent. It works if I provide a field with the wrong type (for example, some_field | WithMsg "custom error" Number, and I provide some_field = "a string"). When applied to record contracts, it doesn't work. For example:

some_field | WithMsg "custom error" {
  a_field | String,
  another_field | String
}

In this case, if I fail to provide a_field, an error is raised (as expected) but it doesn't seem to trigger my WithMsg contract.

Is there a way to provided custom error messages to any contracts?

[jneem]

The issue here is that record contracts are lazy, and so actually your call to std.contract.check succeeds. For example,

std.contract.check { a_field | String } label { a_field = 1 }
# => 'Ok { a_field | String = 1 }

That is, the record contract's check just merges the field contracts into the record. It's only later, when the a_field field gets evaluated, that the String contract failure triggers.

As for how to enable this use-case, we might need to add something to the standard library. We have std.deep_seq for forcing full evaluation and we have std.contract.check for checking contracts without terminating on failure, but we don't currently have a way to combine the two, by forcing full evaluation and returning an error (instead of terminating) on failure.

[NicholasPini]

I've read a bit more about delayed checks and came up with this:

let WithMsg = fun msg Contract =>
  std.contract.custom (fun label value =>
    let new_label = std.contract.label.append_note msg label in
    let delayed = std.contract.apply Contract new_label value in
    'Ok delayed
  )
in
# ...

It still doesn't work tho. It's weird because my understanding is that this is not run immediately, so it should work with records, and it mimics what the documentation does when explaining delayed checks. I've tried applying this contract to the most inner field (the one that is not provided by the user) and also to the record itself:

{
  a_record | WithMsg "some error" { 
    a_field | WithMsg "another_error" String, 
    another_field | WithMsg "yet_another_error" String 
  }
}

The error message does not have the additional note in all of these cases.

Note that I'm using Nickel to check a TOML file using the --apply-contract flag, not sure if it matters.

[jneem]

The reason the message isn't showing up in this example is it's a missing field and not a contract failure. I mean, the a_record field is undefined, and so nickel errors before evaluating its contract. But if I assign it an invalid value:

let WithMsg = fun msg Contract =>
  std.contract.custom (fun label value =>
    let new_label = std.contract.label.append_note msg label in
    std.contract.check Contract new_label value
  )
in
{
  a_record
    | WithMsg
      "some error"
      {
        a_field | WithMsg "another_error" String,
        another_field | WithMsg "yet_another_error" String
      }
    = 1,
}

I get

error: contract broken by the value of `a_record`
[...snip]
note: from a parent contract violation
 = some error

I do think that a missing field should be a contract violation (if it's a field that was required by the contract), but currently it's a separate error.

[NicholasPini]

Now I get it! I've always assumed all Nickel errors were contract violations (I mean, except for syntax errors and things along those lines). Thank you.