Trait ObservableCacheEx 

pub trait ObservableCacheEx<T: Clone + 'static, K: Eq + Hash + Clone + 'static> {
    // Required method
    fn change_sets(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>;

    // Provided methods
    fn and_cache(
        &self,
        others: Vec<Rc<dyn IObservable<ChangeSet<T, K>>>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: Deref { ... }
    fn async_dispose_many(
        &self,
        disposals_completed_accessor: impl Fn(Rc<dyn IObservable<()>>) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: AsAsyncDisposable + PartialEq { ... }
    fn async_dispose_many_with(
        &self,
        to_item_disposal: impl Fn(&T) -> Option<ItemDisposal> + 'static,
        disposals_completed_accessor: impl Fn(Rc<dyn IObservable<()>>) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: PartialEq { ... }
    fn except(
        &self,
        others: Vec<Rc<dyn IObservable<ChangeSet<T, K>>>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: Deref { ... }
    fn full_join<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>(
        &self,
        right: Rc<dyn IObservable<ChangeSet<TR, KR>>>,
        right_key_selector: impl Fn(&TR) -> K + 'static,
        result_selector: impl Fn(Option<&T>, Option<&TR>) -> D + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, K>>> { ... }
    fn full_join_with_key<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>(
        &self,
        right: Rc<dyn IObservable<ChangeSet<TR, KR>>>,
        right_key_selector: impl Fn(&TR) -> K + 'static,
        result_selector: impl Fn(&K, Option<&T>, Option<&TR>) -> D + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, K>>> { ... }
    fn full_join_many<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>(
        &self,
        right: Rc<dyn IObservable<ChangeSet<TR, KR>>>,
        right_key_selector: impl Fn(&TR) -> K + 'static,
        result_selector: impl Fn(Option<&T>, &ImmutableGroup<TR, KR, K>) -> D + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, K>>> { ... }
    fn full_join_many_with_key<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>(
        &self,
        right: Rc<dyn IObservable<ChangeSet<TR, KR>>>,
        right_key_selector: impl Fn(&TR) -> K + 'static,
        result_selector: impl Fn(&K, Option<&T>, &ImmutableGroup<TR, KR, K>) -> D + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, K>>> { ... }
    fn inner_join<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>(
        &self,
        right: Rc<dyn IObservable<ChangeSet<TR, KR>>>,
        right_key_selector: impl Fn(&TR) -> K + 'static,
        result_selector: impl Fn(&T, &TR) -> D + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, (K, KR)>>> { ... }
    fn inner_join_with_key<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>(
        &self,
        right: Rc<dyn IObservable<ChangeSet<TR, KR>>>,
        right_key_selector: impl Fn(&TR) -> K + 'static,
        result_selector: impl Fn(&(K, KR), &T, &TR) -> D + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, (K, KR)>>> { ... }
    fn inner_join_many<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>(
        &self,
        right: Rc<dyn IObservable<ChangeSet<TR, KR>>>,
        right_key_selector: impl Fn(&TR) -> K + 'static,
        result_selector: impl Fn(&T, &ImmutableGroup<TR, KR, K>) -> D + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, K>>> { ... }
    fn inner_join_many_with_key<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>(
        &self,
        right: Rc<dyn IObservable<ChangeSet<TR, KR>>>,
        right_key_selector: impl Fn(&TR) -> K + 'static,
        result_selector: impl Fn(&K, &T, &ImmutableGroup<TR, KR, K>) -> D + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, K>>> { ... }
    fn left_join<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>(
        &self,
        right: Rc<dyn IObservable<ChangeSet<TR, KR>>>,
        right_key_selector: impl Fn(&TR) -> K + 'static,
        result_selector: impl Fn(&T, Option<&TR>) -> D + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, K>>> { ... }
    fn left_join_with_key<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>(
        &self,
        right: Rc<dyn IObservable<ChangeSet<TR, KR>>>,
        right_key_selector: impl Fn(&TR) -> K + 'static,
        result_selector: impl Fn(&K, &T, Option<&TR>) -> D + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, K>>> { ... }
    fn left_join_many<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>(
        &self,
        right: Rc<dyn IObservable<ChangeSet<TR, KR>>>,
        right_key_selector: impl Fn(&TR) -> K + 'static,
        result_selector: impl Fn(&T, &ImmutableGroup<TR, KR, K>) -> D + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, K>>> { ... }
    fn left_join_many_with_key<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>(
        &self,
        right: Rc<dyn IObservable<ChangeSet<TR, KR>>>,
        right_key_selector: impl Fn(&TR) -> K + 'static,
        result_selector: impl Fn(&K, &T, &ImmutableGroup<TR, KR, K>) -> D + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, K>>> { ... }
    fn or(
        &self,
        others: Vec<Rc<dyn IObservable<ChangeSet<T, K>>>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: Deref { ... }
    fn right_join<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>(
        &self,
        right: Rc<dyn IObservable<ChangeSet<TR, KR>>>,
        right_key_selector: impl Fn(&TR) -> K + 'static,
        result_selector: impl Fn(Option<&T>, &TR) -> D + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, KR>>> { ... }
    fn right_join_with_key<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>(
        &self,
        right: Rc<dyn IObservable<ChangeSet<TR, KR>>>,
        right_key_selector: impl Fn(&TR) -> K + 'static,
        result_selector: impl Fn(&KR, Option<&T>, &TR) -> D + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, KR>>> { ... }
    fn right_join_many<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>(
        &self,
        right: Rc<dyn IObservable<ChangeSet<TR, KR>>>,
        right_key_selector: impl Fn(&TR) -> K + 'static,
        result_selector: impl Fn(Option<&T>, &ImmutableGroup<TR, KR, K>) -> D + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, K>>> { ... }
    fn right_join_many_with_key<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>(
        &self,
        right: Rc<dyn IObservable<ChangeSet<TR, KR>>>,
        right_key_selector: impl Fn(&TR) -> K + 'static,
        result_selector: impl Fn(&K, Option<&T>, &ImmutableGroup<TR, KR, K>) -> D + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, K>>> { ... }
    fn transform_async<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T) -> Fut + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_async_with_key<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T, K) -> Fut + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_async_with_previous<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T, Option<T>, K) -> Fut + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_async_with_token<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T, Option<T>, K, CancellationToken) -> Fut + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_async_forced<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T) -> Fut + 'static,
        force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_async_with_key_forced<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T, K) -> Fut + 'static,
        force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_async_with_previous_forced<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T, Option<T>, K) -> Fut + 'static,
        force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_async_with_token_forced<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T, Option<T>, K, CancellationToken) -> Fut + 'static,
        force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_async_with_options<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T) -> Fut + 'static,
        options: TransformAsyncOptions,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_async_with_key_and_options<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T, K) -> Fut + 'static,
        options: TransformAsyncOptions,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_async_with_previous_and_options<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T, Option<T>, K) -> Fut + 'static,
        options: TransformAsyncOptions,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_async_with_token_and_options<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T, Option<T>, K, CancellationToken) -> Fut + 'static,
        options: TransformAsyncOptions,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_many_async<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, Fut: Future<Output = Result<Vec<D>, ObservableError>> + 'static>(
        &self,
        many_selector: impl Fn(T) -> Fut + 'static,
        key_selector: impl Fn(&D) -> DK + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_many_async_with_key<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, Fut: Future<Output = Result<Vec<D>, ObservableError>> + 'static>(
        &self,
        many_selector: impl Fn(T, K) -> Fut + 'static,
        key_selector: impl Fn(&D) -> DK + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_many_async_with<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, Fut: Future<Output = Result<Vec<D>, ObservableError>> + 'static>(
        &self,
        many_selector: impl Fn(T, K) -> Fut + 'static,
        key_selector: impl Fn(&D) -> DK + 'static,
        equality_comparer: Option<Rc<dyn Fn(&D, &D) -> bool>>,
        comparer: Option<Rc<dyn Fn(&D, &D) -> Ordering>>,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_many_async_observable_collection<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: ObservableCollectionEx<D> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>(
        &self,
        many_selector: impl Fn(T) -> Fut + 'static,
        key_selector: impl Fn(&D) -> DK + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_many_async_observable_collection_with_key<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: ObservableCollectionEx<D> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>(
        &self,
        many_selector: impl Fn(T, K) -> Fut + 'static,
        key_selector: impl Fn(&D) -> DK + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_many_async_observable_collection_with<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: ObservableCollectionEx<D> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>(
        &self,
        many_selector: impl Fn(T, K) -> Fut + 'static,
        key_selector: impl Fn(&D) -> DK + 'static,
        equality_comparer: Option<Rc<dyn Fn(&D, &D) -> bool>>,
        comparer: Option<Rc<dyn Fn(&D, &D) -> Ordering>>,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_many_async_observable_cache<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: IObservableCache<D, DK> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>(
        &self,
        many_selector: impl Fn(T) -> Fut + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_many_async_observable_cache_with_key<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: IObservableCache<D, DK> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>(
        &self,
        many_selector: impl Fn(T, K) -> Fut + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_many_async_observable_cache_with<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: IObservableCache<D, DK> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>(
        &self,
        many_selector: impl Fn(T, K) -> Fut + 'static,
        equality_comparer: Option<Rc<dyn Fn(&D, &D) -> bool>>,
        comparer: Option<Rc<dyn Fn(&D, &D) -> Ordering>>,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_many_safe_async<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, Fut: Future<Output = Result<Vec<D>, ObservableError>> + 'static>(
        &self,
        many_selector: impl Fn(T) -> Fut + 'static,
        key_selector: impl Fn(&D) -> DK + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_many_safe_async_with_key<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, Fut: Future<Output = Result<Vec<D>, ObservableError>> + 'static>(
        &self,
        many_selector: impl Fn(T, K) -> Fut + 'static,
        key_selector: impl Fn(&D) -> DK + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_many_safe_async_with<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, Fut: Future<Output = Result<Vec<D>, ObservableError>> + 'static>(
        &self,
        many_selector: impl Fn(T, K) -> Fut + 'static,
        key_selector: impl Fn(&D) -> DK + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
        equality_comparer: Option<Rc<dyn Fn(&D, &D) -> bool>>,
        comparer: Option<Rc<dyn Fn(&D, &D) -> Ordering>>,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_many_safe_async_observable_collection<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: ObservableCollectionEx<D> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>(
        &self,
        many_selector: impl Fn(T) -> Fut + 'static,
        key_selector: impl Fn(&D) -> DK + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_many_safe_async_observable_collection_with_key<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: ObservableCollectionEx<D> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>(
        &self,
        many_selector: impl Fn(T, K) -> Fut + 'static,
        key_selector: impl Fn(&D) -> DK + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_many_safe_async_observable_collection_with<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: ObservableCollectionEx<D> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>(
        &self,
        many_selector: impl Fn(T, K) -> Fut + 'static,
        key_selector: impl Fn(&D) -> DK + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
        equality_comparer: Option<Rc<dyn Fn(&D, &D) -> bool>>,
        comparer: Option<Rc<dyn Fn(&D, &D) -> Ordering>>,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_many_safe_async_observable_cache<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: IObservableCache<D, DK> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>(
        &self,
        many_selector: impl Fn(T) -> Fut + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_many_safe_async_observable_cache_with_key<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: IObservableCache<D, DK> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>(
        &self,
        many_selector: impl Fn(T, K) -> Fut + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_many_safe_async_observable_cache_with<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: IObservableCache<D, DK> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>(
        &self,
        many_selector: impl Fn(T, K) -> Fut + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
        equality_comparer: Option<Rc<dyn Fn(&D, &D) -> bool>>,
        comparer: Option<Rc<dyn Fn(&D, &D) -> Ordering>>,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_safe_async<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T) -> Fut + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe_async_with_key<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T, K) -> Fut + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe_async_with_previous<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T, Option<T>, K) -> Fut + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe_async_with_token<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T, Option<T>, K, CancellationToken) -> Fut + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe_async_forced<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T) -> Fut + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
        force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe_async_with_key_forced<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T, K) -> Fut + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
        force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe_async_with_previous_forced<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T, Option<T>, K) -> Fut + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
        force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe_async_with_token_forced<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T, Option<T>, K, CancellationToken) -> Fut + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
        force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe_async_with_options<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T) -> Fut + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
        options: TransformAsyncOptions,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe_async_with_key_and_options<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T, K) -> Fut + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
        options: TransformAsyncOptions,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe_async_with_previous_and_options<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T, Option<T>, K) -> Fut + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
        options: TransformAsyncOptions,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe_async_with_token_and_options<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>(
        &self,
        transform_factory: impl Fn(T, Option<T>, K, CancellationToken) -> Fut + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
        options: TransformAsyncOptions,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn xor(
        &self,
        others: Vec<Rc<dyn IObservable<ChangeSet<T, K>>>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: Deref { ... }
    fn adapt(
        &self,
        adaptor: Rc<dyn IChangeSetAdaptor<T, K>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn adapt_sorted(
        &self,
        adaptor: Rc<dyn ISortedChangeSetAdaptor<T, K>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where Self: Sized + 'static { ... }
    fn auto_refresh<P: IntoPropertyChain<T>>(
        &self,
        property_accessor: P,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where P::Value: 'static { ... }
    fn auto_refresh_with<P: IntoPropertyChain<T>>(
        &self,
        property_accessor: P,
        change_set_buffer: Option<Duration>,
        property_change_throttle: Option<Duration>,
        scheduler: Option<Rc<dyn IScheduler>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where P::Value: 'static { ... }
    fn auto_refresh_any(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: NotifyPropertyChangedEx { ... }
    fn auto_refresh_any_with(
        &self,
        change_set_buffer: Option<Duration>,
        property_change_throttle: Option<Duration>,
        scheduler: Option<Rc<dyn IScheduler>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: NotifyPropertyChangedEx { ... }
    fn auto_refresh_on_observable<A: 'static>(
        &self,
        reevaluator: impl Fn(&T) -> Rc<dyn IObservable<A>> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn auto_refresh_on_observable_with<A: 'static>(
        &self,
        reevaluator: impl Fn(&T) -> Rc<dyn IObservable<A>> + 'static,
        change_set_buffer: Option<Duration>,
        scheduler: Option<Rc<dyn IScheduler>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn auto_refresh_on_observable_with_key<A: 'static>(
        &self,
        reevaluator: impl Fn(&T, &K) -> Rc<dyn IObservable<A>> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn auto_refresh_on_observable_with_key_with<A: 'static>(
        &self,
        reevaluator: impl Fn(&T, &K) -> Rc<dyn IObservable<A>> + 'static,
        change_set_buffer: Option<Duration>,
        scheduler: Option<Rc<dyn IScheduler>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn batch(&self, time_span: Duration) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn batch_on(
        &self,
        time_span: Duration,
        scheduler: Rc<dyn IScheduler>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn batch_if(
        &self,
        pause_if_true_selector: Rc<dyn IObservable<bool>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn batch_if_on(
        &self,
        pause_if_true_selector: Rc<dyn IObservable<bool>>,
        scheduler: Rc<dyn IScheduler>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn batch_if_with_initial(
        &self,
        pause_if_true_selector: Rc<dyn IObservable<bool>>,
        initial_pause_state: bool,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn batch_if_with_initial_on(
        &self,
        pause_if_true_selector: Rc<dyn IObservable<bool>>,
        initial_pause_state: bool,
        scheduler: Rc<dyn IScheduler>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn batch_if_with_time_out(
        &self,
        pause_if_true_selector: Rc<dyn IObservable<bool>>,
        time_out: Option<Duration>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn batch_if_with_time_out_on(
        &self,
        pause_if_true_selector: Rc<dyn IObservable<bool>>,
        time_out: Option<Duration>,
        scheduler: Rc<dyn IScheduler>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn batch_if_with_initial_and_time_out(
        &self,
        pause_if_true_selector: Rc<dyn IObservable<bool>>,
        initial_pause_state: bool,
        time_out: Option<Duration>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn batch_if_with_initial_and_time_out_on(
        &self,
        pause_if_true_selector: Rc<dyn IObservable<bool>>,
        initial_pause_state: bool,
        time_out: Option<Duration>,
        scheduler: Rc<dyn IScheduler>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn batch_if_with_timer(
        &self,
        pause_if_true_selector: Rc<dyn IObservable<bool>>,
        timer: Option<Rc<dyn IObservable<()>>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn batch_if_with_timer_on(
        &self,
        pause_if_true_selector: Rc<dyn IObservable<bool>>,
        timer: Option<Rc<dyn IObservable<()>>>,
        scheduler: Rc<dyn IScheduler>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn batch_if_with_initial_and_timer(
        &self,
        pause_if_true_selector: Rc<dyn IObservable<bool>>,
        initial_pause_state: bool,
        timer: Option<Rc<dyn IObservable<()>>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn batch_if_with_initial_and_timer_on(
        &self,
        pause_if_true_selector: Rc<dyn IObservable<bool>>,
        initial_pause_state: bool,
        timer: Option<Rc<dyn IObservable<()>>>,
        scheduler: Rc<dyn IScheduler>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn bind<C: IObservableCollection<T> + Clone + 'static>(
        &self,
        destination: &C,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: PartialEq,
             Self: Sized + 'static { ... }
    fn bind_with_threshold<C: IObservableCollection<T> + Clone + 'static>(
        &self,
        destination: &C,
        refresh_threshold: usize,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: PartialEq { ... }
    fn bind_with_options<C: IObservableCollection<T> + Clone + 'static>(
        &self,
        destination: &C,
        options: BindingOptions,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: PartialEq,
             Self: Sized + 'static { ... }
    fn bind_with_adaptor<C: IObservableCollection<T> + Clone + 'static>(
        &self,
        destination: &C,
        updater: Rc<dyn IObservableCollectionAdaptor<T, K>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: PartialEq { ... }
    fn bind_with_sorted_adaptor<C: IObservableCollection<T> + Clone + 'static>(
        &self,
        destination: &C,
        updater: Rc<dyn ISortedObservableCollectionAdaptor<T, K>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: PartialEq,
             Self: Sized + 'static { ... }
    fn bind_read_only(
        &self,
    ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)
       where T: PartialEq,
             Self: Sized + 'static { ... }
    fn bind_read_only_with(
        &self,
        reset_threshold: usize,
        use_replace_for_updates: bool,
    ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)
       where T: PartialEq,
             Self: Sized + 'static { ... }
    fn bind_read_only_with_options(
        &self,
        options: BindingOptions,
    ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)
       where T: PartialEq,
             Self: Sized + 'static { ... }
    fn bind_read_only_with_adaptor(
        &self,
        adaptor: Rc<dyn IObservableCollectionAdaptor<T, K>>,
    ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)
       where T: PartialEq { ... }
    fn bind_read_only_with_sorted_adaptor(
        &self,
        adaptor: Rc<dyn ISortedObservableCollectionAdaptor<T, K>>,
    ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)
       where T: PartialEq,
             Self: Sized + 'static { ... }
    fn bind_to_observable_list(
        &self,
    ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, Rc<dyn IObservableList<T>>)
       where T: PartialEq,
             Self: Sized + 'static { ... }
    fn buffer_initial(
        &self,
        initial_buffer: Duration,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn buffer_initial_on(
        &self,
        initial_buffer: Duration,
        scheduler: Rc<dyn IScheduler>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn cast_cache<U: Clone + 'static>(
        &self,
        converter: impl Fn(&T) -> U + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn change_key<K2: Eq + Hash + Clone + 'static>(
        &self,
        key_selector: impl Fn(&T) -> K2 + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K2>>> { ... }
    fn change_key_with_key<K2: Eq + Hash + Clone + 'static>(
        &self,
        key_selector: impl Fn(&K, &T) -> K2 + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K2>>> { ... }
    fn clone_to(
        &self,
        target: Rc<RefCell<Vec<T>>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: PartialEq { ... }
    fn convert<U: Clone + 'static>(
        &self,
        conversion_factory: impl Fn(&T) -> U + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn defer_until_loaded(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn dispose_many(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: AsDisposable { ... }
    fn dispose_many_with(
        &self,
        to_disposable: impl Fn(&T) -> Option<Rc<dyn IDisposable>> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn distinct_values<V: Eq + Hash + Clone + 'static>(
        &self,
        value_selector: impl Fn(&T) -> V + 'static,
    ) -> Rc<dyn IObservable<DistinctChangeSet<V>>> { ... }
    fn ensure_unique_keys(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn expire_after(
        &self,
        time_selector: impl Fn(&T) -> Option<Duration> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn expire_after_on(
        &self,
        time_selector: impl Fn(&T) -> Option<Duration> + 'static,
        scheduler: Rc<dyn IScheduler>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn expire_after_with_polling(
        &self,
        time_selector: impl Fn(&T) -> Option<Duration> + 'static,
        polling_interval: Option<Duration>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn expire_after_with_polling_on(
        &self,
        time_selector: impl Fn(&T) -> Option<Duration> + 'static,
        polling_interval: Option<Duration>,
        scheduler: Rc<dyn IScheduler>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn filter_immutable(
        &self,
        predicate: impl Fn(&T) -> bool + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn filter_immutable_with(
        &self,
        predicate: impl Fn(&T) -> bool + 'static,
        suppress_empty_change_sets: bool,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn try_filter_immutable(
        &self,
        predicate: impl Fn(&T) -> Result<bool, ObservableError> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn try_filter_immutable_with(
        &self,
        predicate: impl Fn(&T) -> Result<bool, ObservableError> + 'static,
        suppress_empty_change_sets: bool,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn filter_on_observable(
        &self,
        filter_factory: impl Fn(&T) -> Rc<dyn IObservable<bool>> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn filter_on_observable_with(
        &self,
        filter_factory: impl Fn(&T) -> Rc<dyn IObservable<bool>> + 'static,
        buffer: Option<Duration>,
        scheduler: Option<Rc<dyn IScheduler>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn filter_on_observable_with_key(
        &self,
        filter_factory: impl Fn(&T, &K) -> Rc<dyn IObservable<bool>> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn filter_on_observable_with_key_with(
        &self,
        filter_factory: impl Fn(&T, &K) -> Rc<dyn IObservable<bool>> + 'static,
        buffer: Option<Duration>,
        scheduler: Option<Rc<dyn IScheduler>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn flatten(&self) -> Rc<dyn IObservable<Change<T, K>>> { ... }
    fn for_each_change(
        &self,
        action: impl Fn(&Change<T, K>) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn group<G: Eq + Hash + Clone + 'static>(
        &self,
        group_selector_key: impl Fn(&T) -> G + 'static,
    ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>> { ... }
    fn group_with<G: Eq + Hash + Clone + 'static>(
        &self,
        group_selector_key: impl Fn(&T) -> G + 'static,
        regrouper: Rc<dyn IObservable<()>>,
    ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>> { ... }
    fn group_with_result_groups<G: Eq + Hash + Clone + 'static, C: IChangeSet<G, G>>(
        &self,
        group_selector: impl Fn(&T) -> G + 'static,
        result_group_source: Rc<dyn IObservable<C>>,
    ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>> { ... }
    fn group_dynamic<G: Eq + Hash + Clone + 'static>(
        &self,
        group_selector_key_observable: Rc<dyn IObservable<Rc<dyn Fn(&T) -> G>>>,
    ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>> { ... }
    fn group_dynamic_with<G: Eq + Hash + Clone + 'static>(
        &self,
        group_selector_key_observable: Rc<dyn IObservable<Rc<dyn Fn(&T) -> G>>>,
        regrouper: Rc<dyn IObservable<()>>,
    ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>> { ... }
    fn group_dynamic_with_key<G: Eq + Hash + Clone + 'static>(
        &self,
        group_selector_key_observable: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> G>>>,
    ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>> { ... }
    fn group_dynamic_with_key_with<G: Eq + Hash + Clone + 'static>(
        &self,
        group_selector_key_observable: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> G>>>,
        regrouper: Rc<dyn IObservable<()>>,
    ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>> { ... }
    fn group_on_observable<G: Eq + Hash + Clone + 'static>(
        &self,
        group_observable_selector: impl Fn(&T) -> Rc<dyn IObservable<G>> + 'static,
    ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>> { ... }
    fn group_on_observable_with_key<G: Eq + Hash + Clone + 'static>(
        &self,
        group_observable_selector: impl Fn(&T, &K) -> Rc<dyn IObservable<G>> + 'static,
    ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>> { ... }
    fn try_group_on_observable<G: Eq + Hash + Clone + 'static>(
        &self,
        group_observable_selector: impl Fn(&T) -> Result<Rc<dyn IObservable<G>>, ObservableError> + 'static,
    ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>> { ... }
    fn try_group_on_observable_with_key<G: Eq + Hash + Clone + 'static>(
        &self,
        group_observable_selector: impl Fn(&T, &K) -> Result<Rc<dyn IObservable<G>>, ObservableError> + 'static,
    ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>> { ... }
    fn group_on_property<G: Eq + Hash + Clone + 'static>(
        &self,
        property_selector: PropertyPath<T, G>,
    ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>> { ... }
    fn group_on_property_with<G: Eq + Hash + Clone + 'static>(
        &self,
        property_selector: PropertyPath<T, G>,
        property_changed_throttle: Duration,
    ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>> { ... }
    fn group_on_property_with_on<G: Eq + Hash + Clone + 'static>(
        &self,
        property_selector: PropertyPath<T, G>,
        property_changed_throttle: Duration,
        scheduler: Rc<dyn IScheduler>,
    ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>> { ... }
    fn group_on_property_with_immutable_state<G: Eq + Hash + Clone + 'static>(
        &self,
        property_selector: PropertyPath<T, G>,
    ) -> Rc<dyn IObservable<ImmutableGroupChangeSet<T, K, G>>> { ... }
    fn group_on_property_with_immutable_state_with<G: Eq + Hash + Clone + 'static>(
        &self,
        property_selector: PropertyPath<T, G>,
        property_changed_throttle: Duration,
    ) -> Rc<dyn IObservable<ImmutableGroupChangeSet<T, K, G>>> { ... }
    fn group_on_property_with_immutable_state_with_on<G: Eq + Hash + Clone + 'static>(
        &self,
        property_selector: PropertyPath<T, G>,
        property_changed_throttle: Duration,
        scheduler: Rc<dyn IScheduler>,
    ) -> Rc<dyn IObservable<ImmutableGroupChangeSet<T, K, G>>> { ... }
    fn group_with_immutable_state<G: Eq + Hash + Clone + 'static>(
        &self,
        group_selector_key: impl Fn(&T) -> G + 'static,
    ) -> Rc<dyn IObservable<ImmutableGroupChangeSet<T, K, G>>> { ... }
    fn group_with_immutable_state_with<G: Eq + Hash + Clone + 'static>(
        &self,
        group_selector_key: impl Fn(&T) -> G + 'static,
        regrouper: Rc<dyn IObservable<()>>,
    ) -> Rc<dyn IObservable<ImmutableGroupChangeSet<T, K, G>>> { ... }
    fn ignore_same_reference_update(
        &self,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: Deref { ... }
    fn ignore_update_when(
        &self,
        ignore_function: impl Fn(&T, &T) -> bool + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn include_update_when(
        &self,
        include_function: impl Fn(&T, &T) -> bool + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn invoke_evaluate(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: IEvaluateAware { ... }
    fn limit_size_to(&self, size: usize) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn merge_change_sets(
        &self,
        other: Rc<dyn IObservable<ChangeSet<T, K>>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: PartialEq { ... }
    fn merge_change_sets_with_comparer(
        &self,
        other: Rc<dyn IObservable<ChangeSet<T, K>>>,
        equality_comparer: impl Fn(&T, &T) -> bool + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn merge_change_sets_ordered_by(
        &self,
        other: Rc<dyn IObservable<ChangeSet<T, K>>>,
        comparer: Rc<dyn Fn(&T, &T) -> Ordering>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: PartialEq { ... }
    fn merge_change_sets_with(
        &self,
        other: Rc<dyn IObservable<ChangeSet<T, K>>>,
        equality_comparer: Option<Rc<dyn Fn(&T, &T) -> bool>>,
        comparer: Option<Rc<dyn Fn(&T, &T) -> Ordering>>,
        scheduler: Option<Rc<dyn IScheduler>>,
        completable: bool,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: PartialEq { ... }
    fn merge_change_sets_many(
        &self,
        others: Vec<Rc<dyn IObservable<ChangeSet<T, K>>>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: PartialEq { ... }
    fn merge_change_sets_many_with(
        &self,
        others: Vec<Rc<dyn IObservable<ChangeSet<T, K>>>>,
        equality_comparer: Option<Rc<dyn Fn(&T, &T) -> bool>>,
        comparer: Option<Rc<dyn Fn(&T, &T) -> Ordering>>,
        scheduler: Option<Rc<dyn IScheduler>>,
        completable: bool,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: PartialEq { ... }
    fn merge_many<D: 'static>(
        &self,
        observable_selector: impl Fn(&T) -> Rc<dyn IObservable<D>> + 'static,
    ) -> Rc<dyn IObservable<D>> { ... }
    fn merge_many_with_key<D: 'static>(
        &self,
        observable_selector: impl Fn(&T, &K) -> Rc<dyn IObservable<D>> + 'static,
    ) -> Rc<dyn IObservable<D>> { ... }
    fn merge_many_change_sets<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static>(
        &self,
        observable_selector: impl Fn(&T) -> Rc<dyn IObservable<ChangeSet<D, DK>>> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn merge_many_change_sets_with_key<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static>(
        &self,
        observable_selector: impl Fn(&T, &K) -> Rc<dyn IObservable<ChangeSet<D, DK>>> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn merge_many_change_sets_with_comparer<D: Clone + 'static, DK: Eq + Hash + Clone + 'static>(
        &self,
        observable_selector: impl Fn(&T) -> Rc<dyn IObservable<ChangeSet<D, DK>>> + 'static,
        equality_comparer: impl Fn(&D, &D) -> bool + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn merge_many_change_sets_ordered_by<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static>(
        &self,
        observable_selector: impl Fn(&T) -> Rc<dyn IObservable<ChangeSet<D, DK>>> + 'static,
        comparer: Rc<dyn Fn(&D, &D) -> Ordering>,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn merge_many_change_sets_with<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static>(
        &self,
        observable_selector: impl Fn(&T, &K) -> Rc<dyn IObservable<ChangeSet<D, DK>>> + 'static,
        equality_comparer: Option<Rc<dyn Fn(&D, &D) -> bool>>,
        comparer: Option<Rc<dyn Fn(&D, &D) -> Ordering>>,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn merge_many_change_sets_with_source_comparer<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static>(
        &self,
        observable_selector: impl Fn(&T) -> Rc<dyn IObservable<ChangeSet<D, DK>>> + 'static,
        source_comparer: Rc<dyn Fn(&T, &T) -> Ordering>,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>
       where T: PartialEq { ... }
    fn merge_many_change_sets_with_source_comparer_with<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static>(
        &self,
        observable_selector: impl Fn(&T, &K) -> Rc<dyn IObservable<ChangeSet<D, DK>>> + 'static,
        source_comparer: Rc<dyn Fn(&T, &T) -> Ordering>,
        resort_on_source_refresh: bool,
        equality_comparer: Option<Rc<dyn Fn(&D, &D) -> bool>>,
        child_comparer: Option<Rc<dyn Fn(&D, &D) -> Ordering>>,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>
       where T: PartialEq { ... }
    fn merge_many_list_change_sets<D: Clone + PartialEq + 'static>(
        &self,
        observable_selector: impl Fn(&T) -> Rc<dyn IObservable<ChangeSet<D>>> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D>>> { ... }
    fn merge_many_list_change_sets_with_key<D: Clone + PartialEq + 'static>(
        &self,
        observable_selector: impl Fn(&T, &K) -> Rc<dyn IObservable<ChangeSet<D>>> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D>>> { ... }
    fn merge_many_list_change_sets_with<D: Clone + PartialEq + 'static>(
        &self,
        observable_selector: impl Fn(&T, &K) -> Rc<dyn IObservable<ChangeSet<D>>> + 'static,
        equality_comparer: Option<Rc<dyn Fn(&D, &D) -> bool>>,
    ) -> Rc<dyn IObservable<ChangeSet<D>>> { ... }
    fn merge_many_items<D: 'static>(
        &self,
        observable_selector: impl Fn(&T) -> Rc<dyn IObservable<D>> + 'static,
    ) -> Rc<dyn IObservable<ItemWithValue<T, D>>> { ... }
    fn merge_many_items_with_key<D: 'static>(
        &self,
        observable_selector: impl Fn(&T, &K) -> Rc<dyn IObservable<D>> + 'static,
    ) -> Rc<dyn IObservable<ItemWithValue<T, D>>> { ... }
    fn of_type_cache<U: 'static>(
        &self,
    ) -> Rc<dyn IObservable<ChangeSet<Rc<U>, K>>>
       where T: AnyObject { ... }
    fn of_type_cache_with<U: 'static>(
        &self,
        suppress_empty_change_sets: bool,
    ) -> Rc<dyn IObservable<ChangeSet<Rc<U>, K>>>
       where T: AnyObject { ... }
    fn on_item_added(
        &self,
        add_action: impl Fn(&T) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn on_item_added_with_key(
        &self,
        add_action: impl Fn(&T, &K) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn on_item_refreshed(
        &self,
        refresh_action: impl Fn(&T) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn on_item_refreshed_with_key(
        &self,
        refresh_action: impl Fn(&T, &K) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn on_item_removed(
        &self,
        remove_action: impl Fn(&T) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn on_item_removed_with_key(
        &self,
        remove_action: impl Fn(&T, &K) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn on_item_removed_with(
        &self,
        remove_action: impl Fn(&T, &K) + 'static,
        invoke_on_unsubscribe: bool,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn on_item_updated(
        &self,
        update_action: impl Fn(&T, &T) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn on_item_updated_with_key(
        &self,
        update_action: impl Fn(&T, &T, &K) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn populate_into<D: ISourceCache<T, K> + Clone + 'static>(
        &self,
        destination: &D,
    ) -> Rc<dyn IDisposable> { ... }
    fn populate_into_intermediate(
        &self,
        destination: &IntermediateCache<T, K>,
    ) -> Rc<dyn IDisposable> { ... }
    fn populate_into_lock_free(
        &self,
        destination: &LockFreeObservableCache<T, K>,
    ) -> Rc<dyn IDisposable> { ... }
    fn query_when_changed(&self) -> Rc<dyn IObservable<Rc<dyn IQuery<T, K>>>> { ... }
    fn query_when_changed_with<R: 'static>(
        &self,
        result_selector: impl Fn(Rc<dyn IQuery<T, K>>) -> R + 'static,
    ) -> Rc<dyn IObservable<R>> { ... }
    fn query_when_changed_with_trigger<V: 'static>(
        &self,
        item_changed_trigger: impl Fn(&T) -> Rc<dyn IObservable<V>> + 'static,
    ) -> Rc<dyn IObservable<Rc<dyn IQuery<T, K>>>> { ... }
    fn ref_count(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn remove_key(&self) -> Rc<dyn IObservable<ChangeSet<T>>>
       where T: PartialEq { ... }
    fn skip_initial(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn sort(
        &self,
        comparer: Rc<dyn Fn(&T, &T) -> Ordering>,
    ) -> Rc<dyn IObservable<SortedChangeSet<T, K>>> { ... }
    fn sort_with(
        &self,
        comparer: Rc<dyn Fn(&T, &T) -> Ordering>,
        sort_optimisations: SortOptimisations,
        reset_threshold: usize,
    ) -> Rc<dyn IObservable<SortedChangeSet<T, K>>> { ... }
    fn sort_dynamic(
        &self,
        comparer_observable: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>,
    ) -> Rc<dyn IObservable<SortedChangeSet<T, K>>> { ... }
    fn sort_dynamic_with(
        &self,
        comparer_observable: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>,
        sort_optimisations: SortOptimisations,
        reset_threshold: usize,
    ) -> Rc<dyn IObservable<SortedChangeSet<T, K>>> { ... }
    fn sort_dynamic_with_resorter(
        &self,
        comparer_observable: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>,
        resorter: Rc<dyn IObservable<()>>,
        sort_optimisations: SortOptimisations,
        reset_threshold: usize,
    ) -> Rc<dyn IObservable<SortedChangeSet<T, K>>> { ... }
    fn sort_with_resorter(
        &self,
        comparer: Rc<dyn Fn(&T, &T) -> Ordering>,
        resorter: Rc<dyn IObservable<()>>,
        sort_optimisations: SortOptimisations,
        reset_threshold: usize,
    ) -> Rc<dyn IObservable<SortedChangeSet<T, K>>> { ... }
    fn sort_and_bind<L: IList<T> + Clone + 'static>(
        &self,
        target: &L,
        comparer: Rc<dyn Fn(&T, &T) -> Ordering>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: PartialEq { ... }
    fn sort_and_bind_with(
        &self,
        target: &(impl IList<T> + Clone + 'static),
        comparer: Rc<dyn Fn(&T, &T) -> Ordering>,
        options: SortAndBindOptions,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: PartialEq { ... }
    fn sort_and_bind_by_default(
        &self,
        target: &(impl IList<T> + Clone + 'static),
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: Ord { ... }
    fn sort_and_bind_by_default_with(
        &self,
        target: &(impl IList<T> + Clone + 'static),
        options: SortAndBindOptions,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: Ord { ... }
    fn sort_and_bind_on_observable(
        &self,
        target: &(impl IList<T> + Clone + 'static),
        comparer_changed: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: PartialEq { ... }
    fn sort_and_bind_on_observable_with(
        &self,
        target: &(impl IList<T> + Clone + 'static),
        comparer_changed: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>,
        options: SortAndBindOptions,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: PartialEq { ... }
    fn sort_and_bind_read_only(
        &self,
        comparer: Rc<dyn Fn(&T, &T) -> Ordering>,
    ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)
       where T: PartialEq { ... }
    fn sort_and_bind_read_only_with(
        &self,
        comparer: Rc<dyn Fn(&T, &T) -> Ordering>,
        options: SortAndBindOptions,
    ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)
       where T: PartialEq { ... }
    fn sort_and_bind_read_only_by_default(
        &self,
    ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)
       where T: Ord { ... }
    fn sort_and_bind_read_only_by_default_with(
        &self,
        options: SortAndBindOptions,
    ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)
       where T: Ord { ... }
    fn sort_and_bind_read_only_on_observable(
        &self,
        comparer_changed: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>,
    ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)
       where T: PartialEq { ... }
    fn sort_and_bind_read_only_on_observable_with(
        &self,
        comparer_changed: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>,
        options: SortAndBindOptions,
    ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)
       where T: PartialEq { ... }
    fn bind_to_list(
        &self,
        target_list: &(impl IList<T> + Clone + 'static),
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: PartialEq,
             Self: Sized + 'static { ... }
    fn bind_to_list_with(
        &self,
        target_list: &(impl IList<T> + Clone + 'static),
        options: SortAndBindOptions,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: PartialEq,
             Self: Sized + 'static { ... }
    fn bind_read_only_with_sort_and_bind_options(
        &self,
        options: SortAndBindOptions,
    ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)
       where T: PartialEq,
             Self: Sized + 'static { ... }
    fn sort_by<V: PartialOrd + 'static>(
        &self,
        expression: impl Fn(&T) -> V + 'static,
    ) -> Rc<dyn IObservable<SortedChangeSet<T, K>>> { ... }
    fn sort_by_with<V: PartialOrd + 'static>(
        &self,
        expression: impl Fn(&T) -> V + 'static,
        sort_order: SortDirection,
        sort_optimisations: SortOptimisations,
        reset_threshold: usize,
    ) -> Rc<dyn IObservable<SortedChangeSet<T, K>>> { ... }
    fn start_with_empty(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn start_with_item(
        &self,
        item: T,
        key: K,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn start_with_keyed_item(
        &self,
        item: T,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>>
       where T: IKey<K> { ... }
    fn subscribe_many(
        &self,
        subscription_factory: impl Fn(&T) -> Rc<dyn IDisposable> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn subscribe_many_with_key(
        &self,
        subscription_factory: impl Fn(&T, &K) -> Rc<dyn IDisposable> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn suppress_refresh(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn to_collection(&self) -> Rc<dyn IObservable<Vec<T>>> { ... }
    fn to_observable_optional(&self, key: K) -> Rc<dyn IObservable<Option<T>>>
       where T: PartialEq { ... }
    fn to_observable_optional_with_comparer(
        &self,
        key: K,
        equality_comparer: impl Fn(&T, &T) -> bool + 'static,
    ) -> Rc<dyn IObservable<Option<T>>> { ... }
    fn to_observable_optional_with_initial(
        &self,
        key: K,
        initial_optional_when_missing: bool,
    ) -> Rc<dyn IObservable<Option<T>>>
       where T: PartialEq { ... }
    fn to_observable_optional_with_initial_and_comparer(
        &self,
        key: K,
        initial_optional_when_missing: bool,
        equality_comparer: impl Fn(&T, &T) -> bool + 'static,
    ) -> Rc<dyn IObservable<Option<T>>> { ... }
    fn to_sorted_collection<S: Ord + 'static>(
        &self,
        sort: impl Fn(&T) -> S + 'static,
        sort_order: SortDirection,
    ) -> Rc<dyn IObservable<Vec<T>>> { ... }
    fn to_sorted_collection_with_comparer(
        &self,
        comparer: Rc<dyn Fn(&T, &T) -> Ordering>,
    ) -> Rc<dyn IObservable<Vec<T>>> { ... }
    fn transform<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T) -> U + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_with_key<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T, &K) -> U + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_with_previous<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T, Option<&T>, &K) -> U + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_with_refresh<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T) -> U + 'static,
        transform_on_refresh: bool,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_with_key_and_refresh<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T, &K) -> U + 'static,
        transform_on_refresh: bool,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_with_previous_and_refresh<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T, Option<&T>, &K) -> U + 'static,
        transform_on_refresh: bool,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_forced<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T) -> U + 'static,
        force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T) -> bool>>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_with_key_forced<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T, &K) -> U + 'static,
        force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_with_previous_forced<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T, Option<&T>, &K) -> U + 'static,
        force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_forced_all<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T) -> U + 'static,
        force_transform: Rc<dyn IObservable<()>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_with_key_forced_all<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T, &K) -> U + 'static,
        force_transform: Rc<dyn IObservable<()>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_with_previous_forced_all<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T, Option<&T>, &K) -> U + 'static,
        force_transform: Rc<dyn IObservable<()>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn try_transform<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T) -> Result<U, ObservableError> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn try_transform_with_key<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T, &K) -> Result<U, ObservableError> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn try_transform_with_previous<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T, Option<&T>, &K) -> Result<U, ObservableError> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn try_transform_with_previous_and_refresh<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T, Option<&T>, &K) -> Result<U, ObservableError> + 'static,
        transform_on_refresh: bool,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn try_transform_with_previous_forced<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T, Option<&T>, &K) -> Result<U, ObservableError> + 'static,
        force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn try_transform_with_previous_forced_all<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T, Option<&T>, &K) -> Result<U, ObservableError> + 'static,
        force_transform: Rc<dyn IObservable<()>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_immutable<U: 'static>(
        &self,
        transform_factory: impl Fn(&T) -> U + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn try_transform_immutable<U: 'static>(
        &self,
        transform_factory: impl Fn(&T) -> Result<U, ObservableError> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_many<D: Clone + Deref + 'static, DK: Eq + Hash + Clone + 'static>(
        &self,
        many_selector: impl Fn(&T) -> Vec<D> + 'static,
        key_selector: impl Fn(&D) -> DK + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_many_observable_cache<D: Clone + Deref + 'static, DK: Eq + Hash + Clone + 'static, C: IObservableCache<D, DK> + 'static>(
        &self,
        many_selector: impl Fn(&T) -> C + 'static,
        key_selector: impl Fn(&D) -> DK + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_many_observable_collection<D: Clone + PartialEq + Deref + 'static, DK: Eq + Hash + Clone + 'static, C: ObservableCollectionEx<D> + 'static>(
        &self,
        many_selector: impl Fn(&T) -> C + 'static,
        key_selector: impl Fn(&D) -> DK + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<D, DK>>> { ... }
    fn transform_on_observable<U: Clone + PartialEq + 'static>(
        &self,
        transform_factory: impl Fn(&T) -> Rc<dyn IObservable<U>> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_on_observable_with_key<U: Clone + PartialEq + 'static>(
        &self,
        transform_factory: impl Fn(&T, &K) -> Rc<dyn IObservable<U>> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T) -> Result<U, ObservableError> + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe_with_key<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T, &K) -> Result<U, ObservableError> + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe_with_previous<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T, Option<&T>, &K) -> Result<U, ObservableError> + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe_forced<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T) -> Result<U, ObservableError> + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
        force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T) -> bool>>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe_with_key_forced<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T, &K) -> Result<U, ObservableError> + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
        force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe_with_previous_forced<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T, Option<&T>, &K) -> Result<U, ObservableError> + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
        force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe_forced_all<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T) -> Result<U, ObservableError> + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
        force_transform: Rc<dyn IObservable<()>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe_with_key_forced_all<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T, &K) -> Result<U, ObservableError> + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
        force_transform: Rc<dyn IObservable<()>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_safe_with_previous_forced_all<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T, Option<&T>, &K) -> Result<U, ObservableError> + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
        force_transform: Rc<dyn IObservable<()>>,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_to_tree(
        &self,
        pivot_on: impl Fn(&T) -> K + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<Rc<Node<T, K>>, K>>> { ... }
    fn transform_to_tree_with(
        &self,
        pivot_on: impl Fn(&T) -> K + 'static,
        predicate_changed: Rc<dyn IObservable<Rc<dyn Fn(&Rc<Node<T, K>>) -> bool>>>,
    ) -> Rc<dyn IObservable<ChangeSet<Rc<Node<T, K>>, K>>> { ... }
    fn transform_with_inline_update<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T) -> U + 'static,
        update_action: impl Fn(&U, &T) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_with_inline_update_with<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T) -> U + 'static,
        update_action: impl Fn(&U, &T) + 'static,
        transform_on_refresh: bool,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_with_inline_update_safe<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T) -> Result<U, ObservableError> + 'static,
        update_action: impl Fn(&U, &T) -> Result<(), ObservableError> + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn transform_with_inline_update_safe_with<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T) -> Result<U, ObservableError> + 'static,
        update_action: impl Fn(&U, &T) -> Result<(), ObservableError> + 'static,
        error_handler: impl Fn(Error<T, K>) + 'static,
        transform_on_refresh: bool,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn try_transform_with_inline_update<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T) -> Result<U, ObservableError> + 'static,
        update_action: impl Fn(&U, &T) -> Result<(), ObservableError> + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn try_transform_with_inline_update_with<U: Clone + 'static>(
        &self,
        transform_factory: impl Fn(&T) -> Result<U, ObservableError> + 'static,
        update_action: impl Fn(&U, &T) -> Result<(), ObservableError> + 'static,
        transform_on_refresh: bool,
    ) -> Rc<dyn IObservable<ChangeSet<U, K>>> { ... }
    fn true_for_all<V: Clone + 'static>(
        &self,
        observable_selector: impl Fn(&T) -> Rc<dyn IObservable<V>> + 'static,
        equality_condition: impl Fn(&V) -> bool + 'static,
    ) -> Rc<dyn IObservable<bool>> { ... }
    fn true_for_all_with_item<V: Clone + 'static>(
        &self,
        observable_selector: impl Fn(&T) -> Rc<dyn IObservable<V>> + 'static,
        equality_condition: impl Fn(&T, &V) -> bool + 'static,
    ) -> Rc<dyn IObservable<bool>> { ... }
    fn true_for_any<V: Clone + 'static>(
        &self,
        observable_selector: impl Fn(&T) -> Rc<dyn IObservable<V>> + 'static,
        equality_condition: impl Fn(&V) -> bool + 'static,
    ) -> Rc<dyn IObservable<bool>> { ... }
    fn true_for_any_with_item<V: Clone + 'static>(
        &self,
        observable_selector: impl Fn(&T) -> Rc<dyn IObservable<V>> + 'static,
        equality_condition: impl Fn(&T, &V) -> bool + 'static,
    ) -> Rc<dyn IObservable<bool>> { ... }
    fn sort_and_virtualize(
        &self,
        comparer: Rc<dyn Fn(&T, &T) -> Ordering>,
        virtual_requests: Rc<dyn IObservable<VirtualRequest>>,
    ) -> Rc<dyn IObservable<ChangeSetWithContext<T, K, VirtualContext<T>>>> { ... }
    fn sort_and_virtualize_dynamic(
        &self,
        comparer_changed: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>,
        virtual_requests: Rc<dyn IObservable<VirtualRequest>>,
    ) -> Rc<dyn IObservable<ChangeSetWithContext<T, K, VirtualContext<T>>>> { ... }
    fn sort_and_virtualize_with(
        &self,
        comparer: Rc<dyn Fn(&T, &T) -> Ordering>,
        virtual_requests: Rc<dyn IObservable<VirtualRequest>>,
        options: SortAndVirtualizeOptions,
    ) -> Rc<dyn IObservable<ChangeSetWithContext<T, K, VirtualContext<T>>>> { ... }
    fn sort_and_virtualize_dynamic_with(
        &self,
        comparer_changed: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>,
        virtual_requests: Rc<dyn IObservable<VirtualRequest>>,
        options: SortAndVirtualizeOptions,
    ) -> Rc<dyn IObservable<ChangeSetWithContext<T, K, VirtualContext<T>>>> { ... }
    fn top(
        &self,
        comparer: Rc<dyn Fn(&T, &T) -> Ordering>,
        size: usize,
    ) -> Rc<dyn IObservable<ChangeSetWithContext<T, K, VirtualContext<T>>>> { ... }
    fn sort_and_page(
        &self,
        comparer: Rc<dyn Fn(&T, &T) -> Ordering>,
        page_requests: Rc<dyn IObservable<PageRequest>>,
    ) -> Rc<dyn IObservable<ChangeSetWithContext<T, K, PageContext<T>>>> { ... }
    fn sort_and_page_dynamic(
        &self,
        comparer_changed: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>,
        page_requests: Rc<dyn IObservable<PageRequest>>,
    ) -> Rc<dyn IObservable<ChangeSetWithContext<T, K, PageContext<T>>>> { ... }
    fn sort_and_page_with(
        &self,
        comparer: Rc<dyn Fn(&T, &T) -> Ordering>,
        page_requests: Rc<dyn IObservable<PageRequest>>,
        options: SortAndPageOptions,
    ) -> Rc<dyn IObservable<ChangeSetWithContext<T, K, PageContext<T>>>> { ... }
    fn sort_and_page_dynamic_with(
        &self,
        comparer_changed: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>,
        page_requests: Rc<dyn IObservable<PageRequest>>,
        options: SortAndPageOptions,
    ) -> Rc<dyn IObservable<ChangeSetWithContext<T, K, PageContext<T>>>> { ... }
    fn watch(&self, key: K) -> Rc<dyn IObservable<Change<T, K>>> { ... }
    fn watch_value(&self, key: K) -> Rc<dyn IObservable<T>> { ... }
    fn when_any_property_changed(
        &self,
        properties_to_monitor: &[&str],
    ) -> Rc<dyn IObservable<T>>
       where T: NotifyPropertyChangedEx { ... }
    fn when_property_changed<P: IntoPropertyChain<T>>(
        &self,
        property_accessor: P,
    ) -> Rc<dyn IObservable<PropertyValue<T, P::Value>>>
       where P::Value: 'static { ... }
    fn when_property_changed_with<P: IntoPropertyChain<T>>(
        &self,
        property_accessor: P,
        notify_on_initial_value: bool,
    ) -> Rc<dyn IObservable<PropertyValue<T, P::Value>>>
       where P::Value: 'static { ... }
    fn when_value_changed<P: IntoPropertyChain<T>>(
        &self,
        property_accessor: P,
    ) -> Rc<dyn IObservable<P::Value>>
       where P::Value: 'static { ... }
    fn when_value_changed_with<P: IntoPropertyChain<T>>(
        &self,
        property_accessor: P,
        notify_on_initial_value: bool,
    ) -> Rc<dyn IObservable<P::Value>>
       where P::Value: 'static { ... }
    fn where_reasons_are(
        &self,
        reasons: &[ChangeReason],
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn where_reasons_are_not(
        &self,
        reasons: &[ChangeReason],
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn as_aggregator(&self) -> ChangeSetAggregator<T, K> { ... }
    fn as_observable_cache(&self) -> ObservableCache<T, K> { ... }
    fn collect_update_stats(&self) -> Rc<dyn IObservable<ChangeSummary>> { ... }
    fn filter(
        &self,
        filter: impl Fn(&T) -> bool + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn filter_with(
        &self,
        filter: impl Fn(&T) -> bool + 'static,
        suppress_empty_change_sets: bool,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn filter_dynamic(
        &self,
        predicate_changed: Rc<dyn IObservable<Rc<dyn Fn(&T) -> bool>>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn filter_dynamic_with(
        &self,
        predicate_changed: Rc<dyn IObservable<Rc<dyn Fn(&T) -> bool>>>,
        suppress_empty_change_sets: bool,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn filter_dynamic_reapply(
        &self,
        predicate_changed: Rc<dyn IObservable<Rc<dyn Fn(&T) -> bool>>>,
        reapply_filter: Rc<dyn IObservable<()>>,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn filter_dynamic_reapply_with(
        &self,
        predicate_changed: Rc<dyn IObservable<Rc<dyn Fn(&T) -> bool>>>,
        reapply_filter: Rc<dyn IObservable<()>>,
        suppress_empty_change_sets: bool,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn filter_with_state<S: 'static>(
        &self,
        predicate_state: Rc<dyn IObservable<S>>,
        predicate: impl Fn(&S, &T) -> bool + 'static,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn filter_with_state_with<S: 'static>(
        &self,
        predicate_state: Rc<dyn IObservable<S>>,
        predicate: impl Fn(&S, &T) -> bool + 'static,
        suppress_empty_change_sets: bool,
    ) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
    fn not_empty(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>> { ... }
}

The operators of caches (ObservableCacheEx).

Required Methods

fn change_sets(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The sequence as plain change sets (the upcast of a sorted, paged or contextual change set to IChangeSet<TObject, TKey>).

Provided Methods

fn and_cache( &self, others: Vec<Rc<dyn IObservable<ChangeSet<T, K>>>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: Deref,

The sequence combined with others: the items that are in every one of them (And(IObservable<IChangeSet>, params IObservable<IChangeSet>[])). The sequences are subscribed in order when the result is subscribed. An item that a sequence gives again as the same object (T: Deref) is not updated.

Panics

When others is empty (ArgumentException: “At least one additional stream must be supplied”).

fn async_dispose_many( &self, disposals_completed_accessor: impl Fn(Rc<dyn IObservable<()>>) + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: AsAsyncDisposable + PartialEq,

Disposes the items that are disposable, at once or by a task, when they are removed or replaced by an item that is not equal to them, and every item left when the sequence ends, fails or the subscription is disposed; the change sets are forwarded first. disposals_completed_accessor receives, once per subscription, a sequence of one value that ends when the disposals by tasks have all ended, and fails with the error of one (AsyncDisposeMany(Action<IObservable<Unit>>)).

The items tell how they are disposed through AsAsyncDisposable; an item for which it gives None is left alone.

fn async_dispose_many_with( &self, to_item_disposal: impl Fn(&T) -> Option<ItemDisposal> + 'static, disposals_completed_accessor: impl Fn(Rc<dyn IObservable<()>>) + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: PartialEq,

async_dispose_many for items that to_item_disposal tells how to dispose (item is IDisposable, item is IAsyncDisposable).

fn except( &self, others: Vec<Rc<dyn IObservable<ChangeSet<T, K>>>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: Deref,

The items of the sequence that are in none of others (Except(IObservable<IChangeSet>, params IObservable<IChangeSet>[])). The sequences are subscribed in order when the result is subscribed. An item that a sequence gives again as the same object (T: Deref) is not updated.

Panics

When others is empty (ArgumentException: “At least one additional stream must be supplied”).

fn full_join<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>( &self, right: Rc<dyn IObservable<ChangeSet<TR, KR>>>, right_key_selector: impl Fn(&TR) -> K + 'static, result_selector: impl Fn(Option<&T>, Option<&TR>) -> D + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, K>>>

The left items and the right items, the right ones keyed by the left key that right_key_selector maps them to, joined by that key and combined by result_selector (upstream’s Optionals are Options); a result exists while either side has an item of its key (SQL FULL OUTER JOIN). The selector does not take the key (FullJoin(IObservable<IChangeSet<TRight, TRightKey>>, Func<TRight, TLeftKey>, Func<Optional<TLeft>, Optional<TRight>, TDestination>)).

fn full_join_with_key<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>( &self, right: Rc<dyn IObservable<ChangeSet<TR, KR>>>, right_key_selector: impl Fn(&TR) -> K + 'static, result_selector: impl Fn(&K, Option<&T>, Option<&TR>) -> D + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, K>>>

full_join whose selector also takes the key (FullJoin(IObservable<IChangeSet<TRight, TRightKey>>, Func<TRight, TLeftKey>, Func<TLeftKey, Optional<TLeft>, Optional<TRight>, TDestination>)).

When several right items map to one left key, the latest one is joined.

fn full_join_many<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>( &self, right: Rc<dyn IObservable<ChangeSet<TR, KR>>>, right_key_selector: impl Fn(&TR) -> K + 'static, result_selector: impl Fn(Option<&T>, &ImmutableGroup<TR, KR, K>) -> D + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, K>>>

The left items and the groups of the right items, by the left key that right_key_selector maps them to, joined by that key, an empty group when there is none, combined by result_selector; a result exists while the left item or the group does (SQL FULL OUTER JOIN of the grouped right side). The selector does not take the key (FullJoinMany(IObservable<IChangeSet<TRight, TRightKey>>, Func<TRight, TLeftKey>, Func<Optional<TLeft>, IGrouping<TRight, TRightKey, TLeftKey>, TDestination>)).

fn full_join_many_with_key<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>( &self, right: Rc<dyn IObservable<ChangeSet<TR, KR>>>, right_key_selector: impl Fn(&TR) -> K + 'static, result_selector: impl Fn(&K, Option<&T>, &ImmutableGroup<TR, KR, K>) -> D + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, K>>>

full_join_many whose selector also takes the key (FullJoinMany(IObservable<IChangeSet<TRight, TRightKey>>, Func<TRight, TLeftKey>, Func<TLeftKey, Optional<TLeft>, IGrouping<TRight, TRightKey, TLeftKey>, TDestination>)).

fn inner_join<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>( &self, right: Rc<dyn IObservable<ChangeSet<TR, KR>>>, right_key_selector: impl Fn(&TR) -> K + 'static, result_selector: impl Fn(&T, &TR) -> D + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, (K, KR)>>>

The pairs of a left item and a right item whose key right_key_selector maps to the key of the left item, combined by result_selector, keyed by both keys; a pair exists while both items do (SQL INNER JOIN). The selector does not take the keys (InnerJoin(IObservable<IChangeSet<TRight, TRightKey>>, Func<TRight, TLeftKey>, Func<TLeft, TRight, TDestination>)).

fn inner_join_with_key<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>( &self, right: Rc<dyn IObservable<ChangeSet<TR, KR>>>, right_key_selector: impl Fn(&TR) -> K + 'static, result_selector: impl Fn(&(K, KR), &T, &TR) -> D + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, (K, KR)>>>

inner_join whose selector also takes the pair of keys, the key of the result (InnerJoin(IObservable<IChangeSet<TRight, TRightKey>>, Func<TRight, TLeftKey>, Func<(TLeftKey leftKey, TRightKey rightKey), TLeft, TRight, TDestination>)).

A left change pairs the left item with every right item of its key; a right change pairs the right item with the left item of its key, and removes its former pair when its key changed. The left items present at the subscription are joined once the right items arrive, in one change set.

fn inner_join_many<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>( &self, right: Rc<dyn IObservable<ChangeSet<TR, KR>>>, right_key_selector: impl Fn(&TR) -> K + 'static, result_selector: impl Fn(&T, &ImmutableGroup<TR, KR, K>) -> D + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, K>>>

The left items with the group of the right items whose key right_key_selector maps to their key, combined by result_selector, keyed by the left key; a result exists while the left item and at least one right item do (SQL INNER JOIN of the grouped right side). The selector does not take the key (InnerJoinMany(IObservable<IChangeSet<TRight, TRightKey>>, Func<TRight, TLeftKey>, Func<TLeft, IGrouping<TRight, TRightKey, TLeftKey>, TDestination>)).

fn inner_join_many_with_key<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>( &self, right: Rc<dyn IObservable<ChangeSet<TR, KR>>>, right_key_selector: impl Fn(&TR) -> K + 'static, result_selector: impl Fn(&K, &T, &ImmutableGroup<TR, KR, K>) -> D + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, K>>>

inner_join_many whose selector also takes the key (InnerJoinMany(IObservable<IChangeSet<TRight, TRightKey>>, Func<TRight, TLeftKey>, Func<TLeftKey, TLeft, IGrouping<TRight, TRightKey, TLeftKey>, TDestination>)).

fn left_join<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>( &self, right: Rc<dyn IObservable<ChangeSet<TR, KR>>>, right_key_selector: impl Fn(&TR) -> K + 'static, result_selector: impl Fn(&T, Option<&TR>) -> D + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, K>>>

Each left item with the right item whose key right_key_selector maps to its key, if any (upstream’s Optional<TRight> is an Option), combined by result_selector, keyed by the left key; a result exists while the left item does (SQL LEFT JOIN). The selector does not take the key (LeftJoin(IObservable<IChangeSet<TRight, TRightKey>>, Func<TRight, TLeftKey>, Func<TLeft, Optional<TRight>, TDestination>)).

fn left_join_with_key<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>( &self, right: Rc<dyn IObservable<ChangeSet<TR, KR>>>, right_key_selector: impl Fn(&TR) -> K + 'static, result_selector: impl Fn(&K, &T, Option<&TR>) -> D + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, K>>>

left_join whose selector also takes the left key (LeftJoin(IObservable<IChangeSet<TRight, TRightKey>>, Func<TRight, TLeftKey>, Func<TLeftKey, TLeft, Optional<TRight>, TDestination>)).

When several right items map to one left key, the latest one is joined. The right items present at the subscription are joined as the left items arrive, in one change set.

fn left_join_many<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>( &self, right: Rc<dyn IObservable<ChangeSet<TR, KR>>>, right_key_selector: impl Fn(&TR) -> K + 'static, result_selector: impl Fn(&T, &ImmutableGroup<TR, KR, K>) -> D + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, K>>>

Each left item with the group of the right items whose key right_key_selector maps to its key, an empty group when there is none, combined by result_selector, keyed by the left key; a result exists while the left item does (SQL LEFT JOIN of the grouped right side). The selector does not take the key (LeftJoinMany(IObservable<IChangeSet<TRight, TRightKey>>, Func<TRight, TLeftKey>, Func<TLeft, IGrouping<TRight, TRightKey, TLeftKey>, TDestination>)).

fn left_join_many_with_key<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>( &self, right: Rc<dyn IObservable<ChangeSet<TR, KR>>>, right_key_selector: impl Fn(&TR) -> K + 'static, result_selector: impl Fn(&K, &T, &ImmutableGroup<TR, KR, K>) -> D + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, K>>>

left_join_many whose selector also takes the key (LeftJoinMany(IObservable<IChangeSet<TRight, TRightKey>>, Func<TRight, TLeftKey>, Func<TLeftKey, TLeft, IGrouping<TRight, TRightKey, TLeftKey>, TDestination>)).

fn or( &self, others: Vec<Rc<dyn IObservable<ChangeSet<T, K>>>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: Deref,

The sequence combined with others: the items that are in any of them (Or(IObservable<IChangeSet>, params IObservable<IChangeSet>[])). The sequences are subscribed in order when the result is subscribed. An item that a sequence gives again as the same object (T: Deref) is not updated.

Panics

When others is empty (ArgumentException: “At least one additional stream must be given”).

fn right_join<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>( &self, right: Rc<dyn IObservable<ChangeSet<TR, KR>>>, right_key_selector: impl Fn(&TR) -> K + 'static, result_selector: impl Fn(Option<&T>, &TR) -> D + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, KR>>>

Each right item with the left item of the key right_key_selector maps it to, if any (upstream’s Optional<TLeft> is an Option), combined by result_selector, keyed by the right key; a result exists while the right item does (SQL RIGHT JOIN). The selector does not take the key (RightJoin(IObservable<IChangeSet<TRight, TRightKey>>, Func<TRight, TLeftKey>, Func<Optional<TLeft>, TRight, TDestination>)).

fn right_join_with_key<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>( &self, right: Rc<dyn IObservable<ChangeSet<TR, KR>>>, right_key_selector: impl Fn(&TR) -> K + 'static, result_selector: impl Fn(&KR, Option<&T>, &TR) -> D + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, KR>>>

right_join whose selector also takes the right key (RightJoin(IObservable<IChangeSet<TRight, TRightKey>>, Func<TRight, TLeftKey>, Func<TRightKey, Optional<TLeft>, TRight, TDestination>)).

The left items present at the subscription are joined as the right items arrive, in one change set.

fn right_join_many<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>( &self, right: Rc<dyn IObservable<ChangeSet<TR, KR>>>, right_key_selector: impl Fn(&TR) -> K + 'static, result_selector: impl Fn(Option<&T>, &ImmutableGroup<TR, KR, K>) -> D + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, K>>>

Each group of the right items, by the left key that right_key_selector maps them to, with the left item of that key, if any, combined by result_selector, keyed by the left key; a result exists while the group has items (SQL RIGHT JOIN of the grouped right side). The selector does not take the key (RightJoinMany(IObservable<IChangeSet<TRight, TRightKey>>, Func<TRight, TLeftKey>, Func<Optional<TLeft>, IGrouping<TRight, TRightKey, TLeftKey>, TDestination>)).

fn right_join_many_with_key<TR: Clone + 'static, KR: Eq + Hash + Clone + 'static, D: Clone + 'static>( &self, right: Rc<dyn IObservable<ChangeSet<TR, KR>>>, right_key_selector: impl Fn(&TR) -> K + 'static, result_selector: impl Fn(&K, Option<&T>, &ImmutableGroup<TR, KR, K>) -> D + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, K>>>

right_join_many whose selector also takes the key (RightJoinMany(IObservable<IChangeSet<TRight, TRightKey>>, Func<TRight, TLeftKey>, Func<TLeftKey, Optional<TLeft>, IGrouping<TRight, TRightKey, TLeftKey>, TDestination>)).

fn transform_async<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T) -> Fut + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

Each item in the form the future of transform_factory gives it: an addition or an update awaits the factory, a removal removes the item, a refresh is forwarded (TransformAsync(Func<TSource, Task<TDestination>>, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)).

fn transform_async_with_key<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T, K) -> Fut + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_async with a factory of the item and its key (TransformAsync(Func<TSource, TKey, Task<TDestination>>, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)).

fn transform_async_with_previous<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T, Option<T>, K) -> Fut + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_async with a factory of the item, the item it replaces (for an update) and the key (TransformAsync(Func<TSource, Optional<TSource>, TKey, Task<TDestination>>, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)).

fn transform_async_with_token<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T, Option<T>, K, CancellationToken) -> Fut + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_async_with_previous whose factory also takes the token that the disposal of the subscription cancels (TransformAsync(Func<TSource, Optional<TSource>, TKey, CancellationToken, Task<TDestination>>, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)).

fn transform_async_forced<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T) -> Fut + 'static, force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_async that also transforms again, as updates, the items that each predicate of force_transform accepts (TransformAsync(Func<TSource, Task<TDestination>>, IObservable<Func<TSource, TKey, bool>>)).

fn transform_async_with_key_forced<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T, K) -> Fut + 'static, force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_async_with_key with the predicates of transform_async_forced (TransformAsync(Func<TSource, TKey, Task<TDestination>>, IObservable<Func<TSource, TKey, bool>>)).

fn transform_async_with_previous_forced<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T, Option<T>, K) -> Fut + 'static, force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_async_with_previous with the predicates of transform_async_forced (TransformAsync(Func<TSource, Optional<TSource>, TKey, Task<TDestination>>, IObservable<Func<TSource, TKey, bool>>)).

fn transform_async_with_token_forced<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T, Option<T>, K, CancellationToken) -> Fut + 'static, force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_async_with_token with the predicates of transform_async_forced (TransformAsync(Func<TSource, Optional<TSource>, TKey, CancellationToken, Task<TDestination>>, IObservable<Func<TSource, TKey, bool>>)).

fn transform_async_with_options<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T) -> Fut + 'static, options: TransformAsyncOptions, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_async with the greatest number of transforms in flight and the handling of refreshes of options (TransformAsync(Func<TSource, Task<TDestination>>, TransformAsyncOptions)).

fn transform_async_with_key_and_options<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T, K) -> Fut + 'static, options: TransformAsyncOptions, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_async_with_key with options (TransformAsync(Func<TSource, TKey, Task<TDestination>>, TransformAsyncOptions)).

fn transform_async_with_previous_and_options<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T, Option<T>, K) -> Fut + 'static, options: TransformAsyncOptions, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_async_with_previous with options (TransformAsync(Func<TSource, Optional<TSource>, TKey, Task<TDestination>>, TransformAsyncOptions)).

fn transform_async_with_token_and_options<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T, Option<T>, K, CancellationToken) -> Fut + 'static, options: TransformAsyncOptions, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_async_with_token with options (TransformAsync(Func<TSource, Optional<TSource>, TKey, CancellationToken, Task<TDestination>>, TransformAsyncOptions)).

fn transform_many_async<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, Fut: Future<Output = Result<Vec<D>, ObservableError>> + 'static>( &self, many_selector: impl Fn(T) -> Fut + 'static, key_selector: impl Fn(&D) -> DK + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

The items that the future of many_selector gives for each item, keyed by key_selector (TransformManyAsync(Func<TSource, Task<IEnumerable<TDestination>>>, Func<TDestination, TDestinationKey>, IEqualityComparer<TDestination>? = null, IComparer<TDestination>? = null)).

fn transform_many_async_with_key<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, Fut: Future<Output = Result<Vec<D>, ObservableError>> + 'static>( &self, many_selector: impl Fn(T, K) -> Fut + 'static, key_selector: impl Fn(&D) -> DK + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

transform_many_async with a selector of the item and its key (TransformManyAsync(Func<TSource, TSourceKey, Task<IEnumerable<TDestination>>>, Func<TDestination, TDestinationKey>, ..)).

fn transform_many_async_with<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, Fut: Future<Output = Result<Vec<D>, ObservableError>> + 'static>( &self, many_selector: impl Fn(T, K) -> Fut + 'static, key_selector: impl Fn(&D) -> DK + 'static, equality_comparer: Option<Rc<dyn Fn(&D, &D) -> bool>>, comparer: Option<Rc<dyn Fn(&D, &D) -> Ordering>>, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

transform_many_async_with_key with the equality of the children (PartialEq when None) and their comparer (TransformManyAsync(Func<TSource, TSourceKey, Task<IEnumerable<TDestination>>>, Func<TDestination, TDestinationKey>, IEqualityComparer<TDestination>?, IComparer<TDestination>?)).

fn transform_many_async_observable_collection<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: ObservableCollectionEx<D> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>( &self, many_selector: impl Fn(T) -> Fut + 'static, key_selector: impl Fn(&D) -> DK + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

The items of the observable collection that the future of many_selector gives for each item, keyed by key_selector, followed as the collections change (TransformManyAsync<.., TCollection>(Func<TSource, Task<TCollection>>, Func<TDestination, TDestinationKey>, IEqualityComparer<TDestination>? = null, IComparer<TDestination>? = null)).

fn transform_many_async_observable_collection_with_key<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: ObservableCollectionEx<D> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>( &self, many_selector: impl Fn(T, K) -> Fut + 'static, key_selector: impl Fn(&D) -> DK + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

transform_many_async_observable_collection with a selector of the item and its key (TransformManyAsync<.., TCollection>(Func<TSource, TSourceKey, Task<TCollection>>, Func<TDestination, TDestinationKey>, ..)).

fn transform_many_async_observable_collection_with<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: ObservableCollectionEx<D> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>( &self, many_selector: impl Fn(T, K) -> Fut + 'static, key_selector: impl Fn(&D) -> DK + 'static, equality_comparer: Option<Rc<dyn Fn(&D, &D) -> bool>>, comparer: Option<Rc<dyn Fn(&D, &D) -> Ordering>>, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

transform_many_async_observable_collection_with_key with the equality of the children (PartialEq when None) and their comparer (TransformManyAsync<.., TCollection>(Func<TSource, TSourceKey, Task<TCollection>>, Func<TDestination, TDestinationKey>, IEqualityComparer<TDestination>?, IComparer<TDestination>?)).

fn transform_many_async_observable_cache<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: IObservableCache<D, DK> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>( &self, many_selector: impl Fn(T) -> Fut + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

The items of the observable cache that the future of many_selector gives for each item, followed as the caches change (TransformManyAsync(Func<TSource, Task<IObservableCache<TDestination, TDestinationKey>>>, IEqualityComparer<TDestination>? = null, IComparer<TDestination>? = null)).

fn transform_many_async_observable_cache_with_key<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: IObservableCache<D, DK> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>( &self, many_selector: impl Fn(T, K) -> Fut + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

transform_many_async_observable_cache with a selector of the item and its key (TransformManyAsync(Func<TSource, TSourceKey, Task<IObservableCache<TDestination, TDestinationKey>>>, ..)).

fn transform_many_async_observable_cache_with<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: IObservableCache<D, DK> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>( &self, many_selector: impl Fn(T, K) -> Fut + 'static, equality_comparer: Option<Rc<dyn Fn(&D, &D) -> bool>>, comparer: Option<Rc<dyn Fn(&D, &D) -> Ordering>>, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

transform_many_async_observable_cache_with_key with the equality of the children (PartialEq when None) and their comparer (TransformManyAsync(Func<TSource, TSourceKey, Task<IObservableCache<TDestination, TDestinationKey>>>, IEqualityComparer<TDestination>?, IComparer<TDestination>?)).

fn transform_many_safe_async<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, Fut: Future<Output = Result<Vec<D>, ObservableError>> + 'static>( &self, many_selector: impl Fn(T) -> Fut + 'static, key_selector: impl Fn(&D) -> DK + 'static, error_handler: impl Fn(Error<T, K>) + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

The items that the future of many_selector gives for each item, keyed by key_selector (TransformManySafeAsync(Func<TSource, Task<IEnumerable<TDestination>>>, Func<TDestination, TDestinationKey>, IEqualityComparer<TDestination>? = null, IComparer<TDestination>? = null)).

fn transform_many_safe_async_with_key<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, Fut: Future<Output = Result<Vec<D>, ObservableError>> + 'static>( &self, many_selector: impl Fn(T, K) -> Fut + 'static, key_selector: impl Fn(&D) -> DK + 'static, error_handler: impl Fn(Error<T, K>) + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

transform_many_safe_async with a selector of the item and its key (TransformManySafeAsync(Func<TSource, TSourceKey, Task<IEnumerable<TDestination>>>, Func<TDestination, TDestinationKey>, ..)).

fn transform_many_safe_async_with<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, Fut: Future<Output = Result<Vec<D>, ObservableError>> + 'static>( &self, many_selector: impl Fn(T, K) -> Fut + 'static, key_selector: impl Fn(&D) -> DK + 'static, error_handler: impl Fn(Error<T, K>) + 'static, equality_comparer: Option<Rc<dyn Fn(&D, &D) -> bool>>, comparer: Option<Rc<dyn Fn(&D, &D) -> Ordering>>, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

transform_many_safe_async_with_key with the equality of the children (PartialEq when None) and their comparer (TransformManySafeAsync(Func<TSource, TSourceKey, Task<IEnumerable<TDestination>>>, Func<TDestination, TDestinationKey>, IEqualityComparer<TDestination>?, IComparer<TDestination>?)).

fn transform_many_safe_async_observable_collection<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: ObservableCollectionEx<D> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>( &self, many_selector: impl Fn(T) -> Fut + 'static, key_selector: impl Fn(&D) -> DK + 'static, error_handler: impl Fn(Error<T, K>) + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

The items of the observable collection that the future of many_selector gives for each item, keyed by key_selector, followed as the collections change (TransformManySafeAsync<.., TCollection>(Func<TSource, Task<TCollection>>, Func<TDestination, TDestinationKey>, IEqualityComparer<TDestination>? = null, IComparer<TDestination>? = null)).

fn transform_many_safe_async_observable_collection_with_key<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: ObservableCollectionEx<D> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>( &self, many_selector: impl Fn(T, K) -> Fut + 'static, key_selector: impl Fn(&D) -> DK + 'static, error_handler: impl Fn(Error<T, K>) + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

transform_many_safe_async_observable_collection with a selector of the item and its key (TransformManySafeAsync<.., TCollection>(Func<TSource, TSourceKey, Task<TCollection>>, Func<TDestination, TDestinationKey>, ..)).

fn transform_many_safe_async_observable_collection_with<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: ObservableCollectionEx<D> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>( &self, many_selector: impl Fn(T, K) -> Fut + 'static, key_selector: impl Fn(&D) -> DK + 'static, error_handler: impl Fn(Error<T, K>) + 'static, equality_comparer: Option<Rc<dyn Fn(&D, &D) -> bool>>, comparer: Option<Rc<dyn Fn(&D, &D) -> Ordering>>, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

transform_many_safe_async_observable_collection_with_key with the equality of the children (PartialEq when None) and their comparer (TransformManySafeAsync<.., TCollection>(Func<TSource, TSourceKey, Task<TCollection>>, Func<TDestination, TDestinationKey>, IEqualityComparer<TDestination>?, IComparer<TDestination>?)).

fn transform_many_safe_async_observable_cache<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: IObservableCache<D, DK> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>( &self, many_selector: impl Fn(T) -> Fut + 'static, error_handler: impl Fn(Error<T, K>) + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

The items of the observable cache that the future of many_selector gives for each item, followed as the caches change (TransformManySafeAsync(Func<TSource, Task<IObservableCache<TDestination, TDestinationKey>>>, IEqualityComparer<TDestination>? = null, IComparer<TDestination>? = null)).

fn transform_many_safe_async_observable_cache_with_key<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: IObservableCache<D, DK> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>( &self, many_selector: impl Fn(T, K) -> Fut + 'static, error_handler: impl Fn(Error<T, K>) + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

transform_many_safe_async_observable_cache with a selector of the item and its key (TransformManySafeAsync(Func<TSource, TSourceKey, Task<IObservableCache<TDestination, TDestinationKey>>>, ..)).

fn transform_many_safe_async_observable_cache_with<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static, C: IObservableCache<D, DK> + 'static, Fut: Future<Output = Result<C, ObservableError>> + 'static>( &self, many_selector: impl Fn(T, K) -> Fut + 'static, error_handler: impl Fn(Error<T, K>) + 'static, equality_comparer: Option<Rc<dyn Fn(&D, &D) -> bool>>, comparer: Option<Rc<dyn Fn(&D, &D) -> Ordering>>, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

transform_many_safe_async_observable_cache_with_key with the equality of the children (PartialEq when None) and their comparer (TransformManySafeAsync(Func<TSource, TSourceKey, Task<IObservableCache<TDestination, TDestinationKey>>>, IEqualityComparer<TDestination>?, IComparer<TDestination>?)).

fn transform_safe_async<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T) -> Fut + 'static, error_handler: impl Fn(Error<T, K>) + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

Each item in the form the future of transform_factory gives it: an addition or an update awaits the factory, a removal removes the item, a refresh is forwarded (TransformSafeAsync(Func<TSource, Task<TDestination>>, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)).

fn transform_safe_async_with_key<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T, K) -> Fut + 'static, error_handler: impl Fn(Error<T, K>) + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_safe_async with a factory of the item and its key (TransformSafeAsync(Func<TSource, TKey, Task<TDestination>>, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)).

fn transform_safe_async_with_previous<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T, Option<T>, K) -> Fut + 'static, error_handler: impl Fn(Error<T, K>) + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_safe_async with a factory of the item, the item it replaces (for an update) and the key (TransformSafeAsync(Func<TSource, Optional<TSource>, TKey, Task<TDestination>>, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)).

fn transform_safe_async_with_token<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T, Option<T>, K, CancellationToken) -> Fut + 'static, error_handler: impl Fn(Error<T, K>) + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_safe_async_with_previous whose factory also takes the token that the disposal of the subscription cancels (TransformSafeAsync(Func<TSource, Optional<TSource>, TKey, CancellationToken, Task<TDestination>>, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)).

fn transform_safe_async_forced<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T) -> Fut + 'static, error_handler: impl Fn(Error<T, K>) + 'static, force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_safe_async that also transforms again, as updates, the items that each predicate of force_transform accepts (TransformSafeAsync(Func<TSource, Task<TDestination>>, IObservable<Func<TSource, TKey, bool>>)).

fn transform_safe_async_with_key_forced<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T, K) -> Fut + 'static, error_handler: impl Fn(Error<T, K>) + 'static, force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_safe_async_with_key with the predicates of transform_safe_async_forced (TransformSafeAsync(Func<TSource, TKey, Task<TDestination>>, IObservable<Func<TSource, TKey, bool>>)).

fn transform_safe_async_with_previous_forced<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T, Option<T>, K) -> Fut + 'static, error_handler: impl Fn(Error<T, K>) + 'static, force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_safe_async_with_previous with the predicates of transform_safe_async_forced (TransformSafeAsync(Func<TSource, Optional<TSource>, TKey, Task<TDestination>>, IObservable<Func<TSource, TKey, bool>>)).

fn transform_safe_async_with_token_forced<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T, Option<T>, K, CancellationToken) -> Fut + 'static, error_handler: impl Fn(Error<T, K>) + 'static, force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_safe_async_with_token with the predicates of transform_safe_async_forced (TransformSafeAsync(Func<TSource, Optional<TSource>, TKey, CancellationToken, Task<TDestination>>, IObservable<Func<TSource, TKey, bool>>)).

fn transform_safe_async_with_options<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T) -> Fut + 'static, error_handler: impl Fn(Error<T, K>) + 'static, options: TransformAsyncOptions, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_safe_async with the greatest number of transforms in flight and the handling of refreshes of options (TransformSafeAsync(Func<TSource, Task<TDestination>>, TransformAsyncOptions)).

fn transform_safe_async_with_key_and_options<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T, K) -> Fut + 'static, error_handler: impl Fn(Error<T, K>) + 'static, options: TransformAsyncOptions, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_safe_async_with_key with options (TransformSafeAsync(Func<TSource, TKey, Task<TDestination>>, TransformAsyncOptions)).

fn transform_safe_async_with_previous_and_options<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T, Option<T>, K) -> Fut + 'static, error_handler: impl Fn(Error<T, K>) + 'static, options: TransformAsyncOptions, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_safe_async_with_previous with options (TransformSafeAsync(Func<TSource, Optional<TSource>, TKey, Task<TDestination>>, TransformAsyncOptions)).

fn transform_safe_async_with_token_and_options<U: Clone + 'static, Fut: Future<Output = Result<U, ObservableError>> + 'static>( &self, transform_factory: impl Fn(T, Option<T>, K, CancellationToken) -> Fut + 'static, error_handler: impl Fn(Error<T, K>) + 'static, options: TransformAsyncOptions, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_safe_async_with_token with options (TransformSafeAsync(Func<TSource, Optional<TSource>, TKey, CancellationToken, Task<TDestination>>, TransformAsyncOptions)).

fn xor( &self, others: Vec<Rc<dyn IObservable<ChangeSet<T, K>>>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: Deref,

The sequence combined with others: the items that are in exactly one of them (Xor(IObservable<IChangeSet>, params IObservable<IChangeSet>[])). The sequences are subscribed in order when the result is subscribed. An item that a sequence gives again as the same object (T: Deref) is not updated.

Panics

When others is empty (ArgumentException: “At least one additional stream must be given”).

fn adapt( &self, adaptor: Rc<dyn IChangeSetAdaptor<T, K>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

Hands each change set to adaptor as it passes (Adapt(IChangeSetAdaptor<TObject, TKey>)).

fn adapt_sorted( &self, adaptor: Rc<dyn ISortedChangeSetAdaptor<T, K>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where Self: Sized + 'static,

Hands each sorted change set to adaptor as it passes (Adapt(ISortedChangeSetAdaptor<TObject, TKey>) of a sorted source), as plain change sets.

Panics

When the source is not a sequence of sorted change sets.

fn auto_refresh<P: IntoPropertyChain<T>>( &self, property_accessor: P, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where P::Value: 'static,

The changes, with a refresh of an item whenever the property of property_accessor changes on it, so that the operators downstream evaluate it again (AutoRefresh(Expression<Func<TObject, TProperty>>)).

The path observes its own steps, so the items need not be INotifyPropertyChanged themselves (upstream’s constraint TObject : INotifyPropertyChanged).

fn auto_refresh_with<P: IntoPropertyChain<T>>( &self, property_accessor: P, change_set_buffer: Option<Duration>, property_change_throttle: Option<Duration>, scheduler: Option<Rc<dyn IScheduler>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where P::Value: 'static,

auto_refresh that gathers the refreshes of each change_set_buffer into one change set and throttles the changes of the property of each item by property_change_throttle, on scheduler (AutoRefresh(Expression<Func<TObject, TProperty>>, TimeSpan? changeSetBuffer, TimeSpan? propertyChangeThrottle, IScheduler? scheduler)).

fn auto_refresh_any(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: NotifyPropertyChangedEx,

The changes, with a refresh of an item whenever any of its properties changes (AutoRefresh(); the overloads of upstream share the name AutoRefresh).

fn auto_refresh_any_with( &self, change_set_buffer: Option<Duration>, property_change_throttle: Option<Duration>, scheduler: Option<Rc<dyn IScheduler>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: NotifyPropertyChangedEx,

auto_refresh_any that gathers the refreshes of each change_set_buffer into one change set and throttles the changes of the properties of each item by property_change_throttle, on scheduler (AutoRefresh(TimeSpan? changeSetBuffer, TimeSpan? propertyChangeThrottle, IScheduler? scheduler)).

fn auto_refresh_on_observable<A: 'static>( &self, reevaluator: impl Fn(&T) -> Rc<dyn IObservable<A>> + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The changes, with a refresh of an item whenever the sequence reevaluator makes for it produces a value, so that the operators downstream evaluate it again (AutoRefreshOnObservable(Func<TObject, IObservable<TAny>>)).

fn auto_refresh_on_observable_with<A: 'static>( &self, reevaluator: impl Fn(&T) -> Rc<dyn IObservable<A>> + 'static, change_set_buffer: Option<Duration>, scheduler: Option<Rc<dyn IScheduler>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

auto_refresh_on_observable that gathers the refreshes of each change_set_buffer into one change set, on scheduler (AutoRefreshOnObservable(Func<TObject, IObservable<TAny>>, TimeSpan? changeSetBuffer, IScheduler? scheduler)).

fn auto_refresh_on_observable_with_key<A: 'static>( &self, reevaluator: impl Fn(&T, &K) -> Rc<dyn IObservable<A>> + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

auto_refresh_on_observable with a reevaluator that is given the key (AutoRefreshOnObservable(Func<TObject, TKey, IObservable<TAny>>)).

fn auto_refresh_on_observable_with_key_with<A: 'static>( &self, reevaluator: impl Fn(&T, &K) -> Rc<dyn IObservable<A>> + 'static, change_set_buffer: Option<Duration>, scheduler: Option<Rc<dyn IScheduler>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

auto_refresh_on_observable_with_key that gathers the refreshes of each change_set_buffer into one change set, on scheduler (AutoRefreshOnObservable(Func<TObject, TKey, IObservable<TAny>>, TimeSpan?, IScheduler?)).

fn batch(&self, time_span: Duration) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The change sets of each time_span, as one change set; the windows without change sets are left out (Batch(TimeSpan, IScheduler? = null), on the default scheduler).

fn batch_on( &self, time_span: Duration, scheduler: Rc<dyn IScheduler>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

batch on scheduler (Batch(TimeSpan, IScheduler)).

fn batch_if( &self, pause_if_true_selector: Rc<dyn IObservable<bool>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The change sets, held back while pause_if_true_selector last gave true and delivered as one when it gives false (BatchIf(IObservable<bool>)).

fn batch_if_on( &self, pause_if_true_selector: Rc<dyn IObservable<bool>>, scheduler: Rc<dyn IScheduler>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

batch_if with the timers on scheduler (BatchIf(IObservable<bool>, IScheduler?)).

fn batch_if_with_initial( &self, pause_if_true_selector: Rc<dyn IObservable<bool>>, initial_pause_state: bool, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

batch_if, paused from the start when initial_pause_state is true (BatchIf(IObservable<bool>, bool, IScheduler? = null)).

fn batch_if_with_initial_on( &self, pause_if_true_selector: Rc<dyn IObservable<bool>>, initial_pause_state: bool, scheduler: Rc<dyn IScheduler>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

batch_if_with_initial on scheduler.

fn batch_if_with_time_out( &self, pause_if_true_selector: Rc<dyn IObservable<bool>>, time_out: Option<Duration>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

batch_if whose pause ends by itself after time_out (BatchIf(IObservable<bool>, TimeSpan?, IScheduler? = null)).

fn batch_if_with_time_out_on( &self, pause_if_true_selector: Rc<dyn IObservable<bool>>, time_out: Option<Duration>, scheduler: Rc<dyn IScheduler>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

batch_if_with_time_out on scheduler.

fn batch_if_with_initial_and_time_out( &self, pause_if_true_selector: Rc<dyn IObservable<bool>>, initial_pause_state: bool, time_out: Option<Duration>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

batch_if_with_time_out, paused from the start when initial_pause_state is true (BatchIf(IObservable<bool>, bool, TimeSpan?, IScheduler? = null)).

fn batch_if_with_initial_and_time_out_on( &self, pause_if_true_selector: Rc<dyn IObservable<bool>>, initial_pause_state: bool, time_out: Option<Duration>, scheduler: Rc<dyn IScheduler>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

batch_if_with_initial_and_time_out on scheduler.

fn batch_if_with_timer( &self, pause_if_true_selector: Rc<dyn IObservable<bool>>, timer: Option<Rc<dyn IObservable<()>>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

batch_if that also delivers, and pauses again, at each value of timer; the pause ends when timer ends (BatchIf(IObservable<bool>, IScheduler?, IObservable<Unit>?)).

fn batch_if_with_timer_on( &self, pause_if_true_selector: Rc<dyn IObservable<bool>>, timer: Option<Rc<dyn IObservable<()>>>, scheduler: Rc<dyn IScheduler>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

batch_if_with_timer on scheduler.

fn batch_if_with_initial_and_timer( &self, pause_if_true_selector: Rc<dyn IObservable<bool>>, initial_pause_state: bool, timer: Option<Rc<dyn IObservable<()>>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

batch_if_with_timer, paused from the start when initial_pause_state is true (BatchIf(IObservable<bool>, bool, IObservable<Unit>?, IScheduler? = null)).

fn batch_if_with_initial_and_timer_on( &self, pause_if_true_selector: Rc<dyn IObservable<bool>>, initial_pause_state: bool, timer: Option<Rc<dyn IObservable<()>>>, scheduler: Rc<dyn IScheduler>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

batch_if_with_initial_and_timer on scheduler.

fn bind<C: IObservableCollection<T> + Clone + 'static>( &self, destination: &C, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: PartialEq, Self: Sized + 'static,

Applies the change sets to destination with the default options (Bind(IObservableCollection<TObject>, int refreshThreshold = 25), and Bind(IObservableCollection<TObject>) of a sorted source).

fn bind_with_threshold<C: IObservableCollection<T> + Clone + 'static>( &self, destination: &C, refresh_threshold: usize, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: PartialEq,

bind with a threshold of changes above which the collection is loaded again with a reset (Bind(IObservableCollection<TObject>, int refreshThreshold)); it binds as a plain source, as upstream’s only form with a threshold does.

fn bind_with_options<C: IObservableCollection<T> + Clone + 'static>( &self, destination: &C, options: BindingOptions, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: PartialEq, Self: Sized + 'static,

bind with options (Bind(IObservableCollection<TObject>, BindingOptions)).

fn bind_with_adaptor<C: IObservableCollection<T> + Clone + 'static>( &self, destination: &C, updater: Rc<dyn IObservableCollectionAdaptor<T, K>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: PartialEq,

Applies the change sets to destination through updater (Bind(IObservableCollection<TObject>, IObservableCollectionAdaptor<TObject, TKey>)).

fn bind_with_sorted_adaptor<C: IObservableCollection<T> + Clone + 'static>( &self, destination: &C, updater: Rc<dyn ISortedObservableCollectionAdaptor<T, K>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: PartialEq, Self: Sized + 'static,

Applies the sorted change sets to destination through updater (Bind(IObservableCollection<TObject>, ISortedObservableCollectionAdaptor<TObject, TKey>)).

Panics

When the source is not a sequence of sorted change sets.

fn bind_read_only( &self, ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)

where T: PartialEq, Self: Sized + 'static,

Applies the change sets to a new collection, returned as a read-only view (Bind(out ReadOnlyObservableCollection<TObject>, int resetThreshold = 25, bool useReplaceForUpdates = true, adaptor = null), and its sorted form).

The results of SortAndPage and SortAndVirtualize are bound sorted by the comparer of their context (Bind(out ReadOnlyObservableCollection<TObject>) of IChangeSet<TObject, TKey, PageContext<TObject>>, BindPaged).

fn bind_read_only_with( &self, reset_threshold: usize, use_replace_for_updates: bool, ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)

where T: PartialEq, Self: Sized + 'static,

bind_read_only with a threshold and the choice of replacements (Bind(out ReadOnlyObservableCollection<TObject>, int, bool)).

fn bind_read_only_with_options( &self, options: BindingOptions, ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)

where T: PartialEq, Self: Sized + 'static,

bind_read_only with options (Bind(out ReadOnlyObservableCollection<TObject>, BindingOptions)).

fn bind_read_only_with_adaptor( &self, adaptor: Rc<dyn IObservableCollectionAdaptor<T, K>>, ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)

where T: PartialEq,

bind_read_only through adaptor (Bind(out ReadOnlyObservableCollection<TObject>, .., IObservableCollectionAdaptor<TObject, TKey>)).

fn bind_read_only_with_sorted_adaptor( &self, adaptor: Rc<dyn ISortedObservableCollectionAdaptor<T, K>>, ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)

where T: PartialEq, Self: Sized + 'static,

bind_read_only of a sorted source through adaptor (Bind(out ReadOnlyObservableCollection<TObject>, .., ISortedObservableCollectionAdaptor<TObject, TKey>)).

Panics

When the source is not a sequence of sorted change sets.

fn bind_to_observable_list( &self, ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, Rc<dyn IObservableList<T>>)

where T: PartialEq, Self: Sized + 'static,

Fills a new observable list with the items, without their keys, as the change sets pass; the list is disposed when the sequence ends (BindToObservableList(out IObservableList<TObject>), and its form for a sorted source, which keeps the order of the sort).

fn buffer_initial( &self, initial_buffer: Duration, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The change sets of the first initial_buffer after the first one, as one change set, then the change sets as they come (BufferInitial(TimeSpan, IScheduler? = null), on the default scheduler).

fn buffer_initial_on( &self, initial_buffer: Duration, scheduler: Rc<dyn IScheduler>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

buffer_initial on scheduler (BufferInitial(TimeSpan, IScheduler)).

fn cast_cache<U: Clone + 'static>( &self, converter: impl Fn(&T) -> U + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

The change sets with each item converted by converter (Cast(Func<TSource, TDestination>); named cast_cache beside ObservableExt::cast).

fn change_key<K2: Eq + Hash + Clone + 'static>( &self, key_selector: impl Fn(&T) -> K2 + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K2>>>

The changes keyed by key_selector of the item (ChangeKey(Func<TObject, TDestinationKey>)); the indexes are dropped, as upstream’s are.

fn change_key_with_key<K2: Eq + Hash + Clone + 'static>( &self, key_selector: impl Fn(&K, &T) -> K2 + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K2>>>

The changes keyed by key_selector of the key and the item (ChangeKey(Func<TSourceKey, TObject, TDestinationKey>)).

fn clone_to( &self, target: Rc<RefCell<Vec<T>>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: PartialEq,

The change sets, applied to target as they pass: an addition adds the item, an update replaces the previous item by it, and a removal removes it (Clone(ICollection<TObject>); named clone_to beside Clone::clone).

fn convert<U: Clone + 'static>( &self, conversion_factory: impl Fn(&T) -> U + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

The change sets with each item, and each previous item, converted by conversion_factory (Convert(Func<TObject, TDestination>)).

fn defer_until_loaded(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The change sets from the first one; empty change sets are left out (DeferUntilLoaded(IObservable<IChangeSet>)).

fn dispose_many(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: AsDisposable,

Disposes each item when it is removed or replaced (by another item), and every item left when the subscription ends; the change sets are forwarded first (DisposeMany).

The items are disposables through AsDisposable; an item for which it gives None is left alone, as upstream leaves an item that is not an IDisposable.

fn dispose_many_with( &self, to_disposable: impl Fn(&T) -> Option<Rc<dyn IDisposable>> + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

dispose_many for items that to_disposable makes disposables of (item as IDisposable).

fn distinct_values<V: Eq + Hash + Clone + 'static>( &self, value_selector: impl Fn(&T) -> V + 'static, ) -> Rc<dyn IObservable<DistinctChangeSet<V>>>

The distinct values that value_selector gives for the items, as the changes of a cache keyed by the values (DistinctValues(Func<TObject, TValue>)).

fn ensure_unique_keys(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The change sets with one change per key, the changes of a key within a change set combined; moves are left out (EnsureUniqueKeys).

fn expire_after( &self, time_selector: impl Fn(&T) -> Option<Duration> + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The items, each removed once the time that time_selector gives for it has passed (None: never), timed on the default scheduler; the sequence ends once the source has and no expiration is pending (ExpireAfter(Func<TObject, TimeSpan?>)).

fn expire_after_on( &self, time_selector: impl Fn(&T) -> Option<Duration> + 'static, scheduler: Rc<dyn IScheduler>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

expire_after on scheduler (ExpireAfter(.., IScheduler)).

fn expire_after_with_polling( &self, time_selector: impl Fn(&T) -> Option<Duration> + 'static, polling_interval: Option<Duration>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

expire_after that removes the expired items every polling_interval rather than at their times (ExpireAfter(.., TimeSpan?)).

fn expire_after_with_polling_on( &self, time_selector: impl Fn(&T) -> Option<Duration> + 'static, polling_interval: Option<Duration>, scheduler: Rc<dyn IScheduler>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

expire_after_with_polling on scheduler (ExpireAfter(.., TimeSpan?, IScheduler)).

fn filter_immutable( &self, predicate: impl Fn(&T) -> bool + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The items that predicate accepts, for items that never change: faster than filter, as nothing is cached; an update is evaluated by both of its items, a refresh is not evaluated again, and moves and indexes are dropped (FilterImmutable(Func<TObject, bool>, bool suppressEmptyChangeSets = true)).

fn filter_immutable_with( &self, predicate: impl Fn(&T) -> bool + 'static, suppress_empty_change_sets: bool, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

filter_immutable that keeps the empty change sets when suppress_empty_change_sets is false (FilterImmutable(Func<TObject, bool>, bool)).

fn try_filter_immutable( &self, predicate: impl Fn(&T) -> Result<bool, ObservableError> + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

filter_immutable with a predicate that may fail: a failure ends the sequence with its error (upstream catches the exception of the predicate).

fn try_filter_immutable_with( &self, predicate: impl Fn(&T) -> Result<bool, ObservableError> + 'static, suppress_empty_change_sets: bool, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

try_filter_immutable that keeps the empty change sets when suppress_empty_change_sets is false.

fn filter_on_observable( &self, filter_factory: impl Fn(&T) -> Rc<dyn IObservable<bool>> + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The items whose sequence of filter_factory produced true last; an item is excluded until its sequence produces a value (FilterOnObservable(Func<TObject, IObservable<bool>>)).

fn filter_on_observable_with( &self, filter_factory: impl Fn(&T) -> Rc<dyn IObservable<bool>> + 'static, buffer: Option<Duration>, scheduler: Option<Rc<dyn IScheduler>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

filter_on_observable that gathers the changes of the filters of each buffer into one change set, on scheduler (FilterOnObservable(Func<TObject, IObservable<bool>>, TimeSpan? buffer, IScheduler? scheduler)).

fn filter_on_observable_with_key( &self, filter_factory: impl Fn(&T, &K) -> Rc<dyn IObservable<bool>> + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

filter_on_observable with a factory that is given the key (FilterOnObservable(Func<TObject, TKey, IObservable<bool>>)).

fn filter_on_observable_with_key_with( &self, filter_factory: impl Fn(&T, &K) -> Rc<dyn IObservable<bool>> + 'static, buffer: Option<Duration>, scheduler: Option<Rc<dyn IScheduler>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

filter_on_observable_with_key that gathers the changes of the filters of each buffer into one change set, on scheduler (FilterOnObservable(Func<TObject, TKey, IObservable<bool>>, TimeSpan?, IScheduler?)).

fn flatten(&self) -> Rc<dyn IObservable<Change<T, K>>>

The changes of the change sets, one at a time (Flatten).

fn for_each_change( &self, action: impl Fn(&Change<T, K>) + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

Runs action for each change, before the change set is forwarded (ForEachChange(Action<Change<TObject, TKey>>)).

fn group<G: Eq + Hash + Clone + 'static>( &self, group_selector_key: impl Fn(&T) -> G + 'static, ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>>

The items grouped by the key group_selector_key selects: a change set of groups, each with the cache of its items; an update or a refresh evaluates the group of the item again (Group(Func<TObject, TGroupKey>)).

fn group_with<G: Eq + Hash + Clone + 'static>( &self, group_selector_key: impl Fn(&T) -> G + 'static, regrouper: Rc<dyn IObservable<()>>, ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>>

group that evaluates the group of every item again when regrouper produces a value (Group(Func<TObject, TGroupKey>, IObservable<Unit>)).

fn group_with_result_groups<G: Eq + Hash + Clone + 'static, C: IChangeSet<G, G>>( &self, group_selector: impl Fn(&T) -> G + 'static, result_group_source: Rc<dyn IObservable<C>>, ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>>

The groups of the keys of result_group_source (a change set whose items are their own keys, as distinct_values gives), each with the items whose key group_selector selects: a group exists while its key does, even without items (Group(Func<TObject, TGroupKey>, IObservable<IDistinctChangeSet<TGroupKey>>)).

fn group_dynamic<G: Eq + Hash + Clone + 'static>( &self, group_selector_key_observable: Rc<dyn IObservable<Rc<dyn Fn(&T) -> G>>>, ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>>

The items grouped by the latest selector of group_selector_key_observable: nothing is grouped until the first selector, and each new one evaluates the group of every item again (Group(IObservable<Func<TObject, TGroupKey>>, IObservable<Unit>? regrouper = null)).

fn group_dynamic_with<G: Eq + Hash + Clone + 'static>( &self, group_selector_key_observable: Rc<dyn IObservable<Rc<dyn Fn(&T) -> G>>>, regrouper: Rc<dyn IObservable<()>>, ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>>

group_dynamic that evaluates the group of every item again when regrouper produces a value (Group(IObservable<Func<TObject, TGroupKey>>, IObservable<Unit>)).

fn group_dynamic_with_key<G: Eq + Hash + Clone + 'static>( &self, group_selector_key_observable: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> G>>>, ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>>

group_dynamic with selectors of the item and its key (Group(IObservable<Func<TObject, TKey, TGroupKey>>, IObservable<Unit>? regrouper = null)).

fn group_dynamic_with_key_with<G: Eq + Hash + Clone + 'static>( &self, group_selector_key_observable: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> G>>>, regrouper: Rc<dyn IObservable<()>>, ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>>

group_dynamic_with_key that evaluates the group of every item again when regrouper produces a value (Group(IObservable<Func<TObject, TKey, TGroupKey>>, IObservable<Unit>)).

fn group_on_observable<G: Eq + Hash + Clone + 'static>( &self, group_observable_selector: impl Fn(&T) -> Rc<dyn IObservable<G>> + 'static, ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>>

The items grouped by the latest value of the sequence of group keys that group_observable_selector gives for each item; the result ends when the source and every sequence of group keys have ended (GroupOnObservable(Func<TObject, IObservable<TGroupKey>>)).

fn group_on_observable_with_key<G: Eq + Hash + Clone + 'static>( &self, group_observable_selector: impl Fn(&T, &K) -> Rc<dyn IObservable<G>> + 'static, ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>>

group_on_observable with a selector of the item and its key (GroupOnObservable(Func<TObject, TKey, IObservable<TGroupKey>>)).

fn try_group_on_observable<G: Eq + Hash + Clone + 'static>( &self, group_observable_selector: impl Fn(&T) -> Result<Rc<dyn IObservable<G>>, ObservableError> + 'static, ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>>

group_on_observable with a selector that may fail; a failure ends the result with its error (GroupOnObservable with a selector that throws).

fn try_group_on_observable_with_key<G: Eq + Hash + Clone + 'static>( &self, group_observable_selector: impl Fn(&T, &K) -> Result<Rc<dyn IObservable<G>>, ObservableError> + 'static, ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>>

group_on_observable_with_key with a selector that may fail; a failure ends the result with its error.

fn group_on_property<G: Eq + Hash + Clone + 'static>( &self, property_selector: PropertyPath<T, G>, ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>>

The items grouped by the value of the property property_selector, which is evaluated again when the property changes on an item (GroupOnProperty(Expression<Func<TObject, TGroupKey>>)).

fn group_on_property_with<G: Eq + Hash + Clone + 'static>( &self, property_selector: PropertyPath<T, G>, property_changed_throttle: Duration, ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>>

group_on_property that evaluates the groups once the property has not changed for property_changed_throttle, timed on the default scheduler (GroupOnProperty(Expression, TimeSpan?)).

fn group_on_property_with_on<G: Eq + Hash + Clone + 'static>( &self, property_selector: PropertyPath<T, G>, property_changed_throttle: Duration, scheduler: Rc<dyn IScheduler>, ) -> Rc<dyn IObservable<GroupChangeSet<T, K, G>>>

group_on_property_with timed on scheduler (GroupOnProperty(Expression, TimeSpan?, IScheduler?)).

fn group_on_property_with_immutable_state<G: Eq + Hash + Clone + 'static>( &self, property_selector: PropertyPath<T, G>, ) -> Rc<dyn IObservable<ImmutableGroupChangeSet<T, K, G>>>

The states of the groups of the items by the value of the property property_selector, which is evaluated again when the property changes on an item (GroupOnPropertyWithImmutableState(Expression<Func<TObject, TGroupKey>>)).

fn group_on_property_with_immutable_state_with<G: Eq + Hash + Clone + 'static>( &self, property_selector: PropertyPath<T, G>, property_changed_throttle: Duration, ) -> Rc<dyn IObservable<ImmutableGroupChangeSet<T, K, G>>>

group_on_property_with_immutable_state that evaluates the groups once the property has not changed for property_changed_throttle, timed on the default scheduler (GroupOnPropertyWithImmutableState(Expression, TimeSpan?)).

fn group_on_property_with_immutable_state_with_on<G: Eq + Hash + Clone + 'static>( &self, property_selector: PropertyPath<T, G>, property_changed_throttle: Duration, scheduler: Rc<dyn IScheduler>, ) -> Rc<dyn IObservable<ImmutableGroupChangeSet<T, K, G>>>

group_on_property_with_immutable_state_with timed on scheduler (GroupOnPropertyWithImmutableState(Expression, TimeSpan?, IScheduler?)).

fn group_with_immutable_state<G: Eq + Hash + Clone + 'static>( &self, group_selector_key: impl Fn(&T) -> G + 'static, ) -> Rc<dyn IObservable<ImmutableGroupChangeSet<T, K, G>>>

The items grouped by the key group_selector_key selects, as states of the groups that do not change: a group whose items change is updated with its new state (GroupWithImmutableState(Func<TObject, TGroupKey>, IObservable<Unit>? regrouper = null)).

fn group_with_immutable_state_with<G: Eq + Hash + Clone + 'static>( &self, group_selector_key: impl Fn(&T) -> G + 'static, regrouper: Rc<dyn IObservable<()>>, ) -> Rc<dyn IObservable<ImmutableGroupChangeSet<T, K, G>>>

group_with_immutable_state that evaluates the group of every item again when regrouper produces a value (GroupWithImmutableState(Func<TObject, TGroupKey>, IObservable<Unit>)).

fn ignore_same_reference_update(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: Deref,

The changes without the updates whose current item is the previous one (IgnoreSameReferenceUpdate, IgnoreUpdateWhen((c, p) => ReferenceEquals(c, p))).

Deviation (DEVIATIONS.md, DynamicData): the reference of an item is the object its pointer refers to (T: Deref, an Rc<..> for the classes of upstream); two items are the same reference when they point to the same object.

fn ignore_update_when( &self, ignore_function: impl Fn(&T, &T) -> bool + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The changes without the updates that ignore_function accepts; it is given the current and the previous item. The change sets left empty are dropped (IgnoreUpdateWhen(Func<TObject, TObject, bool>)).

fn include_update_when( &self, include_function: impl Fn(&T, &T) -> bool + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The changes without the updates that include_function rejects; it is given the current and the previous item. The change sets left empty are dropped (IncludeUpdateWhen(Func<TObject, TObject, bool>)).

fn invoke_evaluate(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: IEvaluateAware,

Calls evaluate on the item of each refresh before the change set is forwarded (InvokeEvaluate).

fn limit_size_to(&self, size: usize) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The items, the oldest removed beyond size (LimitSizeTo(IObservable<IChangeSet>, int)).

Panics

For a size of zero (ArgumentException).

fn merge_change_sets( &self, other: Rc<dyn IObservable<ChangeSet<T, K>>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: PartialEq,

The change sets of the sequence and of other, merged; it completes when both have completed (MergeChangeSets(IObservable<IChangeSet>, IObservable<IChangeSet>, IScheduler? = null, bool completable = true)).

fn merge_change_sets_with_comparer( &self, other: Rc<dyn IObservable<ChangeSet<T, K>>>, equality_comparer: impl Fn(&T, &T) -> bool + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

merge_change_sets with the equality of the items (MergeChangeSets(.., IObservable<IChangeSet>, IEqualityComparer<TObject>, ..)).

fn merge_change_sets_ordered_by( &self, other: Rc<dyn IObservable<ChangeSet<T, K>>>, comparer: Rc<dyn Fn(&T, &T) -> Ordering>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: PartialEq,

merge_change_sets where the value of a key is the least by comparer (MergeChangeSets(.., IObservable<IChangeSet>, IComparer<TObject>, ..)).

fn merge_change_sets_with( &self, other: Rc<dyn IObservable<ChangeSet<T, K>>>, equality_comparer: Option<Rc<dyn Fn(&T, &T) -> bool>>, comparer: Option<Rc<dyn Fn(&T, &T) -> Ordering>>, scheduler: Option<Rc<dyn IScheduler>>, completable: bool, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: PartialEq,

merge_change_sets with every argument: the equality of the items (PartialEq when None), the comparer, the scheduler that enumerates the two sequences, and whether the merge completes after them (MergeChangeSets(.., IObservable<IChangeSet>, IEqualityComparer<TObject>, IComparer<TObject>, IScheduler?, bool)).

fn merge_change_sets_many( &self, others: Vec<Rc<dyn IObservable<ChangeSet<T, K>>>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: PartialEq,

The change sets of the sequence and of others, merged (MergeChangeSets(IObservable<IChangeSet>, IEnumerable<IObservable<IChangeSet>>, IScheduler? = null, bool completable = true)).

fn merge_change_sets_many_with( &self, others: Vec<Rc<dyn IObservable<ChangeSet<T, K>>>>, equality_comparer: Option<Rc<dyn Fn(&T, &T) -> bool>>, comparer: Option<Rc<dyn Fn(&T, &T) -> Ordering>>, scheduler: Option<Rc<dyn IScheduler>>, completable: bool, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: PartialEq,

merge_change_sets_many with every argument (MergeChangeSets(.., IEnumerable<IObservable<IChangeSet>>, IEqualityComparer<TObject>, IComparer<TObject>, IScheduler?, bool)).

fn merge_many<D: 'static>( &self, observable_selector: impl Fn(&T) -> Rc<dyn IObservable<D>> + 'static, ) -> Rc<dyn IObservable<D>>

The values of the sequence that observable_selector chooses for each item, merged; the sequence of an item is subscribed while the item is in the cache. The merge completes when the source and every sequence have completed (MergeMany(Func<TObject, IObservable<TDestination>>)).

fn merge_many_with_key<D: 'static>( &self, observable_selector: impl Fn(&T, &K) -> Rc<dyn IObservable<D>> + 'static, ) -> Rc<dyn IObservable<D>>

merge_many with a selector that takes the key (MergeMany(Func<TObject, TKey, IObservable<TDestination>>)).

fn merge_many_change_sets<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static>( &self, observable_selector: impl Fn(&T) -> Rc<dyn IObservable<ChangeSet<D, DK>>> + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

The change sets of the cache that observable_selector chooses for each item, merged (MergeManyChangeSets(Func<TObject, IObservable<IChangeSet<TDestination, TDestinationKey>>>, IEqualityComparer<TDestination>? = null, IComparer<TDestination>? = null)).

fn merge_many_change_sets_with_key<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static>( &self, observable_selector: impl Fn(&T, &K) -> Rc<dyn IObservable<ChangeSet<D, DK>>> + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

merge_many_change_sets with a selector that takes the key (MergeManyChangeSets(Func<TObject, TKey, IObservable<IChangeSet<TDestination, TDestinationKey>>>, ..)).

fn merge_many_change_sets_with_comparer<D: Clone + 'static, DK: Eq + Hash + Clone + 'static>( &self, observable_selector: impl Fn(&T) -> Rc<dyn IObservable<ChangeSet<D, DK>>> + 'static, equality_comparer: impl Fn(&D, &D) -> bool + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

merge_many_change_sets with the equality of the children (MergeManyChangeSets(.., IEqualityComparer<TDestination>)).

fn merge_many_change_sets_ordered_by<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static>( &self, observable_selector: impl Fn(&T) -> Rc<dyn IObservable<ChangeSet<D, DK>>> + 'static, comparer: Rc<dyn Fn(&D, &D) -> Ordering>, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

merge_many_change_sets where the value of a key is the least child by comparer (MergeManyChangeSets(.., IComparer<TDestination>)).

fn merge_many_change_sets_with<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static>( &self, observable_selector: impl Fn(&T, &K) -> Rc<dyn IObservable<ChangeSet<D, DK>>> + 'static, equality_comparer: Option<Rc<dyn Fn(&D, &D) -> bool>>, comparer: Option<Rc<dyn Fn(&D, &D) -> Ordering>>, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

merge_many_change_sets with every argument: a selector that takes the key, the equality of the children (PartialEq when None) and their comparer (MergeManyChangeSets(Func<TObject, TKey, ..>, IEqualityComparer<TDestination>?, IComparer<TDestination>?)).

fn merge_many_change_sets_with_source_comparer<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static>( &self, observable_selector: impl Fn(&T) -> Rc<dyn IObservable<ChangeSet<D, DK>>> + 'static, source_comparer: Rc<dyn Fn(&T, &T) -> Ordering>, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

where T: PartialEq,

The change sets of the cache chosen for each item, merged, where the children of the least parent by source_comparer win; a refresh of a parent chooses its children again (MergeManyChangeSets(Func<TObject, IObservable<..>>, IComparer<TObject> sourceComparer, IEqualityComparer<TDestination>? = null, IComparer<TDestination>? = null)).

fn merge_many_change_sets_with_source_comparer_with<D: Clone + PartialEq + 'static, DK: Eq + Hash + Clone + 'static>( &self, observable_selector: impl Fn(&T, &K) -> Rc<dyn IObservable<ChangeSet<D, DK>>> + 'static, source_comparer: Rc<dyn Fn(&T, &T) -> Ordering>, resort_on_source_refresh: bool, equality_comparer: Option<Rc<dyn Fn(&D, &D) -> bool>>, child_comparer: Option<Rc<dyn Fn(&D, &D) -> Ordering>>, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

where T: PartialEq,

merge_many_change_sets_with_source_comparer with every argument: a selector that takes the key, whether a refresh of a parent chooses its children again, the equality of the children (that of the parents and the children when None) and the comparer of the children (MergeManyChangeSets(Func<TObject, TKey, ..>, IComparer<TObject>, bool resortOnSourceRefresh, IEqualityComparer<TDestination>?, IComparer<TDestination>?)).

fn merge_many_list_change_sets<D: Clone + PartialEq + 'static>( &self, observable_selector: impl Fn(&T) -> Rc<dyn IObservable<ChangeSet<D>>> + 'static, ) -> Rc<dyn IObservable<ChangeSet<D>>>

The change sets of the list that observable_selector chooses for each item, merged into those of one list (MergeManyChangeSets(Func<TObject, IObservable<IChangeSet< TDestination>>>, IEqualityComparer<TDestination>? = null)).

fn merge_many_list_change_sets_with_key<D: Clone + PartialEq + 'static>( &self, observable_selector: impl Fn(&T, &K) -> Rc<dyn IObservable<ChangeSet<D>>> + 'static, ) -> Rc<dyn IObservable<ChangeSet<D>>>

merge_many_list_change_sets with a selector that takes the key (MergeManyChangeSets(Func<TObject, TKey, IObservable<IChangeSet< TDestination>>>, ..)).

fn merge_many_list_change_sets_with<D: Clone + PartialEq + 'static>( &self, observable_selector: impl Fn(&T, &K) -> Rc<dyn IObservable<ChangeSet<D>>> + 'static, equality_comparer: Option<Rc<dyn Fn(&D, &D) -> bool>>, ) -> Rc<dyn IObservable<ChangeSet<D>>>

merge_many_list_change_sets_with_key with the equality of the children, which the copies of the child lists use (MergeManyChangeSets(Func<TObject, TKey, ..>, IEqualityComparer<TDestination>)).

fn merge_many_items<D: 'static>( &self, observable_selector: impl Fn(&T) -> Rc<dyn IObservable<D>> + 'static, ) -> Rc<dyn IObservable<ItemWithValue<T, D>>>

As merge_many, with each value paired with the item whose sequence produced it (MergeManyItems(Func<TObject, IObservable<TDestination>>)).

fn merge_many_items_with_key<D: 'static>( &self, observable_selector: impl Fn(&T, &K) -> Rc<dyn IObservable<D>> + 'static, ) -> Rc<dyn IObservable<ItemWithValue<T, D>>>

merge_many_items with a selector that takes the key (MergeManyItems(Func<TObject, TKey, IObservable<TDestination>>)).

fn of_type_cache<U: 'static>(&self) -> Rc<dyn IObservable<ChangeSet<Rc<U>, K>>>

where T: AnyObject,

The items that are of U, an update that changes that becoming an addition or a removal; empty change sets are left out (OfType<TDestination>(bool suppressEmptyChangeSets = true); named of_type_cache beside ObservableExt::of_type). The items are Rc<dyn Any>.

fn of_type_cache_with<U: 'static>( &self, suppress_empty_change_sets: bool, ) -> Rc<dyn IObservable<ChangeSet<Rc<U>, K>>>

where T: AnyObject,

of_type_cache that keeps the empty change sets when suppress_empty_change_sets is false (OfType<TDestination>(bool)).

fn on_item_added( &self, add_action: impl Fn(&T) + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

Runs add_action for each item added, before the change set is forwarded (OnItemAdded(Action<TObject>)).

fn on_item_added_with_key( &self, add_action: impl Fn(&T, &K) + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

on_item_added with the key (OnItemAdded(Action<TObject, TKey>)).

fn on_item_refreshed( &self, refresh_action: impl Fn(&T) + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

Runs refresh_action for each item refreshed, before the change set is forwarded (OnItemRefreshed(Action<TObject>)).

fn on_item_refreshed_with_key( &self, refresh_action: impl Fn(&T, &K) + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

on_item_refreshed with the key (OnItemRefreshed(Action<TObject, TKey>)).

fn on_item_removed( &self, remove_action: impl Fn(&T) + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

Runs remove_action for each item removed, before the change set is forwarded, and for every item left when the subscription ends (OnItemRemoved(Action<TObject>, bool invokeOnUnsubscribe = true)).

fn on_item_removed_with_key( &self, remove_action: impl Fn(&T, &K) + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

on_item_removed with the key (OnItemRemoved(Action<TObject, TKey>, bool invokeOnUnsubscribe = true)).

fn on_item_removed_with( &self, remove_action: impl Fn(&T, &K) + 'static, invoke_on_unsubscribe: bool, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

on_item_removed_with_key, for the items left when the subscription ends only when invoke_on_unsubscribe is true (OnItemRemoved(Action<TObject, TKey>, bool invokeOnUnsubscribe)).

fn on_item_updated( &self, update_action: impl Fn(&T, &T) + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

Runs update_action with the new item and the one it replaces, for each update, before the change set is forwarded (OnItemUpdated(Action<TObject, TObject>)).

fn on_item_updated_with_key( &self, update_action: impl Fn(&T, &T, &K) + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

on_item_updated with the key (OnItemUpdated(Action<TObject, TObject, TKey>)).

fn populate_into<D: ISourceCache<T, K> + Clone + 'static>( &self, destination: &D, ) -> Rc<dyn IDisposable>

Applies each change set to destination (PopulateInto(ISourceCache)).

fn populate_into_intermediate( &self, destination: &IntermediateCache<T, K>, ) -> Rc<dyn IDisposable>

Applies each change set to destination (PopulateInto(IIntermediateCache)).

fn populate_into_lock_free( &self, destination: &LockFreeObservableCache<T, K>, ) -> Rc<dyn IDisposable>

Applies each change set to destination (PopulateInto(LockFreeObservableCache)).

fn query_when_changed(&self) -> Rc<dyn IObservable<Rc<dyn IQuery<T, K>>>>

A snapshot of the items to query after each change set (QueryWhenChanged()).

fn query_when_changed_with<R: 'static>( &self, result_selector: impl Fn(Rc<dyn IQuery<T, K>>) -> R + 'static, ) -> Rc<dyn IObservable<R>>

What result_selector makes of a snapshot of the items after each change set (QueryWhenChanged(Func<IQuery<TObject, TKey>, TDestination>)).

fn query_when_changed_with_trigger<V: 'static>( &self, item_changed_trigger: impl Fn(&T) -> Rc<dyn IObservable<V>> + 'static, ) -> Rc<dyn IObservable<Rc<dyn IQuery<T, K>>>>

A snapshot of the items after each change set and each value of the observable that item_changed_trigger gives for an item (QueryWhenChanged(Func<TObject, IObservable<TValue>>)).

fn ref_count(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>

One cache of the sequence, shared by the subscribers: made when the first subscribes, disposed when the last unsubscribes (RefCount).

fn remove_key(&self) -> Rc<dyn IObservable<ChangeSet<T>>>

where T: PartialEq,

The changes as changes of a list, without their keys: an update becomes a removal and an addition, and a refresh a replacement of the item by itself (RemoveKey()).

fn skip_initial(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The change sets after the first one (SkipInitial).

fn sort( &self, comparer: Rc<dyn Fn(&T, &T) -> Ordering>, ) -> Rc<dyn IObservable<SortedChangeSet<T, K>>>

The items, sorted by comparer: each change set has the indexes of its changes and the sorted items (Sort(IComparer<TObject>) with the default optimisations and reset threshold).

fn sort_with( &self, comparer: Rc<dyn Fn(&T, &T) -> Ordering>, sort_optimisations: SortOptimisations, reset_threshold: usize, ) -> Rc<dyn IObservable<SortedChangeSet<T, K>>>

sort with sort_optimisations and reset_threshold, the number of changes from which the sorted items are rebuilt rather than edited (0 never rebuilds) (Sort(IComparer<TObject>, SortOptimisations, int resetThreshold)).

fn sort_dynamic( &self, comparer_observable: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>, ) -> Rc<dyn IObservable<SortedChangeSet<T, K>>>

The items, sorted by the latest comparer of comparer_observable; nothing is produced before the first comparer (Sort(IObservable<IComparer<TObject>>) with the default optimisations and reset threshold).

fn sort_dynamic_with( &self, comparer_observable: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>, sort_optimisations: SortOptimisations, reset_threshold: usize, ) -> Rc<dyn IObservable<SortedChangeSet<T, K>>>

sort_dynamic with sort_optimisations and reset_threshold (Sort(IObservable<IComparer<TObject>>, SortOptimisations, int resetThreshold)).

fn sort_dynamic_with_resorter( &self, comparer_observable: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>, resorter: Rc<dyn IObservable<()>>, sort_optimisations: SortOptimisations, reset_threshold: usize, ) -> Rc<dyn IObservable<SortedChangeSet<T, K>>>

sort_dynamic_with that also sorts again, with moves, whenever resorter notifies (Sort(IObservable<IComparer<TObject>>, IObservable<Unit>, SortOptimisations, int resetThreshold)).

fn sort_with_resorter( &self, comparer: Rc<dyn Fn(&T, &T) -> Ordering>, resorter: Rc<dyn IObservable<()>>, sort_optimisations: SortOptimisations, reset_threshold: usize, ) -> Rc<dyn IObservable<SortedChangeSet<T, K>>>

sort_with that also sorts again, with moves, whenever resorter notifies (Sort(IComparer<TObject>, IObservable<Unit>, SortOptimisations, int resetThreshold)).

fn sort_and_bind<L: IList<T> + Clone + 'static>( &self, target: &L, comparer: Rc<dyn Fn(&T, &T) -> Ordering>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: PartialEq,

Sorts the items by comparer into target (SortAndBind(IList<TObject>, IComparer<TObject>)), with the options of DynamicDataOptions.SortAndBind.

fn sort_and_bind_with( &self, target: &(impl IList<T> + Clone + 'static), comparer: Rc<dyn Fn(&T, &T) -> Ordering>, options: SortAndBindOptions, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: PartialEq,

sort_and_bind with options (SortAndBind(IList<TObject>, IComparer<TObject>, SortAndBindOptions)).

fn sort_and_bind_by_default( &self, target: &(impl IList<T> + Clone + 'static), ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: Ord,

Sorts the items in their natural order into target (SortAndBind(IList<TObject>), Comparer<TObject>.Default).

fn sort_and_bind_by_default_with( &self, target: &(impl IList<T> + Clone + 'static), options: SortAndBindOptions, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: Ord,

sort_and_bind_by_default with options (SortAndBind(IList<TObject>, SortAndBindOptions)).

fn sort_and_bind_on_observable( &self, target: &(impl IList<T> + Clone + 'static), comparer_changed: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: PartialEq,

Sorts the items into target by the latest comparer of comparer_changed, sorting again at each one (SortAndBind(IList<TObject>, IObservable<IComparer<TObject>>)).

fn sort_and_bind_on_observable_with( &self, target: &(impl IList<T> + Clone + 'static), comparer_changed: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>, options: SortAndBindOptions, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: PartialEq,

sort_and_bind_on_observable with options (SortAndBind(IList<TObject>, IObservable<IComparer<TObject>>, SortAndBindOptions)).

fn sort_and_bind_read_only( &self, comparer: Rc<dyn Fn(&T, &T) -> Ordering>, ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)

where T: PartialEq,

Sorts the items by comparer into a new collection, returned as a read-only view (SortAndBind(out ReadOnlyObservableCollection<TObject>, IComparer<TObject>)).

fn sort_and_bind_read_only_with( &self, comparer: Rc<dyn Fn(&T, &T) -> Ordering>, options: SortAndBindOptions, ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)

where T: PartialEq,

sort_and_bind_read_only with options, whose initial capacity sizes the collection (SortAndBind(out ReadOnlyObservableCollection<TObject>, IComparer<TObject>, SortAndBindOptions)).

fn sort_and_bind_read_only_by_default( &self, ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)

where T: Ord,

Sorts the items in their natural order into a new collection, returned as a read-only view (SortAndBind(out ReadOnlyObservableCollection<TObject>)).

fn sort_and_bind_read_only_by_default_with( &self, options: SortAndBindOptions, ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)

where T: Ord,

sort_and_bind_read_only_by_default with options (SortAndBind(out ReadOnlyObservableCollection<TObject>, SortAndBindOptions)).

fn sort_and_bind_read_only_on_observable( &self, comparer_changed: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>, ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)

where T: PartialEq,

Sorts the items by the latest comparer of comparer_changed into a new collection, returned as a read-only view (SortAndBind(out ReadOnlyObservableCollection<TObject>, IObservable<IComparer<TObject>>)).

fn sort_and_bind_read_only_on_observable_with( &self, comparer_changed: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>, options: SortAndBindOptions, ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)

where T: PartialEq,

sort_and_bind_read_only_on_observable with options (SortAndBind(out ReadOnlyObservableCollection<TObject>, IObservable<IComparer<TObject>>, SortAndBindOptions)).

fn bind_to_list( &self, target_list: &(impl IList<T> + Clone + 'static), ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: PartialEq, Self: Sized + 'static,

Binds the results of SortAndPage or SortAndVirtualize to target_list, sorted by the comparer of their context, with the options of their context (Bind(IList<TObject>) of IChangeSet<TObject, TKey, PageContext<TObject>> and of IChangeSet<TObject, TKey, VirtualContext<TObject>>).

Panics

When the source is not a result of SortAndPage or SortAndVirtualize.

fn bind_to_list_with( &self, target_list: &(impl IList<T> + Clone + 'static), options: SortAndBindOptions, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: PartialEq, Self: Sized + 'static,

bind_to_list with options (Bind(IList<TObject>, SortAndBindOptions) of the paged and virtualised change sets).

Panics

When the source is not a result of SortAndPage or SortAndVirtualize.

fn bind_read_only_with_sort_and_bind_options( &self, options: SortAndBindOptions, ) -> (Rc<dyn IObservable<ChangeSet<T, K>>>, ReadOnlyObservableCollection<T>)

where T: PartialEq, Self: Sized + 'static,

Binds the results of SortAndPage or SortAndVirtualize to a new collection, returned as a read-only view (Bind(out ReadOnlyObservableCollection<TObject>, SortAndBindOptions) of the paged and virtualised change sets). Their form without options is bind_read_only.

Panics

When the source is not a result of SortAndPage or SortAndVirtualize.

fn sort_by<V: PartialOrd + 'static>( &self, expression: impl Fn(&T) -> V + 'static, ) -> Rc<dyn IObservable<SortedChangeSet<T, K>>>

The items, sorted by the value that expression reads, ascending (SortBy(Func<TObject, IComparable>) with the default direction, optimisations and reset threshold).

fn sort_by_with<V: PartialOrd + 'static>( &self, expression: impl Fn(&T) -> V + 'static, sort_order: SortDirection, sort_optimisations: SortOptimisations, reset_threshold: usize, ) -> Rc<dyn IObservable<SortedChangeSet<T, K>>>

The items, sorted by the value that expression reads, in sort_order (SortBy(Func<TObject, IComparable>, SortDirection, SortOptimisations, int)).

fn start_with_empty(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>

An empty change set, then the change sets (StartWithEmpty).

fn start_with_item( &self, item: T, key: K, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

A change set that adds item under key, then the change sets (StartWithItem(TObject, TKey)).

fn start_with_keyed_item(&self, item: T) -> Rc<dyn IObservable<ChangeSet<T, K>>>

where T: IKey<K>,

A change set that adds item under its own key, then the change sets (StartWithItem(TObject) for an item that is an IKey<TKey>).

fn subscribe_many( &self, subscription_factory: impl Fn(&T) -> Rc<dyn IDisposable> + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

Makes a subscription for each item with subscription_factory, when it is added; the subscription is disposed when the item is removed or replaced, or when the subscription to the result ends. The change sets are forwarded as they are (SubscribeMany(Func<TObject, IDisposable>)).

fn subscribe_many_with_key( &self, subscription_factory: impl Fn(&T, &K) -> Rc<dyn IDisposable> + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

subscribe_many with a factory that takes the key (SubscribeMany(Func<TObject, TKey, IDisposable>)).

fn suppress_refresh(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The changes without the refreshes (SuppressRefresh, WhereReasonsAreNot(Refresh)).

fn to_collection(&self) -> Rc<dyn IObservable<Vec<T>>>

The items of the cache after each change set (ToCollection): a copy of the items, in the order of the cache.

fn to_observable_optional(&self, key: K) -> Rc<dyn IObservable<Option<T>>>

where T: PartialEq,

The item of key as an option each time it changes, None when it is removed; equal successive items are left out (ToObservableOptional(TKey, IEqualityComparer? = null)).

fn to_observable_optional_with_comparer( &self, key: K, equality_comparer: impl Fn(&T, &T) -> bool + 'static, ) -> Rc<dyn IObservable<Option<T>>>

to_observable_optional with the equality of equality_comparer (ToObservableOptional(TKey, IEqualityComparer)).

fn to_observable_optional_with_initial( &self, key: K, initial_optional_when_missing: bool, ) -> Rc<dyn IObservable<Option<T>>>

where T: PartialEq,

to_observable_optional that starts with None when the item is not there at first and initial_optional_when_missing is true (ToObservableOptional(TKey, bool, IEqualityComparer? = null)).

fn to_observable_optional_with_initial_and_comparer( &self, key: K, initial_optional_when_missing: bool, equality_comparer: impl Fn(&T, &T) -> bool + 'static, ) -> Rc<dyn IObservable<Option<T>>>

to_observable_optional_with_initial with the equality of equality_comparer.

fn to_sorted_collection<S: Ord + 'static>( &self, sort: impl Fn(&T) -> S + 'static, sort_order: SortDirection, ) -> Rc<dyn IObservable<Vec<T>>>

The items of the cache after each change set, sorted by the key that sort gives (ToSortedCollection(Func<TObject, TSortKey>, SortDirection sortOrder = Ascending)); a stable sort, as OrderBy and OrderByDescending are.

fn to_sorted_collection_with_comparer( &self, comparer: Rc<dyn Fn(&T, &T) -> Ordering>, ) -> Rc<dyn IObservable<Vec<T>>>

The items of the cache after each change set, sorted by comparer (ToSortedCollection(IComparer<TObject>)).

fn transform<U: Clone + 'static>( &self, transform_factory: impl Fn(&T) -> U + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

Each item in the form transform_factory gives it, under the same key: an addition or an update transforms the item, a removal removes it, a refresh is forwarded and a move ignored (Transform(Func<TSource, TDestination>, IObservable<Func<TSource, bool>>? forceTransform = null)).

fn transform_with_key<U: Clone + 'static>( &self, transform_factory: impl Fn(&T, &K) -> U + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform with a factory of the item and its key (Transform(Func<TSource, TKey, TDestination>, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)).

fn transform_with_previous<U: Clone + 'static>( &self, transform_factory: impl Fn(&T, Option<&T>, &K) -> U + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform with a factory of the item, the item it replaces (for an update) and the key (Transform(Func<TSource, Optional<TSource>, TKey, TDestination>, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)).

fn transform_with_refresh<U: Clone + 'static>( &self, transform_factory: impl Fn(&T) -> U + 'static, transform_on_refresh: bool, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform that, when transform_on_refresh is true, transforms a refreshed item again and emits it as an update (Transform(Func<TSource, TDestination>, bool transformOnRefresh)).

fn transform_with_key_and_refresh<U: Clone + 'static>( &self, transform_factory: impl Fn(&T, &K) -> U + 'static, transform_on_refresh: bool, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_with_key with the flag of transform_with_refresh (Transform(Func<TSource, TKey, TDestination>, bool transformOnRefresh)).

fn transform_with_previous_and_refresh<U: Clone + 'static>( &self, transform_factory: impl Fn(&T, Option<&T>, &K) -> U + 'static, transform_on_refresh: bool, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_with_previous with the flag of transform_with_refresh (Transform(Func<TSource, Optional<TSource>, TKey, TDestination>, bool transformOnRefresh)).

fn transform_forced<U: Clone + 'static>( &self, transform_factory: impl Fn(&T) -> U + 'static, force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T) -> bool>>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform that also transforms again, as updates, the items that each predicate of force_transform accepts (Transform(Func<TSource, TDestination>, IObservable<Func<TSource, bool>>)).

fn transform_with_key_forced<U: Clone + 'static>( &self, transform_factory: impl Fn(&T, &K) -> U + 'static, force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_with_key that also transforms again, as updates, the items that each predicate of force_transform accepts (Transform(Func<TSource, TKey, TDestination>, IObservable<Func<TSource, TKey, bool>>)).

fn transform_with_previous_forced<U: Clone + 'static>( &self, transform_factory: impl Fn(&T, Option<&T>, &K) -> U + 'static, force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_with_previous that also transforms again, as updates, the items that each predicate of force_transform accepts (Transform(Func<TSource, Optional<TSource>, TKey, TDestination>, IObservable<Func<TSource, TKey, bool>>)).

fn transform_forced_all<U: Clone + 'static>( &self, transform_factory: impl Fn(&T) -> U + 'static, force_transform: Rc<dyn IObservable<()>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform that transforms every item again, as updates, whenever force_transform produces a value (Transform(Func<TSource, TDestination>, IObservable<Unit>)).

fn transform_with_key_forced_all<U: Clone + 'static>( &self, transform_factory: impl Fn(&T, &K) -> U + 'static, force_transform: Rc<dyn IObservable<()>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_with_key that transforms every item again whenever force_transform produces a value (Transform(Func<TSource, TKey, TDestination>, IObservable<Unit>)).

fn transform_with_previous_forced_all<U: Clone + 'static>( &self, transform_factory: impl Fn(&T, Option<&T>, &K) -> U + 'static, force_transform: Rc<dyn IObservable<()>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_with_previous that transforms every item again whenever force_transform produces a value (Transform(Func<TSource, Optional<TSource>, TKey, TDestination>, IObservable<Unit>)).

fn try_transform<U: Clone + 'static>( &self, transform_factory: impl Fn(&T) -> Result<U, ObservableError> + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform with a factory that may fail: its error ends the sequence (Transform(Func<TSource, TDestination>) with a factory that throws).

fn try_transform_with_key<U: Clone + 'static>( &self, transform_factory: impl Fn(&T, &K) -> Result<U, ObservableError> + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_with_key with a factory that may fail.

fn try_transform_with_previous<U: Clone + 'static>( &self, transform_factory: impl Fn(&T, Option<&T>, &K) -> Result<U, ObservableError> + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_with_previous with a factory that may fail.

fn try_transform_with_previous_and_refresh<U: Clone + 'static>( &self, transform_factory: impl Fn(&T, Option<&T>, &K) -> Result<U, ObservableError> + 'static, transform_on_refresh: bool, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_with_previous_and_refresh with a factory that may fail.

fn try_transform_with_previous_forced<U: Clone + 'static>( &self, transform_factory: impl Fn(&T, Option<&T>, &K) -> Result<U, ObservableError> + 'static, force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_with_previous_forced with a factory that may fail.

fn try_transform_with_previous_forced_all<U: Clone + 'static>( &self, transform_factory: impl Fn(&T, Option<&T>, &K) -> Result<U, ObservableError> + 'static, force_transform: Rc<dyn IObservable<()>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_with_previous_forced_all with a factory that may fail.

fn transform_immutable<U: 'static>( &self, transform_factory: impl Fn(&T) -> U + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

Each change with its items transformed by transform_factory and every other part kept, the indexes included; nothing is cached, so the factory runs for every change (the previous item of an update too) and should be cheap and pure (TransformImmutable(Func<TSource, TDestination>)).

fn try_transform_immutable<U: 'static>( &self, transform_factory: impl Fn(&T) -> Result<U, ObservableError> + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_immutable with a factory that may fail: its error ends the sequence, and the change set that raised it is not emitted (TransformImmutable with a factory that throws).

fn transform_many<D: Clone + Deref + 'static, DK: Eq + Hash + Clone + 'static>( &self, many_selector: impl Fn(&T) -> Vec<D> + 'static, key_selector: impl Fn(&D) -> DK + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

The items that many_selector gives for each item, keyed by key_selector (TransformMany(Func<TSource, IEnumerable<TDestination>>, Func<TDestination, TDestinationKey>)). A refresh of an item of the source takes its items again.

fn transform_many_observable_cache<D: Clone + Deref + 'static, DK: Eq + Hash + Clone + 'static, C: IObservableCache<D, DK> + 'static>( &self, many_selector: impl Fn(&T) -> C + 'static, key_selector: impl Fn(&D) -> DK + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

The items of the cache that many_selector gives for each item, keyed by key_selector, followed as the caches change (TransformMany(Func<TSource, IObservableCache<TDestination, TDestinationKey>>, Func<TDestination, TDestinationKey>)).

fn transform_many_observable_collection<D: Clone + PartialEq + Deref + 'static, DK: Eq + Hash + Clone + 'static, C: ObservableCollectionEx<D> + 'static>( &self, many_selector: impl Fn(&T) -> C + 'static, key_selector: impl Fn(&D) -> DK + 'static, ) -> Rc<dyn IObservable<ChangeSet<D, DK>>>

The items of the observable collection that many_selector gives for each item, keyed by key_selector, followed as the collections change (TransformMany(Func<TSource, ObservableCollection<TDestination>>, Func<TDestination, TDestinationKey>), TransformMany(Func<TSource, ReadOnlyObservableCollection<TDestination>>, Func<TDestination, TDestinationKey>)).

fn transform_on_observable<U: Clone + PartialEq + 'static>( &self, transform_factory: impl Fn(&T) -> Rc<dyn IObservable<U>> + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

For each item, the latest distinct value of the observable transform_factory makes of it, under the key of the item: an addition or an update subscribes to a new observable, a removal ends it and removes the value. The values that one change set of the source makes at once come as one change set; the sequence ends when the source and every observable have ended, and fails with the first error of any of them (TransformOnObservable(Func<TSource, IObservable<TDestination>>)).

fn transform_on_observable_with_key<U: Clone + PartialEq + 'static>( &self, transform_factory: impl Fn(&T, &K) -> Rc<dyn IObservable<U>> + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_on_observable with a factory of the item and its key (TransformOnObservable(Func<TSource, TKey, IObservable<TDestination>>)).

fn transform_safe<U: Clone + 'static>( &self, transform_factory: impl Fn(&T) -> Result<U, ObservableError> + 'static, error_handler: impl Fn(Error<T, K>) + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform whose factory may fail: an error goes to error_handler and leaves the item out (TransformSafe(Func<TSource, TDestination>, Action<Error<TSource, TKey>>, IObservable<Func<TSource, bool>>? forceTransform = null)).

fn transform_safe_with_key<U: Clone + 'static>( &self, transform_factory: impl Fn(&T, &K) -> Result<U, ObservableError> + 'static, error_handler: impl Fn(Error<T, K>) + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_safe with a factory of the item and its key (TransformSafe(Func<TSource, TKey, TDestination>, Action<Error<TSource, TKey>>, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)).

fn transform_safe_with_previous<U: Clone + 'static>( &self, transform_factory: impl Fn(&T, Option<&T>, &K) -> Result<U, ObservableError> + 'static, error_handler: impl Fn(Error<T, K>) + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_safe with a factory of the item, the item it replaces and the key (TransformSafe(Func<TSource, Optional<TSource>, TKey, TDestination>, Action<Error<TSource, TKey>>, IObservable<Func<TSource, TKey, bool>>? forceTransform = null)).

fn transform_safe_forced<U: Clone + 'static>( &self, transform_factory: impl Fn(&T) -> Result<U, ObservableError> + 'static, error_handler: impl Fn(Error<T, K>) + 'static, force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T) -> bool>>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_safe that also transforms again, as updates, the items that each predicate of force_transform accepts (TransformSafe(Func<TSource, TDestination>, Action<Error<TSource, TKey>>, IObservable<Func<TSource, bool>>)).

fn transform_safe_with_key_forced<U: Clone + 'static>( &self, transform_factory: impl Fn(&T, &K) -> Result<U, ObservableError> + 'static, error_handler: impl Fn(Error<T, K>) + 'static, force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_safe_with_key that also transforms again the items that each predicate of force_transform accepts (TransformSafe(Func<TSource, TKey, TDestination>, Action<Error<TSource, TKey>>, IObservable<Func<TSource, TKey, bool>>)).

fn transform_safe_with_previous_forced<U: Clone + 'static>( &self, transform_factory: impl Fn(&T, Option<&T>, &K) -> Result<U, ObservableError> + 'static, error_handler: impl Fn(Error<T, K>) + 'static, force_transform: Rc<dyn IObservable<Rc<dyn Fn(&T, &K) -> bool>>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_safe_with_previous that also transforms again the items that each predicate of force_transform accepts (TransformSafe(Func<TSource, Optional<TSource>, TKey, TDestination>, Action<Error<TSource, TKey>>, IObservable<Func<TSource, TKey, bool>>)).

fn transform_safe_forced_all<U: Clone + 'static>( &self, transform_factory: impl Fn(&T) -> Result<U, ObservableError> + 'static, error_handler: impl Fn(Error<T, K>) + 'static, force_transform: Rc<dyn IObservable<()>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_safe that transforms every item again whenever force_transform produces a value (TransformSafe(Func<TSource, TDestination>, Action<Error<TSource, TKey>>, IObservable<Unit>)).

fn transform_safe_with_key_forced_all<U: Clone + 'static>( &self, transform_factory: impl Fn(&T, &K) -> Result<U, ObservableError> + 'static, error_handler: impl Fn(Error<T, K>) + 'static, force_transform: Rc<dyn IObservable<()>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_safe_with_key that transforms every item again whenever force_transform produces a value (TransformSafe(Func<TSource, TKey, TDestination>, Action<Error<TSource, TKey>>, IObservable<Unit>)).

fn transform_safe_with_previous_forced_all<U: Clone + 'static>( &self, transform_factory: impl Fn(&T, Option<&T>, &K) -> Result<U, ObservableError> + 'static, error_handler: impl Fn(Error<T, K>) + 'static, force_transform: Rc<dyn IObservable<()>>, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_safe_with_previous that transforms every item again whenever force_transform produces a value (TransformSafe(Func<TSource, Optional<TSource>, TKey, TDestination>, Action<Error<TSource, TKey>>, IObservable<Unit>)).

fn transform_to_tree( &self, pivot_on: impl Fn(&T) -> K + 'static, ) -> Rc<dyn IObservable<ChangeSet<Rc<Node<T, K>>, K>>>

The items as the nodes of a tree, each the child of the node whose key pivot_on gives for it; the sequence has the roots (TransformToTree(Func<TObject, TKey>, IObservable<Func<Node<TObject, TKey>, bool>>? predicateChanged = null)).

fn transform_to_tree_with( &self, pivot_on: impl Fn(&T) -> K + 'static, predicate_changed: Rc<dyn IObservable<Rc<dyn Fn(&Rc<Node<T, K>>) -> bool>>>, ) -> Rc<dyn IObservable<ChangeSet<Rc<Node<T, K>>, K>>>

transform_to_tree whose sequence has the nodes that the latest predicate of predicate_changed accepts, instead of the roots (TransformToTree(Func<TObject, TKey>, IObservable<Func<Node<TObject, TKey>, bool>>)).

fn transform_with_inline_update<U: Clone + 'static>( &self, transform_factory: impl Fn(&T) -> U + 'static, update_action: impl Fn(&U, &T) + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

Each item transformed once by transform_factory; an update calls update_action with the transformed item and the new item instead, and emits a refresh (TransformWithInlineUpdate(Func<TSource, TDestination>, Action<TDestination, TSource>)).

fn transform_with_inline_update_with<U: Clone + 'static>( &self, transform_factory: impl Fn(&T) -> U + 'static, update_action: impl Fn(&U, &T) + 'static, transform_on_refresh: bool, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_with_inline_update that, when transform_on_refresh is true, updates the transformed item on a refresh too (TransformWithInlineUpdate(Func<TSource, TDestination>, Action<TDestination, TSource>, bool transformOnRefresh)).

fn transform_with_inline_update_safe<U: Clone + 'static>( &self, transform_factory: impl Fn(&T) -> Result<U, ObservableError> + 'static, update_action: impl Fn(&U, &T) -> Result<(), ObservableError> + 'static, error_handler: impl Fn(Error<T, K>) + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_with_inline_update whose factory and update may fail: an error goes to error_handler (TransformWithInlineUpdate(Func<TSource, TDestination>, Action<TDestination, TSource>, Action<Error<TSource, TKey>>)).

fn transform_with_inline_update_safe_with<U: Clone + 'static>( &self, transform_factory: impl Fn(&T) -> Result<U, ObservableError> + 'static, update_action: impl Fn(&U, &T) -> Result<(), ObservableError> + 'static, error_handler: impl Fn(Error<T, K>) + 'static, transform_on_refresh: bool, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_with_inline_update_safe with the flag of transform_with_inline_update_with (TransformWithInlineUpdate(Func<TSource, TDestination>, Action<TDestination, TSource>, Action<Error<TSource, TKey>>, bool transformOnRefresh)).

fn try_transform_with_inline_update<U: Clone + 'static>( &self, transform_factory: impl Fn(&T) -> Result<U, ObservableError> + 'static, update_action: impl Fn(&U, &T) -> Result<(), ObservableError> + 'static, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

transform_with_inline_update whose factory and update may fail: an error ends the sequence.

fn try_transform_with_inline_update_with<U: Clone + 'static>( &self, transform_factory: impl Fn(&T) -> Result<U, ObservableError> + 'static, update_action: impl Fn(&U, &T) -> Result<(), ObservableError> + 'static, transform_on_refresh: bool, ) -> Rc<dyn IObservable<ChangeSet<U, K>>>

try_transform_with_inline_update with the flag of transform_with_inline_update_with.

fn true_for_all<V: Clone + 'static>( &self, observable_selector: impl Fn(&T) -> Rc<dyn IObservable<V>> + 'static, equality_condition: impl Fn(&V) -> bool + 'static, ) -> Rc<dyn IObservable<bool>>

Whether equality_condition holds for the latest value of the observable that observable_selector gives for each item, each item having one, each time the result changes (TrueForAll(Func<TObject, IObservable<TValue>>, Func<TValue, bool>)).

fn true_for_all_with_item<V: Clone + 'static>( &self, observable_selector: impl Fn(&T) -> Rc<dyn IObservable<V>> + 'static, equality_condition: impl Fn(&T, &V) -> bool + 'static, ) -> Rc<dyn IObservable<bool>>

true_for_all with a condition of the item and its value (TrueForAll(Func<TObject, IObservable<TValue>>, Func<TObject, TValue, bool>)).

fn true_for_any<V: Clone + 'static>( &self, observable_selector: impl Fn(&T) -> Rc<dyn IObservable<V>> + 'static, equality_condition: impl Fn(&V) -> bool + 'static, ) -> Rc<dyn IObservable<bool>>

Whether equality_condition holds for the latest value of the observable that observable_selector gives for some item, each time the result changes (TrueForAny(Func<TObject, IObservable<TValue>>, Func<TValue, bool>)).

fn true_for_any_with_item<V: Clone + 'static>( &self, observable_selector: impl Fn(&T) -> Rc<dyn IObservable<V>> + 'static, equality_condition: impl Fn(&T, &V) -> bool + 'static, ) -> Rc<dyn IObservable<bool>>

true_for_any with a condition of the item and its value (TrueForAny(Func<TObject, IObservable<TValue>>, Func<TObject, TValue, bool>)).

fn sort_and_virtualize( &self, comparer: Rc<dyn Fn(&T, &T) -> Ordering>, virtual_requests: Rc<dyn IObservable<VirtualRequest>>, ) -> Rc<dyn IObservable<ChangeSetWithContext<T, K, VirtualContext<T>>>>

The window of the items, sorted by comparer, that the latest request of virtual_requests asks for; the change sets hold the changes of the window, with the window, the comparer and the options as their context (SortAndVirtualize(IComparer, IObservable<IVirtualRequest>)).

fn sort_and_virtualize_dynamic( &self, comparer_changed: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>, virtual_requests: Rc<dyn IObservable<VirtualRequest>>, ) -> Rc<dyn IObservable<ChangeSetWithContext<T, K, VirtualContext<T>>>>

sort_and_virtualize sorted by the latest comparer of comparer_changed (SortAndVirtualize(IObservable<IComparer>, IObservable<IVirtualRequest>)).

fn sort_and_virtualize_with( &self, comparer: Rc<dyn Fn(&T, &T) -> Ordering>, virtual_requests: Rc<dyn IObservable<VirtualRequest>>, options: SortAndVirtualizeOptions, ) -> Rc<dyn IObservable<ChangeSetWithContext<T, K, VirtualContext<T>>>>

sort_and_virtualize with options (SortAndVirtualize(IComparer, IObservable<IVirtualRequest>, SortAndVirtualizeOptions)).

fn sort_and_virtualize_dynamic_with( &self, comparer_changed: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>, virtual_requests: Rc<dyn IObservable<VirtualRequest>>, options: SortAndVirtualizeOptions, ) -> Rc<dyn IObservable<ChangeSetWithContext<T, K, VirtualContext<T>>>>

sort_and_virtualize_dynamic with options (SortAndVirtualize(IObservable<IComparer>, IObservable<IVirtualRequest>, SortAndVirtualizeOptions)).

fn top( &self, comparer: Rc<dyn Fn(&T, &T) -> Ordering>, size: usize, ) -> Rc<dyn IObservable<ChangeSetWithContext<T, K, VirtualContext<T>>>>

The first size items, sorted by comparer (Top(IComparer<TObject>, int size)).

Panics

When size is 0 (ArgumentOutOfRangeException).

fn sort_and_page( &self, comparer: Rc<dyn Fn(&T, &T) -> Ordering>, page_requests: Rc<dyn IObservable<PageRequest>>, ) -> Rc<dyn IObservable<ChangeSetWithContext<T, K, PageContext<T>>>>

The page of the items, sorted by comparer, that the latest request of page_requests asks for; the change sets hold the changes of the page, with the page, the comparer and the options as their context (SortAndPage(IComparer, IObservable<IPageRequest>)).

fn sort_and_page_dynamic( &self, comparer_changed: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>, page_requests: Rc<dyn IObservable<PageRequest>>, ) -> Rc<dyn IObservable<ChangeSetWithContext<T, K, PageContext<T>>>>

sort_and_page sorted by the latest comparer of comparer_changed (SortAndPage(IObservable<IComparer>, IObservable<IPageRequest>)).

fn sort_and_page_with( &self, comparer: Rc<dyn Fn(&T, &T) -> Ordering>, page_requests: Rc<dyn IObservable<PageRequest>>, options: SortAndPageOptions, ) -> Rc<dyn IObservable<ChangeSetWithContext<T, K, PageContext<T>>>>

sort_and_page with options (SortAndPage(IComparer, IObservable<IPageRequest>, SortAndPageOptions)).

fn sort_and_page_dynamic_with( &self, comparer_changed: Rc<dyn IObservable<Rc<dyn Fn(&T, &T) -> Ordering>>>, page_requests: Rc<dyn IObservable<PageRequest>>, options: SortAndPageOptions, ) -> Rc<dyn IObservable<ChangeSetWithContext<T, K, PageContext<T>>>>

sort_and_page_dynamic with options (SortAndPage(IObservable<IComparer>, IObservable<IPageRequest>, SortAndPageOptions)).

fn watch(&self, key: K) -> Rc<dyn IObservable<Change<T, K>>>

The changes of the item of key (Watch(IObservable<IChangeSet>, TKey)).

fn watch_value(&self, key: K) -> Rc<dyn IObservable<T>>

The item of key each time it changes (WatchValue(IObservable<IChangeSet>, TKey)).

fn when_any_property_changed( &self, properties_to_monitor: &[&str], ) -> Rc<dyn IObservable<T>>

where T: NotifyPropertyChangedEx,

The item, whenever one of properties_to_monitor changes on it, or any property when none is given, for every item, merged (WhenAnyPropertyChanged(params string[])).

fn when_property_changed<P: IntoPropertyChain<T>>( &self, property_accessor: P, ) -> Rc<dyn IObservable<PropertyValue<T, P::Value>>>

where P::Value: 'static,

The changes of the property of property_accessor of every item, as the item with the value, the current values first, merged; an item that a null step of the path leaves without a value produces nothing (WhenPropertyChanged(Expression<Func<TObject, TValue>>, bool notifyOnInitialValue = true)).

fn when_property_changed_with<P: IntoPropertyChain<T>>( &self, property_accessor: P, notify_on_initial_value: bool, ) -> Rc<dyn IObservable<PropertyValue<T, P::Value>>>

where P::Value: 'static,

when_property_changed that starts with the current values only when notify_on_initial_value is true (WhenPropertyChanged(Expression<Func<TObject, TValue>>, bool)).

fn when_value_changed<P: IntoPropertyChain<T>>( &self, property_accessor: P, ) -> Rc<dyn IObservable<P::Value>>

where P::Value: 'static,

The values of the property of property_accessor of every item, its current value first, merged; an item that a null step of the path leaves without a value produces nothing (WhenValueChanged(Expression<Func<TObject, TValue>>, bool notifyOnInitialValue = true)).

fn when_value_changed_with<P: IntoPropertyChain<T>>( &self, property_accessor: P, notify_on_initial_value: bool, ) -> Rc<dyn IObservable<P::Value>>

where P::Value: 'static,

when_value_changed that starts with the current values only when notify_on_initial_value is true (WhenValueChanged(Expression<Func<TObject, TValue>>, bool)).

fn where_reasons_are( &self, reasons: &[ChangeReason], ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The changes of the given reasons; the change sets left empty are dropped (WhereReasonsAre(params ChangeReason[])).

Panics

When reasons is empty (ArgumentException: “Must select at least one reason”).

fn where_reasons_are_not( &self, reasons: &[ChangeReason], ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The changes of reasons other than the given ones; the change sets left empty are dropped (WhereReasonsAreNot(params ChangeReason[])).

Panics

When reasons is empty (ArgumentException: “Must select at least one reason”).

fn as_aggregator(&self) -> ChangeSetAggregator<T, K>

Records the change sets, the items and the end of the sequence, for tests (TestEx.AsAggregator).

fn as_observable_cache(&self) -> ObservableCache<T, K>

A cache of the items of the sequence, which applies its change sets (AsObservableCache(IObservable<IChangeSet>, bool applyLocking = true); there is no locking on one thread).

fn collect_update_stats(&self) -> Rc<dyn IObservable<ChangeSummary>>

The statistics of each change set and of all of them so far (CollectUpdateStats).

fn filter( &self, filter: impl Fn(&T) -> bool + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The items that filter accepts; an update or a refresh evaluates the item again (Filter(Func<TObject, bool>, bool suppressEmptyChangeSets = true)).

fn filter_with( &self, filter: impl Fn(&T) -> bool + 'static, suppress_empty_change_sets: bool, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

filter that keeps the empty change sets when suppress_empty_change_sets is false (Filter(Func<TObject, bool>, bool)).

fn filter_dynamic( &self, predicate_changed: Rc<dyn IObservable<Rc<dyn Fn(&T) -> bool>>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The items that the latest predicate of predicate_changed accepts: each new predicate evaluates every item again; until the first, no item is included (Filter(IObservable<Func<TObject, bool>>, bool suppressEmptyChangeSets = true)).

fn filter_dynamic_with( &self, predicate_changed: Rc<dyn IObservable<Rc<dyn Fn(&T) -> bool>>>, suppress_empty_change_sets: bool, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

filter_dynamic that keeps the empty change sets when suppress_empty_change_sets is false (Filter(IObservable<Func<TObject, bool>>, bool)).

fn filter_dynamic_reapply( &self, predicate_changed: Rc<dyn IObservable<Rc<dyn Fn(&T) -> bool>>>, reapply_filter: Rc<dyn IObservable<()>>, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

filter_dynamic that also evaluates every item again with the latest predicate when reapply_filter produces a value (Filter(IObservable<Func<TObject, bool>>, IObservable<Unit>, bool suppressEmptyChangeSets = true)).

fn filter_dynamic_reapply_with( &self, predicate_changed: Rc<dyn IObservable<Rc<dyn Fn(&T) -> bool>>>, reapply_filter: Rc<dyn IObservable<()>>, suppress_empty_change_sets: bool, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

filter_dynamic_reapply that keeps the empty change sets when suppress_empty_change_sets is false (Filter(IObservable<Func<TObject, bool>>, IObservable<Unit>, bool)).

fn filter_with_state<S: 'static>( &self, predicate_state: Rc<dyn IObservable<S>>, predicate: impl Fn(&S, &T) -> bool + 'static, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The items that predicate accepts with the latest value of predicate_state: each new value evaluates every item again; until the first, no item is included (Filter<TObject, TKey, TState>(IObservable<TState>, Func<TState, TObject, bool>, bool suppressEmptyChangeSets = true)).

fn filter_with_state_with<S: 'static>( &self, predicate_state: Rc<dyn IObservable<S>>, predicate: impl Fn(&S, &T) -> bool + 'static, suppress_empty_change_sets: bool, ) -> Rc<dyn IObservable<ChangeSet<T, K>>>

filter_with_state that keeps the empty change sets when suppress_empty_change_sets is false (Filter<TObject, TKey, TState>(IObservable<TState>, Func<TState, TObject, bool>, bool)).

fn not_empty(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>

The change sets that have changes (NotEmpty).

Dyn Compatibility

This trait is not dyn compatible.

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

Implementations on Foreign Types

impl<T: Clone + 'static, K: Eq + Hash + Clone + 'static, C: IChangeSet<T, K>> ObservableCacheEx<T, K> for Rc<dyn IObservable<C>>

fn change_sets(&self) -> Rc<dyn IObservable<ChangeSet<T, K>>>

Implementors