Add transformed operation to Future

[mats-stripe]

Summary

This adds a new operation to our fork of Future, transformed(with:). This will allow us to apply a simple synchronous transform to a Promise value.

Note

Our implementation of Future is quoted to being taken from Swift by Sundell. This implementation of transformed(with:) also comes from the same source.

Here is the author's blog post with some more details.

At its core, this unlocks basic functionally for transforming a Promise value:

let promise = Promise<Int>(value: 42)

let doubledFuture = promise.transformed { value in
    return value * 2
}

doubledFuture.observe { result in
    switch result {
    case .success(let value):
        print("Transformed value: \(value)") // Transformed value: 84
    case .failure(let error):
        print("Error: \(error)")
    }
}

At a practical level, this unlocks type erasure of Future values. Here's a simple example:

protocol Animal {
    var name: String { get }
}

struct Dog: Animal {
    let name: String
}

struct Cat: Animal {
    let name: String
}

func getRandomAnimal() -> Future<Animal> {
    let randomNumber = Int.random(in: 0...1)
    if randomNumber == 0 {
        return getRandomDog() // Cannot convert value of type 'Future<Dog>' to closure result type 'Future<any Animal>'
    } else {
        return getRandomCat()
            .transformed { $0 as Animal } // Works!
    }
}

func getRandomDog() -> Future<Dog> {
    let promise = Promise<Dog>()
    promise.resolve(with: Dog(name: "Buddy"))
    return promise
}

func getRandomCat() -> Future<Cat> {
    let promise = Promise<Cat>()
    promise.resolve(with: Cat(name: "Whiskers"))
    return promise
}

In this scenario, the getRandomAnimal() function would get a compile error:

Cannot convert value of type 'Future<Dog>' to closure result type 'Future<any Animal>'

However, we fix that error bellow using .transformed { $0 as Animal }

Motivation

Unlocks type erasure of Future values.

Testing

Added a bunch of unit tests for Async.swift!

Changelog

N/a - these methods are all behind a @_spi(STP) class.

[porter-stripe]

✅ hopefully we can get FC to use Swift async/await in the future!