是否有一种简洁的方法来定义内联特征实现？

Question

At a high level, I want to create an object that holds an integer, and then be able to perform various comparisons (<, >, etc.) against numbers that are input as strings. I am trying to get as much duplicated code pulled out as possible.

I have code like the following:

/// Implement some binary op, like < or >=
trait Comparison {
    fn compare(a: i32, b: i32) -> bool;
}

struct Checker {
    lhs: i32,
    op: Box<dyn Comparison>,
}
impl Checker {
    fn check(&self, rhs: &str) -> bool {
        let i_rhs = rhs.parse::<i32>();
        if self.op.compare(self.lhs, i_rhs) {
            do_stuff()
        }
    }
}

trait DataChecker {
    fn check(&self, rhs: &str) -> bool;
}

struct GreaterThanChecker {
    data: Checker,
}

impl DataChecker for GreaterThanChecker {
    fn check(&self, rhs: &str) -> bool {
        return self.data.check(rhs);
    }
}

impl GreaterThanChecker {
    fn new(lhs: i32) -> Self {
        Self {
            data: DataChecker {
                lhs: lhs,
                op: todo!("???"),
            },
        }
    }
}

At the moment, I am not seeing a better way to handle the ??? above than defining

struct GreaterThanComparison {}
impl Comparison for GreaterThanComparison {
    fn compare(a: i32, b: i32) -> bool {
        a > b
    }
}

and then GreaterThanComparison {} in place of the ??? above. There will also very similar structs for LessThan , GreaterThanOrEquals , etc.

In Java, I could just write op: (a,b) -> a > b , which is much more concise. Is there something similar that could be done in Rust? Or other places where I could make things more concise?

As I was writing this, I realized that one answer is probably macros, but I am not familiar enough with them at this point to want to try to go down that path.

Answer 1

This answer is based on @EvilTak's comment.

Using Fn(...)->... will allow lambdas to work. Lambdas are not Sized , so they need to be Box ed.

struct Checker {
  lhs: i32,
  op: Box<dyn Comparison>
}

impl GreaterThanChecker {
  fn new(lhs: i32) -> Self {
     Self {
       data: DataChecker {
         lhs: lhs,
         op: Box::new(|a,b| a > b)
       }
     }
  }
}

impl Checker {
  fn check(&self, rhs: &str) -> bool {
    let i_rhs = rhs.parse::<i32>();
    // Need parentheses around self.op or else the compiler 
    // thinks we are trying to call the method named op, 
    // not the one stored in op
    if (self.op)(self.lhs, i_rhs) {
       do_stuff()
    }
  }
}

The Comparison classes then go away.