Trait FilterFn 

pub trait FilterFn<A, I, T>: Send + 'static {
    // Required method
    fn execute(&self, scope: &mut Scope<I>, value: &T) -> Result<bool>;
}

Filter function.

Required Methods

fn execute(&self, scope: &mut Scope<I>, value: &T) -> Result<bool>

Executes the filter function.

Errors

This method returns an error if the function fails to execute.

Dyn Compatibility

This trait is dyn compatible.

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

Implementors

impl<F, R, I, T1, T2, T3, T4, T5, T6, T7, T8> FilterFn<ForIdSplat, I, (T1, T2, T3, T4, T5, T6, T7, T8)> for F

where F: Fn(&I, &T1, &T2, &T3, &T4, &T5, &T6, &T7, &T8) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3, T4, T5, T6, T7, T8> FilterFn<ForKeySplat, I, (T1, T2, T3, T4, T5, T6, T7, T8)> for F

where F: Fn(&Key<I>, &T1, &T2, &T3, &T4, &T5, &T6, &T7, &T8) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3, T4, T5, T6, T7, T8> FilterFn<ForScopeSplat, I, (T1, T2, T3, T4, T5, T6, T7, T8)> for F

where F: Fn(&mut Scope<I>, &T1, &T2, &T3, &T4, &T5, &T6, &T7, &T8) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3, T4, T5, T6, T7, T8> FilterFn<ForSplat, I, (T1, T2, T3, T4, T5, T6, T7, T8)> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5, &T6, &T7, &T8) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3, T4, T5, T6, T7> FilterFn<ForIdSplat, I, (T1, T2, T3, T4, T5, T6, T7)> for F

where F: Fn(&I, &T1, &T2, &T3, &T4, &T5, &T6, &T7) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3, T4, T5, T6, T7> FilterFn<ForKeySplat, I, (T1, T2, T3, T4, T5, T6, T7)> for F

where F: Fn(&Key<I>, &T1, &T2, &T3, &T4, &T5, &T6, &T7) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3, T4, T5, T6, T7> FilterFn<ForScopeSplat, I, (T1, T2, T3, T4, T5, T6, T7)> for F

where F: Fn(&mut Scope<I>, &T1, &T2, &T3, &T4, &T5, &T6, &T7) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3, T4, T5, T6, T7> FilterFn<ForSplat, I, (T1, T2, T3, T4, T5, T6, T7)> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5, &T6, &T7) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3, T4, T5, T6> FilterFn<ForIdSplat, I, (T1, T2, T3, T4, T5, T6)> for F

where F: Fn(&I, &T1, &T2, &T3, &T4, &T5, &T6) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3, T4, T5, T6> FilterFn<ForKeySplat, I, (T1, T2, T3, T4, T5, T6)> for F

where F: Fn(&Key<I>, &T1, &T2, &T3, &T4, &T5, &T6) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3, T4, T5, T6> FilterFn<ForScopeSplat, I, (T1, T2, T3, T4, T5, T6)> for F

where F: Fn(&mut Scope<I>, &T1, &T2, &T3, &T4, &T5, &T6) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3, T4, T5, T6> FilterFn<ForSplat, I, (T1, T2, T3, T4, T5, T6)> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5, &T6) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3, T4, T5> FilterFn<ForIdSplat, I, (T1, T2, T3, T4, T5)> for F

where F: Fn(&I, &T1, &T2, &T3, &T4, &T5) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3, T4, T5> FilterFn<ForKeySplat, I, (T1, T2, T3, T4, T5)> for F

where F: Fn(&Key<I>, &T1, &T2, &T3, &T4, &T5) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3, T4, T5> FilterFn<ForScopeSplat, I, (T1, T2, T3, T4, T5)> for F

where F: Fn(&mut Scope<I>, &T1, &T2, &T3, &T4, &T5) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3, T4, T5> FilterFn<ForSplat, I, (T1, T2, T3, T4, T5)> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3, T4> FilterFn<ForIdSplat, I, (T1, T2, T3, T4)> for F

where F: Fn(&I, &T1, &T2, &T3, &T4) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3, T4> FilterFn<ForKeySplat, I, (T1, T2, T3, T4)> for F

where F: Fn(&Key<I>, &T1, &T2, &T3, &T4) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3, T4> FilterFn<ForScopeSplat, I, (T1, T2, T3, T4)> for F

where F: Fn(&mut Scope<I>, &T1, &T2, &T3, &T4) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3, T4> FilterFn<ForSplat, I, (T1, T2, T3, T4)> for F

where F: Fn(&T1, &T2, &T3, &T4) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3> FilterFn<ForIdSplat, I, (T1, T2, T3)> for F

where F: Fn(&I, &T1, &T2, &T3) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3> FilterFn<ForKeySplat, I, (T1, T2, T3)> for F

where F: Fn(&Key<I>, &T1, &T2, &T3) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3> FilterFn<ForScopeSplat, I, (T1, T2, T3)> for F

where F: Fn(&mut Scope<I>, &T1, &T2, &T3) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2, T3> FilterFn<ForSplat, I, (T1, T2, T3)> for F

where F: Fn(&T1, &T2, &T3) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2> FilterFn<ForIdSplat, I, (T1, T2)> for F

where F: Fn(&I, &T1, &T2) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2> FilterFn<ForKeySplat, I, (T1, T2)> for F

where F: Fn(&Key<I>, &T1, &T2) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2> FilterFn<ForScopeSplat, I, (T1, T2)> for F

where F: Fn(&mut Scope<I>, &T1, &T2) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1, T2> FilterFn<ForSplat, I, (T1, T2)> for F

where F: Fn(&T1, &T2) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1> FilterFn<ForIdSplat, I, (T1,)> for F

where F: Fn(&I, &T1) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1> FilterFn<ForKeySplat, I, (T1,)> for F

where F: Fn(&Key<I>, &T1) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1> FilterFn<ForScopeSplat, I, (T1,)> for F

where F: Fn(&mut Scope<I>, &T1) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T1> FilterFn<ForSplat, I, (T1,)> for F

where F: Fn(&T1) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T> FilterFn<ForId, I, T> for F

where F: Fn(&I) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T> FilterFn<ForIdValue, I, T> for F

where F: Fn(&I, &T) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T> FilterFn<ForKey, I, T> for F

where F: Fn(&Key<I>) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T> FilterFn<ForKeyValue, I, T> for F

where F: Fn(&Key<I>, &T) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T> FilterFn<ForScope, I, T> for F

where F: Fn(&mut Scope<I>) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T> FilterFn<ForScopeValue, I, T> for F

where F: Fn(&mut Scope<I>, &T) -> R + Send + 'static, R: IntoResult<bool>, I: Display,

impl<F, R, I, T> FilterFn<ForValue, I, T> for F

where F: Fn(&T) -> R + Send + 'static, R: IntoResult<bool>, I: Display,