在Kotlin中使用arrow-kt处理配置传递的Reader Monad替代方案

为什么Arrow 1.x没有Reader Monad #

Arrow v1.x移除了传统的Reader Monad实现，核心原因是：

• 纯函数场景下，(Config) -> A类型本身就是Reader的本质——接收环境参数并返回结果，无需额外的monad包装。
• 针对suspend函数的单子推导，Arrow转向了贴合Kotlin原生协程的方案，用Effect类型或上下文作用域替代了ReaderT的角色，减少不必要的抽象。

纯函数场景的替代方案 #

直接使用(Config) -> A函数类型，结合Arrow提供的函数组合工具来串联依赖配置的逻辑。

示例代码 #

首先定义配置类：

data class Config(val apiKey: String, val timeout: Long)

定义依赖配置的纯函数：

data class User(val id: String, val name: String)
data class Order(val id: String, val userId: String)

fun fetchUser(config: Config): User {
    // 模拟使用config调用API
    return User("user-1", "Alice")
}

fun fetchOrders(config: Config, userId: String): List<Order> {
    // 模拟使用config调用API
    return listOf(Order("order-1", userId))
}

直接传递参数组合

最直观的方式是直接在顶层函数中传递Config参数：

fun fetchUserWithOrders(config: Config): Pair<User, List<Order>> {
    val user = fetchUser(config)
    val orders = fetchOrders(config, user.id)
    return user to orders
}

用Arrow的函数组合工具

如果需要更灵活的函数组合，可以使用Arrow的curry扩展将多参数函数转为柯里化形式，再通过andThen串联：

import arrow.core.curry

// 将fetchOrders转为柯里化函数：Config -> (String) -> List<Order>
val curriedFetchOrders = ::fetchOrders.curry()

// 组合成接收Config的函数
val fetchUserWithOrders: (Config) -> Pair<User, List<Order>> = ::fetchUser
    .andThen { user -> config -> user to curriedFetchOrders(config)(user.id) }

Suspend函数场景的替代方案 #

对于涉及协程的异步逻辑，Arrow推荐使用Effect类型或上下文作用域来传递配置，这两种方式都能自然融入Kotlin的suspend体系。

方案1：使用Arrow的Effect类型 #

Effect<E, A>本质是suspend E.() -> A，即带环境参数的suspend函数，完全可以替代传统的ReaderT monad。

示例代码

import arrow.core.Effect

// 定义依赖Config的Effect
val fetchUser: Effect<Config, User> = Effect {
    // 直接通过this访问Config
    println("Using API key: ${this.apiKey}")
    User("user-1", "Alice")
}

// 接收userId的Effect
val fetchOrders: (String) -> Effect<Config, List<Order>> = { userId ->
    Effect {
        println("Using timeout: ${this.timeout}")
        listOf(Order("order-1", userId))
    }
}

// 组合Effect（类似Reader的flatMap）
val fetchUserWithOrders: Effect<Config, Pair<User, List<Order>>> =
    fetchUser.flatMap { user ->
        fetchOrders(user.id).map { orders -> user to orders }
    }

// 运行Effect，传入Config
suspend fun runLogic() {
    val config = Config("my-api-key", 5000)
    val result = fetchUserWithOrders(config)
    println("Result: $result")
}

方案2：使用上下文作用域 #

通过定义带Config的作用域接口，将依赖配置的suspend函数作为作用域的扩展函数，实现隐式传递。

示例代码

// 定义配置作用域
interface ConfigScope {
    val config: Config
}

// 实现作用域
class DefaultConfigScope(override val config: Config) : ConfigScope

// 定义作用域内的suspend函数
suspend fun ConfigScope.fetchUser(): User {
    println("Using API key: ${config.apiKey}")
    return User("user-1", "Alice")
}

suspend fun ConfigScope.fetchOrders(userId: String): List<Order> {
    println("Using timeout: ${config.timeout}")
    return listOf(Order("order-1", userId))
}

// 组合逻辑，通过run提供作用域
suspend fun fetchUserWithOrders(config: Config): Pair<User, List<Order>> =
    DefaultConfigScope(config).run {
        val user = fetchUser()
        val orders = fetchOrders(user.id)
        user to orders
    }

总结 #

在Arrow 1.x中：

• 纯函数场景直接用(Config) -> A类型，结合Arrow的函数组合工具即可替代Reader Monad。
• Suspend函数场景优先使用Effect类型（贴合Arrow的函数式风格）或上下文作用域（更贴近Kotlin原生语法），两者都能高效传递配置环境，无需专门的Reader实现。

内容的提问来源于stack exchange，提问作者Ulrich Schuster