Selecting function reference before application: problem with type inference

Question

I want to choose function reference before applying it to arguments, but Kotlin cannot infer its type.

Suppose I have a class

class Circle(val radius: Float)

and a function

fun sortByRadius(circles: MutableList<Circle>, ascending: Boolean) {
    if (ascending)
        circles.sortBy { it.radius }
    else
        circles.sortByDescending { it.radius }
}

I want too rewrite this function body to something like this:

circles.(
    if (ascending) MutableList<Circle>::sortBy
    else MutableList<Circle>::sortByDescending
) { it.radius }

but it does not work. Also I found out that

(MutableList<Circle>::sortBy)(circles) { it.radius }

almost works, Kotlin just can not infer Float type of radius; so I wonder how to specify it. Then we could write

(if (ascending) MutableList<Circle>::sortBy
    else MutableList<Circle>::sortByDescending)(circles) { it.radius }

score 1 · Accepted Answer · answered Mar 04 '19 at 08:57

Nice question, and it doesn't seem to be possible (using function references). I've tried to specify expected type explicitly:

val f: MutableList<Circle>.((Circle) -> Float) -> Unit = 
    if (ascending) MutableList<Circle>::sortBy else MutableList<Circle>::sortByDescending

but the error message says

Type inference failed. Please try to specify type arguments explicitly.

and the grammar doesn't allow it:

callableReference
  : (receiverType? '::' (simpleIdentifier | 'class'))
  ;

i.e. :: can only be followed by an identifier or class. Which is a strange hole because Java grammar does allow type parameters before method name.

Bound references don't help either:

(circles::sortBy) { it.radius } // doesn't compile

Not even explicit type works, which quite surprised me:

val f: ((Circle) -> Float) -> Unit = circles::sortBy

but this does:

val f: ((Circle) -> Float) -> Unit = { circles.sortBy(it) }

So ultimately you can write (parentheses around lambdas required)

val f: ((Circle) -> Float) -> Unit = 
  if (ascending) ({ circles.sortBy(it) }) else ({ circles.sortByDescending(it) })
f { it.radius }

but probably not want to!

Thanks. So for some reason type inference for lambdas works better than for function references. — Pier Bezuhoff, Mar 05 '19 at 17:19

amatkivskiy · Answer 2 · 2019-03-04T07:31:18.680

0

Do not know whether I fully get your point but here what I wrote for your case:

fun main() {
    val circles = mutableListOf(
        Circle(.1f), Circle(.5f), Circle(3f)
    )

    val sortBy: (MutableList<Circle>, selector: (Circle) -> Float) -> Unit = { list, selector ->
        list.sortBy(selector)
    }

    val sortByDescending: (MutableList<Circle>, selector: (Circle) -> Float) -> Unit = { list, selector ->
        list.sortByDescending(selector)
    }

    val ascending = false
    (if (ascending) sortBy else sortByDescending)(circles) {
        it.radius
    }
    // Or maybe more clear way
    //(if (ascending) sortBy else sortByDescending).invoke(circles) {
    //    it.radius
    //}
}

Hope this will help you.

edited Mar 04 '19 at 07:31

answered Feb 21 '19 at 12:31

amatkivskiy

1,154
8
11

yeah, let me fix his, please take a look into update answer. – amatkivskiy Mar 04 '19 at 07:28
Yes, but it's a bit tiresome to wrap every single function. Especially if i use `when` with a bunch of branches instead of `if`. – Pier Bezuhoff Mar 05 '19 at 19:15

Selecting function reference before application: problem with type inference

2 Answers2