What are the differences between throws and rethrows in Swift?
From "Declarations" in the Swift book:
Rethrowing Functions and Methods
A function or method can be declared with the
rethrows
keyword to indicate that it throws an error only if one of it’s function parameters throws an error. These functions and methods are known as rethrowing functions and rethrowing methods. Rethrowing functions and methods must have at least one throwing function parameter.
A typical example is the map
method:
public func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
If map
is called with a non-throwing transform, it does not throw
an error itself and can be called without try
:
// Example 1:
let a = [1, 2, 3]
func f1(n: Int) -> Int {
return n * n
}
let a1 = a.map(f1)
But if map
is called with a throwing closure then itself can throw
and must be called with try
:
// Example 2:
let a = [1, 2, 3]
enum CustomError: Error {
case illegalArgument
}
func f2(n: Int) throws -> Int {
guard n >= 0 else {
throw CustomError.illegalArgument
}
return n*n
}
do {
let a2 = try a.map(f2)
} catch {
// ...
}
- If
map
were declared asthrows
instead ofrethrows
then you would have to call it withtry
even in example 1, which is "inconvenient" and bloats the code unnecessary. - If
map
were declared withoutthrows/rethrows
then you could not call it with a throwing closure as in example 2.
The same is true for other methods from the Swift Standard Library
which take function parameters: filter()
, index(where:)
, forEach()
and many many more.
In your case,
func throwCustomError(function:(String) throws -> ()) throws
denotes a function which can throw an error, even if called with a non-throwing argument, whereas
func rethrowCustomError(function:(String) throws -> ()) rethrows
denotes a function which throws an error only if called with a throwing argument.
Roughly speaking, rethrows
is for functions which do not throw
errors "on their own", but only "forward" errors from their function
parameters.
Just to add something along with Martin's answer. A non throwing function with the same signature as a throwing function is considered a sub-type
of the throwing function. That is why rethrows can determine which one it is and only require try
when the func param also throws, but still accepts the same function signature that doesn't throw. It's a convenient way to only have to use a do try block when the func param throws, but the other code in the function doesn't throw an error.