由于类型不能在语言中表示，因此使用返回类型推断：

class Example {
    private fun findUsers(instanceWrapper: ExceptionInstanceWrapper) =
        object {
            val sender = userCrud.findOne(instanceWrapper.fromWho)
            val receiver = userCrud.findOne(instanceWrapper.toWho)
        }

    fun foo() = findUsers(ExceptionInstanceWrapper()).sender
}

另一种选择是设计一个数据类：

class Example {
    private data class Users(val sender: User, val receiver: User)
    private fun findUsers(instanceWrapper: ExceptionInstanceWrapper): Users {
        return Users(
            sender = userCrud.findOne(instanceWrapper.fromWho),
            receiver = userCrud.findOne(instanceWrapper.toWho)
        )
    }

    fun foo() = findUsers(ExceptionInstanceWrapper()).sender
}

只需将函数定义为lambda即可。
下面是我在另一个上下文中编写的简单对象：

private val Map = {
    val data = IntArray(400)

    for (index in data.indices) {
        data[index] = index * 3
    }

    object {
        val get = { x: Int, y: Int ->
            data[y * 20 + x]
        }
    }
}

fun main() {
    val map = Map()
    println(map.get(12,1))
}

不幸的是，你不能赋值类型名，所以它只能作为返回值而不能作为参数。也许他们会使这成为可能，这样我们就可以最终使用OOP JS风格了。
或者，它们可以实现与函数类型等价的对象类型，但这样做可能会太冗长。然后，您可以使用typedef，但这实际上只是一种类定义😅

另一种选择是为返回类型创建一个泛型类：

data class OutVal<T>(private var v: T?) {
    fun set(newVal: T) {
        v = newVal
    }

    fun get() = v
}

用法示例：

private fun findUsers(instanceWrapper: ExceptionInstanceWrapper,
                      sender: OutVal<String>, receiver: OutVal<String>) {
        sender.set(userCrud.findOne(instanceWrapper.fromWho))
        receiver.set(userCrud.findOne(instanceWrapper.toWho))
}

val sender = OutVal("")
val receiver = OutVal("")
findUsers(instanceWrapper, sender, receiver)
sender.get() // ...
receiver.get() // ...