Composing Multiple Async Results via an Applicative Builder in Java 8

Attila Mihaly BalazsDecember 21st, 2015Last Updated: December 21st, 2015

0 58 8 minutes read

A few months ago, I put out a publication where I explain in detail an abstraction I came up with named Outcome, which helped me A LOT to code without side-effects by enforcing the use of semantics. By following this simple (and yet powerful) convention, I ended up turning any kind of failure (a.k.a. Exception) into an explicit result from a function, making everything much easier to reason about. I don’t know you but I was tired of dealing with exceptions that teared everything down, so I did something about it, and to be honest, it worked really well. So before I keep going with my tales from the trenches, I really recommend going over that post. Now let’s solve some asynchronous issues by using eccentric applicative ideas, shall we?

Something wicked this way comes

Life was real good, our coding was fast-paced, cleaner and composable as ever, but, out of the blue, we stumble upon a “missing” feature (evil laughs please): we needed to combine several asynchronous Outcome instances in a non-blocking fashion….

Excited by the idea, I got down to work. I experimented for a fair amount of time seeking for a robust and yet simple way of expressing these kind of situations; while the new ComposableFuture API turned out to be much nicer that I expected (though I still don’t understand why they decided to use names like applyAsync or thenComposeAsync instead of map or flatMap), I always ended up with implementations too verbose and repetitive comparing to some stuff I did with Scala, but after some long “Mate” sessions, I had my “Hey! moment”: Why not using something similar to an applicative?

The problem

Suppose that we have these two asynchronous results:

CompletableFuture<Outcome<String>> textf = 
    completedFuture(maybe("And the number is %s!"));

CompletableFuture<Outcome<Integer>> numberf = 
    completedFuture(maybe(22));

and a silly entity called Message:

public static class Message{

    private final String _text;
    private final Integer _number;

    private Message(String msg, Integer number){
        _text = msg;
        _number = number;
    }

    public String getContent(){
        return String.format(_text,_number);
    }
}

I need something that given textf and numberf it will give me back something like

//After combining textf and numberf
CompletableFuture<Outcome<Message>> message = ....

So I wrote a letter to Santa Claus:

I want to asynchronously format the string returned by textf using the number returned by numberf only when both values are available, meaning that both futures completed successfully and none of the outcomes did fail. Of course, we need to be non-blocking.
In case of failures, I want to collect all failures that took place during the execution of textf and/or numberf and return them to the caller, again, without blocking at all.
I don’t want to be constrained by the number of values to be combined, it must be capable of handling a fair amount of asynchronous results. Did I say without blocking? There you go…
Not die during the attempt.

Applicative builder to the rescue

If you think about it, one simple way to put what we’re trying to achieve is as follows:

// Given a String -> Given a number -> Format the message
f: String -> Integer -> Message

Checking the definition of f, it is saying something like: “Given a String, I will return a function that takes an Integer as parameter, that when applied, will return an instance of type Message“, this way, instead of waiting for all values to be available at once, we can partially apply one value at a time, getting an actual description of the construction process of a Message instance. That sounded great.

To achieve that, it would be really awesome if we could take the construction lambda Message:new and curry it, boom!, done!, but in Java that’s impossible (to do in a generic, beautiful and concise way), so for the sake of our example, I decided to go with our beloved Builder pattern, which kinda does the job:

public static class Builder implements WannabeApplicative<Message> {

    private String _text;
    private Integer _number;

    public Builder text(String text){
        _text=text;
        return this;
    }

    public Builder number(Integer number){
        _number=number;
        return this;
    }

    @Override
    public Message apply() {
        return new Message(_text,_number);
    }
}

And here’s the WannabeApplicative<T> definition:

public interface WannabeApplicative<V>
{
    V apply();
}

Disclamer: For those functional freaks out there, this is not an applicative per se, I’m aware of that, but I took some ideas from it an adapted them according to the tools that the language offered me out of the box. So, if you’re feeling curious, go check this post for a more formal example.

If you’re still with me, we could agree that we’ve done nothing too complicated so far, but now we need to express a building step, which, remember, needs to be non-blocking and capable to combine any previous failure that might have took place in other executions with potentially new ones. So, in order to do that, I came up with something as follows:

public static class CompositionSources<B>
{
    private CompositionSources(){ }

    public interface Partial<B>
    {
        CompletableFuture<Outcome<B>> apply(CompletableFuture<Outcome<B>> b);
    }

    public interface MergingStage<B, V>{
        Partial<B> by(BiFunction<Outcome<B>, Outcome<V>, Outcome<B>> f);
    }

    public <V> MergingStage<B, V> value(CompletableFuture<Outcome<V>> value){

        return f -> builder
                 -> builder.thenCombine(value, (b, v) -> f.apply(b, v)
                                                          .dependingOn(b)
                                                          .dependingOn(v));
    }

    public static <B> CompositionSources<B> stickedTo(Class<B> clazz)
    {
        return new CompositionSources<>();
    }
}

First of all, we’ve got two functional interfaces: one is Partial<B>, which represents a lazy application of a value to a builder, and the second one, MergingStage<B,V>, represents the “how” to combine both the builder and the value. Then, we’ve got a method called value that, given an instance of type CompletableFuture<Outcome<V>>, it will return an instance of type MergingStage<B,V>, and believe or not, here’s where the magic takes place. If you remember the MergingState definition, you’ll see it’s a BiFunction, where the first parameter is of type Outcome<B> and the second one is of type Outcome<V>. Now, if you follow the types, you can tell that we’ve got two things: the partial state of the building process on one side (type parameter B) and a new value that need to be applied to the current state of the builder (type parameter V), so that, when applied, it will generate a new builder instance with the “next state in the building sequence”, which is represented by Partial<B>. Last but not least, we’ve got the stickedTo method, which basically is a (awful java) hack to stick to a specific applicative type (builder) while defining building step. For instance, having:

CompositionSources<Builder> sources = CompositionSources.stickedTo(Builder.class);

I can define partial value applications to any Builder instance as follows:

//What we're gonna do with the async text when available
Partial<Builder> textToApply = 
    sources.value(textf)
            .by((builder, text) -> builder.flatMapR(b -> text.mapR(b::text)));

//Same thing for the number
Partial<Builder> numberToApply = 
    sources.value(numberf)
            .by((builder, number) -> builder.flatMapR(b -> number.mapR(b::number)));

See that we haven’t built anything yet, we just described what we want to do with each value when the time comes, we might want to perform some validations before using the new value (here’s when Outcome plays an important role) or just use it as it is, it’s really up to us, but the main point is that we haven’t applied anything yet. In order to do so, and to finally tight up all loose ends, I came up with some other definition, which looks as follows:

public static class FutureCompositions<V , A extends WannabeApplicative<V>>{

    private final Supplier<CompletableFuture<Outcome<A>>> _partial;

    private FutureCompositions(Supplier<CompletableFuture<Outcome<A>>> state)
    {
        _partial=state;
    }

    public FutureCompositions<V, A> binding(Partial<A> stage)
    {
        return new FutureCompositions<>(() -> stage.apply(_partial.get()));
    }

    public CompletableFuture<Outcome<V>> perform()
    {
        return _partial.get().thenApply(p -> p.mapR(WannabeApplicative::apply));
    }

    public static <V, A extends WannabeApplicative<V>> FutureCompositions<V, A> begin(A applicative)
    {
        return new FutureCompositions<>(() -> completedFuture(maybe(applicative)));
    }
}

Hope it’s not that overwhelming, but I’ll try to break it down as clearer as possible. In order to start specifying how you’re going to combine the whole thing together, you will start by calling begin with an instance of type WannabeApplicative<V>, which, in our case, type parameter V is equal to Builder.

FutureCompositions<Message, Builder> ab = begin(Message.applicative())

See that, after you invoke begin, you will get a new instance of FutureCompositions with a lazily evaluated partial state inside of it, making it the one and only owner of the whole building process state, and that was the ultimate goal of everything we’ve done so far, to fully gain control over when and how things will be combined. Next, we must specify the values that we want to combine, and that’s what the binding method is for:

ab.binding(textToApply)
  .binding(numberToApply);

This is how we supply our builder instance with all the values that need to be merged together along with the specification of what’s supposed to happen with each one of them, by using our previously defined Partial instances. Also see that everything’s still lazy evaluated, nothing has happened yet, but still we stacked all “steps” until we finally decide to materialize the result, which will happen when you call perform.

CompletableFuture<Outcome<Message>> message = ab.perform();

From that very moment everything will unfold, each building stage will get evaluated, where failures could be returned and collected within an Outcome instance or simply the newly available values will be supplied to the target builder instance, one way or the other, all steps will be executed until nothing’s to be done. I will try to depict what just happened as follows

If you pay attention to the left side of the picture, you can easily see how each step gets “defined” as I showed before, following the previous “declaration” arrow direction, meaning, how you actually described the building process. Now, from the moment that you call perform, each applicative instance (remember Builder in our case) will be lazily evaluated in the opposite direction: it will start by evaluating the last specified stage in the stack, which will then proceed to evaluate the next one and so forth up to the point where we reach the “beginning” of the building definition, where it will start to unfold o roll out evaluation each step up to the top, collecting everything it can by using the MergingStage specification.

And this is just the beginning….

I’m sure a lot could be done to improve this idea, for example:

The two consecutive calls to dependingOn at CompositionSources.values() sucks, too verbose to my taste, I must do something about it.
I’m not quite sure to keep passing Outcome instances to a MergingStage, it would look cleaner and easier if we unwrap the values to be merged before invoking it and just return Either<Failure,V> instead – this will reduce complexity and increase flexibility on what’s supposed to happen behind the scenes.
Though using the Builder pattern did the job, it feels old-school, I would love to easily curry constructors, so in my to-do list is to check if jOOλ or Javaslang have something to offer on that matter.
Better type inference so that the any unnecessary noise gets remove from the code, for example, the stickedTo method, it really is a code smell, something that I hated from the first place. Definitely need more time to figure out an alternative way to infer the applicative type from the definition itself.