How to work with multiple params?

[mohaemen]

Assume the following situation

    public void Do(long Id)
    {
         GetEntity1ById(id)
            .Bind(entity1 => _entity2Service.GetByEntity1(entity1))
            .Bind(entity2 => _anotherService.DoSomethingWithBothEntities(entity1, entity2));
    }

The second Bind cannot see entity1 anymore, how can this be resolved?

[vkhorikov]

I usually just fall back to regular if statements. Alternatively, you can do something like this:

        public void Do(long Id)
        {
             GetEntity1ById(id)
                .Bind(entity1 => (e1: entity1, e2: _entity2Service.GetByEntity1(entity1)))
                .Bind((entity1, entity2) => _anotherService.DoSomethingWithBothEntities(entity1, entity2));
        }

[mohaemen]

Thank you, that is a nice solution, but probably you know where I am going with this.

        public void Do(long Id)
        {
             GetEntity1ById(id)
                .Bind(entity1 => _entity2Service.GetByEntity1(entity1))
                .Bind(entity2 => _entity3Service.GetByEntity2(entity2))
                .Bind(entity3 => _entity4Service.GetByEntity3(entity3))
                .Bind(entity4 => _anotherService.DoSomethingWithEntity1And4(entity1, entity4));
       }

As you can see, entity1 is required in a later call not the directly one after it.
If we try using the solution above, it would be like this

        public void Do(long Id)
        {
             GetEntity1ById(id)
                .Bind(entity1 => (e1: entity1, e2: _entity2Service.GetByEntity1(entity1)))
                .Bind((entity1, entity2)=> (e1: entity1, e3: _entity3Service.GetByEntity2(entity2)))
                .Bind((entity1, entity3)=> (e1: entity1, e4: _entity4Service.GetByEntity3(entity3)))
                .Bind((entity1, entity4) => _anotherService.DoSomethingWithEntity1And4(entity1, entity4));
       }

Which means passing down entity1 as a param even though it is not being used in the middle, just because we know we are going to need it in a later call.

Or an extreme scenario like this

        public void Do(long Id)
        {
             GetEntity1ById(id)
                .Bind(entity1 => (e1: entity1, e2: _entity2Service.GetByEntity1(entity1)))
                .Bind((entity1, entity2)=> (e1: entity1, e2: entity2, e3: _entity3Service.GetByEntity2(entity2)))
                .Bind((entity1, entity2, entity3)=> (e1: entity1, e2: entity2, e3: entity3, e4: _entity4Service.GetByEntity3(entity3)))
                .Bind((entity1, entity2, entity3, entity4) => _anotherService.DoSomethingWithAllEntities(entity1, entity2, entity3, entity4));
       }

[vkhorikov]

That's correct, it's only good if the chain isn't too complicated. You may also try something like this:

        public void Do(long Id)
        {
             var e2;
             
             GetEntity1ById(id)
                .Bind(entity1 => e2 =_entity2Service.GetByEntity1(entity1))
                .Bind(entity1 => _anotherService.DoSomethingWithBothEntities(entity1, e2));
        }

I personally don't quite like this solution because the saving of the result into a local state goes against FP principles. But it might still be better than falling back to regular if statements, and the state itself is local (local variables), so the functional principles violation isn't that huge.

[mohaemen]

Cool, now comes the fun part :D

I did actually work for an employer where we built an in-house library that does what this repo does, and we came across lots of different issues and scenarios.
The example I mentioned above is actually a very close match to one of the many scenarios we had to deal with when working with Bind.
The solution you provided, storing the value in a local variable, was exactly what I did to get around passing a returned value from one of the first Binds to a later one.
Sometimes it got really complicated where I needed to store 3 local variables in that method, and that triggered other engineers on how is that against FP.

We had to use Bind, as all services, repositories etc where using they "Maybe" return types (it was called something different), a different solution that a lot of engineers were doing is putting Bind inside Bind, an extreme one had 5 levels of Binds.

Something like this

        public void Do(long Id)
        {
             GetEntity1ById(id)
                .Bind(v1 => M1().Bind(v2 => M2())) //Bind in bind
                .Bind(v3 => M3().Bind(v4 => M4()).Bind(v5 => M5())) // 2 levels (Bind to result of Bind)
                .Bind(v6 => M6().Bind(v7 => M7().Bind(v8 => M8()))) // different 2 levels (Bind to result of method inside the Bind)
                .Bind(v9 => M9().Bind(v10 => M10().Bind(v11 => M11()).Bind(v12 => M12()))) // 3 levels of Bind inside
                .Bind(v13=> M13());
        }

This is obviously just a "sketch" of the calls, but with actual services, methods and variables names in place, and the code expanded into multiple lines, it was a nightmare to even look at and read, let alone debugging it.
This code above was something very close to a real life code, that in order to write it in a cleaner way you will have to store values in few local variables.

I just didn't get why it was so important to protect FP at the cost of having bad code like that.
I came up with a different solution that you don't need to store any local variables, but that too got criticized, it has to be in proper FP :D

[vkhorikov]

I don't like these overcomplicated and nested calls either. I'd recommend extracting complicated parts into private methods and giving them meaningful names so that the code becomes easier to grasp. Also, regular if-then clauses, albeit more verbose, usually work better in complicated cases readability wise.

What was the different solution you came up with?

[mohaemen]

I don't fully remember it, but basically was having a dictionary that stores your returns in every call, and you get it by type.
Something like this

 public void Do(long id)
        {
           //GetEntity1ById returns an instance of type Entity
           //M1                   returns an instance of type Class1
           //M2                   returns an instance of type Class2

             GetEntity1ById(id)
                .BindCollection(entity => M1(entity))
                .BindCollection(collection => M2(collection.Get<Class1>())) 
                .BindCollection(collection => M3(collection.Get<Entity>(), collection.Get<Class2>());
        }

So you will have all returned values in the dictionary, and you can access them from any Bind, this meant no need for Bind inside Bind, and you can reuse a value returned from the first Bind in the last one.

There was a question of what if you need to store two instances of the same type T? You can just have List in the dictionary instead in that case.

I know it is not perfect, I only created a POC because of the complains on storing values in local variable, and I need to pass values from one method to the next.

[mohaemen]

The issue with regular if-then is you need to manually manage the "Maybe" result and check if an error or not, it was advised against having a manual check for the error and let the library handle it and fall back for you.

Seeing an if-statement on Maybe.Result.HasError or Maybe.Result.Error != null (I don't remember how it was done) was considered not-clean-code, and we were encouraged to convert it to utilize Bind

[vkhorikov]

Both if and Bind are fine depending on the situation. It's just a matter of what gives you the simplest, easy to understand code.

[JMPSequeira]

Here's an idea:

[Serializable]
public struct Relay<T, TResult> : IResult<TResult>, ISerializable
    where T : struct, IEquatable<T>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<T>
{
    private readonly Result<TResult> _result;

    public Relay(Result<TResult> result, T relay = default)
    {
        _result = result;
        Relayed = relay;
    }

    public T Relayed { get; }

    public TResult Value => _result.Value;

    public bool IsFailure => _result.IsFailure;

    public bool IsSuccess => _result.IsSuccess;

    public string Error => _result.Error;

    public static implicit operator Relay<T, TResult>(Result<TResult> result)
    {
        return new Relay<T, TResult>(result);
    }

    public static implicit operator T(Relay<T, TResult> relay)
    {
        return relay.Relayed;
    }

    public void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        ((ISerializable)_result).GetObjectData(info, context);
    }

}

public static class ExtensionsExample
{
    public static Relay<TRelay, TResult> ToRelay<TRelay, TResult>(this Result<TResult> result, TRelay relay)
        where TRelay : struct, IEquatable<TRelay>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<TRelay>
    {
        return new Relay<TRelay, TResult>(result, relay);
    }

    public static Relay<TRelay, TResult> ToRelay<TRelay, TResult>(this Result<TResult> result, Func<TResult, TRelay> func)
        where TRelay : struct, IEquatable<TRelay>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<TRelay>
    {
        if (result.IsSuccess)
        {
            return new Relay<TRelay, TResult>(result, func(result.Value));
        }

        return result;

    }

    public static Relay<TRelay, TResult> ToRelay<TRelay, TResult>(this Result<TResult> result, Func<TRelay> func)
        where TRelay : struct, IEquatable<TRelay>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<TRelay>
    {
        if (result.IsSuccess)
        {
            return new Relay<TRelay, TResult>(result, func());
        }

        return result;

    }

    public static Result<TOut> Disperse<TRelay, TResult, TOut>(this Relay<TRelay, TResult> relay, Func<TResult, TRelay, TOut> func)
        where TRelay : struct, IEquatable<TRelay>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<TRelay>
    {
        if (relay.IsFailure)
        {
            return Result.Failure<TOut>(relay.Error);
        }

        return func(relay.Value, relay);
    }

    public static Relay<TRelay, TOut> Bind<TRelay, TResult, TOut>(this Relay<TRelay, TResult> relay, Func<TResult, Result<TOut>> func)
        where TRelay : struct, IEquatable<TRelay>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<TRelay>
    {
        if (relay.IsFailure)
        {
            return Result.Failure<TOut>(relay.Error);
        }

        Result<TOut> result = func(relay.Value);

        return result.IsSuccess
            ? new Relay<TRelay, TOut>(result, relay)
            : result;
    }

    public static Relay<TRelay, TOut> Bind<TRelay, TResult, TOut>(this Relay<TRelay, TResult> relay, Func<TResult, Result<TOut>> func, Func<TOut, TRelay, TRelay> relayFunc)
        where TRelay : struct, IEquatable<TRelay>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<TRelay>
    {
        if (relay.IsFailure)
        {
            return Result.Failure<TOut>(relay.Error);
        }

        Result<TOut> result = func(relay.Value);

        return result.IsSuccess
            ? new Relay<TRelay, TOut>(result, relayFunc(result.Value, relay))
            : result;
    }
}

Usage Example:

GetEntity1().ToRelay((e1) => (entity: e1, parent: default(Entity)))
            .Bind((e1) => GetEntity2(e1.ParentId), (e2, relay) => relay with { parent = e2 })
            .Bind((e2) => DoEntity(e2))
            .Disperse((_, relay) => DoWithEntities(relay.entity, relay.parent));

[JMPSequeira]

Maybe without the value tuple and with unconstrained generic, leaving to the implementer whatever is chosen.
Would work ok with anonymous objects, would only copy the reference.

[rutkowskit]

In my project, I created a simple extension to solve a similar problem:

public static partial class ResultExtensions
{
    public static Result<(T, K)> BindJoin<T, K>(this Result<T> result, Func<T, Result<K>> toJoin)
    {
        return result.Bind(r1 => toJoin(r1).Map(r2 => (r1, r2)));
    }
    public static Result<(T, K)> BindJoin<T, K>(this Result<T> result, Func<T, K> toJoin)
    {
        return result.BindJoin((t) => Result.Success(toJoin(t)));
    }
   // etc. - as many as you need in your scenario
}

Example usage (publishing event to rabbitmq):

var result = CreateMessageBody(message)
            .BindJoin(body => GetChannel())
            .BindJoin(bc=> bc.Item2.DeclareEventsExchnage<T>())
            .Tap(bce=>
            {
                var ((body, channel), exchangeName) = bce;
                var properties = channel.CreateBasicProperties();
                properties.DeliveryMode = 1;
                properties.Persistent = false;
                channel.BasicPublish(exchangeName, "", properties, body: body);
            });

You can also give the resulting tupple elements some other names like (T A, T B) rather then Item1, Item2. For me the default naming is OK :)