Add `List.From<T>` factory method taking `IEnumerable<T> where T : IValue`

[dahlia]

The current signature of Bencodex.Types.List(IEnumerable<IValue>) constructor requires frequent type casting to IEnumerable<IValue>, because C# does not automatically infer G<T> where T : B to G<B>. For example, the following code fails to build:

int[] ints = { 1, 2, 3, 4 };
IEnumerable<Bencodex.Types.Integer> bInts =
    ints.Select(i => (Bencodex.Types.Integer)i);
var list = new Bencodex.Types.List(bInts);  // Type error

It's because IEnumerable<Bencodex.Types.Integer> cannot be passed to IEnumerable<IValue>, even though Bencodex.Types.Integer implements IValue. Instead, we need to explicitly cast bInts so that the code is compiled:

var list = new Bencodex.Types.List(bInts.Cast<IValue>());

This can be fixed by changing the parameter type from IEnumerable<IValue> instead of IEnumerable<T> where T : IValue. However, unfortunately .NET disallows constructors to have type parameters. Therefore, we need add a separate factory method instead:

public static List From<T>(IEnumerable<T> values)
    where T : IValue;

Or, we might be better to have extension methods on IEnumerable<T> where T : IValue instead:

public static class EnumerableExtensions
{
    public static Bencodex.Types.List ToBencodexList<T>(this IEnumerable<T> source)
        where T : IValue;
    public static Bencodex.Types.Dictionary ToBencodexDictionary<TKey, TValue>(
        this IEnumerable<KeyValuePair<TKey, TValue>> source
    )
        where TKey : IKEy
        where TValue : IValue;
}

[greymistcube]

It'd be nice if class can be converted to interfaces automatically, but I need to ask what the goal is for the suggested solutions are. In either case, additional syntax is required anyway with an explicit intention of type casting to IValue, which bInts.Cast<IValue>() does already.

[dahlia]

Indeed, it's not more than shortcut. I just want to write code like:

var list = bInts.ToBencodexList();

… instead of:

var list = new Bencodex.Types.List(bInts.Cast<IValue>());

… which is quite unclear its intention.

[greymistcube]

Hmm... perhaps trying to do two conversions at once is the problem. That is, IEnumerable<Bencodex.Types.Integer> to Bencodex.Types.List<IValue>. Converting the "outer" type to a concrete type while flipping the "inner" type to an interface seems kinda icky, but I guess its harmless enough. Just voicing my concern.

[greymistcube]

I think adding another layer of interface would at least get rid of the necessity for "late" casting.

Bencodex.Types.Integer : IValueInteger
IValueInteger : IValue

Not sure how cost effective this would be though since this would require

IEnumerable<IValueInteger> bInts =
    ints.Select(i => (Bencodex.Types.Integer)i as IValueInteger);

In the first place. 😛