Dynamically evaluating templated Strings in Kotlin

Question

Suppose that I have the following piece of Kotlin code:

fun main(args: Array<String>) {
    val a = "test"
    println(args.first())
}

If I pass in an argument $a, the output is going to be $a. As I understand it Kotlin takes care of String templates by generating the code for the output on compilation, presumably using a StringBuilder. Is there some way to evaluate Strings that aren't in the source code with regards to templates in their current context? String templates are very useful and it'd be great to be capable of evaluating expressions that come from a dynamic context, such as configuration files, but as far as I can tell this can't be done.

Lacking that, what would be a good approach towards this? Invoking a scripting engine?

Answer 1

If you need to evaluate arbitrary expressions in this way, then yes, you need a scripting engine. Kotlin has a JSR 223 implementation that you can use, see the examples here (the kotlin-jsr223-* projects).

Here is a basic usage example:

val engine = ScriptEngineManager().getEngineByExtension("kts")!!
engine.eval("val x = 3")
val res = engine.eval("x + 2")
Assert.assertEquals(5, res)

^{The code is taken from KotlinJsr223ScriptEngineIT.kt, and remember to configure the service via META-INF}

Answer 2

For completeness, here are also some ways to dynamically evaluate String templates in your Kotlin code.

The normal behavior of String templates is to evaluate the contents of the String at compile time. It will not change during the execution of your code:

fun main() {
    var subject = "world"
    val hello = "hello $subject"

    subject = "stackoverflow"
    println(hello)
}

// Output: hello world

There are multiple workarounds for this restriction:

Lambda function

You can wrap your String in a lambda function, so everytime you call your function, it will evaluate a new instance of the String.

fun main() {
    var subject = "world"
    val hello = {"hello $subject"}

    subject = "stackoverflow"
    println(hello())
}

// Output: hello stackoverflow

Advantage

• Support String operations

Disadvantage

• Must call it like a function

Anonymous object

You can create anonymous objects (similar to static in Java) and override the toString method.

fun main() {
    var subject = "world"
    val hello = object { override fun toString() = "hello $subject"}

    subject = "stackoverflow"
    println(hello())
}
    
// Output: hello stackoverflow

Note: I would not recommend this approach.

Advantage

• No function call needed

Disadvantage

• Does not support all String operations

Property Delegation

You can delegate property operator functions to an external class to achieve the dynamic evaluation of String templates.

import kotlin.reflect.KProperty

fun main() {
    var subject = "world"
    val hello: String by dynamicStringTemplate { "hello $subject" }

    subject = "stackoverflow"
    println(hello)
}

// Output: hello stackoverflow
 
class dynamicStringTemplate(var value: () -> String) {
    operator fun getValue(thisRef: Nothing?, prop: KProperty<*>): String {       
        return this.value()
    }
 
    operator fun setValue(thisRef:  Nothing?, prop: KProperty<*>, value: String) {
        this.value = {value}
    }
}

Advantages

• Supports all String operations
• Works the same as a String

Disadvantage

• Additional class must be created

Answer 3

Is there some way to evaluate Strings that aren't in the source code with regards to templates in their current context?

There are no template strings in your code sample and a is unused. Am I understanding correctly that you'd like to do something like val evaluated = evalStringTemplate(template, arg1, arg2, ...) with template being a String like "$a" and arg1, arg2, ... being arguments for the template?

If so, there's no Kotlin-specific way to do this, but you can use the Java Formatter class.