Kotlin Infix功能带有仿制药

Question

尝试编写一个简单的Kotlin Infix函数以进行加操作。通用类型怎么了？

infix fun <T : Number> T.myPlus(that: T): T = this + that

Answer 1

正如其他人提到的那样，由于各种原因，没有使用仿制药的解决方案。您必须为每种数字类型（字节，短，int，long，float，double）定义一个扩展功能。例如，您可以这样做：

when (that) {
    is Byte, is Short, is Int, is Long -> that.toLong().plus(this)
    is Float -> that + this
    is Double -> that + this
    else -> throw Exception("Types mismatch")
}

即使这样做，在某些情况下，您还需要决定是否要截断或围绕结果。

val n1 = 1230000000000000000L
val n2 = 123.7

这种情况（n1是长的，n2是浮点）可以像这样处理：

is Float -> this + that.toLong()

导致12330000000000000123

，或者可以这样处理：

is Float -> this.toFloat() + that

导致1.23E18中。

Answer 2

您忘记了运算符关键字：

infix运算符fun t.plus（that：t）：t = t = this + tht that

edit：

infix fun Number.infixPlus(that: Number): Number =
  when (that) {
    is Int    -> this.toInt() + that
    is Long   -> this.toLong() + that
    is Float  -> this.toFloat() + that
    is Double -> this.toDouble() + that
    else      -> throw Exception()
  }

val n1 = 123
val n2 = 123.456

val result = n1 infixPlus n2

println("result: " + result)

println("is Int: " + (result is Int))
println("is Long: " + (result is Long))
println("is Float: " + (result is Float))
println("is Double: " + (result is Double))

Answer 3

更多的铸造安全性：

infix fun Number.infixPlus(that: Number): Number {
    return when {
        this is Int && that is Int -> this + that
        this is Double && that is Double -> this + that
        this is Float && that is Float -> this + that
        else -> throw Exception("Types mismatch")
    }
}

上述。示例args：

val n1 = 1230000000000000000L
val n2 = 123

val result = n1 infixPlus n2
result: -1313144709

没有例外和错误结果。

Answer 4

您必须找到结果的正确类型：

val types = listOf("Double", "Float", "Long", "Integer", "Short", "Byte")
infix fun <T : Number> T.myPlus(that: T): T {
    return when(types[min(types.indexOf(this.javaClass.simpleName), types.indexOf(that.javaClass.simpleName))]) {
        types[0] -> (this.toDouble() + that.toDouble()) as T
        types[1] -> (this.toFloat() + that.toFloat()) as T
        types[2] -> (this.toLong() + that.toLong()) as T
        types[3] -> (this.toInt() + that.toInt()) as T
        types[4] -> (this.toShort() + that.toShort()) as T
        types[5] -> (this.toByte() + that.toByte()) as T
        else -> throw IllegalArgumentException()
    }
}