Is there anything you could do with an inline clas...

# language-proposals

[trevjones]

Is there anything you could do with an inline class that you can’t do with an inline func that returns an object: WhateverInterfaceOrClass() either way it ends up as a template for the compiler no?

[karelpeeters]

I'm not sure I'm understanding you, can you give some example code?

[trevjones]

something like:

inline fun TabLayout.onTabReselected(crossinline onTabReselected: (tab: TabLayout.Tab) -> Unit) {
    addOnTabSelectedListener(object : TabLayout.OnTabSelectedListener {
        override fun onTabReselected(tab: TabLayout.Tab) = onTabReselected(tab)

        override fun onTabUnselected(tab: TabLayout.Tab?) {}

        override fun onTabSelected(tab: TabLayout.Tab?) {}
    })
}

[trevjones]

only instead of the set

[trevjones]

just return it

[trevjones]

let me do a new one that one is bad

[trevjones]

abstract class MyInlineClass<T> {
    abstract fun someFactoryMethod(): T
}

inline fun <T> someInlineClass(crossinline someFunc: () -> T) : MyInlineClass<T> {
    return object : MyInlineClass<T>() {
        override fun someFactoryMethod(): T {
            return someFunc()
        }
    }
}

[karelpeeters]

Ah I meant inline in a "the class doesn't actually exist"-way. An example:

inline data class Point(
    val x: Int
    val y: Int
) {
    fun opposite() = Point(-x, -y) //implicit inline
    
    //generated toString, equals, ...
}
fun foo(point: Point) {
    println(point.opposite())
}

would be compiled to

fun foo(x: Int, y: Int) {
    println("Point(x=${-x}, y=${-y})")
}

[trevjones]

so like a value type?

[karelpeeters]

Well values types have pass-by-value semantics, inline classes not necessarily.

[trevjones]

seems like you save one allocation and end up with a java interop story that is a mess

[trevjones]

potentially a mess

[karelpeeters]

It can make a significant difference in high-performance situations like game physics.

[karelpeeters]

Actually Java interop wouldn't be too bad, the Java-code would just see the non-inline versions of the methods of the inline class.

[karelpeeters]

Similar to how inline extension functions work today.