How to construct `Either<L, R>` without implicit conversions?

I’m having an issue where I’m being forced not to use implicit conversions:

public interface X { }
public class Y : X { }

Either<string, X> a = new Y();          // compiles
Either<string, X> b = new Y() as X;  // Cannot convert initializer type 'X' to target type 'Either<string, X>'

This looks like a compiler bug in IMO, but I’m hesitant to rush to such a harsh conclusion.

In any case, because I have an instance of an interface, and not of the concrete class, I have to construct an Either using some other means.

Maybe I’m missing something, but the constructors are private, and the two static helpers Right and Left are internal.

[louthy]

@dcastro It’s because implicit operators don’t work with interfaces, it’s a limitation of C#. In your IEnumerable example instead use the lang-ext built-in List<T>()

        Either<Exception, IEnumerable<T>> F<T>()
        {
            return List<T>();
        }

Make sure you’re using static LanguageExt.Prelude. If not, then you can directly use the Empty field on the Lst<T> type:

        Either<Exception, IEnumerable<T>> F<T>()
        {
            return Lst<T>.Empty;
        }

If you want to do similar behaviour yourself, try this:

        static class Empty<T>
        {
            public static readonly T[] Enumerable = new T[0];
        }

        Either<Exception, IEnumerable<T>> F<T>()
        {
            return Empty<T>.Enumerable;
        }

That avoids the allocation and implicitly casts.

[louthy]

I’m unclear on why you aren’t using the one that compiles?

The static functions you’re after for explicitly defining left and right are: Prelude.Left<string, X>(…) and Prelude.Right<string, X>(…)

On Thu, 4 Aug 2016 at 11:24 Diogo Castro [e-mail] wrote:

I’m having an issue where I’m being forced not to use implicit conversions:

public interface X { }public class Y : X { }

Either<string, X> a = new Y(); // compiles Either<string, X> b = new Y() as X; // Cannot convert initializer type ‘X’ to target type ‘Either<string, X>’

This looks like a compiler bug in IMO, but I’m hesitant to rush to such a harsh conclusion.

In any case, because I have an instance of an interface, and not of the concrete class, I have to construct an Either using some other means.

Maybe I’m missing something, but the constructors are private, and the two static helpers Right https://github.com/louthy/language-ext/blob/master/LanguageExt.Core/Either.cs#L627 and Left https://github.com/louthy/language-ext/blob/master/LanguageExt.Core/Either.cs#L631 are internal.

— You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub https://github.com/louthy/language-ext/issues/121, or mute the thread https://github.com/notifications/unsubscribe-auth/AB5kk9SEvRWYQZgsZtJf74d31tJ4DPiwks5qcb3ngaJpZM4JcjoM .