Trait Joiner 

pub trait Joiner<A, B>: Send + Sync {
    // Required method
    fn matches(&self, a: &A, b: &B) -> bool;

    // Provided method
    fn and<J>(self, other: J) -> AndJoiner<Self, J>
       where Self: Sized,
             J: Joiner<A, B> { ... }
}

Required Methods

fn matches(&self, a: &A, b: &B) -> bool

Provided Methods

fn and<J>(self, other: J) -> AndJoiner<Self, J>

where Self: Sized, J: Joiner<A, B>,

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<A, B, F> Joiner<A, B> for FilteringJoiner<F>

where F: Fn(&A, &B) -> bool + Send + Sync,

impl<A, B, F> Joiner<A, B> for FnJoiner<F>

where F: Fn(&A, &B) -> bool + Send + Sync,

impl<A, B, J1, J2> Joiner<A, B> for AndJoiner<J1, J2>

where J1: Joiner<A, B>, J2: Joiner<A, B>,

impl<A, B, T, Fa, Fb, Mode> Joiner<A, B> for EqualJoiner<Fa, Fb, T, Mode>

where T: PartialEq, Fa: Fn(&A) -> T + Send + Sync, Fb: Fn(&B) -> T + Send + Sync,

impl<A, B, T, Fa, Fb> Joiner<A, B> for GreaterThanJoiner<Fa, Fb, T>

where T: Ord, Fa: Fn(&A) -> T + Send + Sync, Fb: Fn(&B) -> T + Send + Sync,

impl<A, B, T, Fa, Fb> Joiner<A, B> for GreaterThanOrEqualJoiner<Fa, Fb, T>

where T: Ord, Fa: Fn(&A) -> T + Send + Sync, Fb: Fn(&B) -> T + Send + Sync,

impl<A, B, T, Fa, Fb> Joiner<A, B> for LessThanJoiner<Fa, Fb, T>

where T: Ord, Fa: Fn(&A) -> T + Send + Sync, Fb: Fn(&B) -> T + Send + Sync,

impl<A, B, T, Fa, Fb> Joiner<A, B> for LessThanOrEqualJoiner<Fa, Fb, T>

where T: Ord, Fa: Fn(&A) -> T + Send + Sync, Fb: Fn(&B) -> T + Send + Sync,

impl<A, B, T, Fsa, Fea, Fsb, Feb> Joiner<A, B> for OverlappingJoiner<Fsa, Fea, Fsb, Feb, T>

where T: Ord, Fsa: Fn(&A) -> T + Send + Sync, Fea: Fn(&A) -> T + Send + Sync, Fsb: Fn(&B) -> T + Send + Sync, Feb: Fn(&B) -> T + Send + Sync,