alexito4 / baggins

🎒 My personal bag of holding for Swift extensions.

Hi there 👋

I'm Alejandro Martinez, a.k.a @alexito4. I'm a Software Developer currently based in the beautiful city of Girona in Catalonia, Spain.

I love to share my knowledge and so I spent a bunch of time writing educational content, mostly about Swift and iOS development, on my website. I also create video content for my Youtube channel.

baggins's Issues

Cancellation may not work as expected

Hi,

I've used your code for some time now and it's really useful and has helped me a lot. While refactoring some code to better handle user cancellation of long running tasks I noticed that I get a TimeoutError instead of a CancellationError sometimes. I was able to write a test case that shows it:

func testTimeout() async throws {
    let task = Task {
        do {
            try await withTimeout(2.0) {
                try? await Task.sleep(seconds:3.0)

                // Simulate needing to do a little work before politely exiting
                let delay = Task.detached {
                    try? await Task.sleep(seconds:0.5)
                }
                await delay.value

                try Task.checkCancellation()
            }
        } catch {
            throw error
        }
    }

    Task {
        try await Task.sleep(seconds: 1.0)
        task.cancel()
    }

    do {
        try await task.value
        XCTAssert(false)
    } catch {
        XCTAssert(error is CancellationError)
    }
}

Does it make sense, or is my test code not written correctly? I can solve the issue by changing the withTimeout function to:

public func withTimeout<R>(
    _ seconds: Double,
    _ work: @escaping () async throws -> R
) async throws -> R {
    try await firstOf {
        try await work()
    } or: {
        try await Task.sleep(seconds: seconds)
        throw TimeoutError()
    }
}

So basically, if the task that is running the withTimeout is cancelled, the or:-block will throw a CancellationError and the surrounding code can know the difference between a timeout and an active cancellation.

Try this, `withTimeout ` seems not work

`
func testAsync() async -> String {
var value = 0
for _ in 0...10_000_0000 {
value += 1
}
return "(value)"
}

    Task {
        do {
            let res = try await withTimeout(0.25) {

                await testAsync()
            }
            print(res)
        } catch {
            print(error)
        }
    }
    
  `