LINQ immediate query execution not caught for type checking

[itmitica]

Should (?) catch type changing from collection to array here: IEnumerable<int> fib2 = fib.Where(x => x > 2).ToArray();.

Catches type change here: Console.WriteLine($"{ fib2[0] }");.

Fixable by Console.WriteLine($"{ fib2.ToArray()[0] }");.

Why does it take two ToArray() or why is the first ToArray() nullified by IEnumerable<int> type annotation?

[bbarry]

Disclaimer: I am not sure I understand what you are saying.

Are you asking "why, on line 14 can I not simply use the syntax fib2[0]?"

fib2 there is of the type IEnumerable<int> there because you explicitly declared the variable to be that type on line 13. This means on line 14, you cannot use the array indexer because the IEnumerable<T> interface doesn't declare an indexer.

This question doesn't really belong here, perhaps community members at Stack Overflow, Reddit, MSDN Forums or other resources may be more helpful. This particular repository is for describing the current and future versions of the C# language. "This is where new C# language features are developed, adopted and specified."

---

If instead what you are trying to do is propose that the syntax fib2[0] should be valid on line 14, even though it is not on the IEnumerable<T> interface because it is known that the actual type is int[] even though the declared type is IEnumerable<T>, that would belong here (but I suspect wouldn't gain much traction).

[itmitica]

IEnumerable<int> fib2 = fib.Where(x => x > 2).ToArray();

Ideally, I think this should yield an error: "could not assign/implicitly convert int[] to IEnumerable<int>".

My opinion is that the behavior of implicit conversion through assignment is not optimal in this case. A pretty big gotcha for me. I was expecting an error like "you can't assign yada yada", if array operations are not possible on the query result, no matter how legal the conversion.

I think that, on line 14, fib2 is IEnumerable as it was explained to me on the issue I opened on omnisharp: dotnet/vscode-csharp#1244

[bbarry]

https://github.com/dotnet/csharplang/blob/6027ad5a4ab013f4fb42f5edd2d667d649fe1bd8/spec/expressions.md#simple-assignment

In a simple assignment, the right operand must be an expression that is implicitly convertible to the type of the left operand. The operation assigns the value of the right operand to the variable, property, or indexer element given by the left operand.

Every class/struct is implicitly convertible to the interfaces that they are declared to implement, and single dimensional arrays are implicitly convertible to IList<T> and base interfaces:

https://github.com/dotnet/csharplang/blob/6027ad5a4ab013f4fb42f5edd2d667d649fe1bd8/spec/conversions.md#implicit-reference-conversions

• From any class_type S to any interface_type T, provided S implements T.
• From a single-dimensional array type S[] to System.Collections.Generic.IList<T> and its base interfaces, provided that there is an implicit identity or reference conversion from S to T.

A proposal that makes breaking changes to those is dead in the water due to how much code depends on them.

[itmitica]

I understood this assignment:

IEnumerable<int> fib2 = fib.Where(x => x > 2).ToArray();

as an expression leading to a explicit conversion (cast), a user-defined conversion or a conversion with helper classes, not an expression prepared for a implicit conversion to another type.

I would like this mechanism to not happen: IEnumerable is implicitly winding back the explicit To Array conversion. But I can learn and live with it also.

[bbarry]

T[] Enumerable.ToArray<T>(this IEnumerable<T> source) is not special. It is just another extension method that happens to have the convenient name ToArray to make it look (a little) like you are explicitly creating an array (what you are doing is explicitly calling a method). And it is not casting.

In fact you could write it yourself (you would need Where for this particular example as well):

public static class Enumerable
{
  public static IEnumerable<T> Where<T>(this IEnumerable<T> source, Func<T, bool> predicate)
  {
    if (source == null) throw new ArgumentNullException(nameof(source));
    if (predicate == null) throw new ArgumentNullException(nameof(predicate));
    foreach(var item in source)
    {
      if (predicate(item)) yield return item;
    }
  }
  public static T[] ToArray<T>(this IEnumerable<T> source)
  {
    if (source == null) throw new ArgumentNullException(nameof(source));
    return new List<T>(source).ToArray();
  }
}

(the actual implementation has a bunch more code for a few tricks to be faster; also for reference, Where)

Aside from the fact that these methods are named what they are, they are not in any way special. You could name them Where => If and ToArray => Evaluate and have your resulting code be:

public class Program
{
 static void Main(string[] args)
 {
   int[] fib = new[] {0, 1, 1, 2, 3, 5};

   IEnumerable<int> fib2 = fib.If(x => x > 2).Evaluate();
   Console.WriteLine($"{ fib2.Evaluate()[0] }");

   int[] fib3 = fib.If(x => x > 2).Evaluate();
   Console.WriteLine($"{ fib3[0] }");
 }
}