A compiler plugin enabling dynamic class delegation similar to property delegations, which simplifies delegation and allows functions to be 'lazy' with persistent values, enhancing flexibility and reducing boilerplate.
Kotlin compiler plugin that allows class delegation to be dynamic like property delegations.
The plugin provides:
public fun <R> dynamicDelegation(value: () -> R): R =
throw NotImplementedError("Implemented as intrinsic")
This function is implemented by the compiler. Here is an example.
Suppose this is your existing code and is published to the public:
interface CommandManager {
val commands: List<Command>
fun register(command: Command)
companion object : CommandManager {
// implement CommandManager
}
}
Suppose then you realized the CommandManager instance should not be static (statically initialized or singleton). You changed the CommandManager to this because you cannot remove code that have been published to the public:
interface CommandManager {
val commands: List<Command>
: CommandManager {
instance lazy { CommandManagerImpl() }
commands: List<Command> () = instance.commands
: = instance.register(command)
}
}
Now with Kotlin Dynamic Delegation, you can do instead:
interface CommandManager {
val commands: List<Command>
fun register(command: Command)
companion object : CommandManager by (dynamicDelegation(Companion::instance)) {
private val instance by lazy { CommandManagerImpl() }
// All delegates will be generated automatically
}
}
Alternatively, it's also possible to do this:
Functions can also be 'lazy' by making a value lazy and persistent.
override fun toString(): String = persistent { this.joinToString() } // initialize lazily once and use afterwards.
is the same as
private val toStringTemp by lazy { this.joinToString() }
override fun toString(): String = toStringTemp
build.gradle.kts
plugins {
id("me.him188.kotlin-dynamic-delegation") version "VERSION"
}
You also need to add a 'compileOnly' dependency 'me.him188:kotlin-dynamic-delegation-runtime':
For JVM projects:
dependencies {
implementation("me.him188:kotlin-dynamic-delegation:VERSION")
}
For MPP, adding to commonMain would automatically add for all targets:
kotlin.sourceSets {
commonMain {
dependencies {
implementation("me.him188:kotlin-dynamic-delegation:VERSION")
}
}
}
See VERSION from releases
IDEA plugin can help to edit code and to report errors before compiling the code. By seeing the type cast hint(see picture below), you will know, without compiling, that your code with dynamic delegations will work.
Plugin Marketplace Page: https://plugins.jetbrains.com/plugin/18219-kotlin-dynamic-delegation
interface CommandManager {
val commands: List<Command>
fun register(command: Command)
companion object : CommandManager by (dynamicDelegation { getCommandManagerImpl() }) {
// All delegates will be generated automatically
}
}
private fun getCommandManagerImpl(): CommandManager {
// This is called to get actual CommandManager instance when a member inside CommandManager.Companion is called.
if (!someChecks()) {
error("It's not the time to call CommandManager!")
}
if (someOtherChecks()) {
currentInstance = CommandManagerImpl() // Possible to update delegated instance
}
return currentInstance
}
private var currentInstance: CommandManager = CommandManagerImpl()
Surfaced from shared tags and platforms — no rankings paid for.