Котлин: обработка звездных дженериков с помощью токенов типов

Как правило, код, который понимает логику внутри Gen и выполняет непроверяемые приведения, должен быть «близок» к нему. Это может быть функция-член или функция расширения, предоставляемая тем же компонентом. Во многих случаях нет необходимости использовать какие-либо сложные способы обеспечения безопасности типов, поскольку код, выполняющий непроверяемое приведение типов, уже дважды проверен разработчиком на корректность.

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

Если нам нужно предоставить типобезопасную функцию doSomething для пользователей Gen, мы можем легко ее реализовать:

fun Gen<*>.doSomethingIfMatches(x: Any) {
    if (token == x::class) {
        @Suppress("UNCHECKED_CAST")
        (this as Gen<Any>).doSomething(x)
    }
}

Если мы реализуем внутреннюю функцию, близкую к Gen, то есть нас, как правило, устраивает непроверяемое приведение типов, но мы хотели бы ограничить нетипизированный код только началом функции, а затем следовать типобезопасным кодом, мы можем сделать универсальная функция и используйте T как «динамический тип»:

fun <T : Any> m(g: Gen<*>, x: T) {
    if (g.token == x::class) {
        @Suppress("UNCHECKED_CAST")
        g as Gen<T>
        g.doSomething(x)
        g.doSomething(8) // compile error
    }
}

Если у нас есть несколько функций, потребляющих или возвращающих X, и нам нужна утилита для переключения из среды нетипизированного кода в типизированную, мы можем сделать это:

fun main() {
    val g: Gen<*> = Gen(String::class)
    g.asTypedOrNull<String>()?.doSomething("hello") // executes
    g.asTypedOrNull<Int>()?.doSomething(42) // doesn't execute
}

@Suppress("UNCHECKED_CAST")
inline fun <reified T : Any> Gen<*>.asTypedOrNull(): Gen<T>? = (this as Gen<T>).takeIf { token == T::class }

Обратите внимание, что в отличие от других примеров, в приведенном выше примере используется тип времени компиляции, а не тип времени выполнения.

Если нам нужно основывать логику на типах времени выполнения, мы могли бы подумать об утилите, которая принимает лямбда-выражение и выполняет его условно, передавая Gen и x соответствующих типов. Однако я не знаю, как представить такой логин в Котлине. Это должно быть что-то похожее на:

fun main() {
    val g: Gen<*> = Gen(String::class)
    g.ifMatches("hello") { doSomething(it) } // executes
    g.ifMatches(42) { doSomething(it) } // doesn't execute
}

inline fun Gen<*>.ifMatches(x: Any, block: <T> Gen<T>.(T) -> Unit): Unit { // syntax error
    if (token == x::class) {
        @Suppress("UNCHECKED_CAST")
        (this as Gen<T>).block(x as T)
    }
}

Но, очевидно, это не компилируется. Мы не можем сделать весь ifMatches универсальным, потому что таким образом вызывающий элемент управляет T, а это не то, что нам нужно.

Думаю, благодаря Бруту я нашел решение, которое искал.

interface TypedCode {
    fun <T : Any> Gen<T>.invoke(value: T) {
}

fun Gen<*>.runIfMatches(value: Any, code: TypedCode) {
    if (token == value::class) {
        this as Gen<Any>
        with(code) { invoke(value) }
    } 
}

fun main() {
    val g: Gen<*> = Gen(String::class)
    val a: Any = "hello"
    g.runIfMatches(a, object : TypedCode {
        override fun <T : Any> Gen<T>.invoke(value: T) {
            doSomething(value) // compiles and executes
        }
    })
    g.runIfMatches(a, object : TypedCode {
        override fun <T : Any> Gen<T>.invoke(value: T) {
            doSomething(8) // does not compile
        }
    })
    g.runIfMatches(8, object : TypedCode {
        override fun <T : Any> Gen<T>.invoke(value: T) {
            doSomething(value) // compiles but does not execute
        }
    })
}

Функция runIfMatches инкапсулирует гарантии, предоставляемые токеном типа среды выполнения, в (обязательно) небезопасный код. Бизнес-логика отделена от этого и работает в безопасной среде.

Синтаксически это не идеально, но, вероятно, это ограничение языка.