Alternative to inherit from Fin and other monads

[eddy-douyere-cko]

Hi there,

I hope you are all doing great.

I would like to use Fin or alternatively Either<L,R> in my project. The issue is that we already have an in-house implementation called Result<T>. Of course everyone has a custom Result<T> 😬.

I can't replace all usages and create a big bang. My idea was to:

1. Extract an interface from our Result<T> implementation
2. Create a new implementation implementing the interface created in step 1. AND inheriting from Fin or Either<L,R>
3. Implement 1. by using Fin or Either<L,R> methods
4. Start using 2. and enjoying the Fin / Either<L,R> functions
5. Start replacing the in-house class usages in our code base.

But, of course, Fin is a struct, which is the beauty of everything right. And I cannot inherit from a struct.

What alternatives do I have ?

I don't want to use composition as I would have redirections and probably some work to do.

Thank you very much.

[aloslider]

I wonder what special functionality of language-ext's Either type do you want to use if it would be possible to inherit structs? And what would be the "extracted interface"?

[eddy-douyere-cko]

Everything basically: Bind, Map, ..., async support, select... Ine on work: have a more functional approach instead of using if else statements like if(result.IsSuccess) DoThis() else Dothat() , because that defeats the purpose of using Monads. These methods will not be part of the interface. Only the legacy public methods will. The interface would allow us to support both implementations at the same time.

[StefanBertels]

Alternatives:

• Add implicit operator to Result<T> so it can be converted to/From Fin<T> and/or Either<Error,T>
• Create a conversion method (maybe extension method) like ToFin() for Result<T> for explicit conversion

IMO evaluation of "5." is a good idea (replace your own data type by Fin).

[eddy-douyere-cko]

Thank you very much for your answers. Let me clarify some aspects and give examples.

We have some Nuget packages where there is code like:

case Result { IsSuccess: true } result:
{
    DoSomething(result.Value);
    break;
}

Several teams use this. I cannot simply replace Result by Fin.

So, I have mainly two possibilities:

• add a case with Fin. Example: case Fin {IsSucc: true} fin: . But then I will have to reference language-ext in all our Nuget packages (all teams would have to agree on that) and do the same work everywhere.
• extract an interface to encapsulate the IsSuccess and Value legacy properties, have an alternative implementation using Fin for our team only.
  I would prefer to directly use Fin or Either, but I basically can't 😕 .

[louthy]

Talk of interfaces makes me feel queasy -- it's not the FP way ;-) Concrete types are better.

Types like Either and Fin are 'discriminated unions', which are meant to be closed and concrete. They represent a fixed number of states and that makes certain completeness reasoning possible. Interfaces+inheritance are the opposite, they're open and have infinite possible states -- making it impossible to know the full extent of their hidden state. This is a big deal in FP.

So, even if Either and Fin were reference types (which they are in v5.0.0-alpha), you still shouldn't use them as a base-type for anything -- because they represent a finite union.

I guess the key questions are:

• What's wrong with your current Result type?
• What capabilities does it have that Either doesn't?
• What do you want to achieve by switching to Either?

One possible approach is to look at using LanguageExt.Core v5.0.0-alpha, it's only marked alpha because it's not feature complete yet, my testing so far has shown it to be stable (although there's some new functionality sans unit-tests atm).

The reason I say this is that instead of migrating to Either, you could make your Result type monadic using the new language-ext traits.

I have also removed Result from LanguageExt.Core, so there won't be any name clashes.

You can follow my series on higher-kinds which walks you through the process of assigning traits to any data-type; and you can use the new Either implementation as a reference.

The latest traits functionality in v5 is all about giving this control back to the you, so you're not forced to use the monadic-types that I build for Language-Ext, you can build your own. And because your implementation will have Functor, Applicative, Foldable, Monad, etc. traits, it will automatically work with the other types in language-ext.

[eddy-douyere-cko]

Hi @louthy

Thank you very much for your answer.

I can assure you, it also makes me queasy 😃 . The main goal of switching to Fin or Either is to have a more functional approach because the code base is entire of if(result.IsSuccess) DoThis() else Dothat(), which does not look like very functionnal.

The inheritance/interface is just a technical trick to support the legacy implementation and the new one. But, I guess that improving it and making it monadic is probably the best approach, indeed. So, thank you :). I'll have a look at this.

I still have the feeling to be reinventing the wheel though when I could reuse an existing implementation.

[louthy]

For sure there's a little bit of wheel reinvention, it sounds like your Result type is (at least on a data level) isomorphic to Fin. But you still get to reuse a lot of the code in language-ext because of the new trait system. You don't have to copy everything in the Either folder. The new trait system allows you to easily augment the type without breaking any existing code.

@StefanBertels 's suggestion of providing implicit conversion operators is something you could also do along with the approach I suggest, So, you could use Fin and Result side-by-side and perhaps gradually replace Result.

I don't know the exact shape of your Result type, but let's say it looks like this:

public abstract record Result<A>
{
    public abstract bool IsSuccess { get; }
}

public record ResultSuccess<A>(A Value) : Result<A>
{
    public override bool IsSuccess => true;
}

public record ResultFail<A>(Error Error) : Result<A>
{
    public override bool IsSuccess => false;
}

First, make it derive from K<Result, A>:

public abstract record Result<A> : K<Result, A>
{
    public abstract bool IsSuccess { get; }
}

Then add a ResultExtensions type to downcast from the K type to a concrete Result type:

public static class ResultExtensions
{
    public static Result<A> As<A>(this K<Result, A> ma) =>
        (Result<A>)ma;
}

Next, create the trait implementation type and implement the traits: Monad, Traversable, and SemiAlternative:

public class Result : Monad<Result>, Traversable<Result>, SemiAlternative<Result>
{
    public static Result<A> Success<A>(A value) =>
        new ResultSuccess<A>(value);
    
    public static Result<A> Fail<A>(Error error) =>
        new ResultFail<A>(error);
    
    static K<Result, B> Applicative<Result>.Apply<A, B>(
        K<Result, Func<A, B>> mf,
        K<Result, A> ma) =>
        (mf, ma) switch
        {
            (ResultSuccess<Func<A, B>> (var f), ResultSuccess<A> (var a)) => Success(f(a)),
            (ResultFail<Func<A, B>> (var e1), _)                          => Fail<B>(e1),
            (_, ResultFail<A> (var e2))                                   => Fail<B>(e2),
            _                                                             => throw new NotSupportedException()
        };

    static K<Result, B> Applicative<Result>.Action<A, B>(
        K<Result, A> ma, 
        K<Result, B> mb) => 
        mb;

    static K<Result, B> Monad<Result>.Bind<A, B>(K<Result, A> ma, Func<A, K<Result, B>> f) =>
        ma switch
        {
            ResultSuccess<A> (var x) => f(x),
            ResultFail<A> (var e)    => Fail<B>(e),
            _                           => throw new NotSupportedException()
        };

    static K<Result, A> Applicative<Result>.Pure<A>(A value) => 
        Success(value);

    static K<F, K<Result, B>> Traversable<Result>.Traverse<F, A, B>(Func<A, K<F, B>> f, K<Result, A> ta) =>
        ta switch
        {
            ResultSuccess<A> (var x) => F.Map(x1 => Success(x1).Kind(), f(x)),
            ResultFail<A> (var e)    => F.Pure(Fail<B>(e).Kind()),
            _                        => throw new NotSupportedException()
        };

    static S Foldable<Result>.FoldWhile<A, S>(
        Func<A, Func<S, S>> f, 
        Func<(S State, A Value), bool> predicate, 
        S state,
        K<Result, A> ta) =>
        ta switch
        {
            ResultSuccess<A> (var x) => predicate((state, x)) ? f(x)(state) : state,
            _                        => state
        };

    static S Foldable<Result>.FoldBackWhile<A, S>(
        Func<S, Func<A, S>> f,
        Func<(S State, A Value), bool> predicate,
        S state,
        K<Result, A> ta) =>
        ta switch
        {
            ResultSuccess<A> (var x) => predicate((state, x)) ? f(state)(x) : state,
            _                        => state
        };

    static K<Result, B> Functor<Result>.Map<A, B>(Func<A, B> f, K<Result, A> ma) => 
        ma switch
        {
            ResultSuccess<A> (var x) => Success(f(x)),
            ResultFail<A> (var e)    => Fail<B>(e),
            _                        => throw new NotSupportedException()
        };

    public static K<Result, A> Combine<A>(K<Result, A> ma, K<Result, A> mb) =>
        ma is ResultSuccess<A> ? ma : mb;
}

This implements:

• Monad<Result>
  • Applicative<Result>
  • Functor<Result>
• Traversable<Result>
  • Foldable<Result>
• SemiAlternative<Result>
  • SemigroupK<Result>

Now add Traverse to Result<A> (which just makes it play nice with C#'s type-system):

public abstract record Result<A>
{
    public abstract bool IsSuccess { get; }

    public K<F, Result<B>> Traverse<F, B>(Func<A, K<F, B>> f) where F : Applicative<F> =>
        Traversable.traverse(f, this).Map(x => x.As());
}

And now, without making any more changes to Result<A> you can use it with LINQ:

var result1 = from x in Result.Success(100)
              from y in Result.Success(200)
              select x + y;

var result2 = from x in Result.Success(100)
              from y in Result.Fail<int>(Errors.Cancelled)
              select x + y;

And because the trait-system is so powerful, you get all of the extension methods listed below available without any additional effort on your part -- all for free!

In the past, if someone wanted to make their own data-types as powerful as the types I've written in language-ext (Option, Either, etc.) then they would have to write 1000s and 1000s of lines of code. Now (with version 5 of language-ext) you can get that power with about 100 lines of code. So, I wouldn't see it as reinventing the wheel, you still get to leverage the core capability of the library, just in a type you control 👍

K<M, A> Combine<M, A>(this K<M, A> mx, K<M, A> my);
S FoldWhile<T, A, S>(this K<T, A> ta, S initialState, Func<A, Func<S, S>> f,  Func<(S State, A Value), bool> predicate);
S FoldWhile<T, A, S>(this K<T, A> ta, S initialState, Func<S, A, S> f, Func<(S State, A Value), bool> predicate);
S FoldBackWhile<T, A, S>(this K<T, A> ta, S initialState, Func<S, Func<A, S>> f, Func<(S State, A Value), bool> predicate);
S FoldBackWhile<T, A, S>(this K<T, A> ta, S initialState, Func<S, A, S> f, Func<(S State, A Value), bool> predicate);
K<M, S> FoldWhileM<T, A, M, S>(this K<T, A> ta, S initialState, Func<A, Func<S, K<M, S>>> f, Func<A, bool> predicate);
K<M, S> FoldWhileM<T, A, M, S>(this K<T, A> ta, S initialState, Func<S, A, K<M, S>> f,  Func<A, bool> predicate);
K<M, S> FoldBackWhileM<T, A, M, S>(this K<T, A> ta, S initialState, Func<S, Func<A, K<M, S>>> f,  Func<A, bool> predicate);
K<M, S> FoldBackWhileM<T, A, M, S>(this K<T, A> ta, S initialState,Func<S, A, K<M, S>> f, Func<A, bool> predicate);
S FoldUntil<T, A, S>(this K<T, A> ta, S initialState, Func<A, Func<S, S>> f, Func<(S State, A Value), bool> predicate);
S FoldUntil<T, A, S>(this K<T, A> ta, S initialState, Func<S, A, S> f, Func<(S State, A Value), bool> predicate);
K<M, S> FoldUntilM<T, A, M, S>(this K<T, A> ta, S initialState, Func<A, Func<S, K<M, S>>> f,  Func<A, bool> predicate);
K<M, S> FoldUntilM<T, A, M, S>(this K<T, A> ta, S initialState, Func<S, A, K<M, S>> f,  Func<A, bool> predicate);
S FoldBackUntil<T, A, S>(this K<T, A> ta, S initialState, Func<S, Func<A, S>> f,  Func<(S State, A Value), bool> predicate);
S FoldBackUntil<T, A, S>(this K<T, A> ta, S initialState, Func<S, A, S> f,  Func<(S State, A Value), bool> predicate);
K<M, S> FoldBackUntilM<T, A, M, S>(this K<T, A> ta, S initialState, Func<S, Func<A, K<M, S>>> f, Func<A, bool> predicate);
K<M, S> FoldBackUntilM<T, A, M, S>(this K<T, A> ta, S initialState, Func<S, A, K<M, S>> f,  Func<A, bool> predicate);
S Fold<T, A, S>(this K<T, A> ta, S initialState, Func<A, Func<S, S>> f);
S Fold<T, A, S>(this K<T, A> ta, S initialState, Func<S, A, S> f);
K<M, S> FoldM<T, A, M, S>(this K<T, A> ta, S initialState, Func<A, Func<S, K<M, S>>> f);
K<M, S> FoldM<T, A, M, S>(this K<T, A> ta, S initialState, Func<S, A, K<M, S>> f);
S FoldBack<T, A, S>(this K<T, A> ta, S initialState, Func<S, Func<A, S>> f);
S FoldBack<T, A, S>(this K<T, A> ta, S initialState, Func<S, A, S> f);
K<M, S> FoldBackM<T, A, M, S>(this K<T, A> ta, S initialState, Func<S, Func<A, K<M, S>>> f);
K<M, S> FoldBackM<T, A, M, S>(this K<T, A> ta, S initialState, Func<S, A, K<M, S>> f);
A Fold<T, A>(this K<T, A> tm);
A FoldWhile<T, A>(this K<T, A> tm, Func<(A State, A Value), bool> predicate);
A FoldUntil<T, A>(this K<T, A> tm, Func<(A State, A Value), bool> predicate);
B FoldMap<T, A, B>(this K<T, A> ta, Func<A, B> f);
B FoldMapWhile<T, A, B>(this K<T, A> ta, Func<A, B> f, Func<(B State, A Value), bool> predicate);
B FoldMapUntil<T, A, B>(this K<T, A> ta, Func<A, B> f, Func<(B State, A Value), bool> predicate);
B FoldMapBack<T, A, B>(this K<T, A> ta, Func<A, B> f);
B FoldMapBackWhile<T, A, B>(this K<T, A> ta, Func<A, B> f, Func<(B State, A Value), bool> predicate);
B FoldMapBackUntil<T, A, B>(this K<T, A> ta, Func<A, B> f, Func<(B State, A Value), bool> predicate);
Seq<A> ToSeq<T, A>(this K<T, A> ta);
Lst<A> ToLst<T, A>(this K<T, A> ta);
Arr<A> ToArr<T, A>(this K<T, A> ta);
EnumerableM<A> ToEnumerable<T, A>(this K<T, A> ta);
bool IsEmpty<T, A>(this K<T, A> ta);
int Count<T, A>(this K<T, A> ta);
bool Exists<T, A>(this K<T, A> ta, Func<A, bool> predicate);
bool ForAll<T, A>(this K<T, A> ta, Func<A, bool> predicate);
bool Contains<EqA, T, A>(this K<T, A> ta, A value);
bool Contains<T, A>(this K<T, A> ta, A value);
Option<A> Find<T, A>(this K<T, A> ta, Func<A, bool> predicate);
Option<A> FindBack<T, A>(this K<T, A> ta, Func<A, bool> predicate);
Seq<A> FindAll<T, A>(this K<T, A> ta, Func<A, bool> predicate);
Seq<A> FindAllBack<T, A>(this K<T, A> ta, Func<A, bool> predicate);
A Sum<T, A>(this K<T, A> ta);
A Product<T, A>(this K<T, A> ta);
Option<A> Head<T, A>(this K<T, A> ta);
Option<A> Last<T, A>(this K<T, A> ta);
K<F, Unit> Iter<T, A, F, B>(this K<T, A> ta, Func<A, K<F, B>> f);
Unit Iter<T, A>(this K<T, A> ta, Action<A> f);
Unit Iter<T, A>(this K<T, A> ta, Action<int, A> f);
Option<A> Min<OrdA, T, A>(this K<T, A> ta);
Option<A> Min<T, A>(this K<T, A> ta);
Option<A> Max<OrdA, T, A>(this K<T, A> ta);
Option<A> Max<T, A>(this K<T, A> ta);
A Min<OrdA, T, A>(this K<T, A> ta, A initialMin);
A Min<T, A>(this K<T, A> ta, A initialMin);
A Max<OrdA, T, A>(this K<T, A> ta, A initialMax);
A Max<T, A>(this K<T, A> ta, A initialMax);
A Average<T, A>(this K<T, A> ta);
B Average<T, A, B>(this K<T, A> ta, Func<A, B> f);
Option<A> At<T, A>(this K<T, A> ta, Index index);
K<M, B> Bind<M, A, B>(this K<M, A> ma, Func<A, K<M, B>> f);
K<M, B> Bind<M, A, B>(this K<M, A> ma, Func<A, Pure<B>> f);
K<M, B> Bind<M, A, B>(this K<M, A> ma, Func<A, IO<B>> f);
K<M, C> SelectMany<M, A, B, C>(this K<M, A> ma, Func<A, K<M, B>> bind,Func<A, B, C> project);
K<M, C> SelectMany<M, A, B, C>(this K<M, A> ma, Func<A, Pure<B>> bind, Func<A, B, C> project);
K<M, C> SelectMany<F, A, C>(this K<F, A> ma, Func<A, Guard<Error, Unit>> bind, Func<A, Unit, C> project);
K<F, C> SelectMany<F, A, C>(this K<F, A> ma, Func<A, Guard<Fail<Error>, Unit>> bind, Func<A, Unit, C> project);
K<F, C> SelectMany<F, B, C>(this Guard<Error, Unit> ma, Func<Unit, K<F, B>> bind, Func<Unit, B, C> project);
K<F, C> SelectMany<F, B, C>(this Guard<Fail<Error>, Unit> ma, Func<Unit, K<F, B>> bind, Func<Unit, B, C> project);
K<M, A> Flatten<M, A>(this K<M, K<M, A>> mma);
K<M, K<N, B>> BindT<M, N, A, B>(this K<M, K<N, A>> mna, Func<A, K<N, B>> f);
K<M, K<N, B>> BindT<M, N, A, B>(this K<M, K<N, A>> mna, Func<A, K<M, K<N, B>>> f);
K<Fnctr, B> Map<Fnctr, A, B>(this K<Fnctr, A> ma, Func<A, B> f);
K<Fnctr, B> Select<Fnctr, A, B>(this K<Fnctr, A> ma, Func<A, B> f);
K<Fnctr, B> Map<Fnctr, A, B>(this Func<A, B> f, K<Fnctr, A> ma);
K<Fnctr, Func<B, C>> Map<Fnctr, A, B, C>(this Func<A, B, C> f, K<Fnctr, A> ma);
K<Fnctr, Func<B, Func<C, D>>> Map<Fnctr, A, B, C, D>(this Func<A, B, C, D> f, K<Fnctr, A> ma);
K<Fnctr, Func<B, Func<C, Func<D, E>>>> Map<Fnctr, A, B, C, D, E>(this Func<A, B, C, D, E> f, K<Fnctr, A> ma);
K<Fnctr, Func<B, Func<C, Func<D, Func<E, F>>>>> Map<Fnctr, A, B, C, D, E, F>(this Func<A, B, C, D, E, F> f, K<Fnctr, A> ma);
K<Fnctr, Func<B, Func<C, Func<D, Func<E, Func<F, G>>>>>> Map<Fnctr, A, B, C, D, E, F, G>(this Func<A, B, C, D, E, F, G> f, K<Fnctr, A> ma);
K<Fnctr, Func<B, Func<C, Func<D, Func<E, Func<F, Func<G, H>>>>>>> Map<Fnctr, A, B, C, D, E, F, G, H>(this Func<A, B, C, D, E, F, G, H> f, K<Fnctr, A> ma);
K<Fnctr, Func<B, Func<C, Func<D, Func<E, Func<F, Func<G, Func<H, I>>>>>>>> Map<Fnctr, A, B, C, D, E, F, G, H, I>(this Func<A, B, C, D, E, F, G, H, I> f, K<Fnctr, A> ma);
K<Fnctr, Func<B, Func<C, Func<D, Func<E, Func<F, Func<G, Func<H, Func<I, J>>>>>>>>> Map<Fnctr, A, B, C, D, E, F, G, H, I, J>(this Func<A, B, C, D, E, F, G, H, I, J> f, K<Fnctr, A> ma);
K<Fnctr, Func<B, Func<C, Func<D, Func<E, Func<F, Func<G, Func<H, Func<I, Func<J, K>>>>>>>>>> Map<Fnctr, A, B, C, D, E, F, G, H, I, J, K>(this Func<A, B, C, D, E, F, G, H, I, J, K> f, K<Fnctr, A> ma);
K<M, K<N, B>> MapT<M, N, A, B>(this K<M, K<N, A>> mna, Func<A, B> f);
K<F, K<T, B>> Traverse<F, A, B>(Func<A, K<F, B>> f,K<T, A> ta);
K<F, K<T, A>> Sequence<F, A>(K<T, K<F, A>> ta);
K<M, K<T, B>> TraverseM<M, A, B>(Func<A, K<M, B>> f,K<T, A> ta);
K<F, K<T, A>> SequenceM<F, A>(K<T, K<F, A>> ta);
K<F, B> Apply<F, A, B>(this K<F, Func<A, B>> mf, K<F, A> ma);
K<F, B> ApplyM<F, A, B>(this K<F, Func<A, K<F, B>>> mf, K<F, A> ma);
K<F, Func<B, C>> Apply<F, A, B, C>(this K<F, Func<A, B, C>> mf, K<F, A> ma);
K<F, Func<B, K<F, C>>> ApplyM<F, A, B, C>(this K<F, Func<A, B, K<F, C>>> mf, K<F, A> ma);
K<F, C> Apply<F, A, B, C>(this K<F, Func<A, B, C>> mf, K<F, A> ma, K<F, B> mb);
K<F, C> ApplyM<F, A, B, C>(this K<F, Func<A, B, K<F, C>>> mf, K<F, A> ma, K<F, B> mb);
K<F, D> Apply<F, A, B, C, D>(this K<F, Func<A, B, C, D>> mf, K<F, A> ma, K<F, B> mb, K<F, C> mc);
K<F, D> ApplyM<F, A, B, C, D>(this K<F, Func<A, B, C, K<F, D>>> mf, K<F, A> ma, K<F, B> mb, K<F, C> mc);
K<F, Func<C, D>> Apply<F, A, B, C, D>(this K<F, Func<A, B, C, D>> mf, K<F, A> ma, K<F, B> mb);
K<F, Func<C, K<F, D>>> ApplyM<F, A, B, C, D>(this K<F, Func<A, B, C, K<F, D>>> mf, K<F, A> ma, K<F, B> mb);
K<F, Func<B,Func<C, D>>> Apply<F, A, B, C, D>(this K<F, Func<A, B, C, D>> mf, K<F, A> ma);
K<F, Func<B,Func<C, K<F, D>>>> ApplyM<F, A, B, C, D>(this K<F, Func<A, B, C, K<F, D>>> mf, K<F, A> ma);
K<F, B> Action<F, A, B>(this K<F, A> ma, K<F, B> mb);
K<F, A> Actions<F, A>(this IEnumerable<K<F, A>> ma);
K<F, B> Lift<F, A, B>(this Func<A, B> f, K<F, A> fa);
K<F, C> Lift<F, A, B, C>(this Func<A, B, C> f, K<F, A> fa, K<F, B> fb);
K<F, C> Lift<F, A, B, C>(this Func<A, Func<B, C>> f, K<F, A> fa, K<F, B> fb);
K<F, D> Lift<F, A, B, C, D>(this Func<A, B, C, D> f, K<F, A> fa, K<F, B> fb, K<F, C> fc);
K<F, D> Lift<F, A, B, C, D>(this Func<A, Func<B, Func<C, D>>> f, K<F, A> fa, K<F, B> fb, K<F, C> fc);
K<Fnctr, R> Apply<Fnctr, A, B, R>(this (K<Fnctr, A>, K<Fnctr, B>) items, Func<A, B, R> f);
K<M, R> ApplyM<M, A, B, R>(this (K<M, A>,K<M, B>) items, Func<A, B, K<M, R>> f)
K<Fnctr, R> Apply<Fnctr, A, B, C, R>(this (K<Fnctr, A>, K<Fnctr, B>, K<Fnctr, C>) items, Func<A, B, C, R> f);
K<M, R> ApplyM<M, A, B, C, R>(this (K<M, A>, K<M, B>, K<M, C>) items, Func<A, B, C, K<M, R>> f);
K<Fnctr, R> Apply<Fnctr, A, B, C, D, R>(this (K<Fnctr, A>, K<Fnctr, B>, K<Fnctr, C>, K<Fnctr, D>) items, Func<A, B, C, D, R> f);
K<M, R> ApplyM<M, A, B, C, D, R>(this (K<M, A>, K<M, B>, K<M, C>, K<M, D>) items, Func<A, B, C, D, K<M, R>> f);
K<Fnctr, R> Apply<Fnctr, A, B, C, D, E, R>(this (K<Fnctr, A>, K<Fnctr, B>, K<Fnctr, C>, K<Fnctr, D>, K<Fnctr, E>) items, Func<A, B, C, D, E, R> f);
K<M, R> ApplyM<M, A, B, C, D, E, R>(this (K<M, A>, K<M, B>, K<M, C>, K<M, D>, K<M, E>) items, Func<A, B, C, D, E, K<M, R>> f);
K<Fnctr, R> Apply<Fnctr, A, B, C, D, E, F, R>(this (K<Fnctr, A>, K<Fnctr, B>, K<Fnctr, C>, K<Fnctr, D>, K<Fnctr, E>, K<Fnctr, F>) items, Func<A, B, C, D, E, F, R> f);
K<M, R> ApplyM<M, A, B, C, D, E, F, R>(this (K<M, A>, K<M, B>, K<M, C>, K<M, D>, K<M, E>, K<M, F>) items, Func<A, B, C, D, E, F, K<M, R>> f);
K<Fnctr, R> Apply<Fnctr, A, B, C, D, E, F, G, R>(this (K<Fnctr, A>, K<Fnctr, B>, K<Fnctr, C>, K<Fnctr, D>, K<Fnctr, E>, K<Fnctr, F>, K<Fnctr, G>) items, Func<A, B, C, D, E, F, G, R> f);
K<M, R> ApplyM<M, A, B, C, D, E, F, G, R>(this (K<M, A>, K<M, B>, K<M, C>, K<M, D>, K<M, E>, K<M, F>, K<M, G>) items,        Func<A, B, C, D, E, F, G, K<M, R>> f);
K<Fnctr, R> Apply<Fnctr, A, B, C, D, E, F, G, H, R>(this (K<Fnctr, A>, K<Fnctr, B>, K<Fnctr, C>, K<Fnctr, D>, K<Fnctr, E>, K<Fnctr, F>, K<Fnctr, G>, K<Fnctr, H>) items, Func<A, B, C, D, E, F, G, H, R> f);
K<M, R> ApplyM<M, A, B, C, D, E, F, G, H, R>(this (K<M, A>, K<M, B>, K<M, C>, K<M, D>, K<M, E>, K<M, F>, K<M, G>, K<M, H>) items, Func<A, B, C, D, E, F, G, H, K<M, R>> f);
K<Fnctr, R> Apply<Fnctr, A, B, C, D, E, F, G, H, I, R>(this (K<Fnctr, A>,K<Fnctr, B>,K<Fnctr, C>,K<Fnctr, D>,K<Fnctr, E>,K<Fnctr, F>,K<Fnctr, G>,K<Fnctr, H>,K<Fnctr, I>) items, Func<A, B, C, D, E, F, G, H, I, R> f);
K<M, R> ApplyM<M, A, B, C, D, E, F, G, H, I, R>(this (K<M, A>, K<M, B>, K<M, C>, K<M, D>, K<M, E>, K<M, F>, K<M, G>, K<M, H>, K<M, I>) items, Func<A, B, C, D, E, F, G, H, I, K<M, R>> f);
K<Fnctr, R> Apply<Fnctr, A, B, C, D, E, F, G, H, I, J, R>(this (K<Fnctr, A>,K<Fnctr, B>,K<Fnctr, C>,K<Fnctr, D>,K<Fnctr, E>,K<Fnctr, F>,K<Fnctr, G>,K<Fnctr, H>,K<Fnctr, I>,K<Fnctr, J>) items,Func<A, B, C, D, E, F, G, H, I, J, R> f);
K<M, R> ApplyM<M, A, B, C, D, E, F, G, H, I, J, R>(this (K<M, A>, K<M, B>, K<M, C>, K<M, D>, K<M, E>, K<M, F>, K<M, G>, K<M, H>, K<M, I>, K<M, J>) items, Func<A, B, C, D, E, F, G, H, I, J, K<M, R>> f);
K<F, A> Add<NumA, F, A>(this K<F, A> fa, K<F, A> fb);
K<F, A> Add<F, A>(this K<F, A> fa, K<F, A> fb);
K<F, A> Subtract<NumA, F, A>(this K<F, A> fa, K<F, A> fb);
K<F, A> Subtract<F, A>(this K<F, A> fa, K<F, A> fb);
K<F, A> Multiply<NumA, F, A>(this K<F, A> fa, K<F, A> fb);
K<F, A> Multiply<F, A>(this K<F, A> fa, K<F, A> fb);
K<F, A> Divide<NumA, F, A>(this K<F, A> fa, K<F, A> fb);
K<F, A> Divide<F, A>(this K<F, A> fa, K<F, A> fb);

[eddy-douyere-cko]

That's very detailed and helpful. Thank you for taking time.
I think I have pretty much everything I need to move on.
Thanx again to both of you and for your work.
Edit: and yes our Result type looks like this 😆