How should one handle chains of operations where some should be async and others sync?

[EivindAntonsen]

Hi,
I am trying to learn the Eff and Aff structures, and was wondering what would be the correct way to handle situations where some operations can be made asynchronously whereas others must be blocking. Some examples are executing flows consisting of multiple function calls. where something happens mid flow that depends on the outcome of earlier async calls.

I'm using LINQ query with from x in collection syntax, and some times run into situations like this:

from x in GetSomeValue()
from y in RunIOAsync(x)
from z in RunDifferentIO(x) // does not depend on y
from a in ComputeNewValue(y, z)
from b in RunIOAsync(a)
from c in RunDifferentIO(a) // does not depend on b

The async method calls obviously must be Aff, but what does that mean for the overall method signature? I guess if some of these return Aff instead of Eff, everything must be Aff? Am I going about this the wrong way?

Previously I've just done these synchronously (only Eff, so no async/await) while using this library, but now I would like to learn how to do this async where possible.

[louthy]

I guess if some of these return Aff instead of Eff, everything must be Aff?

That’s correct, but note that Effs are promoted to be Affs automatically when you combine them in a LINQ expression; so you don’t have to change your synchronous function signatures.

[EivindAntonsen]

No, you're correct. That's what I've been doing and what I will have to learn not to. I have some examples I think :)

Assume a structure like Eff<Seq<Eff< MyObject >>>. This is a mouthful, and doesn't represent the usecase accurately. In my case it's an effect that should result in either a collection of my objects (empty or not) or an error. The reason for this is that if any element in the seq is an error, I should abort and return (the business case doesn't allow for "I don't know if X is present or not because it failed for Y reason").
That means I end up with stuff like this:

.Map(effects => effects.Map(effect => effect.Run()))
.Bind(results => results.Fails().Any()
                     ? FailEff<Seq<MyObject>>(Error.Many(results.Fails()))
                     : SuccessEff(results.Succs()));

Any thoughts on how I can approach this situation differently? I guess this is a case of "not thinking functionally" leading to me doing weird stuff like this. I have other examples too, but let's start with this and maybe I'll understand the rest based on this situation.

Thanks a lot for responding, this is great learning for me!

[louthy]

Replace all of that with:

.Sequence()

To turn a Seq<Eff<...>> into a Eff<Seq<...>> use .Sequence() and .Traverse(). They're two vital functions to learn when it comes to working with nested monadic types (and you want to flip the nesting). No calls to Run() should ever be required until you get to the edge of your application (i.e. Main or a web-request/response handler)

[louthy]

btw. for Aff there's SequenceParallel, SequenceSerial, TraverseParallel, and TraverseSerial. The parallel variants allow you to control the amount of parellelism as well.

[EivindAntonsen]

Wonderful, exactly what I had hoped for! I'll get to work with this right away. Thanks.
I'll keep this thread open/unresolved while I do so in case I get stuck on one of the other .Run() areas. But for now this should probably solve it.

[EivindAntonsen]

Thanks @louthy , this solved my problems. Do you have any recommended reading for understanding these things a bit better? The documentation I see in my IDE is a bit tough to digest: