Effect::new_sync_with_runtime(
    move || {
        /* do something with effect */
    },
    |task| runtime.spawn(task),
);

pub fn new_sync_2<T, M>(
    mut fun: impl EffectFunction<T, M> + Send + Sync + 'static,
    rt: &Runtime,
) -> Self
where
    T: Send + Sync + 'static,
{
    let inner = cfg!(feature = "effects").then(|| {
        let (mut rx, owner, inner) = effect_base();
        let mut first_run = true;
        let value = Arc::new(RwLock::new(None::<T>));

        rt.spawn({
            let value = Arc::clone(&value);
            let subscriber = inner.to_any_subscriber();

            async move {
                while rx.next().await.is_some() {
                    if subscriber
                        .with_observer(|| subscriber.update_if_necessary())
                        || first_run
                    {
                        first_run = false;
                        subscriber.clear_sources(&subscriber);

                        let old_value =
                            mem::take(&mut *value.write().or_poisoned());
                        let new_value = owner.with_cleanup(|| {
                            subscriber.with_observer(|| {
                                run_in_effect_scope(|| fun.run(old_value))
                            })
                        });
                        *value.write().or_poisoned() = Some(new_value);
                    }
                }
            }
        });

        ArenaItem::new_with_storage(Some(inner))
    });

    Self { inner }
}