Melhor conversão de elemento de expressão de coleção

Problema do especialista: https://github.com/dotnet/csharplang/issues/8374

Resumo

Atualiza as melhores regras de conversão para serem mais consistentes com o paramse lidar de forma mais eficaz com os atuais cenários de ambiguidade. Por exemplo, a comparação entre ReadOnlySpan<string> e ReadOnlySpan<object> no momento pode causar ambiguidades durante a resolução de sobrecarga para [""].

Design detalhado

A seguir, as melhores conversões das regras de expressões. Elas substituem as regras no https://github.com/dotnet/csharplang/blob/main/proposals/csharp-12.0/collection-expressions.md#overload-resolution.

Estas regras são:

Considerando uma conversão implícita C₁ que converte de uma expressão E para um tipo T₁, e uma conversão implícita C₂ que converte de uma expressão E para um tipo T₂, C₁ é uma conversão melhor do que C₂ se uma das seguintes condições:

• E é uma expressão de coleção , e C₁ é uma conversão de coleção melhor da expressão do que C₂.
• E não é uma expressão de coleção e uma das seguintes retenções:
  • E corresponde exatamente a T₁ e E não corresponde exatamente a T₂
  • E corresponde exatamente a ambos ou a nenhum de T₁ e T₂, e T₁ é um alvo de conversão melhor do que T₂
• E é um grupo de métodos, ...

Adicionamos uma nova definição para visando a melhor conversão de coleção da expressão, da seguinte maneira:

Considerando:

• E é uma expressão de coleção com expressões de elemento [EL₁, EL₂, ..., ELₙ]
• T₁ e T₂ são tipos de coleção
• E₁ é o tipo de elemento de T₁
• E₂ é o tipo de elemento de T₂
• CE₁ᵢ é a série de conversões de ELᵢ para E₁
• CE₂ᵢ é a série de conversões de ELᵢ para E₂

Se houver uma conversão de identidade de E₁ para E₂, as conversões de elementos serão tão boas quanto as outras. Caso contrário, as conversões de elemento em E₁ serão melhores do que as conversões de elemento para E₂ se:

• Para cada ELᵢ, CE₁ᵢ é pelo menos tão bom quanto CE₂ᵢe
• Há pelo menos um i onde CE₁ᵢ é melhor do que CE₂ᵢ Caso contrário, nenhum conjunto de conversões de elementos é melhor do que o outro, e eles também não são tão bons quanto uns aos outros.
  Comparações de conversão são feitas usando uma conversão melhor da expressão se ELᵢ não for um elemento de propagação. Se ELᵢ for um elemento de distribuição, usaremos uma conversão melhor do tipo de elemento da coleção de spread para E₁ ou E₂, respectivamente.

C₁ é uma conversão de coleção melhor da expressão do que C₂ se:

• Tanto T₁ quanto T₂ não são tipos de intervalo, e T₁ é implicitamente conversível para T₂, e T₂ não é implicitamente conversível para T₁, ou seja,
• E₁ não tem uma conversão de identidade para E₂e as conversões de elemento em E₁ são melhores do que as conversões de elemento para E₂ou
• E₁ tem uma conversão de identidade para E₂, e uma das seguintes condições se aplica:
  • T₁ é System.ReadOnlySpan<E₁>e T₂ é System.Span<E₂>ou
  • T₁ é System.ReadOnlySpan<E₁> ou System.Span<E₁> e T₂ é um array_or_array_interface com o tipo de elementoE₂

Caso contrário, nenhum tipo de coleção é melhor e o resultado é ambíguo.

public void M(ReadOnlySpan<int> ros) { ... }
public void M(Span<int?> span) { ... }

M([]); // Ambiguous

Cenários:

Em inglês sem formatação, os próprios tipos de coleção devem ser iguais, ou inequívocamente melhor (ou seja, List<T> e List<T> são iguais, List<T> é inequívocamente melhor do que IEnumerable<T>, e List<T> e HashSet<T> não podem ser comparados), e as conversões de elementos para o melhor tipo de coleção também devem ser iguais ou melhores (ou seja, não podemos decidir entre ReadOnlySpan<object> e Span<string> para [""], o usuário precisa tomar essa decisão). Mais exemplos disso são:

Perguntas abertas

Até que ponto devemos priorizar ReadOnlySpan/Span em relação a outros tipos?

Conforme especificado hoje, as seguintes sobrecargas seriam ambíguas:

C.M1(["Hello world"]); // Ambiguous, no tiebreak between ROS and List
C.M2(["Hello world"]); // Ambiguous, no tiebreak between Span and List

C.M3(["Hello world"]); // Ambiguous, no tiebreak between ROS and MyList.

C.M4(["Hello", "Hello"]); // Ambiguous, no tiebreak between ROS and HashSet. Created collections have different contents

class C
{
    public static void M1(ReadOnlySpan<string> ros) {}
    public static void M1(List<string> list) {}

    public static void M2(Span<string> ros) {}
    public static void M2(List<string> list) {}

    public static void M3(ReadOnlySpan<string> ros) {}
    public static void M3(MyList<string> list) {}

    public static void M4(ReadOnlySpan<string> ros) {}
    public static void M4(HashSet<string> hashset) {}
}

class MyList<T> : List<T> {}

Até onde queremos ir? A variante List<T> parece razoável, e os subtipos de List<T> existem em abundância. Mas a versão HashSet tem semântica muito diferente, quão certo temos de que é realmente "pior" do que ReadOnlySpan nesta API?