Классы значений inline

Члены

Inline-классы поддерживают некоторые функции обычных классов. В частности, им разрешено объявлять свойства и функции, иметь блок init и вторичные конструкторы:

@JvmInline
value class Person(private val fullName: String) {
    init {
        require(fullName.isNotEmpty()) {
            "Full name shouldn't be empty"
        }
    }

    constructor(firstName: String, lastName: String) : this("$firstName $lastName") {
        require(lastName.isNotBlank()) {
            "Last name shouldn't be empty"
        }
    }

    val length: Int
        get() = fullName.length

    fun greet() {
        println("Hello, $fullName")
    }
}

fun main() {
    val name1 = Person("Kotlin", "Mascot")
    val name2 = Person("Kodee")
    name1.greet() // the `greet()` function is called as a static method
    println(name2.length) // property getter is called as a static method
}

Свойства inline-класса не могут иметь базовые поля. Они могут иметь только простые вычисляемые свойства (без lateinit/делегированных свойств).

Наследование

Inline-классы могут наследоваться от интерфейсов:

interface Printable {
    fun prettyPrint(): String
}

@JvmInline
value class Name(val s: String) : Printable {
    override fun prettyPrint(): String = "Let's $s!"
}

fun main() {
    val name = Name("Kotlin")
    println(name.prettyPrint()) // Still called as a static method
}

Inline-классам запрещено участвовать в иерархии классов. Это означает, что inline-классы не могут расширять другие классы и всегда являются final.

Представление

В сгенерированном коде компилятор Kotlin сохраняет обёртку для каждого inline-класса. Экземпляры inline-класса могут быть представлены во время выполнения либо как обёртки, либо как базовый тип. Это похоже на то, как Int может быть представлен либо как примитивный int , либо как обёртка Integer.

Компилятор Kotlin отдаёт предпочтение использованию базовых типов вместо обёрток для создания наиболее производительного и оптимизированного кода. Однако иногда необходимо сохранить обёртки. Как правило, inline-классы упаковываются всякий раз, когда они используются как другой тип.

interface I

@JvmInline
value class Foo(val i: Int) : I

fun asInline(f: Foo) {}
fun <T> asGeneric(x: T) {}
fun asInterface(i: I) {}
fun asNullable(i: Foo?) {}

fun <T> id(x: T): T = x

fun main() {
    val f = Foo(42) 
    
    asInline(f)    // unboxed: used as Foo itself
    asGeneric(f)   // boxed: used as generic type T
    asInterface(f) // boxed: used as type I
    asNullable(f)  // boxed: used as Foo?, which is different from Foo
    
    // below, 'f' first is boxed (while being passed to 'id') and then unboxed (when returned from 'id') 
    // In the end, 'c' contains unboxed representation (just '42'), as 'f' 
    val c = id(f)  
}

Поскольку inline-классы могут быть представлены как базовым значением, так и обёрткой, сравнение по ссылке для них бессмысленно и поэтому запрещено.

Inline-классы также могут иметь параметр обобщённого типа в качестве базового типа. В этом случае компилятор сопоставляет его с Any? или, в общем случае, с верхним пределом параметра типа.

@JvmInline
value class UserId<T>(val value: T)

fun compute(s: UserId<String>) {} // compiler generates fun compute-<hashcode>(s: Any?)

@JvmInline
value class UInt(val x: Int)

// Represented as 'public final void compute(int x)' on the JVM
fun compute(x: Int) { }

// Also represented as 'public final void compute(int x)' on the JVM!
fun compute(x: UInt) { }

@JvmInline
value class UInt(val x: Int)

fun compute(x: Int) { }

@JvmName("computeUInt")
fun compute(x: UInt) { }

Inline-классы против псевдонимов типов

На первый взгляд, inline-классы очень похожи на псевдонимы типов. Действительно, оба, похоже, вводят новый тип, и оба будут представлены как базовый тип во время выполнения.

Однако ключевое различие заключается в том, что псевдонимы типов совместимы по присваиванию со своим базовым типом (и с другими псевдонимами типов с тем же базовым типом), а inline-классы — нет.

Другими словами, inline-классы вводят по-настоящему новый тип, в отличие от псевдонимов типов, которые вводят только альтернативное имя (псевдоним) для существующего типа:

typealias NameTypeAlias = String

@JvmInline
value class NameInlineClass(val s: String)

fun acceptString(s: String) {}
fun acceptNameTypeAlias(n: NameTypeAlias) {}
fun acceptNameInlineClass(p: NameInlineClass) {}

fun main() {
    val nameAlias: NameTypeAlias = ""
    val nameInlineClass: NameInlineClass = NameInlineClass("")
    val string: String = ""

    acceptString(nameAlias) // OK: pass alias instead of underlying type
    acceptString(nameInlineClass) // Not OK: can't pass inline class instead of underlying type

    // And vice versa:
    acceptNameTypeAlias(string) // OK: pass underlying type instead of alias
    acceptNameInlineClass(string) // Not OK: can't pass underlying type instead of inline class
}

Inline-классы и делегирование

Реализация путём делегирования встроенному значению inline-класса разрешена для интерфейсов:

interface MyInterface {
    fun bar()
    fun foo() = "foo"
}

@JvmInline
value class MyInterfaceWrapper(val myInterface: MyInterface) : MyInterface by myInterface

fun main() {
    val my = MyInterfaceWrapper(object : MyInterface {
        override fun bar() {
            // body
        }
    })
    println(my.foo()) // prints "foo"
}