Dealing With Errors in a Throwing taskGroup

I'm using a withThrowingTaskGroup to iterate through an array of remote URLs, downloading the images and saving them to disk.

private func batchDownloadImages(from remoteImages: [RemoteImageData]) async throws -> [SampleImage]{
    
    try await withThrowingTaskGroup(of: SampleImage.self)  { group in
        
        for image in remoteImages {
            group.addTask(priority: .userInitiated) {
                return try await self.downloadFile(from: image)
            }
        }

        return try await group.reduce(into: [SampleImage]()) { partialResult, name in
            partialResult.append(name)
        }

        //return []
    }

downloadFile(from:) is responsible for downloading the file from the URL and saving it to disk. It will throw an error either when the download fails or when the disk operation fails.

In my current code, if one download fails then all tasks are canceled and the successful downloads rent saved to disk.

If an error is thrown because the download fails I want to ignore it and let all other tasks run as normal (as that one URL might have issues) however if it fails because I can't save it I want to deal with that error and cancel all other tasks. Is this possible?

You can catch the error that gets thrown when the download fails, and only that error.

Suppose downloadFile is something like this:

func downloadFile(from: RemoteImageData) async throws -> SampleImage {
    let image: SampleImage
    do {
        image = try downloadImage()
    } catch {
        throw MyError.downloadFailed(error)
    }
    do {
        try saveImageToFile(image)
    } catch {
        throw MyError.saveFailed(error)
    }
    return image
}

enum MyError: Error {
    case downloadFailed(Error)
    case saveFailed(Error)
}

Then you can catch specifically MyError.downloadFailed:

// Note that the type of the task group has been changed to Result<SampleImage, MyError>
// to include the download errors that gets thrown
try await withThrowingTaskGroup(of: Result<SampleImage, MyError>.self)  { group in
    
    for image in remoteImages {
        group.addTask(priority: .userInitiated) {
            do {
                return Result.success(try await downloadFile(from: image))
            } catch let MyError.downloadFailed(error) {
                return Result.failure(MyError.downloadFailed(error))
            }
        }
    }
    
    return try await group.reduce(into: [SampleImage]()) { partialResult, name in
        switch name {
        case let .success(image):
            partialResult.append(image)
        case let .failure(error):
            print(error) // handle this in some way
        }
    }
}

Effectively, all the download errors will be caught and handled in the reduce, and all the file-saving errors will be thrown, like it was before.