> Le 4 mai 2016 à 08:28, Pyry Jahkola via swift-evolution 
> <[email protected]> a écrit :
> 
> Here's my review of "SE-0073: Marking closures as executing exactly once".
> 
>> What is your evaluation of the proposal?
> 
> +1. I think this is a good idea and should be accepted (without extending the 
> proposed scope).
> 
> However, I think the proposal should be more explicit about the case when 
> (and whether) the block itself throws. Specifically, I think we should 
> highlight that the criterion that
> 
>> it must not be executed on any path that throws
> 
> implies that a @noescape(once) parameter itself cannot throw (until another 
> language change allows otherwise).
> 
> […]
> 
> Being able to throw out of a @noescape(once) block […] would complicate the 
> language by requiring that no one catches the error in the scope where 
> uninitialised variables are defined. I suggest adding this remark to the 
> Future directions.

Hello Pyry,

I quite expect being able to throw out of a @noescape(once) block. Maybe the 
sentence "it must not be executed on any path that throws" should be removed 
from the proposal, should it have the implications you describe.

Here is below what I expect this proposal to allow. So you see one problematic 
case?

        // Function which rethrows closure errors:
        func f1(closure: @noescape(once) () throws -> ()) rethrows {
                try closure()
        }

        // Function which may throw before, inside, or after the closure:
        func f2(closure: @noescape(once) () throws -> ()) throws {
                try mayFailBefore()
                try closure()
                try mayFailAfter()
        }
        
        // Support function
        func getX() throws -> Int { return 1 }
        
Case 1:

        let x: Int
        f1 {
                x = 1
                // use x
        }
        // use x
        
Case 2:

        let x: Int
        do {
                try f1 {
                        x = try getX()
                        // use x
                }
                // use x
        } catch {
                // can't use x
        }
        // can't use x
        
Case 3:

        let x: Int
        do {
                try f1 {
                        x = try getX()
                        // use x
                }
                // use x
        } catch {
                x = 1
        }
        // use x
        
Case 4:

        let x: Int
        do {
                try f2 {
                        x = try getX()
                        // use x
                }
                // use x
        } catch {
                // can't use x
        }
        // can't use x

Case 5:

        let x: Int
        do {
                try f2 {
                        x = try getX()
                        // use x
                }
                // use x
        } catch {
                x = 1
        }
        // use x

Gwendal Roué

_______________________________________________
swift-evolution mailing list
[email protected]
https://lists.swift.org/mailman/listinfo/swift-evolution

Reply via email to