How do I Bind a TryAsync and a Task<Either<>>?

[MrYossu]

I may be doing this completely wrong, so please be patient with me!

I have a set of methods that return TryAsync<T> (very simplified for clarity)...

TryAsync<string> DoStuff1() =>
  TryAsync(async () => {
    // Do something async here
    return "result 1";
  });

TryAsync<string> DoStuff2(string s) =>
  TryAsync(async () => {
    // Do something async here
    return "result 2";
  });

...which I bind together as follows (again, very simplified for clarity)...

await DoStuff1()
  .Bind(s1 => DoStuff2(s1))
  .Match(async s2 => {
    Console.WriteLine($"Success: {s2}");
    },
    s3 => {
      Console.WriteLine($"Failure: {s3}");
    });

This all works fine, but I now want to call a method that returns a Task<Either<string, Unit>> from inside the first lambda in Match. I can do it like this...

await DoStuff1()
  .Bind(s1 => DoStuff2(s1))
  .Match(async s2 => {
    (await DoOtherStuff())
      .Match(_ => {
        Console.WriteLine("Big success");
        },
        ex => {
         Console.WriteLine("Exception calling DoOtherStuff(), so do whatever II");
        });
    },
    s3 => {
      Console.WriteLine($"Failure: {s3}");
    });

However, this seems wrong, as I think I should be able to bind the methods together. However, I'm not sure how to do this. I tried the obvious...

await DoStuff1()
  .Bind(s1 => DoStuff2(s1))
  .Bind(s4 => DoOtherStuff())
  .Match(s2 => {
    Console.WriteLine($"Success: {s2}");
    },
    s3 => {
      Console.WriteLine($"Failure: {s3}");
    });

...but this gave a compiler error on the second Bind saying The type arguments for method 'TryAsyncExtensions.Bind<A, B>(TryAsync, Func<A, TryAsync>)' cannot be inferred from the usage.

Anyone able to advise? Thanks

[evermanwa]

Instead of doing a second bind, you could just use a Map instead, and that works for me. Hard to tell what the end-goal you are going for without more specifics honestly. Hope this helps, and let me know if it works.

[MrYossu]

Thanks for the reply. I'll need to remember where I was doing this, and what I was trying to do now! I'll see if I can get it working and let you know.

Thanks again.

[JeremiahSanders]

The core reason the compiler couldn't infer your types is that a Result<string> and Either<string,Unit> are incompatible. Further, when you chain Try<> or TryAsync<> values, they are unexecuted. It isn't until you execute the chain (e.g., by using .Try() or .ToEither()) that you have a Result<>.

In order to bind the methods shown, I'd recommend addressing this in two steps. First, creating a Try/TryAsync from the execution of your Either<,>-returning method. This allows you to use .Bind() and ensures you maintain your unexecuted state. Then, inside the TryAsync, convert the Either<,> into the appropriate type or throw an Exception (to provide the sad-path failure).

Here's an example:

async Task Main()
{
  var unexecutedTryChain = AsyncStringProvider().Bind(AsyncStringProcessor);
  
  var withAttemptedSideEffect = unexecutedTryChain
    .Bind((string currentStringValue) => 
      Prelude.TryAsync(async () => 
      (await AttemptSideEffectAsync(currentStringValue))
          .Match(
            _ => "Succeeded", // This implementation assumes that your Unit response is a happy-path success.
            (string left) => throw new Exception(left) // This implementation assumes that your string is an error message.
          )
        )
      );

  // Now we execute our TryAsync workflow, awaiting its result.
  Console.WriteLine(await withAttemptedSideEffect.Try());
}

TryAsync<string> AsyncStringProvider(){
  return Prelude.TryAsync (() => "Async string".AsTask());
}

TryAsync<string> AsyncStringProcessor(string currentValue)
{
  return Prelude.TryAsync(() => currentValue.Count().ToString().AsTask());
}

Task<Either<string, Unit>> AttemptSideEffectAsync(string currentValue){
  var parsed = Int32.TryParse(currentValue, out _);
  return 
    (parsed ? 
      Prelude.Right<string, Unit>(Prelude.unit) :
      Prelude.Left<string, Unit>($"Failed to convert '{currentValue}' to int.")
    ).AsTask();
}