Scala update object fields incrementally - scala

Question

I need to build records with multiple fields.
The record definition is like:
class Record(
f1: Int,
f2: String,
...
err: String
)
The logic is like:
record.f1 = get_f1()
record.f2 = get_f2()
...
The calls to get_f1 etc may throw exceptions. When this happen, we set record.err to the exception message.
Right now, my hacky solution is to use a mutable Record instance and patch the fields incrementally. When exception happens, I'll catch it from an outer function and set the err field.
The question is how can I implement this in a more functional way?
------ edit -----
We need the err field to output the first exception
When exception happens, we still want to output the fields already populated

Answer 1

The question is how can I implement this in a more functional way?
By properly modeling this in a functional style.
First, let's remove the err field from the case class, and rather use Either
Second, let's properly handle the nulls using Option
Finally, let's use a functional library like cats.
The end result would be something like this:
import cats.data.EitherNec
import cats.syntax.all._
type Error = String // You may use a better data type.
final case class Record(
f1: Int,
f2: String,
f3: Boolean
)
object Record {
def fromRawData(f1: Option[Int], f2: Option[String], f3: Option[Boolean]): EitherNec[Error, Record] =
(
f1.toRightNec(left = "F1 was empty"),
f2.toRightNec(left = "F2 was empty"),
f3.toRightNec(left = "F3 was empty")
).parMapN(Record.apply)
}
The EitherNec[E, A] is just an alias for Either[NonEmptyChain[E], A]
Meaning that if it is a Left it will hold all the errors;
it also implies that there must be at least one error.
Feel free to ask any follow-up questions you may have.
If you don't want to use cats you can replace the parMapN with a for; but this will stop at the first failure.
You can see the code running here.

Answer 2

This is a (mostly) functional way of doing this:
import scala.util.{Try, Success, Failure}
Try {
Record(getf1(), getf2(), "")
} match {
case Success(r) => r
case Failure(e) => Record(0, "", e.getMessage)
}
If the code inside the Try runs OK then it will return Success and the match will extract the value and return it.
If the code throws an exception then it will be caught by the Try and it will return Failure. The match will catch the error code and then create a value of Return with err set to the error message from the exception.
As others have mentioned, the Either type is a better way of handling the error case as it removes the error information from the Record class itself:
Try {
Record(getf1(), getf2())
}.toEither
The result will be Right(<record>) on success or Left(<exception>) on error. You can use match to determine which answer was given.
For the modified question you need to use a nested chain of Try calls, with one level of nesting for each field in the record.
Try(getf1()) match {
case Failure(e) => Record(0, "", e.getMessage)
case Success(f1) =>
Try(getf2()) match {
case Failure(e) => Record(f1, "", e.getMessage)
case Success(f2) => Record(f1, f2, "")
}
}
This rather tortuous code is the consequence of the hybrid error handling approach in the question. A more standard design would do error handling for the whole record (as in the examples above) or for each individual field (by making each field an Option or Either value).