Underscore for unused parameters in functions

Language Design
1

For lambdas we can use the underscore character for unused parameters which is very nice.

It would be also very nice to use this feature for normal function parameters:

fun(_ : Executor, query : RfidEntryQuery) {  }

Right now, if I try this syntax I get an error about ‘_’ is reserved for Kotlin which makes it possible to add this feature without much headache (I hope).

The use case that results in this is when I pass a function reference with ‘::’

fun attach(on : HTMLElement, callback : (event : Event) -> Unit)) {  }

fun setup() {
    attach(myElement, ::handler)
}

fun handler(event : Event) {
}

If I don’t use the event in handler I get a warning which is actually useful.

However, to remove the warning, I have to add an annotation which has it’s own problems:

  • depending where the programmer puts the suppress may lead to future errors (to wide suppress means possible problems remain hidden)
  • it hurts readability
1 Like
2

It looks kind of similar to the ticket I posted before: KT-17746.

1 Like
3

Yes, it is basically the same.

4

The application of this enhancement would be much broader than the title of that ticket indicates, which might result in lower prioritization than it warrants. See my comment on the ticket, and please consider renaming/rephrasing the problem more broadly in order to get the attention of the product dev team.

5

In that case you should first provide some examples how you would imagine your usecases in a code. I couldn’t quite catch what you wanted to achieve from your comment alone.

6

I have problem understanding your comment as well. Do you mean something like this?

fun main() {
    getData(::filterOdd)
}

fun getData(filter: (Int, String) -> Boolean): List<String> {
    val list: List<String> = ...
    return list.filterIndexed(filter)
}

fun filterOdd(index: Int, _: String) = index % 2 == 1

Yes, this is another case where we are forced to accept some parameters by a function even if it doesn’t actually need them. But I wouldn’t say this broadens the use. I believe people rarely pass function references like this.

8

Additionally, I would like to see this in for loops as well:

    for (y in top ..< bottom) {
        for (x in left ..< right) {
            buf.put(scan++, r)
            buf.put(scan++, g)
            buf.put(scan++, b)
        }
        scan += nextRow
    }

The above marks y and x as unused, but the language does not allow me to replace them with underscore.

(I’m concerned with performance here, that’s why I’m not using forEach. My concern is that the nested forEach might create and destroy lambda objects for each iteration of y and therefore be less efficient. Using ranges seems more efficient, even though this is not clear either. Testing the performance is tricky, because would involve testing the effects of the garbage collector at a later time. Anyway, the exact performance of the loop is off-topic.)

9

forEach is fully inlined, so there are no lambdas in the resulting bytecode at all.

Also, I think there is less need for unused vars in loops than in functions, because if we don’t care about y then for may be not the best fit in the first place as we have repeat. Still, someone could argue that in many cases for (y in top ..< bottom) could be more bug-proof than repeat (top - bottom) (off by one bugs) and I agree.

Anyway, I agree with you. If adding unused vars to functions, it probably make sense to do the same with for loops.

2 Likes