Android 带有vararg参数和convert数组的kotlin引用函数<；挂牌上市<；出来

我是基于这个话题提出这个问题的

所以，我想提前问一下。 有人用数组和列表回答了这个问题

Class Test<T,V>{
   var functionPara :(()->T)? = null
   var recallFunctionWithFunction:( (Array<out T>) -> V)? = null

   constructor(value: ()->T, recallFunctionWithFunction:   (Array<out T>) -> V  ){
   this.functionPara = value
   this.recallFunctionWithFunction = recallFunctionWithFunction
}
inline fun <reified T, V> compose(crossinline f: (Array<out T>) -> V, vararg g: () -> T): () -> V {
val results = g.map { it() }
return { f(results.toTypedArray()) }
}

fun <T, V> compose(f: (List<out T>) -> V, vararg g: () -> T): () -> V {
val results = g.map { it() }
return { f(results) }
}
}
fun runCompose(){
compose(functionPara,recallFunctionWithFunction).invoke()
}

类测试{
var functionPara:（（）->T）？=null
var recallFunctionWithFunction:（（数组）->V）？=null
构造函数（值：（）->T，recallFunctionWithFunction:（数组）->V）{
this.functionPara=值
this.recallFunctionWithFunction=recallFunctionWithFunction
}
内联fun compose（交叉内联f:（数组）->V，vararg g:（）->T:（）->V{
val results=g.map{it（）}
返回{f（results.toTypedArray（））}
}
有趣的组合（f:（列表）->V，vararg g:（）->T:（）->V{
val results=g.map{it（）}
返回{f（结果）}
}
}
有趣的写作{
编写（functionPara，recallFunctionWithFunction）.invoke（）
}

但是我发现当我引用一个带有vararg参数的函数时

fun functionA(vararg :Observable<Any>):LiveData<Boolean>{
}
fun functionB():Observable<Any>{
}

fun函数（vararg:observeable）：LiveData{
}
fun functionB（）：可观察{
}

当我执行：：function之类的操作时，A的类型将是

Array->LiveData

，因此，当我执行类似的操作时

Test（：：functionB，：：function）.runCompose（）

情景1 如果将compose函数与accepting List type一起使用，它将显示由于referencement:：function返回数组而导致的类型不匹配

情景2 如果我将compose函数用于接受数组类型，它将显示错误

无法将“T”用作具体化的类型参数。改用类

---

在上一篇文章中，有人回答我将数组转换为列表。但是如何将带有vararg参数的引用函数转换为原始

Array由于类型擦除，无法将列表转换为类型化数组。我认为最简单的方法是在任何地方使用
List

class Test<T, V>(val recallFunctionWithFunction: (List<T>) -> V, val functionPara: () -> T) {

    inline fun compose(crossinline f: (List<T>) -> V, vararg g: () -> T): () -> V {
        return { f(g.map { it.invoke() }) }
    }

    fun runCompose() {
        compose(recallFunctionWithFunction, functionPara).invoke()
    }
}

fun functionA(l: List<Observable<Any>>): LiveData<Boolean> {
...
}
fun functionB(): Observable<Any> {
...
}

类测试（val-recallFunctionWithFunction:（List）->V，val-functionPara:（）->T）{
内联有趣的组合（交叉内联f:（列表）->V，vararg g:（）->T:（）->V{
返回{f（g.map{it.invoke（）}）}
}
有趣的写作{
编写（recallFunctionWithFunction，functionPara）.invoke（）
}
}
趣味功能（l:列表）：LiveData{
...
}
fun functionB（）：可观察{
...
}

另一个解决方案

class Test<T, V>(
    val recallFunctionWithFunction: (Array<out T>) -> V,
    val functionPara: () -> T,
    val clazz: Class<T>
) {

    companion object {
        inline fun <reified T, V> create(
            noinline recallFunctionWithFunction: (Array<out T>) -> V,
            noinline functionPara: () -> T
        ) = Test(recallFunctionWithFunction, functionPara, T::class.java)
    }

    inline fun compose(crossinline f: (Array<out T>) -> V, vararg g: () -> T): () -> V {
        return {
            @Suppress("UNCHECKED_CAST")
            val arr = java.lang.reflect.Array.newInstance(clazz, g.size) as Array<T>
            g.forEachIndexed { index, fg -> arr[index] = fg.invoke() }
            f(arr)
        }
    }

    fun runCompose() {
        compose(recallFunctionWithFunction, functionPara).invoke()
    }
}

...
val t = Test.create(::functionA, ::functionB)
t.runCompose()

类测试(
val recallFunctionWithFunction:（数组）->V，
val functionPara:（）->T，
瓦尔·克拉兹：课堂
) {
伴星{
内联乐趣创建(
noinline recallFunctionWithFunction:（数组）->V，
noinline函数para:（）->T
)=测试（重新调用FunctionWithFunction、functionPara、T:：class.java）
}
内联fun compose（交叉内联f:（数组）->V，vararg g:（）->T:（）->V{
返回{
@抑制（“未选中的_CAST”）
val arr=java.lang.reflect.Array.newInstance（clazz，g.size）作为数组
g、 ForAchineDexed{index，fg->arr[index]=fg.invoke（）}
f（arr）
}
}
有趣的写作{
编写（recallFunctionWithFunction，functionPara）.invoke（）
}
}
...
val t=测试。创建（：：function，：：functionB）
t、 runCompose（）
它不起作用。因为当我调用Test（：：functionB，：：function）.runCompose（）时：：functionB是Array>-->LiveData而不是list，vararg的函数引用是Array@yuk，正如我所说的，在
function
中也使用list而不是varargs和Array。还添加了另一个解决方案它很有效！！！！非常感谢，但我想是否有更简单的方法。