Error Path Support

[doohochang]

It would be great if Ducktape will support error paths like Chimney.

There are many ways to implement it, but I think adding a function such as def nestPath(fa: F[A], path: String): F[A] into trait Transformer.Mode seems like a good choice. It's for being called with the field names, list indice or coproduct cases reflected from the macro code.

A default implementation such as def nestPath(fa: F[A], path: String): F[A] = fa can be provided to avoid any breaking changes.

[arainko]

Omitting error-path support was a conscious decision I made when designing FallibleTransformers - I feel like a lightweight version of it can be achieved in userland if we follow the newtype per type principle in conjuction with some metainformation mechanism to get the newtype name out (eg. sourcecode).

I actually have an implementation of this ready to go here which then gets passed in here.

An example usage would look like this:

final case class Person(name: Person.Name, age: Person.Age)

object Person {
  object Name extends NewtypeValidated[String, NonEmpty]
  export Name.Type as Name

  object Age extends NewtypeValidated[String, GreaterThan[0]]
  export Age.Name as Age
}

And then when something fails in your fallible transformation you'd get an error message like
Invalid Person.Name - ... which (at least for me) is just enough info.

As for keys and indices, that can also be achieved by creating a new implementation of either Transformer.Mode.Accumulating or Transformer.Mode.FailFast with a special impl for traverseCollection that matches on the type source collection to determine how should the errors look like.

Of course you do not get the exact path of failure that way, but IMO it's enough.

I'm also not completely opposed to the idea of baking in error path support but it'd be pretty low on my priority list right now :)

[doohochang]

Thanks for the comment.

I understand that not supporting error paths is an intentional choice, and I also agree that adding type information into the error could be a solution for most cases.

However I think the most difficult part for now is, there's no way to provide exact error path if I want to use Ducktape syntax.
If I implement fallible transformations in accumulating mode manually, it would be as below.

import zio.prelude.Validation
def transform(source: Source): Validation[Error, Dest] =
  // Zips or accumulates the transformation errors.
  Validation.validateWith(
    transform(source.fieldA).nestPath("fieldA"),
    transform(source.fieldB).nestPath("fieldB")
  ) { (fieldA, fieldB) =>
    Dest(fieldA, fieldB)
  }

But If I use Ducktape syntax, there's no chance to manipulate the paths in the errors because it's all happened in macro.

Of course I understand it could be low priority. Always thanks for your amazing contribution for Scala 3 ecosystem.