A modern programming language that makes developers happier.

kotlinlang

Why it isn't possible to use `*doubleArrayOf(1.0, 2.0)`?

It should be possible, if you assign it to a `vararg`.

though this is usually a code smell if you’re using this at the call site of a vararg function

I have a DoubleArray and a function that takes `vararg Double`

Works fine for me
```
fun test2() {
    val nums = doubleArrayOf(1.0, 2.0)
    test1(*nums)
    test1(*doubleArrayOf(1.0, 2.0))
}

fun test1(vararg nums: Double) {
    println(nums.contentToString())
}
```

there must be something else we’re missing because I can definitely do what you’ve described
```
fun foo(vararg doubles: Double) {

}

fun bar(doubleArray: DoubleArray) {
  foo(*doubleArray)
}
```

Maybe this is the new IntelliJ compile testing?

I remember there's a compiler inference of some sort that was enabled only in IntelliJ, but not in gradle

I'll double check what I'm doing one more time. A dummy attempt worked:

image.png

Perhaps it's because it's a Java vararg function?

Should be possible:
<https://kotlinlang.org/docs/reference/java-interop.html#java-varargs>

Is the java constructor `Double...` or `double...`? The first will take `Array&lt;Double&gt;`, the second `DoubleArray`.

But specifically with double it's not working

It's to be used in hamcrrst Matchers.hasItems(*myDoubles)

It works for `double...` for me, but `Double...` requires `*arrayOf(1.0, 2.0, ...)`

<@UB9K6R4JH> That's a generic function, so it will require the object type, not the primitive (i.e. `Double...` instead of `double...`, and thus `*arrayOf(...)` instead of `*doubleArrayOf(...)`).