So, I know this doesn’t actually address your issue, but I think it is
important to clarify that “rethrows” does not guarantee anything about the
*type* of error thrown by a function. What “rethrows” implies is that the
function *will not throw* unless at least one of its arguments throws.
In particular, if the argument throws, the outer function can throw *any
error or none at all*. For example,
enum CatError: Error { case hairball }
enum DogError: Error { case chasedSkunk }
func foo(_ f: () throws -> Void) rethrows -> Void {
do { try f() }
catch { throw CatError.hairball }
}
do {
try foo{ throw DogError.chasedSkunk }
} catch {
print(error) // hairball
}
Inside foo’s catch block, it is legal to throw any error, or not throw an
error at all. But *outside* that catch block foo cannot throw, which is
causing you consternation.
• • •
I don’t have a good solution for you, but in attempting to find one I *did*
uncover something which compiles that probably shouldn’t. It seems that a
“rethrows” function is currently allowed to throw if a *local* function
throws:
func rethrowing(_ f: () throws -> Void) rethrows -> Void {
func localThrowing() throws -> Void { throw CatError.hairball }
return try localThrowing()
}
do {
try rethrowing{ throw DogError.chasedSkunk }
} catch {
print(error) // hairball
}
I wouldn’t count on this functionality as it is most likely a bug. Indeed,
if we pass in a non-throwing argument then we get a runtime error:
rethrowing{ return } // EXC_BAD_ACCESS (code=1, address=0x0)
Although, if we change “localThrowing” to use do/catch on a call to “f” and
throw only in the catch block, or even use your “var caught: Error?” trick,
then it appears to work as intended with no problems at runtime.
• • •
In the unlikely scenario that the above local-function behavior is valid
and intended, the following function will, technically speaking, let you
work around the issue you’re having:
func withPredicateErrors <Element, Return>
(_ predicate: (Element) throws -> Bool,
do body: @escaping ((Element) -> Bool) -> Return
) rethrows -> Return
{
func bodyWrapper(_ f: (Element) throws -> Bool) throws -> Return {
var caught: Error?
let value = body{ elem in
do {
return try f(elem)
} catch {
caught = error
return true
}
}
if let caught = caught { throw caught }
return value
}
return try bodyWrapper(predicate)
}
It is not pretty, and it probably relies on a compiler bug, but at the
present time, against all odds, it look like this operates as you intend.
Nevin
On Sat, Dec 30, 2017 at 11:15 PM, Brent Royal-Gordon via swift-users <
swift-users@swift.org> wrote:
> I need to do something like this:
>
> func withPredicateErrors<Element, Return>(_ predicate: (Element)
> throws -> Bool, do body: ((Element) -> Bool) -> Return) rethrows -> Return {
> var caught: Error?
> let value = body { elem in
> do {
> return try predicate(elem)
> }
> catch {
> caught = error
> return true // Terminate search
> }
> }
>
> if let caught = caught {
> throw caught
> }
> else {
> return value
> }
> }
>
> The problem is, the Swift compiler doesn't allow the explicit `throw`
> statement; even though it can only throw errors originally thrown by
> `predicate`, the compiler is not smart enough to prove that to itself. I
> cannot make `body` a `throws` function.
>
> Is there any way to do this? Either to override the compiler's safety
> check, or to rewrite this function to avoid it?
>
> --
> Brent Royal-Gordon
> Architechies
>
> _______________________________________________
> swift-users mailing list
> swift-users@swift.org
> https://lists.swift.org/mailman/listinfo/swift-users
>
_______________________________________________
swift-users mailing list
swift-users@swift.org
https://lists.swift.org/mailman/listinfo/swift-users
