[Question] Where(IsT0) followed by Select(AsT0)

[CrispyDrone]

Is there a more concise alternative or elegant way to achieve the following?

// returns IEnumerable<OneOf<Success, MyError>>
var results = ImportFiles(files);

// I only care about the errors that are generated
var errors = results.Where(r => r.IsT1).Select(r => r.AsT1).ToList();

// do something with errors; other api expects a list
ShowErrorsToUser(errors);

I've considered this option, but it's not really any better, even slightly more wordy:

var results = ImportFiles(files);
var errors = new List<FileError>();
foreach (var r in importResults)
{
    r.Switch(_ => { }, errors.Add);
}

ShowErrorsToUser(errors);

I considered using OneOfBase and defining a manual conversion, but that doesn't work with Linq's OfType method, which uses the is operator. Linq's Cast brings me back to square one of needing a Where to filter out nulls.

edit: Cast apparently also doesn't support user-defined conversions.

    class CtxOrError : OneOfBase<Success, FileError>
    {
        protected CtxOrError(OneOf<Success, FileError> input) : base(input)
        {
        }

        public static implicit operator FileError?(CtxOrError input)
            => input.IsT1 ? input.AsT1 : null;
    }

I can just define an extension method like this:

public static class EnumerableExtensions
{
    public static IEnumerable<T0> FilterAsT0<T0, T1>(this IEnumerable<OneOf<T0, T1>> source)
    {
        return source.Where(s => s.IsT0).Select(s => s.AsT0);
    }

    public static IEnumerable<T1> FilterAsT1<T0, T1>(this IEnumerable<OneOf<T0, T1>> source)
    {
        return source.Where(s => s.IsT1).Select(s => s.AsT1);
    }
}

But wondering if there's a built-in way, or an extension method provided in one of the support libraries, thanks!

[emperador-ming]

I’m afraid there isn’t a built-in way or an existing extension method for this (at least none that I’m aware of). Your extensions look perfectly reasonable to me. Alternatively, you could define your own list type, e.g.:

public class ResultList<T> : List<OneOf<T, MyError>> { }

[CrispyDrone]

Thanks for the quick reply!

I'm not sure if I understand ResultList entirely.
To use it, the argument to ShowErrorsToUser would have to change and accept ResultList as well? That can be a solution if we can change it, but not if it's a third party library of course.

[emperador-ming]

My idea was to hide the OneOf details behind ResultList, so callers don’t have to deal with them directly. From the outside it looks like this:

// returns ResultList<Success>
var results = ImportFiles(files);

// other APIs can still work with a simple list of errors
ShowErrorsToUser(results.Errors);

Internally, Errors can be implemented lazily to avoid materializing collections:

public class ResultList<T> : List<OneOf<T, MyError>>
{
    public IEnumerable<MyError> Errors =>
        this.Where(r => r.IsT1).Select(r => r.AsT1);
}

This way the error-handling logic is encapsulated while keeping existing method signatures unchanged.