到目前为止给出的所有答案都是100%正确的，但是既然你有只引用val而不调用函数的想法，我想这可能是一个有用的补充，提到property delegation的可能性。你可以提出一个像这样的委托人：

class StringTemplateDelegate(private val producer: () -> String) {
    private var fixedString: String? = null
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return fixedString ?: producer()
    }
    
    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        fixedString = value
    }
}

fun dynamicTemplate(producer: () -> String) = StringTemplateDelegate(producer)

然后像这样使用它：

val param = mutableListOf("a")
val paramString by dynamicTemplate { "${param[0]}" }
print(paramString) // prints 'a'
param[0] = "b"
print(paramString) // prints 'b'

here是KotlinPlayground上可运行的示例，供您尝试或编辑。
备注：
1.虽然我将委托命名为' StringTemplateDelegate '和提供程序函数' dynamicTemplate '，但是这个实现并不特定于字符串甚至字符串模板。将String类型替换为泛型，您就有了一个委托，每当访问提供程序函数的值时，它就执行该函数。
1.我对委托进行了编码，以便它在技术上也可以用作var，如果您要重新分配它，它将只具有您重新分配给的常量值。这是一个值得怀疑的功能，但它演示了委托如何也可以用于var。

这个想法很有趣，但这不是我所知道的任何语言中的语言特征。关键的问题是程序如何决定备份信息是否已更改，因此必须重新计算，除非您希望在每次访问时计算它。
如果你希望每次访问都更新它，那么你要寻找的是一个函数，因为Strings是不可变的，因此在创建后不能更改。因此，除非你改变paramString引用，否则它下面的值将始终保持不变。（你可以在这方面作弊，但我强烈反对这样做，因为它会有意想不到的副作用，并且不是在任何情况下都可靠地工作）
但是，您可以创建一个DynamicStringTemplate类来实现这一点，但是，每次访问都必须重新计算。我曾经为JUnit测试构建过类似的东西，在那里我需要动态构建Strings来进行比较，但是我使用双问号作为占位符，并根据索引从列表中动态插入值。这是一个有点不那么漂亮，你正在寻找的，但会做的工作，在大多数简单的情况下。
你也可以这样做，尽管遗憾的是，它没有附带你喜欢的花哨模板语法：

class DynamicStringTemplate private constructor() {
    private val elements = ArrayList<Any>()
    override fun toString(): String = get()

    fun get(): String {
        val state = StringBuilder()
        for (element in elements) {
            if (element is Function0<*>) {
                state.append(element.invoke())
            } else {
                state.append(element)
            }
        }
        return state.toString()
    }

    fun append(element: Any): DynamicStringTemplate {
        elements += element
        return this
    }

    operator fun plus(element: Any): DynamicStringTemplate = append(element)
    operator fun invoke(): String = get()

    companion object {
        fun dynTemplate() = DynamicStringTemplate()
        fun dynTemplate(builder: () -> String): DynamicStringTemplate = dynTemplate(builder as Any)
        fun dynTemplate(vararg element: Any): DynamicStringTemplate {
            val template = DynamicStringTemplate()
            template.elements.addAll(element)
            return template
        }
    }
}

下面是一些测试用例来展示它是如何工作的：

@Test
fun test_MonolithicLambdaBuilder() {
    val list = arrayListOf(1, "b", null)
    val template = dynTemplate { "My list contains $list." }
    assertEquals(template(), "My list contains [1, b, null].")
    list[2] = "42"
    assertEquals(template(), "My list contains [1, b, 42].")
}

// This might be the most interesting case for you...
@Test
fun test_NoValueCaptureInKotlin() {
    var a = "a"
    val template = dynTemplate { "My value is $a." }
    assertEquals(template(), "My value is a.")
    a = "b"
    assertEquals(template(), "My value is b.")
}

@Test
fun test_ChainBuilder() {
    val list = arrayListOf(1, "b", null)
    val template = dynTemplate("My list contains ") + list + "."
    assertEquals(template(), "My list contains [1, b, null].")
    list[2] = "42"
    assertEquals(template(), "My list contains [1, b, 42].")
}

@Test
fun test_VarargBuilder() {
    val list = arrayListOf(1, "b", null)
    val template = dynTemplate("My list contains ", list, ".")
    assertEquals(template(), "My list contains [1, b, null].")
    list[2] = "42"
    assertEquals(template(), "My list contains [1, b, 42].")
}

@Test
fun test_Callbacks() {
    var counter = 0
    val template = dynTemplate("This template was called ", { ++counter }, " times.")
    assertEquals(template(), "This template was called 1 times.")
    assertEquals(template(), "This template was called 2 times.")
    assertEquals(template(), "This template was called 3 times.")
}

@Test
fun test_MonolithicCallback() {
    var counter = 0
    val template = dynTemplate { "This template was called ${ ++counter } times." }
    assertEquals(template(), "This template was called 1 times.")
    assertEquals(template(), "This template was called 2 times.")
    assertEquals(template(), "This template was called 3 times.")
}

这还有一个额外的好处，就是您可以通过将模板对象传递给其他函数（如配置求值器）来操作模板对象。

val paramString = "${param[0]}"
paramString是不可变的变量，没有办法改变它。
也许，你可以尝试function way做你想做的事情。
就像这样：

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

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

/* Output: 
hello world
hello stackoverflow
*/

希望能帮上忙。