Try to write a simple Kotlin infix function for plus operation. What's wrong with generic type?
infix fun <T : Number> T.myPlus(that: T): T = this + that
-
Thx for quick reply ;) Yeah, right. How can I restrict a type for simple arithmetic operations? Extending Number seemed right design. I don't want to write a plus extension for Number.lenriq– lenriq2022-05-28 14:44:08 +00:00Commented May 28, 2022 at 14:44
-
Just for testing infix and generics.lenriq– lenriq2022-05-28 14:48:24 +00:00Commented May 28, 2022 at 14:48
-
Something like this: infix fun <T> T.infixPlus(that: T) : T where T : Int, T : Double, T : Float = (this + that) as Tlenriq– lenriq2022-05-28 14:50:23 +00:00Commented May 28, 2022 at 14:50
-
1It has nothing to do with generics. You just cannot add a Number to another Number. There is no plus method defined in the abstract class Number, see kotlinlang.org/api/latest/jvm/stdlib/kotlin/-number.lukas.j– lukas.j2022-05-28 14:57:30 +00:00Commented May 28, 2022 at 14:57
-
So the best way in this stupid example is to write to separate methods for each type? // infix fun Int.infixPlus(that: Int) : Int = this + that // infix fun Float.infixPlus(that: Float) : Float = this + that // infix fun Double.infixPlus(that: Double) : Double = this + thatlenriq– lenriq2022-05-28 15:00:08 +00:00Commented May 28, 2022 at 15:00
|
Show 1 more comment
4 Answers
As others have mentioned, there's no solutions using generics for various reasons. You have to define an extension function for each Number type (Byte, Short, Int, Long, Float, Double). E.g. for Int you could do:
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")
}
Even doing that, in some cases you need to decide whether you want to truncate or round the result.
val n1 = 1230000000000000000L
val n2 = 123.7
This case (n1 is a Long, n2 is a Float) could be handled like this:
is Float -> this + that.toLong()
resulting in 1230000000000000123
or it could be handled like this:
is Float -> this.toFloat() + that
resulting in 1.23E18
Comments
You forgot the operator keyword:
infix operator fun T.plus(that: T): T = this + 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))
A bit more casting safety:
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")
}
}
In prev. example args:
val n1 = 1230000000000000000L
val n2 = 123
val result = n1 infixPlus n2
result: -1313144709
No exception and wrong result.
1 Comment
lenriq
Unfortunately it's runtime only checks.
You have to find the correct type of the result:
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()
}
}
answered May 28, 2022 at 15:59
Nongthonbam Tonthoi
13.1k7 gold badges43 silver badges68 bronze badges
Comments
