Recovered record validation with Try and Using returns limited failure detail

Direct answer

Return Either[Error, ValidatedData] for recovered-file validation. Use scala.util.Try only internally to lift exceptions, and keep scala.util.Using for resource handling. For the standard library API the import is the same in Scala 2.13 and Scala 3.x: import scala.util.Using. Fatal errors are not recoverable by design and must not be encoded in the return type; they escape Try and Using and terminate the process.

Confirmed facts

• scala.util.Try catches only scala.util.control.NonFatal exceptions. Success/Failure is a value, but it discards structured domain error context.
• Fatal errors such as OutOfMemoryError, VirtualMachineError and InterruptedException are not caught by Try. They escape and terminate the process.
• scala.util.Using exists in Scala 2.13 and Scala 3.x under scala.util.Using. Standard usage is Using.resource with an AutoCloseable resource and a by-name usage block.
• Using attempts finalization but does not make fatal errors recoverable.

Likely explanation

For recovered records the public API should preserve parse and validation errors in the left projection of Either. Try is appropriate only as an internal bridge to convert exceptions to domain errors, e.g. Try(parse).toEither.left.map(ParseError). Keeping Try as the return type conflates exceptions with business validation failures and loses detail.

Version-specific implicit evidence for Using.resource is minimal for the standard library. Both Scala 2.13 and Scala 3.x require only import scala.util.Using when working with AutoCloseable. Differences in implicit resolution can appear when mixing third-party Resource type classes or extension methods; verification against the target compiler is needed.

Steps for this case

1. Define a domain error ADT, e.g. sealed trait Error with ParseError, ValidationError cases.
2. Open the recovered file with Using.resource and lift exceptions with Try internally:

   import scala.util.{Using, Try}
   
   def validate(path: String): Either[Error, ValidatedData] =
     Using.resource(java.nio.file.Files.newBufferedReader(java.nio.file.Paths.get(path))) { reader =>
       Try(parse(reader)).toEither.left.map(e => ParseError(e.getMessage))
     }.toEither.left.map(_ => Error.ResourceClosed)
   

3. Do not encode fatal errors in the return type. Let them escape.
4. Compile a minimal snippet with scala.util.Using.resource and scala.util.Try in the target Scala 2.13 and Scala 3.x compiler to confirm signatures and imports.

One diagnostic that changes the recommendation: confirm whether your resources are AutoCloseable or a third-party Resource type class. If the latter, the required implicits and imports differ from the standard library Using.