> 在计算机科学中，柯里化（英语：Currying），又译为卡瑞化或加里化，是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数的技术。


在柯里化中，一个函数接受一个参数并返回一个新的函数，这个新的函数接受下一个参数，依此类推，直到所有参数都被接受并最终返回结果。

在`Scala`这样的支持函数式的编程语言，自带柯理化特性，
```java


 // 正常函数

 // 定义一个接受两个参数的函数
  def add(x: Int, y: Int): Int = x + y

 // 使用原始的add函数
  val result1 = add(3, 4)
  println(s"Result of add(3, 4): $result1")

 // 柯理化函数
 
 // 使用柯里化版本的add函数
 val result2 = curriedAdd(3)(4)
 println(s"Result of curriedAdd(3)(4): $result2")

 // 部分应用函数
 val add3 = curriedAdd(3) _
 val result3 = add3(4)
 println(s"Result of add3(4): $result3")
 
```

Java里面我们需要依赖Java把里面的函数式接口去模拟柯理化

```java

 // 柯里化版本的add函数
 public static Function<Integer, Function<Integer, Integer>> curriedAdd() {
     return a -> b -> a + b;
 }
 // 使用柯里化版本的add函数
 Function<Integer, Function<Integer, Integer>> curriedAdd = curriedAdd();
 Function<Integer, Integer> add3 = curriedAdd.apply(3);
 int result2 = add3.apply(4);
 System.out.println("Result of curriedAdd(3)(4): " + result2);

 // 进一步简化
 int result3 = curriedAdd().apply(3).apply(4);
 System.out.println("Result of curriedAdd(3)(4): " + result3);
 
 
 ```
 
 C++里面我们也是借助lambda和函数包装器实现
 
 ```cpp
 // 定义一个接受两个参数的函数
int add(int a, int b) {
    return a + b;
}

// 柯里化版本的add函数
std::function<int(int)> curriedAdd(int a) {
    return [a](int b) {
        return add(a, b);
    };
}

// 使用原始的add函数
int result1 = add(3, 4);
std::cout << "Result of add(3, 4): " << result1 << std::endl;

// 使用柯里化版本的add函数
auto add3 = curriedAdd(3);
int result2 = add3(4);
std::cout << "Result of curriedAdd(3)(4): " << result2 << std::endl;

// 进一步简化
int result3 = curriedAdd(3)(4);
std::cout << "Result of curriedAdd(3)(4): " << result3 << std::endl;


```
Kotlin里面我们可以通过返回函数的方法来实现柯理化
```kotlin
// 定义一个接受两个参数的函数
fun add(a: Int, b: Int): Int {
    return a + b
}

// 柯里化版本的add函数
fun curriedAdd(a: Int): (Int) -> Int {
    return { b -> add(a, b) }
}

fun main() {
    // 使用原始的add函数
    val result1 = add(3, 4)
    println("Result of add(3, 4): $result1")

    // 使用柯里化版本的add函数
    val add3 = curriedAdd(3)
    val result2 = add3(4)
    println("Result of curriedAdd(3)(4): $result2")

    // 进一步简化
    val result3 = curriedAdd(3)(4)
    println("Result of curriedAdd(3)(4): $result3")
}
````


在`Golang`里函数是一等公民，可以通过返回函数来实现柯理化
```go

// 定义一个接受两个参数的函数
func add(a int, b int) int {
	return a + b
}

// 柯里化版本的add函数
func curriedAdd(a int) func(int) int {
	return func(b int) int {
		return add(a, b)
	}
}
 
// 使用原始的add函数
result1 := add(3, 4)
fmt.Println("Result of add(3, 4):", result1)

// 使用柯里化版本的add函数
add3 := curriedAdd(3)
result2 := add3(4)
fmt.Println("Result of curriedAdd(3)(4):", result2)

// 进一步简化
result3 := curriedAdd(3)(4)
fmt.Println("Result of curriedAdd(3)(4):", result3)

```


Rust实现柯理化
```rust
// 定义一个接受两个参数的函数
    fn add(a: i32, b: i32) -> i32 {
        a + b
    }

    // 柯里化版本的add函数
    fn curried_add(a: i32) -> impl Fn(i32) -> i32 {
        move |b| add(a, b)
    }

    // 使用原始的add函数
    let result1 = add(3, 4);
    println!("Result of add(3, 4): {}", result1);

    // 使用柯里化版本的add函数
    let add3 = curried_add(3);
    let result2 = add3(4);
    println!("Result of curried_add(3)(4): {}", result2);

    // 进一步简化
    let result3 = curried_add(3)(4);
    println!("Result of curried_add(3)(4): {}", result3);
```
    
    
js也可以很简单的实现柯理化
```js
    // 定义一个接受两个参数的函数
function add(a, b) {
  return a + b;
}

// 柯里化版本的add函数
function curriedAdd(a) {
  return function(b) {
    return add(a, b);
  };
}

// 使用原始的add函数
const result1 = add(3, 4);
console.log("Result of add(3, 4):", result1);

// 使用柯里化版本的add函数
const add3 = curriedAdd(3);
const result2 = add3(4);
console.log("Result of curriedAdd(3)(4):", result2);

// 进一步简化
const result3 = curriedAdd(3)(4);
console.log("Result of curriedAdd(3)(4):", result3);
```

Haskell是FP语言的老大哥，函数都是默认柯理化
```kotlin
-- 定义一个接受两个参数的函数
add :: Int -> Int -> Int
add x y = x + y

-- 使用原始的add函数
result1 :: Int
result1 = add 3 4

-- 使用柯里化版本的add函数
add3 :: Int -> Int
add3 = add 3

result2 :: Int
result2 = add3 4
```
Python实现柯理化
```python
def add(a, b):
  return a + b

def curried_add(a):
  def inner(b):
    return add(a, b)
  return inner

add3 = curried_add(3)
print(add3(4))  # 输出: 7

```

上面就是大部分主流语言实现柯理化的思路，观察所有语言实现思路可以得知，尽管有的语言函数不是一等公民，还有的语言内置柯理化特性，但是实现柯理化的思路都是：定义一个接受部分参数并返回一个新函数的函数。



观察以上的例子我们也可以得出柯理化的作用，参数复用（预设参数），延迟执行

还有一个特性是函数组合,我们可以将多个函数组合起来
```js
const compose = (f, g) => x => f(g(x));
const add1 = x => x + 1;
const multiplyBy2 = x => x * 2;
const add1ThenMultiplyBy2 = compose(multiplyBy2, add1);
console.log(add1ThenMultiplyBy2(3)); // 输出: 8
```

好啦，现在实践吧！

之前没学FP的时候不了解什么是柯理化，现在学了FP,才知道柯理化无处不在，就比如说Go后端场景

```go

// 例1

type Logger func(string)

func NewLogger(level string) Logger {
	return func(message string) {
		fmt.Printf("[%s] %s\n", level, message)
	}
}

func main() {
	errorLogger := NewLogger("ERROR")
	infoLogger := NewLogger("INFO")

	errorLogger("Something went wrong!")
	infoLogger("Everything is fine.")
}


// 例2


type HTTPRequest func(string) ([]byte, error)

func NewHTTPRequest(method string, headers map[string]string) HTTPRequest {
	return func(url string) ([]byte, error) {
		req, err := http.NewRequest(method, url, nil)
		if err != nil {
			return nil, err
		}
		for key, value := range headers {
			req.Header.Add(key, value)
		}
		client := &http.Client{}
		resp, err := client.Do(req)
		if err != nil {
			return nil, err
		}
		defer resp.Body.Close()
		return ioutil.ReadAll(resp.Body)
	}
}

func main() {
	getRequest := NewHTTPRequest("GET", map[string]string{"User-Agent": "Go-http-client/1.1"})
	response, err := getRequest("https://api.github.com")
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	fmt.Println("Response:", string(response))
}



// 例3



type QueryFunc func(string) ([]map[string]interface{}, error)

func NewQueryFunc(db *sql.DB) QueryFunc {
	return func(query string) ([]map[string]interface{}, error) {
		rows, err := db.Query(query)
		if err != nil {
			return nil, err
		}
		defer rows.Close()

		columns, err := rows.Columns()
		if err != nil {
			return nil, err
		}

		results := []map[string]interface{}{}
		for rows.Next() {
			values := make([]interface{}, len(columns))
			pointers := make([]interface{}, len(columns))
			for i := range values {
				pointers[i] = &values[i]
			}
			if err := rows.Scan(pointers...); err != nil {
				return nil, err
			}
			result := make(map[string]interface{})
			for i, colName := range columns {
				val := values[i]
				result[colName] = val
			}
			results = append(results, result)
		}
		return results, nil
	}
}

func main() {
	db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
	if err != nil {
		fmt.Println("Error connecting to database:", err)
		return
	}
	defer db.Close()

	queryFunc := NewQueryFunc(db)
	results, err := queryFunc("SELECT * FROM users")
	if err != nil {
		fmt.Println("Error executing query:", err)
		return
	}
	for _, result := range results {
		fmt.Println(result)
	}
}


```
其实这些算是柯理化



各种语言里的柯理化

```java
package com.reservoir.core.utils;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.fasterxml.jackson.databind.ser.Serializers;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Objects;

public class Min<T, M extends BaseMapper<T>> {

    private final QueryWrapper<T> queryWrapper;
    private final UpdateWrapper<T> updateWrapper;
    private boolean orderByCalled = false;
    private boolean limitCalled = false;
    private T entity;
    private List<T> entityList;

    private Min() {
        this.queryWrapper = new QueryWrapper<>();
        this.updateWrapper = new UpdateWrapper<>();
    }

    public static <T, M extends BaseMapper<T>> Min<T, M> select(String... columns) {
        Min<T, M> min = new Min<>();
        if (columns != null && columns.length > 0) {
            min.queryWrapper.select(columns);
        }
        return min;
    }

    public static <T, M extends BaseMapper<T>> Min<T, M> insert(T entity) {
        Min<T, M> min = new Min<>();
        min.entity = entity;
        return min;
    }

    public static <T, M extends BaseMapper<T>> Min<T, M> update() {
        return new Min<>();
    }

    public static <T, M extends BaseMapper<T>> Min<T, M> delete() {
        return new Min<>();
    }

    // Query Methods
    public Min<T, M> innerJoin(String joinTable, String onClause) {
        Objects.requireNonNull(joinTable, "joinTable must not be null");
        Objects.requireNonNull(onClause, "onClause must not be null");
        this.queryWrapper.last("INNER JOIN " + joinTable + " ON " + onClause);
        return this;
    }

    public Min<T, M> leftJoin(String joinTable, String onClause) {
        Objects.requireNonNull(joinTable, "joinTable must not be null");
        Objects.requireNonNull(onClause, "onClause must not be null");
        this.queryWrapper.last("LEFT JOIN " + joinTable + " ON " + onClause);
        return this;
    }

    public Min<T, M> rightJoin(String joinTable, String onClause) {
        Objects.requireNonNull(joinTable, "joinTable must not be null");
        Objects.requireNonNull(onClause, "onClause must not be null");
        this.queryWrapper.last("RIGHT JOIN " + joinTable + " ON " + onClause);
        return this;
    }

    public Min<T, M> where(String column, Object value) {
        Objects.requireNonNull(column, "column must not be null");
        Objects.requireNonNull(value, "value must not be null");
        this.queryWrapper.eq(column, value);
        this.updateWrapper.eq(column, value);
        return this;
    }

    public Min<T, M> and(String column, Object value) {
        return where(column, value); // Alias for where
    }

    public Min<T, M> or(String column, Object value) {
        Objects.requireNonNull(column, "column must not be null");
        Objects.requireNonNull(value, "value must not be null");
        this.queryWrapper.or().eq(column, value);
        this.updateWrapper.or().eq(column, value);
        return this;
    }

    public Min<T, M> like(String column, Object value) {
        Objects.requireNonNull(column, "column must not be null");
        Objects.requireNonNull(value, "value must not be null");
        this.queryWrapper.like(column, value);
        this.updateWrapper.like(column, value);
        return this;
    }

    public Min<T, M> between(String column, Object value1, Object value2) {
        Objects.requireNonNull(column, "column must not be null");
        Objects.requireNonNull(value1, "value1 must not be null");
        Objects.requireNonNull(value2, "value2 must not be null");
        this.queryWrapper.between(column, value1, value2);
        this.updateWrapper.between(column, value1, value2);
        return this;
    }

    public Min<T, M> in(String column, List<?> values) {
        Objects.requireNonNull(column, "column must not be null");
        Objects.requireNonNull(values, "values must not be null");
        if (values.isEmpty()) {
            throw new IllegalArgumentException("values must not be empty");
        }
        this.queryWrapper.in(column, values);
        this.updateWrapper.in(column, values);
        return this;
    }

    public Min<T, M> orderBy(boolean isAsc, String... columns) {
        if (orderByCalled) {
            throw new IllegalStateException("orderBy has already been called");
        }
        orderByCalled = true;
        if (columns != null && columns.length > 0) {
            this.queryWrapper.orderBy(true, isAsc, Arrays.asList(columns));
        }
        return this;
    }

    public Min<T, M> groupBy(String... columns) {
        if (columns != null && columns.length > 0) {
            this.queryWrapper.groupBy(Arrays.asList(columns));
        }
        return this;
    }

    public Min<T, M> limit(int offset, int size) {
        if (limitCalled) {
            throw new IllegalStateException("limit has already been called");
        }
        limitCalled = true;
        if (offset < 0 || size <= 0) {
            throw new IllegalArgumentException("Offset must be >= 0 and size must be > 0");
        }
        this.queryWrapper.last("LIMIT " + offset + ", " + size);
        return this;
    }

    public Min<T, M> having(String column, Object value) {
        Objects.requireNonNull(column, "column must not be null");
        Objects.requireNonNull(value, "value must not be null");
        this.queryWrapper.having(column, value);
        return this;
    }

    public Min<T, M> isNull(String column) {
        Objects.requireNonNull(column, "column must not be null");
        this.queryWrapper.isNull(column);
        this.updateWrapper.isNull(column);
        return this;
    }

    public Min<T, M> isNotNull(String column) {
        Objects.requireNonNull(column, "column must not be null");
        this.queryWrapper.isNotNull(column);
        this.updateWrapper.isNotNull(column);
        return this;
    }

    public  <T> T first(BaseMapper mapper) {
        Objects.requireNonNull(mapper, "mapper must not be null");
        return (T) mapper.selectOne((Wrapper<T>) this.queryWrapper);
    }

    public List<T> list(BaseMapper mapper) {
        Objects.requireNonNull(mapper, "mapper must not be null");
        return  mapper.selectList((Wrapper<T>) this.queryWrapper);
    }

    // Insert Methods
    public Min<T, M> one() {
        Objects.requireNonNull(this.entity, "entity must not be null");
        return this;
    }

    public Min<T, M> list(List<T> entities) {
        Objects.requireNonNull(entities, "entities must not be null");
        if (entities.isEmpty()) {
            throw new IllegalArgumentException("entities must not be empty");
        }
        this.entityList = entities;
        return this;
    }

    public int executeInsert(BaseMapper mapper) {
        Objects.requireNonNull(mapper, "mapper must not be null");
        if (this.entity != null) {
            return mapper.insert(this.entity);
        } else if (this.entityList != null) {
            int count = 0;
            for (T e : this.entityList) {
                count += mapper.insert(e);
            }
            return count;
        } else {
            throw new IllegalStateException("No entity or entityList provided for insert");
        }
    }

    // Update Methods
    public Min<T, M> set(String column, Object value) {
        Objects.requireNonNull(column, "column must not be null");
        Objects.requireNonNull(value, "value must not be null");
        this.updateWrapper.set(column, value);
        return this;
    }

    public int executeUpdate(BaseMapper mapper) {
        Objects.requireNonNull(mapper, "mapper must not be null");
        if (this.updateWrapper.isEmptyOfWhere()) {
            throw new IllegalStateException("Update operation must contain at least one where clause");
        }
        return mapper.update(null, this.updateWrapper);
    }

//    public <M extends BaseMapper<?>> int UpdateRows(M mapper) {
//        return this.executeUpdate((BaseMapper)mapper);
//    }

    // Delete Methods
    public int executeDelete(BaseMapper mapper) {
        Objects.requireNonNull(mapper, "mapper must not be null");
        if (this.queryWrapper.isEmptyOfWhere()) {
            throw new IllegalStateException("Delete operation must contain at least one where clause");
        }
        return mapper.delete((Wrapper<T>) this.queryWrapper);
    }

    // Utility Methods
    public Min<T, M> setFields(Map<String, Object> fieldValues) {
        Objects.requireNonNull(fieldValues, "fieldValues must not be null");
        fieldValues.forEach((key, value) -> {
            Objects.requireNonNull(key, "field key must not be null");
            Objects.requireNonNull(value, "field value must not be null");
            this.updateWrapper.set(key, value);
        });
        return this;
    }
}

```


封装Mybatis-Plus

ApiResult
```kotlin
package com.example.demokt.core.entity

import java.time.LocalDateTime
import java.time.format.DateTimeFormatter

data class ApiResult<T>(
    val code: Int,
    val message: String,
    val data: T?,
    val timestamp: String
) {
    companion object {
        // 创建成功的响应
        fun <T> success(data: T?): ApiResult<T> {
            return ApiResult(ResultCode.SUCCESS.code, ResultCode.SUCCESS.message, data, getCurrentTimestamp())
        }

        // 创建成功的响应，并自定义消息
        fun <T> success(message: String, data: T?): ApiResult<T> {
            return ApiResult(ResultCode.SUCCESS.code, message, data, getCurrentTimestamp())
        }

        // 创建自定义状态码的响应
        fun <T> of(resultCode: ResultCode, data: T?): ApiResult<T> {
            return ApiResult(resultCode.code, resultCode.message, data, getCurrentTimestamp())
        }

        // 创建失败的响应
        fun <T> error(code: Int, message: String): ApiResult<T> {
            return ApiResult(code, message, null, getCurrentTimestamp())
        }

        // 创建失败的响应，并包含数据
        fun <T> error(code: Int, message: String, data: T?): ApiResult<T> {
            return ApiResult(code, message, data, getCurrentTimestamp())
        }

        // 获取当前时间戳
        private fun getCurrentTimestamp(): String {
            val now = LocalDateTime.now()
            val formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
            return now.format(formatter)
        }
    }
}
```
ResultCode
```kotlin
package com.example.demokt.core.entity

enum class ResultCode(val code: Int, val message: String) {
    SUCCESS(200, "Success"),
    ADD_USER_SUCCESS(1001, "添加用户成功"),
    USER_NOT_EXISTS(1002, "用户不存在"),
    USER_ALREADY_EXISTS(1003, "用户已存在"),
    INVALID_CREDENTIALS(1004, "无效的凭证"),
    LOGIN_SUCCESS(1005, "登录成功"),
    LOGIN_FAILED(1006, "登录失败"),
    LOGOUT_SUCCESS(1007, "登出成功"),
    PERMISSION_DENIED(1008, "权限不足"),
    RESOURCE_NOT_FOUND(1009, "资源未找到"),
    RESOURCE_ALREADY_EXISTS(1010, "资源已存在"),
    INVALID_PARAMETERS(1011, "无效的参数"),
    OPERATION_SUCCESS(1012, "操作成功"),
    OPERATION_FAILED(1013, "操作失败"),
    // 用户操作
    USER_ALREADY_BLOCKED(1014, "用户已被封禁"),
    USER_ALREADY_VERIFIED(1015, "用户已验证"),
    USER_VERIFICATION_FAILED(1016, "用户验证失败"),

    SERVER_ERROR(500, "服务器错误"),
    UNKNOWN_ERROR(501, "未知错误"),

    // 注册相关
    REGISTER_SUCCESS(2001, "注册成功"),
    REGISTER_FAILED(2002, "注册失败"),
    EMAIL_ALREADY_EXISTS(2003, "邮箱已存在"),
    USERNAME_ALREADY_EXISTS(2004, "用户名已存在"),
    // 登录/注册
    INVALID_VERIFICATION_CODE(2005, "验证码错误"),
    REGISTRATION_CODE_EXPIRED(2006, "注册码已过期"),
    INVALID_LOGIN_ATTEMPTS(1017, "登录尝试过多，请稍后再试"),

    // 支付相关
    PAYMENT_SUCCESS(3001, "支付成功"),
    PAYMENT_FAILED(3002, "支付失败"),
    INSUFFICIENT_FUNDS(3003, "余额不足"),
    PAYMENT_CANCELED(3004, "支付已取消"),
    // 支付
    PAYMENT_AMOUNT_EXCEEDS_LIMIT(3005, "支付金额超出限制"),
    PAYMENT_METHOD_NOT_SUPPORTED(3006, "不支持的支付方式"),
    PAYMENT_AUTHENTICATION_REQUIRED(3007, "需要支付认证"),

    // 数据库相关
    DATABASE_CONNECTION_SUCCESS(4001, "数据库连接成功"),
    DATABASE_CONNECTION_FAILED(4002, "数据库连接失败"),
    DATABASE_OPERATION_SUCCESS(4003, "数据库操作成功"),
    DATABASE_OPERATION_FAILED(4004, "数据库操作失败"),
    // 数据库操作
    DATABASE_QUERY_FAILED(4005, "数据库查询失败"),
    DATABASE_UPDATE_FAILED(4006, "数据库更新失败"),
    DATABASE_DELETE_FAILED(4007, "数据库删除失败"),


    // 超时相关
    REQUEST_TIMEOUT(5001, "请求超时"),
    SESSION_TIMEOUT(5002, "会话超时"),
    // 超时
    API_TIMEOUT(5003, "API调用超时"),
    IMAGE_UPLOAD_TIMEOUT(5004, "图片上传超时"),

    // 限流相关
    RATE_LIMIT_EXCEEDED(6001, "请求过于频繁，请稍后再试"),
    // 限流
    RATE_LIMIT_EXCEEDED_PER_USER(6002, "用户请求过于频繁，请稍后再试"),
    RATE_LIMIT_EXCEEDED_PER_IP(6003, "IP请求过于频繁，请稍后再试"),

    // 其他
    SERVICE_UNAVAILABLE(7001, "服务不可用"),
    GATEWAY_TIMEOUT(7002, "网关超时"),
    // 其他
    INTERNAL_SERVER_ERROR(7003, "内部服务器错误"),
    CONFIGURATION_ERROR(7004, "配置错误"),
    DEPENDENCY_SERVICE_UNAVAILABLE(7005, "依赖服务不可用"),

    // 文件操作
    FILE_NOT_FOUND(8001, "文件未找到"),
    FILE_UPLOAD_FAILED(8002, "文件上传失败"),
    FILE_DOWNLOAD_FAILED(8003, "文件下载失败"),


    // 网络问题
    CONNECTION_TIMEOUT(9001, "连接超时"),
    REQUEST_FAILED(9002, "请求失败"),
    HOST_UNAVAILABLE(9003, "主机不可用"),

    // 安全问题
    SECURITY_VIOLATION(10001, "安全违规"),
    ENCRYPTION_FAILED(10002, "加密失败"),
    DECRYPTION_FAILED(10003, "解密失败");


    companion object {
        fun fromCode(code: Int): ResultCode {
            return values().find { it.code == code } ?: UNKNOWN_ERROR
        }
    }
}
```

kotlin响应体

```sh
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<EOF
{
    "registry-mirrors": [
        "https://hub.uuuadc.top",
        "https://docker.anyhub.us.kg",
        "https://dockerhub.jobcher.com",
        "https://dockerhub.icu",
        "https://docker.ckyl.me",
        "https://docker.awsl9527.cn"
    ]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
```

直接复制执行


https://cloud.tencent.com/developer/article/2459822