How to chain two methods togther that use Aff

[dirkil]

I have difficulty in getting method calls chained together that use Aff and can fail. Let's say I have an interface with a method that calls a Rest API and returns Aff<Unit>. Now I want to write another method that uses that interface method and embeds it in some error handling / logging. So basically, I have the following code (does not compile):

public interface IAccessClient
{
    Aff<Unit> DeleteClient(Guid clientId);
}

public record InputData(string Name)
{
    public bool IsValid() => true;
}

public class ChainTest
{
    private IAccessClient _accessClient;

    private Aff<InputData> Delete(Guid clientId, InputData inputData)
    {
        return AffMaybe<InputData>(async () =>
        {
            if (inputData.IsValid())
            {
                LogSomething();
                return _accessClient.DeleteClient(clientId).Match(
                    Succ: _ =>
                    {
                        LogSomething();
                        return Fin<InputData>.Succ(inputData);
                    },
                    Fail: error => error);
            }

            return Fin<InputData>.Succ(inputData);
        });
    }

    private void LogSomething()
    {
        // Execute synchronous logging steps
    }

In essence, I want to call ChainTest.Delete().Run(). It's probably a simple scenario but I don't get it to compile. Could someone please enlighten me how to chain these two calls? Any help is very much appreciated.

Regards,
Dirk.

[louthy]

Aff<X> effect = from result1 in YourFirstAffFunction()    // Aff effect
                from result2 in YourSecondAffFunction()   // Aff effect
                select UseBothValues(result1, result2);   // Regular, non-Aff returning function

Fin<X> result = await effect.Run();

This is called monadic binding. All monadic types support this method of chaining. In fact, you can think of monads as programmable semi-colons (the side-effect of the monadic flavour is run between the lines of your code).

If you weren't using LINQ, then the code above would be written like so:

Aff<X> effect = YourFirstAffFunction().Bind(result1 =>
                    YourSecondAffFunction().Map(result2 =>
                        UseBothValues(result1, result2)));

Fin<X> result = await effect.Run();

Which obviously isn't as elegant, so it's worth using LINQ when programming with monadic types.

This can be a little bit of a headfuk when you first start this style of coding, so there's a couple of wiki pages that should help:

• What is LINQ really?
• Does C# Dream of Electric Monads?

One of the key aspects is try to never call Run. Or, ideally only call it at the 'edges' of your program. The bit were you need to realise the effect. Examples of 'edges' are:

• The program's Main function
• A web-request (even then, ideally your web-framework would know what an Aff is and so you never need to call Run.

If you look at thew EffectsExamples sample app, you'll notice that Aff is used everywhere, but Run only gets called in one place: Main

Here's your ChainExample made to leverage the power of the monads:

public class ChainTest
{
    IAccessClient _accessClient;
    
    public Aff<InputData> Delete(Guid clientId, InputData inputData) =>
        from _1 in guard(inputData.IsValid(), Error.New("Input data isn't valid")) 
        from _2 in LogSomething("upfront logging")
        from _3 in _accessClient.DeleteClient(clientId)
        from _4 in LogSomething("additiona logging")
        select inputData;  

    Aff<Unit> LogSomething(string msg) =>
        Aff<Unit>(() => {
            // Do your logging here
            return default;
        });
}

Hopefully it should be clearer now why they're so powerful, they get rid of soooo much boilerplate.

btw, the _1, _2, _3, _4 are just a convention I used for expressions where I discard the result. You could just as easily use any var names you like. Hopefully, Microsoft will implement the discard pattern for LINQ one day!

[dirkil]

This is really great stuff! I am really excited about this. I knew that I needed a Return function to lift it up and each monad must have one (otherwise it wouldn't be a monad) but I tried stuff like Aff<InputData>.Succ(inputData).

I am currently re-writing an existing loader and I am amazed how much shorter the code becomes with your LanguageExt and how much more readable it gets.

If you don't mind, I have another question which is similar. I have a method that needs to process a list of items. Each call is async and could potentially fail. Even if the processing of an item fails it should carry on to process the other items. The result of all should be a list of processing results. The code looks something like this:

public Aff<IEnumerable<ProcessResult>> Process(List<string> itemsToProcess)
    {
        return itemsToProcess.Map(ProcessItem);  // Does not compile!
    }
    
    private Aff<ProcessResult> ProcessItem(string itemId)
    {
        // Do some processing
        return LanguageExt.Aff<ProcessResult>.Success(new ProcessResult(itemId, true, None)); 
    }
    
    Aff<Unit> LogSomething(string msg) =>
        Aff<Unit>(() => {
            // Do your logging here
            return default;
        });

My problem is that Process() needs to return an Aff<IEnumerable<ProcessResult>> but it returns an IEnumerable<Aff<ProcessResult>>. So basically it needs to be switched. I thought I could use Sequence() for that but I couldn't get it to work. Is there an easy fix for that or how would you manage a set of results from a method that returns an IEnumerable<Aff<T>>?

[louthy]

I'm away for a week now (off to the Abu Dhabi Grand Prix, yay!). So, it'll either have to wait, or someone else will help, or you'll work it out!

Good luck!

[StefanBertels]

I think .Sequence() is what you want. Maybe try Seq or Arr instead of List / IEnumerable => public Aff<Arr<ProcessResult>> Process(Arr<string> itemsToProcess)...

[louthy]

SequenceParallel or SequenceSerial for asynchronous types

[dirkil]

Yes, SequenceParallel is the way to go.

Thank you all for yourgreat support!

And Paul: have fun in Abu Dhabi! 🥇