Struct Filter 

pub struct Filter(/* private fields */);

An idempotent, per-cell domain constraint with optional dynamic arguments.

Constructed via Filter::from_fn_0/Filter::from_fn_1/Filter::from_fn_2 for the common typed cases, or Filter::new for the fully type-erased form. Attached to a cell with crate::sheet::Sheet::add_filter.

Its callbacks must be pure, deterministic functions of their input values and immutable captured constants, with no externally observable side effects. Equal inputs produce equivalent outputs or errors. There is no guarantee that a callback executes, or when or how often it executes. This includes range-bound evaluators; the conforming callback must also be idempotent.

Implementations

impl Filter

pub fn new<F>( value_type: TypeId, args: Vec<CellId>, arg_types: Vec<TypeId>, f: F, ) -> Self

where F: Fn(&dyn Any, &[&dyn Any]) -> Result<Box<dyn Any>, Error> + 'static,

Creates a filter from an explicit value TypeId, argument TypeIds, and a type-erased function.

• Precondition: args.len() == arg_types.len().
• Precondition: f returns a value whose runtime type matches value_type.
• Precondition: f satisfies Filter’s purity and idempotence contract.

pub fn from_fn_0<T, F>(f: F) -> Self

where T: Any + 'static, F: Fn(&T) -> Result<T, Error> + 'static,

Creates a filter with no dynamic arguments from a typed closure.

The TypeId for T is captured automatically. The filter is validated against its cell registration when passed to crate::sheet::Sheet::add_filter.

• Precondition: f satisfies Filter’s purity and idempotence contract.

pub fn from_fn_1<A, T, F>(arg: CellId, f: F) -> Self

where A: Any + 'static, T: Any + 'static, F: Fn(&T, &A) -> Result<T, Error> + 'static,

Creates a filter with one dynamic argument cell from a typed closure.

TypeIds for A and T are captured automatically. The filter is validated against its cell registration when passed to crate::sheet::Sheet::add_filter.

• Precondition: f satisfies Filter’s purity and idempotence contract.

pub fn from_fn_2<A, B, T, F>(args: [CellId; 2], f: F) -> Self

where A: Any + 'static, B: Any + 'static, T: Any + 'static, F: Fn(&T, &A, &B) -> Result<T, Error> + 'static,

Creates a filter with two dynamic argument cells from a typed closure.

args[0] maps to A and args[1] maps to B. TypeIds for A, B, and T are captured automatically. The filter is validated when passed to crate::sheet::Sheet::add_filter.

• Precondition: f satisfies Filter’s purity and idempotence contract.

pub fn range<F, B>( value_type: TypeId, args: Vec<CellId>, arg_types: Vec<TypeId>, clamp: F, bounds: B, ) -> Self

where F: Fn(&dyn Any, &[&dyn Any]) -> Result<Box<dyn Any>, Error> + 'static, B: Fn(&[&dyn Any]) -> Option<(Box<dyn Any>, Box<dyn Any>)> + 'static,

Creates a range-clamp filter from an explicit value TypeId, argument TypeIds, a clamp function, and a bounds re-evaluator — the tagged counterpart of what Filter::new builds for FilterKind::Opaque. clamp is Filter’s actual per-write/per-propagate function (called exactly like an opaque filter’s); bounds is called independently, with no candidate value, by crate::sheet::Sheet::filter_range.

• Precondition: args.len() == arg_types.len().
• Precondition: clamp returns a value whose runtime type matches value_type.
• Precondition: when bounds returns Some, the pair’s values have a runtime type matching value_type.
• Precondition: clamp and bounds satisfy Filter’s purity contract; clamp is also idempotent.