Me gusta la sintaxis += de kotlin para las listas. Es una notación concisa e intuitiva.

Pero recientemente descubrí un caso extremo, en el que sospecho que el compilador tiene errores.

java.nio.file.Path se define recursivamente public interface Path extends Iterable<Path>, ... Y eso parece causar problemas para el plus operator de Iterable en kotlin-stdlib .

 private val abc = Path.of("/tmp/abc.txt") private val def = Path.of("/tmp/def.txt") @Test fun `plus operator List Path`() { var list = emptyList<Path>() list += listOf(abc) list += def // (*) should not compile list.asClue { // oops. red bar. it shouldBe listOf(abc, def) } }

La prueba falla con:

 Elements differ at index 1: [\tmp\abc.txt, tmp, def.txt]

En mi opinión, la línea marcada con (*) ni siquiera debería compilarse, ya que no está claro cuál de las siguientes sobrecargas está destinada

• operador divertido Iterable.plus (elemento: T)
• operador divertido Iterable.plus(elementos: Iterable)

Tenga en cuenta que para plusAssign operator MutableList en la compilación MutableList se rechaza correctamente.

 @Test fun `plusAssign operator MutableList Path`() { val list = mutableListOf<Path>() list += listOf(abc) // does not compile, which is good // list += def // (**) list shouldBe listOf(abc) }

La línea marcada con (**) es ambigua para

• operador divertido MutableCollection.plusAssign(elemento: T)
• operador divertido MutableCollection.plusAssign(elementos: Iterable)