一个以 trait 作为参数的 Rust 闭包

Question

我希望我的函数将闭包作为参数，它将PartialOrd（或任何其他特征，这只是一个示例）作为参数，并且我希望能够以任何类型调用该闭包在我的函数中实现PartialOrd。类似这样的东西：

fn my_func(cmp: fn(impl PartialOrd, impl PartialOrd) -> bool) {
    cmp(3, 5);
}

但这当然不起作用，因为impl Trait 在闭包签名中无效。 （我不明白为什么，但我猜它还没有实现。）所以我尝试了这样的事情：

fn my_func<T: PartialOrd>(cmp: fn(T, T) -> bool) {
    cmp(3, 5);
}

这也无法编译，因为（我猜）T 是由调用者确定的，而我只是传递了 i32，它可能与调用者打算调用的内容不同。

那么，我该怎么做呢？我的主要目的是做这样的事情：

fn my_func(cmp: fn(impl PartialOrd, impl PartialOrd) -> bool) {
    if some_condition {
        cmp(type1_instance, type1_instance_2);
    } else {
        cmp(type2_instance, type2_instance_2);
    }
}

type1 和 type2 都实现了 PartialEq。

为了让它更具体，我正在使用chrono 库并想写这样的东西：

fn compare_dates(d1: DateTime, d2: DateTime, cmp: fn(impl PartialOrd, impl PartialOrd) -> bool) -> bool {
    if some_condition {
        cmp(d1, d2)
    } else {
        cmp(d1.date(), d2.date())
    }
}

compare_dates(
    Utc.date(2000 10, 11).and_hour(0,0,0),
    Utc.date(2000 10, 12).and_hour(0,0,0),
    PartialOrd::lt)

注意：DateTime::date() 不返回 DateTime，它返回不同的 Date 类型。

Answer 1

使用单个cmp 的问题在于，虽然它在函数声明中可能是通用的，但在调用函数时它会变得专门化。因此它不能同时用于DateTime 和Date。 （假设您想避免涉及Any 的更复杂的事情。）

您可以通过设置两个 cmp 参数来解决此问题。但是，您仍然可以对实际的 cmp 函数进行单一定义。

// chrono = "0.4.19"
use chrono::{Date, DateTime, TimeZone, Utc};

fn compare_dates<F, G>(
    d1: DateTime<Utc>,
    d2: DateTime<Utc>,
    cmp_date_times: F,
    cmp_dates: G,
) -> bool
where
    F: FnOnce(&DateTime<Utc>, &DateTime<Utc>) -> bool,
    G: FnOnce(&Date<Utc>, &Date<Utc>) -> bool,
{
    let some_condition = ...;
    if some_condition {
        cmp_date_times(&d1, &d2)
    } else {
        cmp_dates(&d1.date(), &d2.date())
    }
}

现在您可以定义一个通用的cmp 函数并将其用于两者。

fn cmp<T: PartialOrd>(lhs: &T, rhs: &T) -> bool {
    lhs < rhs
}

compare_dates(
    Utc.ymd(2000, 10, 11).and_hms(0, 0, 0),
    Utc.ymd(2000, 10, 12).and_hms(0, 0, 0),
    cmp,
    cmp,
    // or
    // cmp::<DateTime<Utc>>,
    // cmp::<Date<Utc>>,
);

你也可以直接传PartialOrd::lt。

compare_dates(
    Utc.ymd(2000, 10, 11).and_hms(0, 0, 0),
    Utc.ymd(2000, 10, 12).and_hms(0, 0, 0),
    PartialOrd::lt,
    PartialOrd::lt,
    // or
    // <DateTime<Utc> as PartialOrd>::lt,
    // <Date<Utc> as PartialOrd>::lt,
    // or
    // DateTime::<Utc>::lt,
    // Date::<Utc>::lt,
);

---

如果你想避免重复参数，那么你也可以定义一个compare_dates!宏。

macro_rules! compare_dates {
    ($d1:expr, $d2:expr, $cmp:expr $(,)?) => {
        compare_dates($d1, $d2, $cmp, $cmp)
    };
}

然后你这样称呼它：

compare_dates!(
    Utc.ymd(2000, 10, 11).and_hms(0, 0, 0),
    Utc.ymd(2000, 10, 12).and_hms(0, 0, 0),
    PartialOrd::lt,
);

compare_dates!(
    Utc.ymd(2000, 10, 11).and_hms(0, 0, 0),
    Utc.ymd(2000, 10, 12).and_hms(0, 0, 0),
    cmp,
);

Answer 2

但这当然行不通，因为 impl Trait 在闭包签名中无效。 （我不明白为什么，但我猜它还没有实现。）

我认为不可能；这会像

这样的东西脱糖

fn my_func(cmp: for<T1: PartialOrd, T2: PartialOrd> fn(T1, T2) -> bool) {
    cmp(3, 5);
}

这不是合法类型（尽管我刚刚了解到在该位置使用生命周期参数is legal，例如for<'a> fn(&'a i32) -> &'a i32）。还要注意T1 和T2 是不同的类型，所以PartialOrd::lt 不会有这种类型。如果一开始就支持它，您可以在没有impl 的情况下明确编写它：

fn my_func(cmp: for<T: PartialOrd> fn(T, T) -> bool) {
    cmp(3, 5);
}

但是，另一种解决方法是将闭包类型转换为特征，并将您想要的特定闭包转换为结构的此特征的实现。在这种情况下是一个单元结构，因为闭包没有捕获任何东西：

trait Cmp {
    fn compare<T: PartialOrd>(&self, x: T, y: T) -> bool;
}

struct Lt;

impl Cmp for Lt {
    fn compare<T: PartialOrd>(&self, x: T, y: T) -> bool {
        x < y
    }
}

fn compare_dates(d1: DateTime, d2: DateTime, cmp: impl Cmp) -> bool {
    if some_condition {
        cmp.compare(d1, d2)
    } else {
        cmp.compare(d1.date(), d2.date())
    }
}

如您所见，您只有一个 cmp 参数，它起到闭包的作用，甚至可以在本地定义：

fn main() {
    struct Lt;
    
    impl Cmp for Lt {
        fn cmp<T: PartialOrd>(&self, x: T, y: T) -> bool {
            x < y
        }
    }

    println!("{}", my_func(Lt));
}

但仍然不如闭包方便。与 vallentin 的答案相比，这是否是一个好的权衡取决于具体情况。