A clean way to attach error messages to form fields?

[amano-kenji]

I created a haskell module that calculates [(n, ErrorMessage)] from Text fields.

I could make a form state type that looks like this.

data FormState = {
  a :: Text
, aError :: Maybe Text
, b :: Text
, bError :: Maybe Text
...
}

I could fill in error fields in EventM. RenderM could render error messages below fields.

Is there a cleaner way to attach error messages to form fields?

[amano-kenji]

It seems I should just have one error field for showing the first error because presenting many errors at once will overwhelm people.

[jtdaugherty]

The built-in form is not designed to specifically allow for presenting validation errors when the per-field validators fail. Validation states are expressed using form attributes. If you want to display your own validation errors, I suspect you’ll need to subvert the built-in validation machinery and just store the validation errors as part of the field values themselves, which you can then have control over rendering. So, for example, instead of having a value of type a in your form state, have a value of type Either ValidationError a. That’ll require you to also update your form state in EventM after you’ve run your own validators.

[amano-kenji]

However, if the form state stores Left ValidationError, the form will not render the invalid value because it doesn't have the value.

[jtdaugherty]

Ah yes, you're right. Another approach that might work -- but that would frankly be an abuse of the abstraction, so I don't recommend it -- would be to make form fields that extract validation values from the form state and use those to render. To do that you'd need to write a new form field constructor similar to editField, except that instead of pulling just one value from the state and turning it into Text, it'd need to pull two: one for the text and one for the (possibly absent) validation error. Since any form field can use whatever bits of the form state it wants, there's nothing preventing this, but since it is a way of using the form abstraction that wasn't what it was designed for, problems could ensue. For example, the lens that puts the validated value back into the state would need to ignore the validation error bit entirely. (That's where this starts to become inadvisable.) At the end of the day, right now, the form abstraction is just not designed for this use case.

[amano-kenji]

For now, I have a list of external validators. My validator function invalidates the first field that fails external validation and sets the other fields valid and sets the error field of the form state to the error message.

data FormState = {
  a :: Text
, b :: Text
, c :: Text
, error :: Maybe Text
}

With this, only the first invalid field has invalid attribute, and its error message is displayed below the rendered form. I didn't want to confuse users with multiple errors and multiple invalid fields.

[amano-kenji]

For example, the lens that puts the validated value back into the state would need to ignore the validation error bit entirely.

What do you mean by ignoring the validation error bit?