Proper way to propagate exceptions in defer block - swift

Question

In the following example, the function usingTemporaryDirectory() creates and deletes a temporary directory, calling a passed function body() in between. If an exception is thrown by createTemporaryDirectory() or the passed function body(), it is propagated to the caller. But the exception thrown by removeDirectory() cannot be passed to the caller because no exception may escape a defer block.
import Foundation
func createTemporaryDirectory() throws -> URL { ... }
func removeDirectory(_ url: URL) throws { ... }
func usingTemporaryDirectory(body: (URL) throws -> ()) throws {
let tempDir = try createTemporaryDirectory()
defer {
// Errors thrown from here are not handled.
try removeDirectory(tempDir)
}
try body(tempDir)
}
What is the proper way to handle such an exception? I see two options:
Just catch the exception and log a message.
Catch the exception, log a message and abort the process.
I don't want to use option 1 because that could lead in this example to an arbitrary number of temporary directories piling up. And I also don't want to use option 2 because that would prevent outer stack frames from completing their cleanup work (e.g. if multiple temporary directories have been created, removal for all of them should at least be attempted).
Java has a feature called suppressed exceptions. In this case the exception thrown in the defer block could be added as a suppressed exception to the exception thrown by body(), if any. Does Swift have a comparable feature?

Answer 1

In this case the exception thrown in the defer block could be added as a suppressed exception to the exception thrown by body(), if any. Does Swift have a comparable feature?
Not that I know of – you could however build something similar yourself. First, let's define an Error type that can store multiple underlying errors:
struct ErrorCollection : Error {
private var errors: [Error] = []
init() {}
init<S : Sequence>(_ sequence: S) where S.Element == Error {
for error in sequence {
append(error)
}
}
mutating func append(_ error: Error) {
switch error {
case let x as ErrorCollection: // ensure we flatten out any nested error collections.
errors.append(contentsOf: x.errors)
case let x:
errors.append(x)
}
}
}
extension ErrorCollection : RandomAccessCollection {
typealias Index = Int
typealias Element = Error
var startIndex: Index { return errors.startIndex }
var endIndex: Index { return errors.endIndex }
func index(_ i: Index, offsetBy n: Index) -> Index {
return errors.index(i, offsetBy: n)
}
subscript(index: Index) -> Element { return errors[index] }
}
Then we can define a Result<T> type which we can use in order to evaluate a closure, storing the return value if successful, otherwise the error it threw. We can then add a then(_:) method to allow us to catch any additional errors, potentially causing the success value to be invalidated:
enum Result<T> {
case success(T)
case failure(Error)
init(_ body: () throws -> T) {
do {
self = .success(try body())
} catch {
self = .failure(error)
}
}
func then(_ body: () throws -> Void) -> Result {
do {
try body()
return self
} catch let nextError {
switch self {
case .success: // invalidate the success value and store the error.
return .failure(nextError)
case .failure(let error): // concatenate the errors.
return .failure(ErrorCollection([error, nextError]))
}
}
}
func materialize() throws -> T {
switch self {
case .success(let value):
return value
case .failure(let error):
throw error
}
}
}
You can then use this like so:
func usingTemporaryDirectory<R>(body: (URL) throws -> R) throws -> R {
let tempDir = try createTemporaryDirectory()
return try Result { try body(tempDir) }
.then { try removeDirectory(tempDir) }
.materialize()
}