Kotlin: succinct way of inverting Int sign depending on Boolean value-CodePudding

I have

var x: Int
var invert: Boolean

and I need the value of the expression

if (invert) -x else x

Is there any more succinct way to write that expression in Kotlin?

CodePudding user response：

There is no shorter expression using only the stdlib to my knowledge.

This is pretty clear, though. Using custom functions to make it shorter is possible, but it would only obscure the meaning IMO.

CodePudding user response：

It's hard to tell which approach might be best without seeing more of the code, but one option is an extension function. For example:

fun Int.negateIf(condition: Boolean) = if (condition) -this else this

(I'm using the term ‘negate’ here, as that's less ambiguous: when dealing with numbers, I think ‘inverse’ more often refers to a multiplicative inverse, i.e. reciprocal.)

You could then use:

x.negateIf(invert)

I think that makes the meaning very clear, and saves a few characters. (The saving is greater if x is a long name or an expression, of course.)

If invert didn't change (e.g. if it were a val), another option would be to derive a multiplier from it, e.g.:

val multiplier = if (invert) -1 else 1

Then you could simply multiply by that:

x * multiplier

That's even shorter, though a little less clear; if you did that, it would be worth adding a comment to explain it.

(BTW, whichever approach you use, there's an extremely rare corner case here: no positive Int has the same magnitude as Int.MIN_VALUE (-2147483648), so you can't negate that one value. Either way, you'll get that same number back. There's no easy way around that, but it's worth being aware of.)

CodePudding user response：

You could create a local extension function.

Local functions are helpful when you want to reduce some repetitive code and you want to access a local variable (in this case, the invert boolean).

Local functions are particularly useful when paired with extension functions, as extension functions only have one 'receiver' - so it would be difficult, or repetitive, to access invert if invert() wasn't a local function.

fun main() {
    val x = 1
    val y = 2
    val z = 3

    var invert = false

    // this local function can still access 'invert'    
    fun Int.invert(): Int = if (invert) -this else this

    println("invert = false -> (${x.invert()}, ${y.invert()}, ${z.invert()})")

    invert = true

    println("invert = true  -> (${x.invert()}, ${y.invert()}, ${z.invert()})")
}

invert = false -> (1, 2, 3)
invert = true  -> (-1, -2, -3)