Question: How to async with two independent Aff/TryAsync

[MrWuffels]

Hi,

I have a little question about the best way handling two different async Monads with side effects, like Aff and TryAsync.
The best thing about async is that it frees the thread for work while an asynchronous operation is waiting for a result of an external source. So sometimes, when two tasks are indepentend of each other, it allows us to run them kind of parallel. In the example below we have to start two different http requests which do not need the result of the other, so we can start the second before the first one has finished

var request1Task = Request1();
var request2Task = Request2();

await request1Task;
await request2Task;

But things get tricky (for me) when it comes to the effect monads. In the following example I will return Aff instead of raw Tasks, but the only way I found to run the execution like the one above is with calling Run on both and awaiting the Fin.

var request1Running = Request1().Run();
var request2Running = Request2().Run();

var fin1 = await request1Running;
var fin2 = await request2Running;

However, from my understanding of the docs the effects should be composed and only be run once at the start of the application, which is broken by this code style.
I understand that this code is not executed directly when wrapped in another Aff itself. That way the rule can be followed but I don't know if that's how it's supposed to be.
So am I missing another way to achieve the effect of the code in the example above?

[louthy]

With Aff you can call:

  Aff<(R1, R2)> mx = (Request1(), Request2()).Sequence();

With up to 5 items in the tuple (which will all run in parallel, and only return when all are complete).

TryAsync doesn't have this behaviour. I'd encourage you to use Aff as it's going to get the lion share of the effort going forward.

[MrWuffels]

@louthy Thank you for answering the question, that's really great that way. So this works more or less like Task.WhenAll(), but then it leads to another question: Is there also an equivalent to Task.WhenAny()?

[MrWuffels]

@louthy Okay, I have even more questions now, for example how to work with a list of Aff<>.
Let's say we get a List of products from a database and have have to ask a service for a related picture. The service does only support requests for a single product. So the C# way would be something like this:

var receivingPictures = GetProducts()
         .Select(async product => product with { Picture = await _pictureService.GetPicture(product.Id) })
         .ToList();

var products = await Task.WhenAll(receivingPictures);

I guess with Aff, when both GetProducts and GetPicture are returning it, it would look something like this:

Aff<List<Aff<Products>>> products = 
       GetProducts().Map(products => products.Select(product => from picture in _pictureService.GetPicture(product.Id)
                                                                select product with { Picture = picture }).ToList())

In this case they probably wouldn't run in parallel and additionally nesting is starting to get a bit complicated to resolve. I guess there will also be a better and easier way, beside of wrapping the operation into a function which pretends to handle the whole bulk

[louthy]

This is what TraverseSerial, TraverseParallel, SequenceSerial, and SequenceParallel are for. They will allow you to flip an IEnumerable<Aff<A>> into Aff<IEnumerable<A>>. The *Parallel variants will even allow you to specify the amount of parallelism, they work with a 'window' of n tasks that keep being used until the sequence is complete - this means you don't end up thrashing your CPU when it's not needed.

In general when you see M<N<A>> and you want to make it into a N<M<A>> there's a Sequence or Traverse extension that will make that happen for you (following the proper rules of both the inner and outer monad).

[LaszloLueck]

What more important IMHO is e.g. if you have an Enumerable<Task<Sideeffects (external API-Call)>>.
If you take e.g. an Enumerable of 1.000.000 of those Tasks and do a .Select or .ForEach, there is a big chance that you crash the external API or the network or even both.
With TraverseParallel with the window of parallelity you can backpressure the amount of simultaneous call to external.

(It´s like groupBy(count) and foldLeft in scala, if you don´t want to use fs2 or akka.streams).

Btw.
Thanks for that outstanding framework!

[MrWuffels]

Thank you for your answers, no questions then anymore. Sorry that I seem to have overlooked it.

And I can agree, it's really a great library!