Is there a way to reuse variables in Kotlin in static functions in multiple calls?

I just found that function params are not mutable in Kotlin. I was expecting mutability with no mention of this in official documentation I found. Personally I think there should be some way to reuse a single variable across multiple static functions in Kotlin. How can this be with immutable params? I am trying for not returning values used, just arrays, reuse values like index of it or same variable used in different functions not needing access to data from other functions. Like in other languages a data thing can be passed around and used but maybe not read in other functions, but it supports writing a thing and using it within scope of a static function.

I have tried Kotlin playground, I expected a var param thing, none present. I tried arrays and lists and found in Kotlin playground, members may be set but not origin array or list. My question is whether this would compile or not. With that I could rig all variables to be in arrays or lists and set as I please. Anyway, question is: how can a set of static functions in Kotlin reuse a variable or variables like var in multiple calls? This is for efficiency sake, more variables, more garbage collection, slower programs, and I would prefer a faster program.

Kotlin doesn't support passing function arguments by a reference. Arguments are always copied. It is not supported by the main target platforms of Kotlin as well: Java and JavaScript.

If you really want to do this, you can create a simple wrapper and pass it around:

fun test(value: Wrapper<String>) {
	value.value = "foo"
}

data class Wrapper<T>(var value: T)

However, this is not really a "Kotlin way". In languages like Kotlin or Java we assume functions/methods receive arguments and they return new values. We can modify passed objects and if the name of the function clearly mentions this, this is not considered a bad practice. But returning results through arguments or replacing variables of the caller, is more typical to languages like C, than Kotlin/Java. I believe Kotlin/Native has some support for pointers, so it could be possible there.

From what I understand, any object with a property can have that property reused including like Array and List and IntArray. This is not a preferred way in Kotlin though and as Louis Wasserman said it may be a negative impact to performance.

As I understand it, a preferred way would be to have a class with a companion object and inside that companion object have a var thing and a function that uses that var thing. If I like want static functions and variables, use @JvmStatic to annotate all that should be static. I know that in Java equivalents first and second work, first is slower, second is faster.

Only problem with second is that only one function call may be done at once per variable. One fix for this could be use different variables per each function. I found that arrays and lists change based on function calls and stay changed outside of function calls, val or not.

fun test(x:DoubleArray):DoubleArray {
    x[0]+=2.0;
    return x;
    //Works here at least on JVM
}

fun main() {
     ar:DoubleArray=DoubleArray(2);
    println(test(ar)[0]);
    println(ar[0]);
    //Both print 2.0 on JVM
    println(ar[1]);
}

class Test private constructor(){
    companion object {
        var variable:Double = 0.0;
        fun test() {
            Test.variable=2.0;
        }
    }
}

That first one is how using an array or list part would be allowed. Second is how to do a static variable usage. I tested and both work on all platforms I could use on Kotlin Playground.

For reusing variables, using a static list or maybe an array and passing an index of static variables to use would allow async for static variables. As some may be lower index done first, a which is a free variable may be needed. In my experience, in Java function speed ranks in following order: regular not static slower, static that changes its parameters middle, static functions that only change static variables fastest. I may try middle for simplicity sake but for fastness sake, use a static list and variable ticket system. Like this:

class XE private constructor() {
    companion object {
        @JvmStatic
        var ints:IntArray=IntArray(1);
        @JvmStatic
        var freeInts:BooleanArray=BooleanArray(1){true};
        @JvmStatic
        fun test(Int ticket=0) {
            XE.freeInts[ticket]=false;
            XE.ints[ticket]=2;
            //Use ints[ticket]
            XE.freeInts[ticket]=true;
        }
        @JvmStatic
        fun getTicket(free:BooleanArray):Int{
            Int index = 0;
            while (!free[index]&&index!=free.size) {
                index+=1;
            }
            return index;
        }
    }
}

For this, a get first ticket available should be. I know this compiles, I tried on Kotlin Playground, all platforms I could. Like my tests in Kotlin Playground exclude JS IR and Wasm but all other platforms currently (JVM, JS, Canvas) were tested in.