useRequest 强类型提示

[junerver]

过去函数的顶级抽象是：

internal typealias TParams = Array<Any?>
internal typealias NormalFunction<TData> = (TParams) -> TData

粗放的使用 Any 类型来作为参数，存在一些弊端，例如在 useRequest、useDebounceFn、useThrottleFn这些使用场景下，由于没有类型提示，很容易传错数值，亦或错误的在闭包中进行类型转换，这些对于项目而言都是不安全因素。

当然，使用 Array<Any?> 抽象参数也是存在优势的，例如可以通过简单的扩展，实现类似原始函数调用的效果：

operator fun <TData> NormalFunction<TData>.invoke(vararg params: Any?) = this(arrayOf(*params))

operator fun VoidFunction.invoke(vararg params: Any?) = this(arrayOf(*params))

这样即可将原本需要通过 arrayOf 传递的参数进行解包装，用户使用时观感接近于原始函数的使用。

在阅读了 Arrow-kt 代码后我改变了一些想法，例如完全可以使用元组类型来抽象参数，那么只需要添加：

operator fun <R> ((None) -> R).invoke() = this.invoke(None)
operator fun <P1, R> ((Tuple1<P1>) -> R).invoke(p1: P1) = this.invoke(tuple(p1))

一样可以保障生成的高阶函数，在使用时的易用性

这会造成一些破坏性的更新，需要添加参数的声明，当然这完全可以通过先声明参数类型是 Array<Any?> 来减少业务代码的变更，然后逐步的使用元组进行替换。

我将在 feat/refactor_TParams 开始逐步修改这一功能

相似问题：#22

[junerver]

使用强类型提示可能会造成， 解构的run函数在不传参数时使用默认参数 这一特性失效，这很好理解，过去不传递参数时使用的是 emptyArray() ，它的类型匹配可以 Array<Any?>。

所以即使只有一个外部参数的情况下也推荐使用 TupleN 来作为函数的参数类型，这样可以通过下面的代码，实现无参数时使用默认参数的特性：

inline operator fun <reified P : Tuple, R> ((P) -> R).invoke() = this.invoke(
    when {
        P::class == None::class -> tuple()
        P::class == Tuple1::class -> tuple(None)
        P::class == Tuple2::class -> tuple(None, None)
        P::class == Tuple3::class -> tuple(None, None, None)
        P::class == Tuple4::class -> tuple(None, None, None, None)
        P::class == Tuple5::class -> tuple(None, None, None, None, None)
        P::class == Tuple6::class -> tuple(None, None, None, None, None, None)
        P::class == Tuple7::class -> tuple(None, None, None, None, None, None, None)
        P::class == Tuple8::class -> tuple(None, None, None, None, None, None, None, None)
        P::class == Tuple9::class -> tuple(None, None, None, None, None, None, None, None, None)
        else -> {
            throw IllegalArgumentException("TupleN only support up to 9 parameters")
        }
    } as P,
)

[junerver]

强烈推荐使用 TupleN 来作为函数参数容器，它可以带来如下便捷的优势：

1. 类型安全
2. 使用 tuple 函数快速创建元组对象
3. 默认参数便捷请求

val (repoInfoState, loadingState, errorState, request) = useRequest(
    requestFn = { it: Tuple2<String, String> -> // 显示声明函数的参数为元组类型，保障参数类型安全
        NetApi.repoInfo(it.first, it.second) // 直接使用元组成员作为参数传递
    },
    optionsOf = {
        println("Configure closure execution!")
        manual = true
        defaultParams = tuple("junerver", "ComposeHooks") // 使用 tuple 函数包装默认参数
    },
)
Row {
    Text(text = "Manual:")
    TButton(text = "request with default") {
        request()
    }
    TButton(text = "request with error params") {
        request("unknow", "unknow")
    }
}

[junerver]

使用强类型还会导致无参数函数无法在不配置 defaultParams 的情况下进行 自动请求，原因与上面是类似的。

过去可以通过 var defaultParams: TParams = emptyArray() 的方式来保障默认参数不为空，使用强类型则必须手动声明默认参数，例如：

val (dataState, loadingState) = useRequest(
    requestFn = {
        mockRequestArticle()
    },
    optionsOf = {
        defaultParams = None // 无参数的自动请求也必须声明默认参数
        this.cacheKey = cacheKey
        staleTime = 5.seconds
    },
)