A Rust closure that takes a trait as argument

user_3716130 0
Viewed 855

I want my function to take a closure as an argument, which takes a PartialOrd (or any other trait, this is just an example) as an argument and I want to be able to call that closure with a any type that implements PartialOrd in my function. Something along the lines of this:

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

But of course this does not work because impl Trait is not valid in closure signatures. (I don't see why but I guess it not implemented yet.) So I tried something like this:

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

This also doesn't compile because (I guess) T is determined by the caller and I'm just passing i32 and it might be different that what the caller is intended to call.

So, how do I go about this? My main purpose is to do something like this:

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);
    }
}

Both type1 and type2 implements PartialEq.

To make it more concerete, I'm using chrono library and want to write something like this:

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)

Note: DateTime::date() does not return DateTime, it returns a different Date type.

rust
2 Answers

The issue with having a single cmp is that while it might be generic in the function declaration, it becomes specialized when the function is called. Thereby it cannot be used for both DateTime and Date. (Assuming you want to avoid something even more complicated involving Any.)

You can workaround this by having having two cmp paramters. However you can still have a single definition of your actual cmp function.

// 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())
    }
}

Now you can define a single generic cmp function and use it for both.

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>>,
);

You can also just pass 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,
);

If you want to avoid the repeated argument, then you can define a compare_dates! macro as well.

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

Which you then call like this:

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,
);
user_24708180

But of course this does not work because impl Trait is not valid in closure signatures. (I don't see why but I guess it not implemented yet.)

I don't think it can be; this would desugar to something like

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

which is not a legal type (though I just learned that using lifetime parameters in that position is legal, e.g. for<'a> fn(&'a i32) -> &'a i32). Also note that T1 and T2 would be different types, so PartialOrd::lt wouldn't have this type. You would instead write it explicitly without impl, again if it were supported in the first place:

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

However, another workaround is to turn the closure type into a trait and the specific closure you want into an implementation of this trait for a struct. In this case a unit struct because the closure doesn't capture anything:

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())
    }
}

As you can see, you have just one cmp argument which plays the role of the closure, and can even be defined locally:

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

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

but is still less convenient than a closure. Whether it's a good tradeoff compared to vallentin's answer will depend on the exact situation.

alexey_r_92040
Related