Seems like there's no lowering / optimization for destructing array declaration of same data type. `...

# announcements

[Animesh Sahu]

Seems like there's no lowering / optimization for destructing array declaration of same data type.

var (e, f, c, d) = arrayOf(1, 10, 12, 55)

Seems to decompile to:

Integer[] var6 = new Integer[]{5, 44, 34};
boolean var8 = false;
int var2 = ((Number)var6[0]).intValue();
var8 = false;
int var3 = ((Number)var6[1]).intValue();
var8 = false;
int var4 = ((Number)var6[2]).intValue();
var8 = false;
int d = ((Number)var6[3]).intValue();

Is there a workaround to declare multiple variables concisely but also with an efficient handling performance wise?

[bombe]

I don’t think there is. I also don’t think there needs to be because frankly, code like var (a, b, c, d, e, f, g) = arrayOf(612, 7652, 721, 67552, 6756, 1235, 75465) would fail a code review so fast you’d get whiplash. 🙂

[Nir]

Is the code generated for destructuring a dataclass efficient? I'd assume it's better

[Nir]

In that case you could write tuples of various sizes and a function that creates then

[Animesh Sahu]

@Nir Yea, its better, but I think creating thousands of dataclasses is overkill here, as the bytecode increases by a huge amount for every data class (all methods like component, toString, copy, etc are generated)

[Nir]

Thousands?

[Nir]

You mean like ten?

[Animesh Sahu]

Still overkill, as an example for 3 ints, its different for 2 int we need different, for double its like....

[Nir]

You only need one tuple class for each ariness

[Nir]

Tuple2, Tuple2, Tuple3, etc

[Nir]

(generic)

[Nir]

And then overloaded tuple functions

[Nir]

Annoying but its a one time cost of maybe 50 lines of code

[Nir]

IMHO Kotlin should really have kept built in tuples.. necessary for things like zip

[Animesh Sahu]

If its generic, there is no difference between this array method, since the types are boxed 😛

[Nir]

I don't know exactly what goes on in the JVM but there's still a huge difference

[Nir]

In one case you know at compile time how many values there are

[Nir]

As opposed to a dynamically sized array