Does EitherAsync await the code inside it?

[MrYossu]

Sorry if this is a dumb question, but I'm confused (as usual).

I am trying to get my head around EitherAsync, and am not sure I have it clear. My understanding is that it can be used like a regular Either, but when you want async code inside. However, I don't think the code in the EitherAsync-returning method is being awaited.

For example, consider the following trivial example...

static EitherAsync<string, int> DoStuff(int n) {
  Task.Delay(3000);
  if (n < 0) {
    return "Negative numbers not allowed".AsTask();
  }
  return n;
}

This returns the correct value, but returns immediately, without the three-second delay I was expecting.

I tried awaiting the delay, but that required making the method async, which gave a compiler exception "The return type of an async method must be void, Task, Task, a task-like type, IAsyncEnumerable, or IAsyncEnumerator."

Anyone able to explain what I'm doing wrong? Thanks

Whilst you're at it, please can you explain why I need the call to AsTask() when returning. I picked that up (along with the general idea how to use this monad) from this issue, where Paul Louth included it. I figured if he used it, it must be the right thing to do! However, the code seems to compile and run fine without it, although that could be related to the main question I asked above.

Any clarification would be greatly appreciated.

[LaszloLueck]

Hi,
i believe that has nothing to do with the EitherAsync.
You start a Task.Delay(3000) and don't await them.
Another Example (as i test it otf):

var sw = Stopwatch.StartNew();
var i = await ReturnAwaited(100);
Console.WriteLine(i);
sw.Stop();
Console.WriteLine($"Method needs {sw.ElapsedMilliseconds} ms");

Task<string> ReturnAwaited(int n)
{
    Task.Delay(1000);
    return $"I'am {n}".AsTask();
}

If i run this code, it finished after 12ms (depends on your computers speed), but not the result what you want!
Why?
The Task.Delay starts a new Task and this task waits exactly 1000ms (or a view more) but the Task.Delay does not await the rest of the method.
Your Computer does the job instantly and returned the string.

How should we resolve this?
Write instead:

var sw = Stopwatch.StartNew();
var i = await ReturnAwaited(100);
Console.WriteLine(i);
sw.Stop();
Console.WriteLine($"Method needs {sw.ElapsedMilliseconds} ms");

async Task<string> ReturnAwaited(int n)
{
    await Task.Delay(1000);
    return $"I'am {n}";
}

Voila!
If i run this, it takes a little more than 1000ms.
We wait for the Task.Delay.
If this should work, you must either "mark" your method as async and you don't need the .asTask() anymore. The await Task.Delay() encapsulated a task.

Hope that helps a little bit.

P.S.
The above example use the async/await nonblocking functionality of dotnet.

You can write something like this (the following example)... but i never ever recommend that, because that is totally blocking code and you absolutely should avoid this!

var sw = Stopwatch.StartNew();
var i = await ReturnAwaited(100);
Console.WriteLine(i);
sw.Stop();
Console.WriteLine($"Method needs {sw.ElapsedMilliseconds} ms");

Task<string> ReturnAwaited(int n)
{
    Task.Delay(1000).Wait();
    return $"I'am {n}".AsTask();
}

Regards.

[MrYossu]

@LaszloLueck Thanks for the reply, but unless I misunderstood you, you've totally missed the point of my question. I know about awaiting async calls, however, as I explained in my question, I can't make the DoStuff() method I showed async, as it gives a compiler error.

This question is not about the regular async/await functionality in .NET, it's about the EitherAsync monad, which (as far as I can see) handles the async part for you.

Apologies if I misunderstood you, but the code you posted does not show me how to write a method that returns EitherAsync<string, int> and does some async calls inside. That's what I'm trying to do, I'm not writing plain .NET async/await methods.

[MrYossu]

OK, so I realised my mistake. I was thinking along the lines of TryAsync, where you can do something like this...

static TryAsync<int> Divide(int n1, int n2) =>
    TryAsync(async () => {
      // Simulate some async operation that might fail
      await Task.Delay(300);
      return n1 / n2;
    });

What I was expecting is to be able to do the same for EitherAsync, but as I can't find a static EitherAsync method, I guess I can't do this.

Anyone know if it's possible to do something similar for EitherAsync?

[MrYossu]

In case it helps anyone, I got an answer on StackOverflow.

No there isn't a static EitherAsync method like there is for TryAsync, but as Task can implicitly be converted to EitherAsync, you can just do the following (using TryAsync rather than Task.Run as this gracefully handles exceptions in the async code)...

static EitherAsync<string, double> Square(double n1, double n2) =>
  TryAsync(async () => {
    await Task.Delay(300);
    return n1 / n2;
  })
  .ToEither(error => error.Message);

Note that the SO answer news up an EitherAsync, but if you have a static using for LanguageExt.Prelude, you don't need it, and the code is four characters shorter 😎)