Dynamically evaluating templated Strings in Kotlin

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

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.