How to apply contracts to record field names

[DrRuhe]

Lets say I have definitions of fruits and want to define recipes, but the recipes should only contain defined fruits:

let fruits = {
    banana.calories = 200,
    apple.calories = 150,
    peach.calories=100,
}
in
let FruitsAreValid = std.contract.from_predicate (fun ingredients =>
    ingredients
        |> std.record.fields
        |> std.array.all (fun used => std.array.elem used (std.record.fields fruits) )
)
in
{
    ingredients = {
        apple = 5,
        banana = 2,
        peach = 3,
        melon = 1,   # this is invalid
    }|FruitsAreValid,
}

This gives the following error:

error: contract broken by a value
   ┌─ assets/fruits.ncl:14:19
   │  
14 │       ingredients = {
   │ ╭───────────────────^
15 │ │         apple = 5,
16 │ │         banana = 2,
17 │ │         peach = 3,
18 │ │         melon = 1,
19 │ │     }|FruitsAreValid,
   │ │       -------------- expected type
   │ ╰─────^ applied to this expression
   │  
   ┌─ <unknown> (generated by evaluation):1:1
   │
 1 │ { ... }
   │ ------- evaluated to this value

How can I apply a contract to record field names, such that the error only points towards the melon?
Additionally, I could not figure out how to customize the error message with the from_predicate function, is that possible?

[vkleen]

The from_predicate function doesn't give you a way of customizing error messages. You can write the contract explicitly like this:

let FruitsAreValid = fun label ingredients =>
  let check =
    ingredients
    |> std.record.fields
    |> std.array.fold_right
      (
        fun ingredient acc =>
          if !std.record.has_field ingredient fruits then
            { error = true, offending_field = ingredient }
          else
            acc
      )
      { error = false, offending_field = "" }
  in
  if check.error then
    std.contract.blame_with_message "the field '%{check.offending_field}' is invalid" label
  else
    ingredients

Unfortunately, I don't know of a stable way of making the error point at the field name. That is something we should add to the error reporting interface, in my opinion.

[vkleen]

Another, slightly weird, way of building a contract specifying that only certain fields are allowed in the record is:

let FruitsAreValid =
  fruits
  |> std.record.fields
  |> std.array.fold_left (fun r fruit => r & { "%{fruit}" | optional }) {}

This code builds a record contract dynamically which ends up enforcing that the only fields in what FruitsAreValid is applied to also appear in fruits.

[DrRuhe]

I just tried to generalize your contract a bit more into a utils.ncl file:

{
    RecordFieldsAreForeignKeysInto = fun foreignRecord label localRecord =>
        let offending_fields =
            localRecord
            |> std.record.fields
            |> std.array.filter
            (
                fun localFieldName => !std.record.has_field localFieldName foreignRecord
            )
        in
        if std.array.length offending_fields > 0 then
            std.contract.blame_with_message "the Fields '%{std.serialize 'Json offending_fields}' are invalid!" label
        else
            localRecord
    ,
}

Now it tells me the term is not serializable?

error: non serializable term
   ┌─ assets/utils.ncl:2:38
   │  
 2 │       RecordFieldsAreForeignKeysInto = fun foreignRecord label localRecord =>
   │ ╭──────────────────────────────────────^
 3 │ │         let offending_fields =
 4 │ │             localRecord
 5 │ │             |> std.record.fields
   · │
13 │ │         else
14 │ │             localRecord
   │ ╰───────────────────────^
   │  
   = Nickel only supports serlializing to and from strings, booleans, numbers, enum tags, `null` (depending on the format), as well as records and arrays of serializable values.
   = Functions and special values (such as contract labels) aren't serializable.
   = If you want serialization to ignore a specific value, please use the `not_exported` metadata.

I am confused by the error... Do you have an idea?

[DrRuhe]

Nvm, I figured out that I forgot to actually pass the foreignRecord into the function. But the error message in that case is rather bad.