More compostional or fluent handling of Eithers with varied Right Results

Simple commented code:

       public static Either<string, string> GetTestMessageType(JObject msg)
        {
            // after some lookup/validation msg, suppose return as:
            return Right("GET_AUTHORS");
        }

        public static Either<string ,Func<JObject, MessageResult>> GetTestHandler(string key)
        {
            try
            {
                // Handlers Dictonary lookup sucsess
                return Right(Handlers.Get(key));
            }
            catch (Exception e)
            {
                // Handlers Dictonary lookup failed
                return Left($"Handler {key} not found. ({e.Message})");
            }
        }

        public static string TestMessageResultError(string err)
        {
            return $"Error:{err}";
        }

        public static object HandleTestMessage(JObject msg)
        {

            // Valid message type? 
            var x = GetTestMessageType(msg);

            // if not return error
            if (x.IsLeft)
            {
                return TestMessageResultError(x.Match(Left: l => l, Right: _ => ""));
            }

            // extract Message Type
            var mt = x.Match(Left: l => l, Right: r => r);

            // Handler exist? 
            var h = GetTestHandler(mt);

            // if not Return error Message Type cannot be handled
            if (h.IsLeft)
                return TestMessageResultError(h.Match(Left: l => l, Right: _ => ""));

            // extract handler func
            var f = h.Match(Left: l => null, Right: r => r);

            // Execute Handler func with msg
            return f(msg);

        }

GetTestMessageType and GetTestHandler return Either with varied Right results.

HandleTestMessage uses both to for handling msg but in verbose manner.

Any suggestion to make it more compostional or fluent style?

[louthy]

Just to be clear, this is a limitation of C#. When you use the ternary operator:

   a = b ? c : d;

If there isn’t a common base type shared by c and d then C# will claim it can’t infer the type of the expression. Even if the type of a is known.

• The return type for Right<R>(r) is EitherRight<R>
• The return type for Left<L> is EitherLeft<L>(l).

They don’t share the same base type

And therefore C# can’t work out what’s going on. So, you can’t do this:

    var a = b 
        ? Right<R>(r) 
        : Left<L>(l);

• The return type for Right<L, R>(r) is Either<L, R>
• The return type for Left<L, R>(l) is Either<L, R>.

Which clearly share the same return type (note both L and R are provided for both), and so you can call:

    var a = b 
        ? Right<L, R>(r) 
        : Left<L, R>(l);

Now the Bind function that can be called on EitherLeft<L> or EitherRight<R> is there to provide the other type in the Either

So,

• For EitherLeft<L> the Bind operation provides the R type.
• For EitherRight<R> the Bind operation provides the L type.

So, there are 3 ways you can do this. And the one you chose should probably be based on the resulting attractiveness/readability of the code:

    static Either<string, Func<JObject, MessageResult>> GetTestHandler(string type) =>
        type == "GET_AUTHORS"
            ? Right(HandleGetAuthors)
            : Left($"Invalid Message type {type}").Bind<Func<JObject, MessageResult>>();

    static Either<string, Func<JObject, MessageResult>> GetTestHandler(string type) =>
        type == "GET_AUTHORS"
            ? Right(HandleGetAuthors).Bind<string>()
            : Left($"Invalid Message type {type}");

    static Either<string, Func<JObject, MessageResult>> GetTestHandler(string type) =>
        type == "GET_AUTHORS"
            ? Right<string, Func<JObject, MessageResult>>(HandleGetAuthors)
            : Left<string, Func<JObject, MessageResult>>($"Invalid Message type {type}");

[imranypatel]

@bender2k14 Thank you.

Just for completeness and documentation for beginners like myself, based on your response, here is the revised version in expression style:

    static Either<string, Func<JObject, MessageResult>> GetTestHandler(string type) =>
            (type == "GET_AUTHORS")
            ? Right(HandleGetAuthors)
            : Left($"Invalid Message type {type}").Bind<Func<JObject, MessageResult>>()