How to implement specification pattern in Rust?

Question

I'm wondering what is the idiomatic way to create a specification pattern in Rust?

Let's say there is a WorkingDay struct and two specifications should be created

IsActiveWorkingDaySpecification
IsInFutureWorkingDaySpecifictaion

My current approach looks like this

struct WorkingDay {
    id: uuid::Uuid,
    date: chrono::NaiveDate,
    is_active: bool,
}

trait Specification<T> {
    fn is_satisfied_by(&self, candidate: &T) -> bool;
}

struct IsActiveWorkingDaySpecification;

impl Specification<WorkingDay> for IsActiveWorkingDaySpecification {
    fn is_satisfied_by(&self, candidate: &WorkingDay) -> bool {
        candidate.is_active == true
    }
}

struct IsInFutureWorkingDaySpecification;

impl Specification<WorkingDay> for IsInFutureWorkingDaySpecification {
    fn is_satisfied_by(&self, candidate: &WorkingDay) -> bool {
        chrono::Utc::now().date().naive_utc() < candidate.date
    }
}

fn main() {
    let working_day = WorkingDay {
        id: uuid::Uuid::new_v4(),
        date: chrono::NaiveDate::from_ymd(2077, 11, 24),
        is_active: true,
    };

    let is_active_working_day_specification = IsActiveWorkingDaySpecification {};
    let is_future_working_day_specification = IsInFutureWorkingDaySpecification {};

    let is_active = is_active_working_day_specification.is_satisfied_by(&working_day);
    let is_in_future = is_future_working_day_specification.is_satisfied_by(&working_day);

    println!("IsActive: {}", is_active);
    println!("IsInFuture: {}", is_in_future);
}

The problem with this code is that the specifications cannot be composed. That is, if specification FutureActiveWorkingDaySpecification needs to be created it forces manually compare results of existing specifications

// cut

fn main () {
    // cut

    let is_active_working_day_specification = IsActiveWorkingDaySpecification {};
    let is_future_working_day_specification = IsInFutureWorkingDaySpecification {};

    let is_active = is_active_working_day_specification.is_satisfied_by(&working_day);
    let is_in_future = is_future_working_day_specification.is_satisfied_by(&working_day);

    let is_active_and_in_future = is_active && is_in_future; // AndSpecification
    let is_active_or_in_future = is_active || is_in_future; // OrSpecification

    // cut
}

I would like to achieve something like this, but don't know how

// cut

fn main () {
    // cut

    let is_active_working_day_specification = IsActiveWorkingDaySpecification {};
    let is_future_working_day_specification = IsInFutureWorkingDaySpecification {};

    // AndSpecification
    let is_active_and_in_future = is_active_working_day_specification
        .and(is_future_working_day_specification)
        .is_satisfied_by(&working_day);

    // OrSpecification
    let is_active_or_in_future = is_active_working_day_specification
        .or(is_future_working_day_specification)
        .is_satisfied_by(&working_day);

    // cut
}

score 2 · Answer 1 · edited May 30 '23 at 16:15

You can add default methods to the Specification trait that return combination structs, eg AndCombination

trait Specification<T> {
    fn is_satisfied_by(&self, candidate: &T) -> bool;
    fn and<O: Specification<T>>(self, other: O) -> AndCombination<Self, O>
    where Self: Sized {
        AndCombination(self, other)
    }
}

struct AndCombination<L, R>(L,R);

impl<T, L, R> Specification<T> for AndCombination<L,R>
    where L: Specification<T>,
        R: Specification<T>
{
    fn is_satisfied_by(&self, candidate: &T) -> bool {
        self.0.is_satisfied_by(candidate) && self.1.is_satisfied_by(candidate)
    }
}

These can then be combined to create composite specifications

let active_future = IsActive.and(IsInFuture);
println!("Day is active in future: {}", active_future.is_satisfied_by(&working_day));

Similar structs can be created for Or and Not.

Playground Example here

I absolutely forgot that trait functions can have [shared behavior](https://doc.rust-lang.org/book/ch10-02-traits.html). I'll try it and give you a feedback — Roman Mahotskyi, Aug 17 '22 at 10:26

score 1 · Accepted Answer · answered Aug 17 '22 at 10:37

This can be done by creating OrSpecification and AndSpecification structs which implement the Specification<T> trait, and then extending Specification<T> to include or and and methods with default implementations which create these:

trait Specification<T>: Sized {
    fn is_satisfied_by(&self, candidate: &T) -> bool;
    
    fn and<S>(self, other: S) -> AndSpecification<Self, S> {
        AndSpecification {
            a: self,
            b: other,
        }
    }
    
    fn or<S>(self, other: S) -> OrSpecification<Self, S> {
        OrSpecification {
            a: self,
            b: other,
        }
    }
}

struct AndSpecification<A, B> {
    a: A,
    b: B,
}

impl<T, A, B> Specification<T> for AndSpecification<A, B>
    where A: Specification<T>,
          B: Specification<T>,
{
    fn is_satisfied_by(&self, candidate: &T) -> bool {
        self.a.is_satisfied_by(candidate) && self.b.is_satisfied_by(candidate)
    }
}

struct OrSpecification<A, B> {
    a: A,
    b: B,
}

impl<T, A, B> Specification<T> for OrSpecification<A, B>
    where A: Specification<T>,
          B: Specification<T>,
{
    fn is_satisfied_by(&self, candidate: &T) -> bool {
        self.a.is_satisfied_by(candidate) || self.b.is_satisfied_by(candidate)
    }
}

Note that the requirement of Specification<T> to implement the Sized trait is avoidable, it would just require using Box in various places. For the sake of clarity here I've just chosen the simpler option.

How to implement specification pattern in Rust?

2 Answers2