curried

简介

使用过程宏实现的currying函数，可用于常规 && 泛型 && map场景。
(此crate可用于稳定渠道。)

用法

use curried::{curry, to_curry};

#[curry]
fn add(a: i32, b: i32, c: i32) -> i32 {
    a + b + c
}

#[curry]
fn concat_string<T>(a: T, b: T, c: T) -> String
where
    T: std::fmt::Display + 'static, // Note: You should additionally add 'static
{
    a.to_string() + &b.to_string() + &c.to_string()
}

fn map(a: i32, b: i32, c: i32) -> i32 {
    a - b - c
}

fn normal_curry() {
    let i = add(1)(2)(3);
    assert_eq!(i, 6);
}

fn generic_curry() {
    let f = concat_string(1)(23);
    let s = f(456);
    assert_eq!(s, "123456");
}

fn map_curry() {
    let f = to_curry!(map(a, b, c));
    let i = [1, 2, 3].map(f(1)(2));
    assert_eq!(i, [-2, -3, -4]);
}

注意

• 这些代码可以成功编译

fn f<T>(_: i32, _: T) {}
f(1, 1);
f(1, "123");


#[curried::curry]
fn g<T>(_: i32, _: T) {}
g(1)(1);
g(1)("123");

• 但以下这些不能

#[curried::curry]
fn f<T>(_: i32, _: T) {}

let g = f(1);
g(1);
g("123");

• 如果您想使用不同类型的参数调用相同的函数

use curried::to_curry;

fn f<T>(_: i32, _: T) {}

let g1 = to_curry!(f(a, b));
let g2 = to_curry!(f(a, b));

let gg1 = g1(1);
gg1(1);

let gg2 = g2(1);
gg2("123");

• 如果您想在map中使用currying函数

use curried::to_curry;

fn product(a: i32, b: i32, c: i32) -> i32 {
    a * b * c
}

// Don't use [curry] proc_attr_macro, use to_curry! to auto deduce type for closure type
let f = to_curry!(product(a, b, c));  

[1, 2, 3].map(f(10)(10));  // [100, 200, 300]