Combining Asyncly Futures

Why use Futures vs Callbacks?

callback hell
callback interface hell
less code
more readable code
composabilty

Composability

chaining
transforming
splitting
joining

Async Computation Graph Notation

Future A

Future B

Future C

operationA()

operationB()

combinator()

Async Computation Graph Notation

ResponseA

ResponseB

ResponseAny

getHttpUrl(serviceA)

getHttpUrl(serviceB)

when_any()

Chaining

DiscoveryResponse

DiscoveredServiceResponse

getHttpUrl(discoveryService)

getHttpUrl(discoveredUrl)

asyncly::Future<Response> getHttpUrl(const std::string& url);

void run() {
    getHttpUrl("https://discovery-service.com/discover-some-service")
        .then(
            [](Response responseFromDiscoveryService) {
                // note that we return another future
                return getHttpUrl(responseFromDiscoveryService.body);
            })
        .then(
            [](Response response) {
               // do something with the response here
               std::cout << response.body << std::endl;
            });
}

Chaining

chains can be as long as you want
don't nest .then(), always move continuations to the outside
the continuation passed to then() should always take arguments as values (we support move semantics, ie T that are not copyable).
T must be movable or copyable
Futures themselves are copyable, but you must only ever call then() once on all copies
then() can return a value instead of a future, that's converted into a resolved future automatically
futures can hold void

Splitting

DiscoveryResponse1

DiscoveredServiceResponse1

getHttpUrl(discoveryService)

getHttpUrl(discoveredUrl1 + "/1")

DiscoveryResponse2

DiscoveredServiceResponse2

getHttpUrl(discoveredUrl + "/2")

DiscoveryResponse

asyncly::split()

asyncly::Future<Response> getHttpUrl(const std::string& url);

void run() {
    auto serviceUrlFuture =
        getHttpUrl("https://discovery.com/some-service");

    // split consumes one future and returns a tuple of two futures
    // T must be copyable!
    auto serviceUrlPair = asyncly::split(std::move(serviceUrlFuture));
    
    auto endpointAFuture = std::get<0>(serviceUrlPair)
        .then([](auto serviceUrl) {
            return getHttpUrl(serviceUrl.body + "/1");
        });
    auto endpointBFuture = std::get<1>(serviceUrlPair)
        .then([](auto serviceUrl) {
            return getHttpUrl(serviceUrl.body + "/2");
        });
        
    // proceed with doing something with the two responses
}

Splitting

when_any

ResponseA

ResponseB

ResponseAorB

getHttpUrl(serviceA)

getHttpUrl(serviceB)

when_any()

asyncly::Future<Response> getHttpUrl(const std::string& url);

void run() {
    auto responseFutureA = getHttpUrl("https://service-a");
    auto responseFutureB = getHttpUrl("https://service-b");

    asyncly::when_any(
            std::move(responseFutureA),
            std::move(responseFutureB))
         .then([](Response result) {
                std::cout << result.body << std::endl;
         });
}

when_any

when_all

ResponseA

ResponseB

ResponseAandB

getHttpUrl(serviceA)

getHttpUrl(serviceB)

when_all()

asyncly::Future<Response> getHttpUrl(const std::string& url);

void run() {
    auto responseFutureA = getHttpUrl("https://service-a");
    auto responseFutureB = getHttpUrl("https://service-b");

    asyncly::when_all(
            std::move(responseFutureA),
            std::move(responseFutureB))
         .then([](Response responseA, Response responseB) {
                std::cout << responseA.body << std::endl;
                std::cout << responseB.body << std::endl;
         });
}

when_all

Composablity

DiscoveryResponse1

DiscoveredServiceResponse1

getHttpUrl(discoveryService)

getHttpUrl(discoveredUrl1 + "/1")

DiscoveryResponse2

DiscoveredServiceResponse2

getHttpUrl(discoveredUrl + "/2")

DiscoveryResponse

asyncly::split()

asyncly::when_all()

BothResponses

asyncly::split()

asyncly::add_timeout()

ResponsesOrTimeout