Type aliasing on a generic function definition

[georgiosatphilips]

Hello,

I have the following function which works fine:

 public static Either<Error, DomainObject> ReadValidatedFileBytes(
        Func<string, Either<Error, string>> pathValidation,
        Func<string, Either<Error, DomainObject>> artefactReader,
        string filePath)
    {
        return Prelude.Right<Error, string >(filePath)
            .Bind(pathValidation)
            .Bind(artefactReader);
    }

The definition is however quite verbose.

Is it possible to alias a function definition such as Func<string, Validation<Error, MyDomainObject>>.
I tried using delegates:

public delegate Validation<Error,T> Validator<T>(T t);
public delegate Validation<Error,TT> Validator<T, TT>(T t);

but of course the following does not compile since delegates cannot be converted automatically:

 public static Either<Error, DomainObject> ReadValidatedFileBytes(
       Validator<string> pathValidation,
        Validator<string, DomainObject> artefactReader,
        string filePath)
    {
        return Prelude.Right<Error, string >(filePath)
            .Bind(pathValidation)
            .Bind(artefactReader);
    }

I am new to the library and FP in general, so trying to browse the library for an existing solution is a bit overwhelming.
Does something exist in the library for that? Or is it not possible and I have to implement my own Bind?

With kind regards
Georgios

[louthy]

One quick thing you can do is to replace your Either<Error, *> with Fin<*>. The Fin type is essentially a built-in alias for Either<Error, *>

You can convert between them using ToFin() and ToEither()

I've never really found typed delegates to help that much with readability.

You could consider 'global using' which allows for project-wide aliases?

[georgiosatphilips]

Thank you for the reply.
Regarding Fin<*>, I find having to call ToFin()/ToEither() an undesirable tradeoff to reduced verbosity.
I guess the 'global using' does ameliorate the situation. Though Func<T, Either<Error, TR>> does seem like a pattern that pops up a lot, which will lead to many aliases. Not sure how problematic this will prove, if at all.