前端开发者的 Kotlin 之旅：函数式编程深入

// 纯函数示例
fun add(a: Int, b: Int): Int = a + b

// 计算圆面积的纯函数
fun calculateCircleArea(radius: Double): Double = Math.PI * radius * radius

// 非纯函数 - 依赖外部状态
var counter = 0
fun incrementCounter(): Int {
    counter++  // 副作用：修改外部状态
    return counter
}

// 非纯函数 - 有I/O副作用
fun fetchUserFromDatabase(id: String): User {
    // 从数据库获取数据 - I/O操作是副作用
    return database.getUserById(id)
}

// 纯函数
function add(a, b) {
    return a + b;
}

// 非纯函数
let counter = 0;
function incrementCounter() {
    counter++;  // 副作用
    return counter;
}

// Kotlin中的不可变性
val immutableList = listOf(1, 2, 3)  // 创建不可变列表
// immutableList.add(4)  // 编译错误！

// 不可变数据类
data class User(val id: String, val name: String)
val user = User("1", "Alice")
// 要"修改"，需创建新实例
val updatedUser = user.copy(name = "Alice Smith")

// 基本函数类型
val add: (Int, Int) -> Int = { a, b -> a + b }

// 带接收者的函数类型 - 类似于在特定类型上扩展方法
val isEven: Int.() -> Boolean = { this % 2 == 0 }
println(4.isEven())  // true

// 存储和传递函数
val functions = listOf<(Int) -> Int>(
    { it + 1 },
    { it * 2 },
    { it * it }
)
val composedResult = functions.fold(5) { acc, function -> function(acc) }
println(composedResult)  // ((5+1)*2)^2 = 144

// JavaScript中的函数传递
const functions = [
    x => x + 1,
    x => x * 2,
    x => x * x
];
const result = functions.reduce((acc, fn) => fn(acc), 5);

// 接受函数作为参数
fun calculate(x: Int, y: Int, operation: (Int, Int) -> Int): Int = operation(x, y)

// 返回函数
fun createMultiplier(factor: Int): (Int) -> Int = { number -> number * factor }

// 使用
val sum = calculate(5, 3) { a, b -> a + b }  // 8
val difference = calculate(5, 3) { a, b -> a - b }  // 2
val double = createMultiplier(2)
println(double(10))  // 20

// 传统方式
fun findEvenNumbers(numbers: List<Int>): List<Int> {
    val result = mutableListOf<Int>()
    for (number in numbers) {
        if (number % 2 == 0) {
            result.add(number)
        }
    }
    return result
}

// 使用高阶函数
fun findEvenNumbers(numbers: List<Int>): List<Int> = numbers.filter { it % 2 == 0 }

// 函数组合 - 将两个函数组合成一个
fun <A, B, C> compose(f: (B) -> C, g: (A) -> B): (A) -> C = { a -> f(g(a)) }

// 柯里化 - 将接受多个参数的函数转换为接受单个参数的函数链
fun <A, B, C> curry(f: (A, B) -> C): (A) -> (B) -> C = { a -> { b -> f(a, b) } }

// 使用示例
val lengthFn: (String) -> Int = { it.length }
val isEven: (Int) -> Boolean = { it % 2 == 0 }
val isEvenLength = compose(isEven, lengthFn)
println(isEvenLength("hello"))  // false - 长度5是奇数

// 柯里化示例
val curriedAdd = curry { a: Int, b: Int -> a + b }
val add5 = curriedAdd(5)
println(add5(3))  // 8

// 函数组合
const compose = (f, g) => x => f(g(x));
const length = str => str.length;
const isEven = num => num % 2 === 0;
const isEvenLength = compose(isEven, length);

// 柯里化
const curry = f => a => b => f(a, b);
const add = (a, b) => a + b;
const curriedAdd = curry(add);
const add5 = curriedAdd(5);
console.log(add5(3));  // 8

// 使用Result类进行错误处理
fun divide(a: Int, b: Int): Result<Int> = runCatching {
    require(b != 0) { "Division by zero" }
    a / b
}

// 使用
val result = divide(10, 2)
val resultZero = divide(10, 0)

println(result.getOrDefault(0))  // 5
println(resultZero.exceptionOrNull()?.message)  // "Division by zero"

// 函数式链式调用
divide(10, 2)
    .map { it * 2 }  // 转换成功结果
    .onSuccess { println("结果: $it") }  // 结果: 10
    .onFailure { println("错误: ${it.message}") }

// JavaScript中类似的模式
function divideSafely(a, b) {
    try {
        if (b === 0) throw new Error("Division by zero");
        return { ok: true, value: a / b };
    } catch (e) {
        return { ok: false, error: e.message };
    }
}

const result = divideSafely(10, 2);
if (result.ok) {
    console.log("结果:", result.value);
} else {
    console.log("错误:", result.error);
}

import arrow.core.Either
import arrow.core.left
import arrow.core.right

// Either类型 - 一个值要么是Left(错误)，要么是Right(正确结果)
fun divideEither(a: Int, b: Int): Either<String, Int> =
    if (b == 0) "除数不能为零".left()
    else (a / b).right()

// 链式处理
divideEither(10, 2)
    .map { it * 2 }  // 只有Right值会被转换
    .fold(
        { error -> println("错误: $error") },
        { value -> println("结果: $value") }  // 结果: 10
    )

// 组合多个可能失败的操作
fun fetchUserData(userId: Int): Either<String, User> = /* ... */
fun fetchUserPosts(user: User): Either<String, List<Post>> = /* ... */

val userPostsEither = fetchUserData(123).flatMap { user -> 
    fetchUserPosts(user)
}

import * as E from 'fp-ts/Either'
import { pipe } from 'fp-ts/function'

const divide = (a, b) => 
  b === 0 ? E.left('division by zero') : E.right(a / b)

pipe(
  divide(10, 2),
  E.map(n => n * 2),
  E.fold(
    error => console.log("错误:", error),
    value => console.log("结果:", value)
  )
)

val items = listOf(1, 2, 3, 4, 5)

// 基本变换
val doubled = items.map { it * 2 }                 // [2, 4, 6, 8, 10]
val evenNumbers = items.filter { it % 2 == 0 }     // [2, 4]
val sum = items.reduce { acc, i -> acc + i }       // 15
val product = items.fold(1) { acc, i -> acc * i }  // 120

// 分组和结构转换
val groupedByEven = items.groupBy { it % 2 == 0 }  // {false=[1,3,5], true=[2,4]}
val indexed = items.mapIndexed { idx, value -> "位置$idx: $value" } 

// 集合间操作
val pairwiseItems = items.zipWithNext()  // [(1,2), (2,3), (3,4), (4,5)]
val letters = listOf("a", "b", "c")
val zipped = items.zip(letters)  // [(1,"a"), (2,"b"), (3,"c")]

// 扁平化操作
val nested = listOf(listOf(1, 2), listOf(3, 4))
val flattened = nested.flatten()  // [1, 2, 3, 4]
val flatMapped = items.flatMap { listOf(it, it * 10) }  // [1, 10, 2, 20, 3, 30, 4, 40, 5, 50]

// 序列操作（惰性求值）- 适合大数据集
val sequence = generateSequence(1) { it + 1 }
val first5 = sequence.take(5).toList()  // [1, 2, 3, 4, 5]

const items = [1, 2, 3, 4, 5];

// 基本操作
const doubled = items.map(x => x * 2);
const evenNumbers = items.filter(x => x % 2 === 0);
const sum = items.reduce((acc, x) => acc + x, 0);

// 扁平化
const nested = [[1, 2], [3, 4]];
const flattened = nested.flat();  // [1, 2, 3, 4]
const flatMapped = items.flatMap(x => [x, x * 10]); // [1, 10, 2, 20, 3, 30, 4, 40, 5, 50]

// JavaScript需要自定义或使用lodash等库实现一些Kotlin标准操作
const groupBy = (array, key) => 
  array.reduce((acc, item) => {
    const group = key(item);
    acc[group] = acc[group] || [];
    acc[group].push(item);
    return acc;
  }, {});

const groupedByEven = groupBy(items, x => x % 2 === 0);

val result = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    .filter { it % 2 == 0 }       // 过滤出偶数 [2, 4, 6, 8, 10]
    .map { it * it }              // 计算平方 [4, 16, 36, 64, 100]
    .sortedByDescending { it }    // 降序排序 [100, 64, 36, 16, 4]
    .take(3)                      // 取前三个 [100, 64, 36]
    .sum()                        // 求和 200

// 实际业务场景示例：处理用户订单
val totalRevenue = users
    .filter { it.isActive }                // 筛选活跃用户
    .flatMap { it.orders }                 // 获取所有订单
    .filter { it.status == OrderStatus.COMPLETED } // 仅完成的订单
    .sumOf { it.amount }                   // 计算总金额

import arrow.core.Option
import arrow.core.none
import arrow.core.some

// 处理可能为null的值
fun findUser(id: Int): Option<String> {
    val users = mapOf(1 to "Alice", 2 to "Bob")
    return Option.fromNullable(users[id])
}

val user1 = findUser(1)  // Some(Alice)
val user3 = findUser(3)  // None

// 函数式处理
user1.fold(
    { "未找到用户" },
    { name -> "找到用户: $name" }
)  // "找到用户: Alice"

// 链式操作
user1
    .map { it.toUpperCase() }  // Some(ALICE)
    .filter { it.length > 10 } // None (不满足条件)
    .getOrElse { "名字太短" }  // "名字太短"

import arrow.core.*
import arrow.typeclasses.Semigroup

// 数据验证，可以收集多个错误
data class User(val name: String, val age: Int, val email: String)

fun validateName(name: String): ValidatedNel<String, String> =
    if (name.isNotBlank()) name.validNel()
    else "名字不能为空".invalidNel()

fun validateAge(age: Int): ValidatedNel<String, Int> =
    if (age >= 18) age.validNel()
    else "年龄必须大于18岁".invalidNel()

fun validateEmail(email: String): ValidatedNel<String, String> =
    if (email.contains("@")) email.validNel()
    else "邮箱格式不正确".invalidNel()

fun validateUser(name: String, age: Int, email: String): ValidatedNel<String, User> {
    return ValidatedNel.zip(
        validateName(name),
        validateAge(age),
        validateEmail(email)
    ) { validName, validAge, validEmail -> 
        User(validName, validAge, validEmail)
    }
}

// 使用
val valid = validateUser("Alice", 20, "alice@example.com")  
// Valid(User(name=Alice, age=20, email=alice@example.com))

val invalid = validateUser("", 15, "invalid-email")
// Invalid(NonEmptyList(名字不能为空, 年龄必须大于18岁, 邮箱格式不正确))

import arrow.core.Either
import arrow.core.left
import arrow.core.right
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

sealed class ApiError {
    object NetworkError : ApiError()
    object NotFound : ApiError()
    data class ServerError(val code: Int) : ApiError()
}

// 函数式API调用
suspend fun fetchUser(id: Int): Either<ApiError, User> {
    return try {
        val response = api.getUser(id)
        when (response.code) {
            200 -> response.body.toUser().right()
            404 -> ApiError.NotFound.left()
            else -> ApiError.ServerError(response.code).left()
        }
    } catch (e: Exception) {
        ApiError.NetworkError.left()
    }
}

// 组合多个请求
suspend fun getUserWithPosts(userId: Int): Either<ApiError, UserWithPosts> {
    return fetchUser(userId).flatMap { user ->
        fetchPosts(userId).map { posts ->
            UserWithPosts(user, posts)
        }
    }
}

// 使用
suspend fun loadUserData(id: Int) {
    fetchUser(id).fold(
        { error -> 
            when(error) {
                is ApiError.NetworkError -> showNetworkError()
                is ApiError.NotFound -> showUserNotFound()
                is ApiError.ServerError -> showServerError(error.code)
            }
        },
        { user -> displayUser(user) }
    )
}

// 状态管理 - 类似React中的reducer模式
sealed class UiState {
    object Loading : UiState()
    data class Error(val message: String) : UiState()
    data class Success(val data: List<Item>) : UiState()
}

sealed class UiAction {
    object LoadData : UiAction()
    object RetryLoading : UiAction()
    data class DataLoaded(val data: List<Item>) : UiAction()
    data class LoadingFailed(val error: String) : UiAction()
}

// 纯函数的reducer
fun reducer(state: UiState, action: UiAction): UiState = when (action) {
    is UiAction.LoadData, is UiAction.RetryLoading -> UiState.Loading
    is UiAction.DataLoaded -> UiState.Success(action.data)
    is UiAction.LoadingFailed -> UiState.Error(action.error)
}

// 在ViewModel中使用
class ItemViewModel {
    private var _state = UiState.Loading
    val state: UiState get() = _state
    
    fun dispatch(action: UiAction) {
        _state = reducer(_state, action)
        notifyStateChanged()
    }
    
    fun loadData() {
        dispatch(UiAction.LoadData)
        viewModelScope.launch {
            try {
                val items = repository.getItems()
                dispatch(UiAction.DataLoaded(items))
            } catch (e: Exception) {
                dispatch(UiAction.LoadingFailed(e.message ?: "Unknown error"))
            }
        }
    }
}

// UI展示
fun renderUi(state: UiState) = when (state) {
    is UiState.Loading -> showLoadingIndicator()
    is UiState.Error -> showErrorMessage(state.message)
    is UiState.Success -> displayItems(state.data)
}

// Kotlin的takeWhile、chunked等特殊操作
val numbers = (1..20).toList()
val firstLessThan10 = numbers.takeWhile { it < 10 }  // [1, 2, 3, ..., 9]
val chunks = numbers.chunked(5)  // [[1-5], [6-10], [11-15], [16-20]]

// 使用作用域函数简化代码
user?.let {
    // 只有当user非空时执行这里的代码
    println(it.name)
    updateUI(it)
}

val user = User().apply {
    name = "Alice"
    age = 30
    email = "alice@example.com"
}