lefts and rights helpers for Either

I am direly missing these functions from Haskell (http://hackage.haskell.org/package/base-4.8.1.0/docs/src/Data.Either.html#lefts).

I’m not sure how to implement them here, since Haskell uses some kind of partial pattern match magic predicates.

I’m generally not too convinced by the asymmetry of Either. In particular the IfLeft/IfRight functions are preferring Right so much that there is practically no chance to extract a left value. Maybe I’m missing the obvious way of doing it.

The following is as far as I came; it doesn’t compile though, because lout might not be instanced (as far as the compiler is concerned).

        public static class EitherExtensions<L, R>
        {
            private static IEnumerable<L> Lefts(this IEnumerable<Either<L, R>> eis)
            {
                return eis.Filter(ei => ei.IsLeft).Map(ei =>
                {
                    L lout;
                    ei.Match(
                        Right: r => { return; },
                        Left: l => { lout = l; });
                    return lout;
                });
            }
        }

[Profpatsch]

Haha, that’s super great!

if you’ve come from a Haskell background why didn’t you go straight to F# rather than C#?

I’m fixing bugs and improving a small C# codebase and originally just wanted a Maybe and an Either type because I loathe the null- and exception-passing style. Maybe it escalated a little …

[louthy]

It wouldn’t be great, no. So the implementation I have done is:

    public static IEnumerable<L> Lefts<L, R>(this IEnumerable<Either<L, R>> self)
    {
        foreach (var item in self)
        {
            if (item.IsLeft)
            {
                yield return item.LeftValue;
            }
        }
    }

And similar for Rights. This imperative loop is the quickest way of yielding the results, but also it’s lazy (if you don’t know C# too well, yield is a coroutines system which works in tandem with foreach via the IEnumerator interface).

I have just done a check-in with updates based on your suggestions:

• Rights and Lefts extension methods for IEnumerable<Either<L,R>> and IEnumerable<EitherUnsafe<L,R>>
• rights and lefts static methods in Prelude
• partition function that returns a tuple of lefts and rights
• More variants of ifLeft and ifRight
• Left variants of iter, forall, fold, exists, map, bind and filter

Note, the LINQ functions Where, Select and SelectMany will continue to be biased toward Right and will early-out when an Either is in a Left or Bottom state.

It’s getting a bit late here (2 am), so I will do a nuget release tomorrow with these updates. So if you want them sooner you’ll need to build from source.