Eu quero criar funções de extensão para classes que encapsulam simplesNumbers. Por exemploDoubleProperty. Eu encontrei o problema, que não consigo sobrecarregar o+ e a+= operador ao mesmo tempo.

Não quero criar um comportamento que passe nos seguintes testes:

class DoublePropertyTest {
    lateinit var doubleProperty: DoubleProperty

    @Before
    fun initialize() {
        doubleProperty = SimpleDoubleProperty(0.1)
    }

    @Test
    fun plus() {
        val someProperty = doubleProperty + 1.5
        assertEquals(someProperty.value, 1.6, 0.001)
    }

    @Test
    fun plusAssign() {
        val someProperty = doubleProperty
        doubleProperty += 1.5 //error if + and += are overloaded

        assert(someProperty === doubleProperty) //fails with only + overloaded
        assertEquals(doubleProperty.value, 1.6, 0.001)
    }
}

Pode ser implementado usando estas funções de extensão:

operator fun ObservableDoubleValue.plus(number: Number): DoubleProperty 
    = SimpleDoubleProperty(get() + number.toDouble())

operator fun WritableDoubleValue.plusAssign(number: Number) 
    = set(get() + number.toDouble())

O problema é que, se+ é substituído pelo+= não pode ser sobrecarregado também:

Assignment operators ambiguity. All these functions match.
- public operator fun ObservableDoubleValue.plus(number: Number): DoubleProperty
- public operator fun WritableDoubleValue.plusAssign(number: Number): Unit

Se eu apenas sobrecarregar o+ operador, um novoDoubleProperty objeto é retornado em+= operações em vez da inicial.

Existe uma maneira de contornar essa limitação?