From 0d8c05136a6809977ab04f9f53c4f5015e8eacb0 Mon Sep 17 00:00:00 2001
From: Zacharie Tevaearai <zacharie.tevaearai@epfl.ch>
Date: Sat, 16 Sep 2023 16:02:11 +0200
Subject: [PATCH 01/11] WIP

---
 examples/basic.rs                   |  44 +-
 examples/read_write.rs              |  88 ++--
 src/commands.rs                     |  39 ++
 src/coroutine/coro_param.rs         | 253 ++++++++++
 src/coroutine/duration.rs           |  32 +-
 src/coroutine/function_coroutine.rs | 247 ++++++++++
 src/coroutine/grab.rs               | 466 ------------------
 src/coroutine/mod.rs                | 361 ++++----------
 src/coroutine/observable.rs         |  59 +++
 src/coroutine/on.rs                 |  94 ++--
 src/coroutine/par_and.rs            |  53 +--
 src/coroutine/par_or.rs             |  53 +--
 src/coroutine/waker.rs              |  15 +
 src/coroutine/when.rs               | 143 +-----
 src/executor/mod.rs                 | 395 ++++++---------
 src/executor/run_ctx.rs             |  31 +-
 src/lib.rs                          | 712 ++++++++++++++--------------
 src/plugin.rs                       |  19 +
 18 files changed, 1444 insertions(+), 1660 deletions(-)
 create mode 100644 src/commands.rs
 create mode 100644 src/coroutine/coro_param.rs
 create mode 100644 src/coroutine/function_coroutine.rs
 delete mode 100644 src/coroutine/grab.rs
 create mode 100644 src/coroutine/observable.rs
 create mode 100644 src/coroutine/waker.rs
 create mode 100644 src/plugin.rs

diff --git a/examples/basic.rs b/examples/basic.rs
index eef73d4..f45f587 100644
--- a/examples/basic.rs
+++ b/examples/basic.rs
@@ -1,32 +1,34 @@
 use std::time::Duration;
 
-use bevy::prelude::*;
+use bevy::{prelude::*, sprite::MaterialMesh2dBundle};
 use corentin::prelude::*;
 
 fn main() {
     App::new()
-        .add_plugins(DefaultPlugins)
-        .insert_resource(Executor::new())
-        .add_systems(Startup, setup_coroutines)
-        .add_systems(Update, run_coroutines)
+        .add_plugins((DefaultPlugins, CorentinPlugin))
+        .add_systems(Startup, setup_scene)
         .run();
 }
 
-fn setup_coroutines(mut executor: ResMut<Executor>) {
-    executor.add(|mut fib| async move {
-        let mut i = 0;
-        loop {
-            let dt = fib.next_tick().await;
-            println!("Last frame lasted for {}", dt.as_secs_f32());
-            fib.duration(Duration::from_secs(1)).await;
-            i += 1;
-            println!("This coroutine has started since {} seconds", i);
-        }
-    });
-}
+fn setup_scene(
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+    mut commands: Commands,
+) {
+    commands.spawn(Camera2dBundle::default());
 
-fn run_coroutines(world: &mut World) {
-    world.resource_scope(|w, mut exec: Mut<Executor>| {
-        exec.tick(w);
-    })
+    // Circle
+    commands
+        .spawn(MaterialMesh2dBundle {
+            mesh: meshes.add(shape::Circle::new(50.).into()).into(),
+            material: materials.add(ColorMaterial::from(Color::PURPLE)),
+            transform: Transform::from_translation(Vec3::new(-150., 0., 0.)),
+            ..default()
+        })
+        .add(coroutine(|fib: Fib, mut transform: W<Transform>| async move {
+            loop {
+                let dt = fib.next_tick().await;
+                transform.get_mut().translation.x += 100.0 * dt.as_secs_f32();
+            }
+        }));
 }
diff --git a/examples/read_write.rs b/examples/read_write.rs
index ebd63cd..8822c9d 100644
--- a/examples/read_write.rs
+++ b/examples/read_write.rs
@@ -1,46 +1,42 @@
-use std::time::Duration;
-
-use bevy::prelude::*;
-use corentin::{coroutine::PrimitiveVoid, prelude::*};
-
-#[derive(Component)]
-struct ExampleComponent(u32);
-
-fn main() {
-    App::new()
-        .add_plugins(DefaultPlugins)
-        .insert_resource(Executor::new())
-        .add_systems(Startup, setup_access)
-        .add_systems(Update, run_coroutines)
-        .run();
-}
-
-fn setup_access(world: &mut World) {
-    world.resource_scope(|w, mut exec: Mut<Executor>| {
-        let e = w.spawn(ExampleComponent(0)).id();
-        exec.add_to_entity(e, move |mut fib, this| async move {
-            loop {
-                let mut b = fib
-                    .duration(Duration::from_secs(1))
-                    .then_grab::<&mut ExampleComponent>(this)
-                    .await;
-                b.0 += 1;
-            }
-        });
-        exec.add(|mut fib| async move {
-            loop {
-                let c = fib
-                    .change::<ExampleComponent>(e)
-                    .then_grab::<&ExampleComponent>(e)
-                    .await;
-                println!("Change detected, value is now {}", c.0);
-            }
-        });
-    })
-}
-
-fn run_coroutines(world: &mut World) {
-    world.resource_scope(|w, mut exec: Mut<Executor>| {
-        exec.tick(w);
-    })
-}
+//use std::time::Duration;
+//
+//use bevy::ecs::system::EntityCommand;
+//use bevy::prelude::*;
+//use corentin::{
+//    coroutine::coro_param::{R, W},
+//    prelude::*,
+//};
+//
+//#[derive(Component)]
+//struct IsClicked(u32);
+//
+//fn main() {
+//    App::new()
+//        .add_plugins((DefaultPlugins, CorentinPlugin))
+//        .add_systems(Startup, setup_access)
+//        .run();
+//}
+//
+//fn setup_scene(
+//    mut meshes: ResMut<Assets<Mesh>>,
+//    mut materials: ResMut<Assets<ColorMaterial>>,
+//    mut commands: Commands,
+//) {
+//    commands.spawn(Camera2dBundle::default());
+//    let e = world.spawn((IsClicked(0))).id();
+//    coroutine(|fib: Fib, mut ex: R<IsClicked>| async move {
+//        loop {
+//            ex.on_change().await;
+//
+//        }
+//    })
+//    .apply(e, world);
+//
+//    coroutine(|_: Fib, ex: R<ExampleComponent>| async move {
+//        loop {
+//            ex.on_change().await;
+//            println!("Change detected, value is now {}", ex.get().0);
+//        }
+//    })
+//    .apply(e, world);
+//}
diff --git a/src/commands.rs b/src/commands.rs
new file mode 100644
index 0000000..904a9d8
--- /dev/null
+++ b/src/commands.rs
@@ -0,0 +1,39 @@
+use bevy::ecs::system::EntityCommand;
+use bevy::utils::synccell::SyncCell;
+use std::marker::PhantomData;
+
+use bevy::prelude::{Entity, World};
+
+use crate::coroutine::UninitCoroutine;
+use crate::executor::Executor;
+
+pub struct AddCoroutine<Marker, C> {
+    coro: C,
+    _phantom: PhantomData<Marker>,
+}
+
+impl<Marker: Send + 'static, C: Send + 'static> EntityCommand for AddCoroutine<Marker, C>
+where
+    C: UninitCoroutine<Marker>,
+{
+    fn apply(self, id: Entity, world: &mut World) {
+        world.resource_scope::<Executor, ()>(|w, mut executor| {
+            if let Some(coroutine) = self.coro.init(id, w) {
+                executor.add(SyncCell::new(Box::pin(coroutine)));
+            }
+        });
+    }
+}
+
+pub fn coroutine<M, C>(coro: C) -> AddCoroutine<M, C> {
+    AddCoroutine::new(coro)
+}
+
+impl<M, C> AddCoroutine<M, C> {
+    pub fn new(coro: C) -> Self {
+        Self {
+            coro,
+            _phantom: PhantomData,
+        }
+    }
+}
diff --git a/src/coroutine/coro_param.rs b/src/coroutine/coro_param.rs
new file mode 100644
index 0000000..dad14eb
--- /dev/null
+++ b/src/coroutine/coro_param.rs
@@ -0,0 +1,253 @@
+use std::{
+    cell::Cell,
+    marker::PhantomData,
+    ops::{Deref, DerefMut},
+    rc::Rc,
+};
+
+use crate::executor::msg_channel::Sender;
+
+use super::{
+    observable::{ObservableId, OnChange},
+    CoroMeta, CoroWrites, WaitingReason,
+};
+use bevy::{
+    ecs::{component::ComponentId, world::unsafe_world_cell::UnsafeWorldCell},
+    prelude::{Component, Entity, Mut, World},
+    utils::all_tuples,
+};
+
+/// Any async function that takes only [`CoroParam`] as arguments can
+/// automatically be turned into a [`Coroutine`].
+pub trait CoroParam: Sized + Send + 'static {
+    /// Initialize the parameter and register any access, if it is invalid (for instance
+    /// conflicting accesses) it will return None.
+    ///
+    /// Note: `world_window` is not yet open at that point, `world` should be used instead.
+    fn init(context: ParamContext, world: &mut World, meta: &mut CoroMeta) -> Option<Self>;
+}
+
+/// A shared ref to a [`World`], it is "open" (meaning it points to a valid world) when the
+/// Coroutine is resumed.
+#[derive(Clone)]
+pub struct WorldWindow(pub(crate) Rc<Cell<*mut World>>);
+
+// Safety: The window is only shared whith the coroutine itself
+unsafe impl Send for WorldWindow {}
+
+impl WorldWindow {
+    /// #Safety
+    /// The caller must ensure that the pointer points to a valid value. (the window should be
+    /// "open").
+    pub unsafe fn world_cell(&self) -> UnsafeWorldCell<'_> {
+        (*self.0.get()).as_unsafe_world_cell()
+    }
+
+    /// Return the appropriate ComponentId, and initialize it if not present in the world
+    ///
+    /// #Safety
+    /// The caller must ensure that the pointer points to a valid value. (the window should be
+    /// "open"). And that it is called with exclusive world.
+    pub unsafe fn component_id<T: Component>(&self) -> ComponentId {
+        let cell = self.world_cell();
+        cell.components()
+            .component_id::<T>()
+            .unwrap_or_else(|| cell.world_mut().init_component::<T>())
+    }
+}
+
+/// All relevent values a [`CoroParam`] might need.
+#[derive(Clone)]
+pub struct ParamContext {
+    pub(crate) owner: Entity,
+    pub(crate) world_window: WorldWindow,
+    pub(crate) yield_sender: Sender<WaitingReason>,
+}
+
+/// Safety ? Who knows...
+unsafe impl Send for ParamContext {}
+unsafe impl Sync for ParamContext {}
+
+/// A readonly reference to a [`Component`] from the owning [`Entity`]
+///
+/// Note that a Coroutine with such parameter will be canceled if the entity does not have the
+/// relevent component.
+pub struct R<T: Component> {
+    context: ParamContext,
+    _phantom: PhantomData<T>,
+}
+
+unsafe impl<T: Component> Send for R<T> {}
+
+impl<T: Component> CoroParam for R<T> {
+    fn init(context: ParamContext, world: &mut World, meta: &mut CoroMeta) -> Option<Self> {
+        let id = world
+            .component_id::<T>()
+            .unwrap_or(world.init_component::<T>());
+
+        if meta.this_writes.contains(id.index()) {
+            return None;
+        }
+
+        meta.this_reads.insert(id.index());
+
+        Some(Self {
+            context,
+            _phantom: PhantomData,
+        })
+    }
+}
+
+/// A guarded readonly reference, cannot be hold accros awaiting points.
+pub struct InGuard<'a, T> {
+    value: &'a T,
+    _phantom: PhantomData<*const T>,
+}
+
+impl<'a, T: Component> Deref for InGuard<'a, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.value
+    }
+}
+
+impl<T: Component> R<T> {
+    pub fn get<'a>(&'a self) -> InGuard<'a, T> {
+        unsafe {
+            InGuard {
+                value: self
+                    .context
+                    .world_window
+                    .world_cell()
+                    .get_entity(self.context.owner)
+                    .unwrap()
+                    .get::<T>()
+                    .unwrap(),
+                _phantom: PhantomData,
+            }
+        }
+    }
+
+    pub fn on_change(&self) -> OnChange<'_> {
+        unsafe {
+            OnChange::new(
+                &self.context,
+                ObservableId::Component(
+                    self.context.owner,
+                    self.context.world_window.component_id::<T>(),
+                ),
+            )
+        }
+    }
+}
+
+pub struct W<T: Component> {
+    _phantom: PhantomData<T>,
+    context: ParamContext,
+}
+
+pub struct InOutGuard<'a, T> {
+    value: Mut<'a, T>,
+    _phantom: PhantomData<*const T>,
+}
+
+impl<'a, T: Component> Deref for InOutGuard<'a, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.value.deref()
+    }
+}
+
+impl<'a, T: Component> DerefMut for InOutGuard<'a, T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.value.deref_mut()
+    }
+}
+
+impl<T: Component> W<T> {
+    pub fn get<'a>(&'a self) -> InGuard<'a, T> {
+        let value = unsafe {
+            self.context.world_window
+                .world_cell()
+                .get_entity(self.context.owner)
+                .unwrap()
+                .get::<T>()
+                .unwrap()
+        };
+
+        InGuard {
+            value,
+            _phantom: PhantomData,
+        }
+    }
+
+    pub fn get_mut<'a>(&'a mut self) -> InOutGuard<'a, T> {
+        unsafe {
+            let cell = self.context.world_window.world_cell();
+            let c_id = cell.components().component_id::<T>().unwrap();
+            cell.get_resource_mut::<CoroWrites>()
+                .unwrap()
+                .0
+                .push_back((self.context.owner, c_id));
+
+            let value = cell.get_entity(self.context.owner).unwrap().get_mut::<T>().unwrap();
+            InOutGuard {
+                value,
+                _phantom: PhantomData,
+            }
+        }
+    }
+
+    pub fn on_change(&self) -> OnChange<'_> {
+        unsafe {
+            OnChange::new(
+                &self.context,
+                ObservableId::Component(
+                    self.context.owner,
+                    self.context.world_window.component_id::<T>(),
+                ),
+            )
+        }
+    }
+}
+
+impl<T: Component> CoroParam for W<T> {
+    fn init(context: ParamContext, w: &mut World, meta: &mut CoroMeta) -> Option<Self> {
+        let id = w.component_id::<T>().unwrap_or(w.init_component::<T>());
+
+        if !meta.this_reads.insert(id.index()) {
+            return None;
+        }
+
+        meta.this_writes.insert(id.index());
+
+        Some(Self {
+            _phantom: PhantomData,
+            context,
+        })
+    }
+}
+
+// TODO: Later
+//impl<T: Component> CoroParam for Option<R<T>> {
+//    
+//}
+
+macro_rules! impl_coro_param {
+    ($($param: ident),*) => {
+        #[allow(non_snake_case, unused_parens, unused_variables)]
+        impl<$($param: CoroParam),*> CoroParam for ($($param,)*) {
+            fn init(context: ParamContext, world: &mut World, meta: &mut CoroMeta) -> Option<Self> {
+                $(let $param = $param::init(context.clone(), world, meta)?;)*
+
+                Some(($($param,)*))
+
+            }
+        }
+
+    };
+}
+
+all_tuples!(impl_coro_param, 0, 16, P);
diff --git a/src/coroutine/duration.rs b/src/coroutine/duration.rs
index 1895a60..fbb2ce7 100644
--- a/src/coroutine/duration.rs
+++ b/src/coroutine/duration.rs
@@ -1,23 +1,21 @@
-use crate::coroutine::{CoroState, Fib, WaitingReason};
+use crate::coroutine::WaitingReason;
 
 use bevy::time::Time;
 use bevy::time::Timer;
 use bevy::time::TimerMode;
 use std::future::Future;
-use std::marker::PhantomData;
 use std::pin::Pin;
 use std::task::Context;
 use std::task::Poll;
 use std::time::Duration;
 
-use super::Primitive;
-use super::PrimitiveVoid;
+use super::CoroState;
+use crate::coroutine::function_coroutine::Fib;
 
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct NextTick<'a> {
     fib: &'a Fib,
     state: CoroState,
-    _phantom: PhantomData<&'a ()>,
 }
 
 impl<'a> NextTick<'a> {
@@ -25,7 +23,6 @@ impl<'a> NextTick<'a> {
         NextTick {
             fib,
             state: CoroState::Running,
-            _phantom: PhantomData,
         }
     }
 }
@@ -41,33 +38,27 @@ impl<'a> Future for NextTick<'a> {
 
                 // SAFETY: None lmao
                 let dt = unsafe {
-                    (*self.fib.world_window.get().unwrap())
-                        .resource::<Time>()
+                    (self.fib.world_window.world_cell())
+                        .get_resource::<Time>()
+                        .unwrap()
                         .delta()
                 };
                 Poll::Ready(dt)
             }
             CoroState::Running => {
                 self.state = CoroState::Halted;
-                self.fib.yield_sender.send(WaitingReason::Tick);
+                self.fib.yield_channel.send(WaitingReason::Tick);
                 Poll::Pending
             }
         }
     }
 }
 
-impl<'cx> Primitive<'cx, Duration> for NextTick<'cx> {
-    fn get_context(&self) -> &Fib {
-        self.fib
-    }
-}
-
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct DurationFuture<'a> {
     fib: &'a Fib,
     duration: Duration,
     state: CoroState,
-    _phantom: PhantomData<&'a ()>,
 }
 
 impl<'a> DurationFuture<'a> {
@@ -76,7 +67,6 @@ impl<'a> DurationFuture<'a> {
             fib,
             duration,
             state: CoroState::Running,
-            _phantom: PhantomData,
         }
     }
 }
@@ -94,7 +84,7 @@ impl<'a> Future for DurationFuture<'a> {
             CoroState::Running => {
                 self.state = CoroState::Halted;
                 self.fib
-                    .yield_sender
+                    .yield_channel
                     .send(WaitingReason::Duration(Timer::new(
                         self.duration,
                         TimerMode::Once,
@@ -104,9 +94,3 @@ impl<'a> Future for DurationFuture<'a> {
         }
     }
 }
-
-impl<'cx> PrimitiveVoid<'cx> for DurationFuture<'cx> {
-    fn get_context(&self) -> &Fib {
-        self.fib
-    }
-}
diff --git a/src/coroutine/function_coroutine.rs b/src/coroutine/function_coroutine.rs
new file mode 100644
index 0000000..a27c60e
--- /dev/null
+++ b/src/coroutine/function_coroutine.rs
@@ -0,0 +1,247 @@
+use std::marker::PhantomData;
+use std::time::Duration;
+use std::{cell::Cell, rc::Rc};
+
+use bevy::prelude::{Entity, Component};
+use bevy::prelude::World;
+use bevy::utils::all_tuples;
+use bevy::utils::synccell::SyncCell;
+use pin_project::pin_project;
+use std::future::Future;
+use std::pin::Pin;
+use std::task::Context;
+use std::task::Poll;
+
+use crate::coroutine::CoroMeta;
+use crate::executor::msg_channel::Receiver;
+use crate::executor::msg_channel::Sender;
+
+use super::coro_param::CoroParam;
+use super::coro_param::ParamContext;
+use super::coro_param::WorldWindow;
+use super::duration::DurationFuture;
+use super::duration::NextTick;
+use super::par_and::ParAnd;
+use super::par_or::ParOr;
+use super::UninitCoroutine;
+use super::{waker, Coroutine, CoroutineResult, WaitingReason};
+
+#[pin_project]
+pub struct FunctionCoroutine<Marker, F>
+where
+    F: CoroutineParamFunction<Marker>,
+{
+    #[pin]
+    future: F::Future,
+    yield_channel: Receiver<WaitingReason>,
+    world_window: Rc<Cell<*mut World>>,
+    meta: CoroMeta,
+}
+
+unsafe impl<Marker, F> Send for FunctionCoroutine<Marker, F> where F: CoroutineParamFunction<Marker> {}
+
+const ERR_WRONGAWAIT: &str = "A coroutine yielded without notifying the executor
+the reason. That is most likely because it awaits a
+future which is not part of this library.";
+
+impl<Marker: 'static, F> Coroutine for FunctionCoroutine<Marker, F>
+where
+    F: CoroutineParamFunction<Marker>,
+{
+    fn resume(self: Pin<&mut Self>, world: &mut World) -> CoroutineResult<WaitingReason, ()> {
+        let waker = waker::create();
+        // Dummy context
+        let mut cx = Context::from_waker(&waker);
+
+        let this = self.project();
+        this.world_window.replace(world as *mut _);
+        let res = this.future.poll(&mut cx);
+        this.world_window.replace(std::ptr::null_mut());
+        match res {
+            Poll::Ready(_) => CoroutineResult::Done(()),
+            Poll::Pending => {
+                CoroutineResult::Yield(this.yield_channel.receive().expect(ERR_WRONGAWAIT))
+            }
+        }
+    }
+
+    fn meta(&self) -> &CoroMeta {
+        &self.meta
+    }
+}
+
+pub trait CoroutineParamFunction<Marker>: Send + 'static {
+    type Future: Future<Output = ()> + Send + 'static;
+    type Params: CoroParam;
+
+    fn init(self, fib: Fib, params: Self::Params) -> Self::Future;
+}
+
+impl<Marker: 'static, F> UninitCoroutine<Marker> for F
+where
+    F: CoroutineParamFunction<Marker>,
+{
+    type Coroutine = FunctionCoroutine<Marker, F>;
+
+    fn init(self, owner: Entity, world: &mut World) -> Option<Self::Coroutine> {
+        let yield_channel = Receiver::default();
+        let world_window = Rc::new(Cell::new(std::ptr::null_mut()));
+
+        let context = ParamContext {
+            owner,
+            world_window: WorldWindow(Rc::clone(&world_window)),
+            yield_sender: yield_channel.sender(),
+        };
+
+        let mut meta = CoroMeta::new(owner);
+
+        let params = F::Params::init(context, world, &mut meta)?;
+        let fib = Fib {
+            world_window: WorldWindow(Rc::clone(&world_window)),
+            yield_channel: yield_channel.sender(),
+            meta: meta.clone(),
+        };
+
+        Some(FunctionCoroutine {
+            future: self.init(fib, params),
+            yield_channel,
+            world_window,
+            meta,
+        })
+    }
+}
+
+/// The `Fib` is the first param of a coroutine, all yielding is done througth it.
+pub struct Fib {
+    pub(crate) world_window: WorldWindow,
+    pub(crate) yield_channel: Sender<WaitingReason>,
+    pub(crate) meta: CoroMeta,
+}
+
+// Safety: No idea....
+unsafe impl Send for Fib {}
+unsafe impl Sync for Fib {}
+
+impl Fib {
+    /// Returns coroutine that resolve the next time the [`Executor`] is ticked (via
+    /// [`run`][crate::executor::Executor::run] for instance). It returns the duration
+    /// of the last frame (delta time).
+    ///
+    /// [`Executor`]: crate::executor::Executor
+    pub fn next_tick(&self) -> NextTick<'_> {
+        NextTick::new(self)
+    }
+
+    ///// Returns a coroutine that resolve after a certain [`Duration`]. Note that if the duration
+    ///// is smaller than the time between two tick of the [`Executor`] it won't be compensated.
+    /////
+    ///// [`Executor`]: crate::executor::Executor
+    pub fn duration(&self, duration: Duration) -> DurationFuture<'_> {
+        DurationFuture::new(self, duration)
+    }
+
+    ///// Returns a coroutine that resolve once any of the underlying coroutine finishes. Note that
+    ///// once this is done, all the others are dropped. The coroutines are resumed from top to
+    ///// bottom, in case multiple of them are ready to make progress at the same time.
+    pub fn par_or<C, Marker: 'static>(&self, coro: C) -> ParOr<'_>
+    where
+        C: UninitCoroutine<Marker>,
+        C::Coroutine: 'static,
+    {
+        // Safety: We are getting polled right now, therefore we have exclusive world access.
+        unsafe {
+            if let Some(c) = coro.init(self.meta.owner, self.world_window.world_cell().world_mut()) {
+                return ParOr::new(self, vec![SyncCell::new(Box::pin(c))]);
+            }
+        }
+        ParOr::new(self, vec![])
+    }
+
+    ///// Returns a coroutine that resolve once all of the underlying coroutine finishes.
+    pub fn par_and<C, Marker>(&mut self, coro: C) -> ParAnd<'_>
+    where
+        C: UninitCoroutine<Marker>,
+    {
+        // Safety: We are getting polled right now, therefore we have exclusive world access.
+        unsafe {
+            if let Some(c) = coro.init(self.meta.owner, self.world_window.world_cell().world_mut()) {
+                return ParAnd::new(self, vec![SyncCell::new(Box::pin(c))]);
+            }
+        }
+        ParAnd::new(self, vec![])
+    }
+
+    ///// Returns a coroutine that resolve once the underlying coroutine finishes,
+    ///// in order to reuse coroutines, because the following won't compile:
+    ///// ```compile_fail
+    /////# use corentin::prelude::*;
+    /////async fn sub_coro(mut fib: Fib) { }
+    /////async fn main_coro(mut fib: Fib) {
+    /////  sub_coro(fib).await;
+    /////  sub_coro(fib).await;
+    /////}
+    /////```
+    ///// But the following will:
+    /////```
+    /////# use corentin::prelude::*;
+    /////async fn sub_coro(mut fib: Fib) { }
+    /////async fn main_coro(mut fib: Fib) {
+    /////  fib.on(sub_coro).await;
+    /////  fib.on(sub_coro).await;
+    /////}
+    /////```
+    //pub fn on<C, Marker>(&mut self, coro: C) -> On<C::Coroutine>
+    //where
+    //    C: UninitCoroutine<Marker>,
+    //{
+    //    unsafe {
+    //        if let Some(c) = coro.init(self.owner, self.world_window.world_cell().world_mut()) {
+    //            return On::new(self, c);
+    //        }
+    //    }
+    //    panic!()
+    //}
+}
+
+macro_rules! impl_coro_function {
+    ($($param: ident),*) => {
+        #[allow(non_snake_case, unused_mut, unused_variables, unused_parens)]
+        impl<Func, Fut, $($param: CoroParam),*> CoroutineParamFunction<fn(Fib, $($param,)*) -> Fut> for Func
+        where
+            Func: FnOnce(Fib, $($param),*) -> Fut + Send + 'static,
+            Fut: Future<Output = ()> + Send + 'static,
+        {
+
+            type Future = Fut;
+            type Params = ($($param),*);
+
+            fn init(self, fib: Fib, params: Self::Params) -> Self::Future {
+                let ($(($param)),*) = params;
+                self(fib, $($param),*)
+            }
+        }
+    };
+}
+
+macro_rules! impl_coro_no_fib_function {
+    ($($param: ident),*) => {
+        #[allow(non_snake_case, unused_mut, unused_variables, unused_parens)]
+        impl<Func, Fut, $($param: CoroParam),*> CoroutineParamFunction<fn($($param,)*) -> Fut> for Func
+        where
+            Func: FnOnce($($param),*) -> Fut + Send + 'static,
+            Fut: Future<Output = ()> + Send + 'static,
+        {
+
+            type Future = Fut;
+            type Params = ($($param),*);
+
+            fn init(self, _fib: Fib, params: Self::Params) -> Self::Future {
+                let ($(($param)),*) = params;
+                self($($param),*)
+            }
+        }
+    };
+}
+
+all_tuples!(impl_coro_function, 0, 16, P);
+all_tuples!(impl_coro_no_fib_function, 0, 16, P);
diff --git a/src/coroutine/grab.rs b/src/coroutine/grab.rs
deleted file mode 100644
index 7dbd52e..0000000
--- a/src/coroutine/grab.rs
+++ /dev/null
@@ -1,466 +0,0 @@
-use std::{
-    future::Future,
-    marker::PhantomData,
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use bevy::{
-    ecs::{component::ComponentId, world::unsafe_world_cell::UnsafeEntityCell},
-    prelude::{Component, Entity, Mut, Ref, World},
-    utils::all_tuples,
-};
-use pin_project::pin_project;
-use tinyset::SetUsize;
-
-use super::Fib;
-
-/// Describe what world access will be perform by a coroutine once resumed
-/// TODO: Benchmark and probably use something like tiny set or whatnot
-pub(crate) enum GrabReason {
-    Single(GrabAccess),
-    Multi(Vec<GrabAccess>),
-}
-
-impl GrabReason {
-    pub fn writes(&self) -> Vec<(Entity, ComponentId)> {
-        match self {
-            GrabReason::Single(s) => s
-                .writes
-                .iter()
-                .map(|c| (s.from, ComponentId::new(c)))
-                .collect(),
-            GrabReason::Multi(m) => m
-                .iter()
-                .flat_map(|s| s.writes.iter().map(|c| (s.from, ComponentId::new(c))))
-                .collect(),
-        }
-    }
-
-    pub(crate) fn is_valid(&self, world: &World) -> bool {
-        match self {
-            GrabReason::Single(a) => a.is_valid(world),
-            GrabReason::Multi(accesses) => accesses.iter().all(|a| a.is_valid(world)),
-        }
-    }
-}
-
-/// A world access from a single [`Entity`].
-pub struct GrabAccess {
-    pub(crate) from: Entity,
-    pub(crate) writes: SetUsize,
-    pub(crate) reads: SetUsize,
-    pub(crate) optional: SetUsize,
-}
-
-impl GrabAccess {
-    fn is_valid(&self, world: &World) -> bool {
-        if let Some(e) = world.get_entity(self.from) {
-            for c in self.writes.iter() {
-                if !e.contains_id(ComponentId::new(c)) && !self.optional.contains(c) {
-                    return false;
-                }
-            }
-            for c in self.reads.iter() {
-                if !e.contains_id(ComponentId::new(c)) && !self.optional.contains(c) {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        false
-    }
-}
-
-pub trait GrabParam {
-    type Fetch<'w>;
-
-    fn get_access(world: &World, from: Entity) -> GrabAccess;
-
-    fn update_access(world: &World, access: &mut GrabAccess);
-
-    /// Fetch the required data from the world.
-    /// # Safety
-    /// While the access itself check that no internal conficlts exist, the caller must ensure that
-    /// nothing will do an incompatible access at the same time (according to the regular Rust
-    /// rules).
-    unsafe fn fetch(entity: UnsafeEntityCell<'_>) -> Self::Fetch<'_>;
-}
-
-impl<T: Component> GrabParam for &T {
-    type Fetch<'w> = Ref<'w, T>;
-
-    fn get_access(world: &World, from: Entity) -> GrabAccess {
-        let mut reads = SetUsize::new();
-        reads.insert(
-            world
-                .component_id::<T>()
-                .expect("Component should have been initialized")
-                .index(),
-        );
-        GrabAccess {
-            from,
-            writes: SetUsize::new(),
-            reads,
-            optional: SetUsize::new(),
-        }
-    }
-
-    fn update_access(world: &World, access: &mut GrabAccess) {
-        let c_id = world
-            .component_id::<T>()
-            .expect("Component should have been initialized");
-        if access.writes.contains(c_id.index()) {
-            panic!("Conflicting access detected");
-        }
-        access.reads.insert(c_id.index());
-    }
-
-    unsafe fn fetch(entity: UnsafeEntityCell<'_>) -> Self::Fetch<'_> {
-        entity.get_ref::<T>().unwrap()
-    }
-}
-
-impl<T: Component> GrabParam for &mut T {
-    type Fetch<'w> = Mut<'w, T>;
-
-    fn get_access(world: &World, from: Entity) -> GrabAccess {
-        let mut writes = SetUsize::new();
-        writes.insert(
-            world
-                .component_id::<T>()
-                .expect("Component should have been initialized")
-                .index(),
-        );
-        GrabAccess {
-            from,
-            writes,
-            reads: SetUsize::new(),
-            optional: SetUsize::new(),
-        }
-    }
-
-    fn update_access(world: &World, access: &mut GrabAccess) {
-        let c_id = world
-            .component_id::<T>()
-            .expect("Component should have been initialized");
-        if access.reads.contains(c_id.index()) {
-            panic!("Conflicting access detected");
-        }
-        access.writes.insert(c_id.index());
-    }
-
-    unsafe fn fetch(entity: UnsafeEntityCell<'_>) -> Self::Fetch<'_> {
-        entity.get_mut::<T>().unwrap()
-    }
-}
-
-impl<T: Component> GrabParam for Option<&T> {
-    type Fetch<'w> = Option<&'w T>;
-
-    fn get_access(world: &World, from: Entity) -> GrabAccess {
-        let mut res = <&T as GrabParam>::get_access(world, from);
-        res.optional.insert(
-            world
-                .component_id::<T>()
-                .expect("Component should have been initialized")
-                .index(),
-        );
-        res
-    }
-
-    fn update_access(world: &World, access: &mut GrabAccess) {
-        <&T as GrabParam>::update_access(world, access);
-        access.optional.insert(
-            world
-                .component_id::<T>()
-                .expect("Component should have been initialized")
-                .index(),
-        );
-    }
-
-    unsafe fn fetch(entity: UnsafeEntityCell<'_>) -> Self::Fetch<'_> {
-        entity.get::<T>()
-    }
-}
-
-impl<T: Component> GrabParam for Option<&mut T> {
-    type Fetch<'w> = Option<Mut<'w, T>>;
-
-    fn get_access(world: &World, from: Entity) -> GrabAccess {
-        let mut res = <&mut T as GrabParam>::get_access(world, from);
-        res.optional.insert(
-            world
-                .component_id::<T>()
-                .expect("Component should have been initialized")
-                .index(),
-        );
-        res
-    }
-
-    fn update_access(world: &World, access: &mut GrabAccess) {
-        <&mut T as GrabParam>::update_access(world, access);
-        access.optional.insert(
-            world
-                .component_id::<T>()
-                .expect("Component should have been initialized")
-                .index(),
-        );
-    }
-
-    unsafe fn fetch(entity: UnsafeEntityCell<'_>) -> Self::Fetch<'_> {
-        entity.get_mut::<T>()
-    }
-}
-
-macro_rules! impl_tuple_grab {
-    ($param1: ident, $($param2: ident),*) => {
-        impl<$param1: GrabParam, $($param2: GrabParam),+> GrabParam for ($param1, $($param2),*)
-        {
-            type Fetch<'w> = ($param1::Fetch<'w>, $($param2::Fetch<'w>),*);
-
-            fn get_access(world: &World, from: Entity) -> GrabAccess {
-                let mut access = $param1::get_access(world, from);
-                $($param2::update_access(world, &mut access));*;
-                access
-            }
-
-            fn update_access(world: &World, access: &mut GrabAccess) {
-                $param1::update_access(world, access);
-                $($param2::update_access(world, access));*;
-            }
-
-            unsafe fn fetch(entity: UnsafeEntityCell<'_>) -> Self::Fetch<'_> {
-                ($param1::fetch(entity), $($param2::fetch(entity)),*)
-            }
-
-        }
-    };
-}
-
-all_tuples!(impl_tuple_grab, 2, 15, G);
-
-#[pin_project]
-pub struct GrabCoroutineVoid<'a, P, F>
-where
-    P: GrabParam,
-    F: Future<Output = ()> + Send + Sync,
-{
-    from: Entity,
-    fib: Fib,
-    #[pin]
-    inner: F,
-    _phantom: PhantomData<P>,
-    _phantom2: PhantomData<&'a ()>,
-}
-
-impl<'a, P, F> GrabCoroutineVoid<'a, P, F>
-where
-    P: GrabParam,
-    F: Future<Output = ()> + Send + Sync,
-{
-    pub fn new(fib: Fib, from: Entity, inner: F) -> Self {
-        GrabCoroutineVoid {
-            from,
-            fib,
-            _phantom: PhantomData,
-            inner,
-            _phantom2: PhantomData,
-        }
-    }
-
-    pub fn and<P2: GrabParam>(self, from: Entity) -> GrabCoroutineVoid2<'a, P, P2, F> {
-        GrabCoroutineVoid2::new(self.fib, self.from, from, self.inner)
-    }
-}
-
-/// A wrapper around another coroutine that returns the requested
-/// data, once the underlying coroutine has finished.
-impl<'a, P, F> Future for GrabCoroutineVoid<'a, P, F>
-where
-    P: GrabParam,
-    F: Future<Output = ()> + Send + Sync,
-{
-    type Output = P::Fetch<'a>;
-
-    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.project();
-
-        match this.inner.poll(_cx) {
-            Poll::Pending => {
-                unsafe {
-                    let world = this.fib.world_window().world();
-                    let access = P::get_access(world, *this.from);
-                    this.fib.grab_sender.send(GrabReason::Single(access));
-                }
-                Poll::Pending
-            }
-            Poll::Ready(_) => {
-                let entity = this.from;
-
-                // Safety: The executor takes care of not executing two conflicting coroutines
-                // at the same time.
-                unsafe {
-                    let world =
-                        &mut *this.fib.world_window.get().expect(
-                            "This function should have been called when a coroutine is polled",
-                        );
-                    let world = world.as_unsafe_world_cell();
-                    let result = P::fetch(world.get_entity(*entity).unwrap());
-                    Poll::Ready(result)
-                }
-            }
-        }
-    }
-}
-
-// TODO: Generalize with a macro instead
-#[pin_project]
-pub struct GrabCoroutineVoid2<'a, P1, P2, F>
-where
-    P1: GrabParam,
-    P2: GrabParam,
-    F: Future<Output = ()> + Send + Sync,
-{
-    from1: Entity,
-    from2: Entity,
-    fib: Fib,
-    #[pin]
-    inner: F,
-    _phantom1: PhantomData<P1>,
-    _phantom2: PhantomData<P2>,
-    _phantoma: PhantomData<&'a ()>,
-}
-
-impl<'a, P1, P2, F> GrabCoroutineVoid2<'a, P1, P2, F>
-where
-    P1: GrabParam,
-    P2: GrabParam,
-    F: Future<Output = ()> + Send + Sync,
-{
-    pub fn new(fib: Fib, from1: Entity, from2: Entity, inner: F) -> Self {
-        assert_ne!(from1, from2, "Conficting grab access detected");
-        GrabCoroutineVoid2 {
-            from1,
-            from2,
-            fib,
-            inner,
-            _phantom1: PhantomData,
-            _phantom2: PhantomData,
-            _phantoma: PhantomData,
-        }
-    }
-}
-
-/// A wrapper around another coroutine that returns the requested
-/// data, once the underlying coroutine has finished.
-impl<'a, P1, P2, F> Future for GrabCoroutineVoid2<'a, P1, P2, F>
-where
-    P1: GrabParam,
-    P2: GrabParam,
-    F: Future<Output = ()> + Send + Sync,
-{
-    type Output = (P1::Fetch<'a>, P2::Fetch<'a>);
-
-    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.project();
-
-        match this.inner.poll(_cx) {
-            Poll::Pending => {
-                unsafe {
-                    let world = this.fib.world_window().world();
-                    let access1 = P1::get_access(world, *this.from1);
-                    let access2 = P2::get_access(world, *this.from2);
-                    this.fib
-                        .grab_sender
-                        .send(GrabReason::Multi(vec![access1, access2]));
-                }
-                Poll::Pending
-            }
-            Poll::Ready(_) => {
-                let entity1 = this.from1;
-                let entity2 = this.from2;
-                unsafe {
-                    let world =
-                        &mut *this.fib.world_window.get().expect(
-                            "This function should have been called when a coroutine is polled",
-                        );
-                    let world = world.as_unsafe_world_cell();
-                    let result1 = P1::fetch(world.get_entity(*entity1).unwrap());
-                    let result2 = P2::fetch(world.get_entity(*entity2).unwrap());
-                    Poll::Ready((result1, result2))
-                }
-            }
-        }
-    }
-}
-
-/// Same as [`GrabCoroutineVoid`], but where the underlying coroutine
-/// can return a value.
-#[pin_project]
-pub struct GrabCoroutine<'a, P, F, O>
-where
-    P: GrabParam,
-    F: Future<Output = O> + Send + Sync,
-{
-    from: Entity,
-    fib: Fib,
-    #[pin]
-    inner: F,
-    _phantom: PhantomData<P>,
-    _phantom2: PhantomData<&'a ()>,
-}
-
-//
-impl<'a, P, F, O> GrabCoroutine<'a, P, F, O>
-where
-    P: GrabParam,
-    F: Future<Output = O> + Send + Sync,
-{
-    pub fn new(fib: Fib, from: Entity, inner: F) -> Self {
-        GrabCoroutine {
-            from,
-            fib,
-            _phantom: PhantomData,
-            inner,
-            _phantom2: PhantomData,
-        }
-    }
-}
-
-impl<'a, P, F, O> Future for GrabCoroutine<'a, P, F, O>
-where
-    P: GrabParam,
-    F: Future<Output = O> + Send + Sync,
-{
-    type Output = (O, P::Fetch<'a>);
-
-    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.project();
-
-        match this.inner.poll(_cx) {
-            Poll::Pending => {
-                unsafe {
-                    let world = this.fib.world_window().world();
-                    let access = P::get_access(world, *this.from);
-                    this.fib.grab_sender.send(GrabReason::Single(access));
-                }
-                Poll::Pending
-            }
-            Poll::Ready(r) => {
-                let entity = this.from;
-                unsafe {
-                    let world =
-                        &mut *this.fib.world_window.get().expect(
-                            "This function should have been called when a coroutine is polled",
-                        );
-                    let world = world.as_unsafe_world_cell();
-                    let result = P::fetch(world.get_entity(*entity).unwrap());
-                    Poll::Ready((r, result))
-                }
-            }
-        }
-    }
-}
diff --git a/src/coroutine/mod.rs b/src/coroutine/mod.rs
index bdd13db..0d58cb0 100644
--- a/src/coroutine/mod.rs
+++ b/src/coroutine/mod.rs
@@ -1,304 +1,131 @@
-use std::cell::Cell;
-use std::future::Future;
-use std::rc::Rc;
-use std::time::Duration;
+use std::collections::VecDeque;
+use std::pin::Pin;
 
 use bevy::ecs::component::ComponentId;
-use bevy::ecs::world::unsafe_world_cell::UnsafeWorldCell;
-use bevy::prelude::Component;
 use bevy::prelude::Entity;
+use bevy::prelude::Resource;
 use bevy::prelude::Timer;
 use bevy::prelude::World;
+use bevy::utils::synccell::SyncCell;
+use tinyset::SetUsize;
 
-use crate::executor::msg_channel::Sender;
-use crate::executor::CoroObject;
+use self::observable::ObservableId;
 
-use duration::{DurationFuture, NextTick};
-use on::On;
-use par_and::ParAnd;
-use par_or::ParOr;
-use when::Change;
-
-use self::grab::GrabCoroutine;
-use self::grab::GrabCoroutineVoid;
-use self::grab::GrabParam;
-use self::grab::GrabReason;
 
 pub mod duration;
-pub mod grab;
-mod on;
-mod par_and;
-mod par_or;
+pub mod coro_param;
+pub mod function_coroutine;
+pub mod observable;
+pub mod on;
+pub mod par_and;
+pub mod par_or;
 mod when;
+mod waker;
 
-#[derive(PartialEq, Eq, Clone, Copy)]
-pub(crate) enum CoroState {
-    Halted,
-    Running,
-}
+/// A coroutine that can be added to an [`Entity`](bevy::prelude::Entity)
+///
+pub trait Coroutine: Send + 'static {
+    /// Resume execution of this coroutine.
+    ///
+    /// It will returns [`CoroutineResult::Yield`] if it can be resumed once again
+    /// or [`CoroutineResult::Done`] if it is done executing. Note that resuming a coroutine which
+    /// has terminate execution will panic.
+    fn resume(self: Pin<&mut Self>, world: &mut World) -> CoroutineResult<WaitingReason, ()>;
 
-pub(crate) enum WaitingReason {
-    Tick,
-    Duration(Timer),
-    Changed {
-        from: Entity,
-        component: ComponentId,
-    },
-    ParOr {
-        coroutines: Vec<CoroObject>,
-    },
-    ParAnd {
-        coroutines: Vec<CoroObject>,
-    },
+    /// Return the metadata of this coroutine, including - ComponentAccess
+    fn meta(&self) -> &CoroMeta;
 }
 
-/// A "Fiber" object, througth which a coroutine
-/// can interact with the rest of the world.
-pub struct Fib {
-    // Maybe replace by a real sender receiver channel at some point
-    pub(crate) yield_sender: Sender<WaitingReason>,
-    pub(crate) owner: Option<Entity>,
-    pub(crate) world_window: Rc<Cell<Option<*mut World>>>,
-    pub(crate) grab_sender: Sender<GrabReason>,
-}
+/// A shared list of modified values (observable), to easily notify the apropriate observers.
+#[derive(Resource, Default)]
+pub(crate) struct CoroWrites(pub VecDeque<(Entity, ComponentId)>);
 
-impl Fib {
-    /// Done like so, to avoid user code to be able to clone the Fiber (can lead to UB)
-    pub(crate) fn clone(&self) -> Self {
-        Self {
-            yield_sender: self.yield_sender.clone(),
-            owner: self.owner,
-            world_window: self.world_window.clone(),
-            grab_sender: self.grab_sender.clone(),
-        }
-    }
-}
+/// A heap allocated Coroutine
+pub(crate) type CoroObject = SyncCell<Pin<Box<dyn Coroutine>>>;
 
-impl Fib {
-    fn component_id<T: Component>(&self) -> ComponentId {
-        // SAFETY: We are in the polling phase, therefore the coroutine is the only one running.
-        unsafe {
-            let w = &mut *self
-                .world_window
-                .get()
-                .expect("This function should have been called when a coroutine is polled");
-            w.component_id::<T>()
-                .expect("Component should have been initialized in the world")
-        }
-    }
 
-    pub(crate) unsafe fn world_window(&self) -> UnsafeWorldCell<'_> {
-        let a = &mut *self
-            .world_window
-            .get()
-            .expect("This function should have been called when a coroutine is polled");
-        a.as_unsafe_world_cell()
-    }
+/// Metadata of a coroutine
+///
+/// This includes
+/// - Which components are read and written to
+#[derive(Clone)]
+pub struct CoroMeta {
+    pub(crate) this_reads: SetUsize,
+    pub(crate) this_writes: SetUsize,
+    pub(crate) owner: Entity,
 }
 
-// SAFETY: Same as Executor, the sender field is only accessed when polled,
-// which is done in a single threaded context.
-unsafe impl Send for Fib {}
-unsafe impl Sync for Fib {}
-
-impl Fib {
-    /// Returns coroutine that resolve the next time the [`Executor`] is ticked (via
-    /// [`run`][crate::executor::Executor::run] for instance). It returns the duration
-    /// of the last frame (delta time).
-    ///
-    /// [`Executor`]: crate::executor::Executor
-    pub fn next_tick(&mut self) -> NextTick<'_> {
-        NextTick::new(self)
+impl CoroMeta {
+    pub fn new(owner: Entity) -> Self {
+        Self {  owner, this_reads: SetUsize::default(), this_writes: SetUsize::default() }
     }
 
-    /// Returns a coroutine that resolve after a certain [`Duration`]. Note that if the duration
-    /// is smaller than the time between two tick of the [`Executor`] it won't be compensated.
-    ///
-    /// [`Executor`]: crate::executor::Executor
-    pub fn duration(&mut self, duration: Duration) -> DurationFuture<'_> {
-        DurationFuture::new(self, duration)
-    }
+    /// Check if the values captured by the coroutine still exists.
+    pub(crate) fn is_valid(&self, world: &World) -> bool {
+        if !world.entities().contains(self.owner) {
+            return false;
+        }
 
-    /// Returns a coroutine that resolve once the [`Component`] of type `T` from a particular
-    /// [`Entity`] has changed. Note that if the entity or the components is removed,
-    /// this coroutine is dropped.
-    pub fn change<T: Component + Unpin>(&mut self, from: Entity) -> Change<'_, T> {
-        Change::new(self, from)
-    }
+        let e = world.entity(self.owner);
+        for r in self.this_reads.iter() {
+            if !e.contains_id(ComponentId::new(r)) {
+                return false;
+            }
+        }
+        for w in self.this_writes.iter() {
+            if !e.contains_id(ComponentId::new(w)) {
+                return false;
+            }
+        }
 
-    /// Returns a coroutine that resolve once any of the underlying coroutine finishes. Note that
-    /// once this is done, all the others are dropped. The coroutines are resumed from top to
-    /// bottom, in case multiple of them are ready to make progress at the same time.
-    pub fn par_or<C, F>(&mut self, closure: C) -> ParOr<'_>
-    where
-        F: Coroutine<'static>,
-        C: FnOnce(Fib) -> F,
-    {
-        let fib = self.clone();
-        let fut = Box::pin(closure(fib));
-        ParOr::new(self, vec![fut])
+        true
     }
+}
 
-    /// Returns a coroutine that resolve once the underlying coroutine finishes,
-    /// in order to reuse coroutines, because the following won't compile:
-    /// ```compile_fail
-    ///# use corentin::prelude::*;
-    ///async fn sub_coro(mut fib: Fib) { }
-    ///async fn main_coro(mut fib: Fib) {
-    ///  sub_coro(fib).await;
-    ///  sub_coro(fib).await;
-    ///}
-    ///```
-    /// But the following will:
-    ///```
-    ///# use corentin::prelude::*;
-    ///async fn sub_coro(mut fib: Fib) { }
-    ///async fn main_coro(mut fib: Fib) {
-    ///  fib.on(sub_coro).await;
-    ///  fib.on(sub_coro).await;
-    ///}
-    ///```
-    pub fn on<C, F>(&mut self, closure: C) -> On<F>
-    where
-        F: Coroutine<'static>,
-        C: FnOnce(Fib) -> F,
-    {
-        let fib = self.clone();
-        let fut = closure(fib);
-        On::new(self, fut)
-    }
 
-    /// Same as [`Self::on()`] but with a coroutine that expect
-    /// an owner entity as a parameter.
-    pub fn on_self<C, F>(&mut self, closure: C) -> On<F>
-    where
-        F: Coroutine<'static>,
-        C: FnOnce(Fib, Entity) -> F,
-    {
-        let fib = self.clone();
-        let fut = closure(
-            fib,
-            self.owner
-                .expect("Cannot call on_self if the coroutine is not owned by any entity."),
-        );
-        On::new(self, fut)
-    }
+/// The result after resuming a `Coroutine`. Either it yields an intermediate value, or return the
+/// final result.
+pub enum CoroutineResult<Y, R> {
+    Yield(Y),
+    Done(R),
+}
 
-    /// Returns a coroutine that resolve once all of the underlying coroutine finishes. The
-    /// coroutines are resumed from top to bottom, in case multiple of them are ready to make
-    /// progress at the same time.
-    pub fn par_and<C, F>(&mut self, closure: C) -> ParAnd<'_>
-    where
-        F: Coroutine<'static>,
-        C: FnOnce(Fib) -> F,
-    {
-        let fib = self.clone();
-        let fut = Box::pin(closure(fib));
-        ParAnd::new(self, vec![fut])
-    }
+pub trait IntoCoroutine<Marker> {
+    type Coroutine: Coroutine;
 
-    pub fn owner(&self) -> Option<Entity> {
-        self.owner
-    }
+    fn into_coroutine(self, owner: Entity) -> Self::Coroutine;
 }
 
-/// Traits defined on all primitive (next_tick, par_and, ...)
-pub trait Primitive<'cx, O>: Future<Output = O> + 'cx + Send + Sync + Sized {
-    fn get_context(&self) -> &Fib;
+/// Any type that can be turned into a [`Coroutine`], given an access to the [`World`], to run
+/// arbitrary setup logic, such as registering [`Component`].
+pub trait UninitCoroutine<Marker> {
+    type Coroutine: Coroutine;
 
-    /// Returns a set of component from an entity, once this coroutine
-    /// has finished. For instance:
-    ///```
-    ///# use corentin::prelude::*;
-    ///# use bevy::prelude::*;
-    ///#[derive(Component)]
-    ///struct Foo(u64);
-    ///#[derive(Component)]
-    ///struct Bar(u64);
+    /// Initialize the Coroutine, or return None if it is invalid.
     ///
-    ///async fn coroutine(mut fib: Fib, e: Entity) {
-    ///     loop {
-    ///         let (dt, (mut foo, bar)) = fib.next_tick().then_grab::<(&mut Foo, &Bar)>(e).await;
-    ///         foo.0 += bar.0 * dt.as_secs();
-    ///     }
-    ///}
-    ///```
-    /// Note that the data is lifetime bounded to the Context, meaning it cannot outlive
-    /// accross awaiting points, for instance this will not compile
-    /// ```compile_fail
-    ///# use corentin::prelude::*;
-    ///# use bevy::prelude::*;
-    ///#[derive(Component)]
-    ///struct Foo(u64);
-    ///#[derive(Component)]
-    ///struct Bar(u64);
-    ///
-    ///async fn coroutine(mut fib: Fib, e: Entity) {
-    ///     loop {
-    ///         let (dt, (mut foo, bar)) = fib.next_tick().then_grab::<(&mut Foo, &Bar)>(e).await;
-    ///         fib.next_tick().await;
-    ///         foo.0 += bar.0 * dt.as_secs();
-    ///     }
-    ///}
-    ///```
-    fn then_grab<'cx2, P: GrabParam>(self, from: Entity) -> GrabCoroutine<'cx2, P, Self, O>
-    where
-        'cx: 'cx2,
-    {
-        let fib = self.get_context().clone();
-        GrabCoroutine::new(fib, from, self)
-    }
+    /// The world should be used to initialize any accesses, such as registering any
+    /// [`Component`](bevy::prelude::Component).
+    fn init(self, owner: Entity, world: &mut World) -> Option<Self::Coroutine>;
 }
 
-pub trait PrimitiveVoid<'cx>: Future<Output = ()> + 'cx + Send + Sync + Sized {
-    fn get_context(&self) -> &Fib;
 
-    /// Returns a set of component from an entity, once this coroutine
-    /// has finished. For instance:
-    ///```
-    ///# use corentin::prelude::*;
-    ///# use bevy::prelude::*;
-    ///# use std::time::Duration;
-    ///#[derive(Component)]
-    ///struct Foo(u64);
-    ///#[derive(Component)]
-    ///struct Bar(u64);
-    ///
-    ///async fn coroutine(mut fib: Fib, e: Entity) {
-    ///     loop {
-    ///         let (mut foo, bar) = fib.duration(Duration::from_secs(1)).then_grab::<(&mut Foo, &Bar)>(e).await;
-    ///         foo.0 += bar.0;
-    ///     }
-    ///}
-    ///```
-    /// Note that the data is lifetime bounded to the Context, meaning it cannot outlive
-    /// accross awaiting points, for instance this will not compile
-    /// ```compile_fail
-    ///# use corentin::prelude::*;
-    ///# use bevy::prelude::*;
-    ///# use std::time::Duration;
-    ///#[derive(Component)]
-    ///struct Foo(u64);
-    ///#[derive(Component)]
-    ///struct Bar(u64);
-    ///
-    ///async fn coroutine(mut fib: Fib, e: Entity) {
-    ///     loop {
-    ///         let (mut foo, bar) = fib.duration(Duration::from_secs(1)).then_grab::<(&mut Foo, &Bar)>(e).await;
-    ///         fib.next_tick().await;
-    ///         foo.0 += bar.0;
-    ///     }
-    ///}
-    ///```
-    fn then_grab<'cx2, P: GrabParam>(self, from: Entity) -> GrabCoroutineVoid<'cx2, P, Self>
-    where
-        'cx: 'cx2,
-    {
-        let fib = self.get_context().clone();
-        GrabCoroutineVoid::new(fib, from, self)
-    }
+/// A [`Coroutine`] can only yield one of these messages Used by the [`Executor`] to know when to
+/// resume a coroutine.
+pub enum WaitingReason {
+    Tick,
+    Duration(Timer),
+    Changed(ObservableId),
+    ParOr {
+        coroutines: Vec<CoroObject>,
+    },
+    ParAnd {
+        coroutines: Vec<CoroObject>,
+    },
 }
 
-/// Shorthand notation
-pub trait Coroutine<'cx, O = ()>: Future<Output = O> + 'cx + Send + Sync {}
-impl<'cx, O, T> Coroutine<'cx, O> for T where T: Future<Output = O> + 'cx + Send + Sync {}
+// TODO put that somewhere else
+#[derive(PartialEq, Eq, Clone, Copy)]
+pub(crate) enum CoroState {
+    Halted,
+    Running,
+}
diff --git a/src/coroutine/observable.rs b/src/coroutine/observable.rs
new file mode 100644
index 0000000..53befc3
--- /dev/null
+++ b/src/coroutine/observable.rs
@@ -0,0 +1,59 @@
+use std::{
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use bevy::{
+    ecs::component::ComponentId,
+    prelude::{Component, Entity, Mut, World},
+};
+
+use crate::{coroutine::WaitingReason, prelude::Fib, executor::msg_channel::Sender};
+
+use super::{CoroState, coro_param::ParamContext};
+
+/// Anything we can observe in the world will have one specific id
+#[derive(Copy, Clone)]
+pub enum ObservableId {
+    Entity(Entity),
+    Component(Entity, ComponentId),
+    Resource(ComponentId),
+}
+
+#[must_use = "futures do nothing unless you `.await` or poll them"]
+pub struct OnChange<'a> {
+    state: CoroState,
+    id: ObservableId,
+    context: &'a ParamContext
+}
+
+
+impl<'a> OnChange<'a> {
+    pub(crate) fn new(context: &'a ParamContext, id: ObservableId) -> Self {
+        Self {
+            state: CoroState::Running,
+            id,
+            context,
+        }
+    }
+}
+
+impl<'a> Future for OnChange<'a> {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        match self.state {
+            CoroState::Halted => {
+                self.state = CoroState::Running;
+                Poll::Ready(())
+            }
+            CoroState::Running => {
+                self.state = CoroState::Halted;
+                self.context.yield_sender.send(WaitingReason::Changed(self.id));
+                Poll::Pending
+            }
+        }
+    }
+}
diff --git a/src/coroutine/on.rs b/src/coroutine/on.rs
index 55b83d9..152d250 100644
--- a/src/coroutine/on.rs
+++ b/src/coroutine/on.rs
@@ -1,47 +1,47 @@
-use pin_project::pin_project;
-use std::future::Future;
-use std::pin::Pin;
-use std::task::Context;
-use std::task::Poll;
-
-use super::Coroutine;
-use super::Fib;
-use super::PrimitiveVoid;
-
-#[pin_project]
-pub struct On<'a, F>
-where
-    F: Future<Output = ()> + 'static + Send + Sync,
-{
-    fib: &'a Fib,
-    #[pin]
-    coroutine: F,
-}
-
-impl<'a, F> On<'a, F>
-where
-    F: Future<Output = ()> + 'static + Send + Sync,
-{
-    pub(crate) fn new(fib: &'a Fib, coroutine: F) -> Self {
-        On { fib, coroutine }
-    }
-}
-
-impl<'a, F> Future for On<'a, F>
-where
-    F: Coroutine<'static>,
-{
-    type Output = ();
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
-        let this = self.project();
-
-        this.coroutine.poll(cx)
-    }
-}
-
-impl<'cx, F: Coroutine<'static>> PrimitiveVoid<'cx> for On<'cx, F> {
-    fn get_context(&self) -> &super::Fib {
-        self.fib
-    }
-}
+//use pin_project::pin_project;
+//use std::future::Future;
+//use std::pin::Pin;
+//use std::task::Context;
+//use std::task::Poll;
+//
+//use crate::prelude::Fib;
+//
+//use super::Coroutine;
+//
+//#[pin_project]
+//pub struct On<'a, F>
+//where
+//    F: Future<Output = ()> + 'static + Send + Sync,
+//{
+//    fib: &'a Fib,
+//    #[pin]
+//    coroutine: F,
+//}
+//
+//impl<'a, F> On<'a, F>
+//where
+//    F: Future<Output = ()> + 'static + Send + Sync,
+//{
+//    pub(crate) fn new(fib: &'a Fib, coroutine: F) -> Self {
+//        On { fib, coroutine }
+//    }
+//}
+//
+//impl<'a, F> Future for On<'a, F>
+//where
+//    F: Coroutine<'static>,
+//{
+//    type Output = ();
+//
+//    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+//        let this = self.project();
+//
+//        this.coroutine.poll(cx)
+//    }
+//}
+//
+//impl<'cx, F: Coroutine<'static>> PrimitiveVoid<'cx> for On<'cx, F> {
+//    fn get_context(&self) -> &super::Fib {
+//        self.fib
+//    }
+//}
diff --git a/src/coroutine/par_and.rs b/src/coroutine/par_and.rs
index e974e10..03459fc 100644
--- a/src/coroutine/par_and.rs
+++ b/src/coroutine/par_and.rs
@@ -1,31 +1,29 @@
-use crate::coroutine::{CoroState, Fib, WaitingReason};
+use bevy::utils::synccell::SyncCell;
+
+use crate::coroutine::{CoroState, WaitingReason};
+use crate::prelude::Fib;
 
 use std::future::Future;
-use std::marker::PhantomData;
 use std::pin::Pin;
 use std::task::Context;
 use std::task::Poll;
 
-use super::PrimitiveVoid;
+use super::IntoCoroutine;
+use super::{CoroObject, Coroutine, UninitCoroutine};
 
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct ParAnd<'a> {
     fib: &'a Fib,
-    coroutines: Vec<Pin<Box<(dyn Future<Output = ()> + 'static + Send + Sync)>>>,
+    coroutines: Vec<CoroObject>,
     state: CoroState,
-    _phantom: PhantomData<&'a ()>,
 }
 
 impl<'a> ParAnd<'a> {
-    pub(crate) fn new(
-        fib: &'a Fib,
-        coroutines: Vec<Pin<Box<(dyn Future<Output = ()> + 'static + Send + Sync)>>>,
-    ) -> Self {
+    pub(crate) fn new(fib: &'a Fib, coroutines: Vec<CoroObject>) -> Self {
         ParAnd {
             fib,
             coroutines,
             state: CoroState::Running,
-            _phantom: PhantomData,
         }
     }
 }
@@ -42,13 +40,10 @@ impl<'a> Future for ParAnd<'a> {
             }
             CoroState::Running => {
                 self.state = CoroState::Halted;
-                // TODO: Will care about performance later, maybe find a way to inline the coroutines
-                // instead of allocating them on the heap ?
-                let temp: Vec<Pin<Box<dyn Future<Output = ()> + Send + Sync>>> =
-                    self.coroutines.drain(..).collect();
+                let coroutines = std::mem::take(&mut self.coroutines);
                 self.fib
-                    .yield_sender
-                    .send(WaitingReason::ParAnd { coroutines: temp });
+                    .yield_channel
+                    .send(WaitingReason::ParAnd { coroutines });
                 Poll::Pending
             }
         }
@@ -56,22 +51,20 @@ impl<'a> Future for ParAnd<'a> {
 }
 
 impl<'a> ParAnd<'a> {
-    /// Add a new coroutine to this [`ParAnd`]. It will have a lower priority than those defined
-    /// above.
-    pub fn with<C, F>(&mut self, closure: C) -> &mut Self
+    /// Add a new coroutine to this [`ParAnd`].
+    pub fn with<C, Marker>(&mut self, coro: C) -> &mut Self
     where
-        F: Future<Output = ()> + 'static + Send + Sync,
-        C: FnOnce(Fib) -> F,
+        C: UninitCoroutine<Marker>,
     {
-        let fib = self.fib.clone();
-        let fut = Box::pin(closure(fib));
-        self.coroutines.push(fut);
+        // Safety: We are getting polled right now, therefore we have exclusive world access.
+        unsafe {
+            if let Some(c) = coro.init(
+                self.fib.meta.owner,
+                self.fib.world_window.world_cell().world_mut(),
+            ) {
+                self.coroutines.push(SyncCell::new(Box::pin(c)));
+            }
+        }
         self
     }
 }
-
-impl<'cx> PrimitiveVoid<'cx> for ParAnd<'cx> {
-    fn get_context(&self) -> &Fib {
-        self.fib
-    }
-}
diff --git a/src/coroutine/par_or.rs b/src/coroutine/par_or.rs
index 9579723..e0a61a3 100644
--- a/src/coroutine/par_or.rs
+++ b/src/coroutine/par_or.rs
@@ -1,31 +1,29 @@
-use crate::coroutine::{CoroState, Fib, WaitingReason};
+use bevy::utils::synccell::SyncCell;
+
+use crate::coroutine::{CoroState, WaitingReason};
 
 use std::future::Future;
-use std::marker::PhantomData;
 use std::pin::Pin;
 use std::task::Context;
 use std::task::Poll;
 
-use super::PrimitiveVoid;
+use super::function_coroutine::Fib;
+use super::CoroObject;
+use super::UninitCoroutine;
 
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct ParOr<'a> {
     fib: &'a Fib,
-    coroutines: Vec<Pin<Box<(dyn Future<Output = ()> + 'static + Send + Sync)>>>,
+    coroutines: Vec<CoroObject>,
     state: CoroState,
-    _phantom: PhantomData<&'a ()>,
 }
 
 impl<'a> ParOr<'a> {
-    pub(crate) fn new(
-        fib: &'a Fib,
-        coroutines: Vec<Pin<Box<(dyn Future<Output = ()> + 'static + Send + Sync)>>>,
-    ) -> Self {
+    pub(crate) fn new(fib: &'a Fib, coroutines: Vec<CoroObject>) -> Self {
         ParOr {
             fib,
             coroutines,
             state: CoroState::Running,
-            _phantom: PhantomData,
         }
     }
 }
@@ -42,13 +40,10 @@ impl<'a> Future for ParOr<'a> {
             }
             CoroState::Running => {
                 self.state = CoroState::Halted;
-                // TODO: Will care about performance later, maybe find a way to inline the coroutines
-                // instead of allocating them on the heap ?
-                let temp: Vec<Pin<Box<dyn Future<Output = ()> + Send + Sync>>> =
-                    self.coroutines.drain(..).collect();
+                let coroutines = std::mem::take(&mut self.coroutines);
                 self.fib
-                    .yield_sender
-                    .send(WaitingReason::ParOr { coroutines: temp });
+                    .yield_channel
+                    .send(WaitingReason::ParOr { coroutines });
                 Poll::Pending
             }
         }
@@ -56,22 +51,20 @@ impl<'a> Future for ParOr<'a> {
 }
 
 impl<'a> ParOr<'a> {
-    /// Add a new coroutine to this [`ParOr`]. It will have a lower priority than those defined
-    /// above.
-    pub fn with<C, F>(&mut self, closure: C) -> &mut Self
+    /// Add a new coroutine to this [`ParOr`].
+    pub fn with<C, Marker: 'static>(&mut self, coro: C) -> &mut Self
     where
-        F: Future<Output = ()> + 'static + Send + Sync,
-        C: FnOnce(Fib) -> F,
+        C: UninitCoroutine<Marker>,
     {
-        let fib = self.fib.clone();
-        let fut = Box::pin(closure(fib));
-        self.coroutines.push(fut);
+        // Safety: We are getting polled right now, therefore we have exclusive world access.
+        unsafe {
+            if let Some(c) = coro.init(
+                self.fib.meta.owner,
+                self.fib.world_window.world_cell().world_mut(),
+            ) {
+                self.coroutines.push(SyncCell::new(Box::pin(c)));
+            }
+        }
         self
     }
 }
-
-impl<'cx> PrimitiveVoid<'cx> for ParOr<'cx> {
-    fn get_context(&self) -> &Fib {
-        self.fib
-    }
-}
diff --git a/src/coroutine/waker.rs b/src/coroutine/waker.rs
new file mode 100644
index 0000000..631cd30
--- /dev/null
+++ b/src/coroutine/waker.rs
@@ -0,0 +1,15 @@
+use std::task::{RawWaker, RawWakerVTable, Waker};
+
+pub fn create() -> Waker {
+    // Safety: The waker points to a vtable with functions that do nothing. Doing
+    // nothing is memory-safe.
+    unsafe { Waker::from_raw(RAW_WAKER) }
+}
+
+const RAW_WAKER: RawWaker = RawWaker::new(std::ptr::null(), &VTABLE);
+const VTABLE: RawWakerVTable = RawWakerVTable::new(clone, do_nothing, do_nothing, do_nothing);
+
+unsafe fn clone(_: *const ()) -> RawWaker {
+    RAW_WAKER
+}
+unsafe fn do_nothing(_: *const ()) {}
diff --git a/src/coroutine/when.rs b/src/coroutine/when.rs
index 6769661..0e7d17e 100644
--- a/src/coroutine/when.rs
+++ b/src/coroutine/when.rs
@@ -1,146 +1,53 @@
-use bevy::prelude::Component;
-use bevy::prelude::Entity;
-
-use crate::coroutine::{CoroState, Fib, WaitingReason};
-
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::Context;
-use std::task::Poll;
-
-use super::PrimitiveVoid;
-
-#[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct Change<'a, T: Component> {
-    fib: &'a Fib,
-    from: Entity,
-    _phantom: PhantomData<T>,
-    state: CoroState,
-}
-
-impl<'a, T: Component + Unpin> Change<'a, T> {
-    pub(crate) fn new(fib: &'a Fib, from: Entity) -> Self {
-        Change {
-            fib,
-            from,
-            _phantom: PhantomData,
-            state: CoroState::Running,
-        }
-    }
-}
-
-impl<'a, T: Component + Unpin> Future for Change<'a, T> {
-    type Output = ();
-
-    fn poll(mut self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
-        match self.state {
-            // We assume the executor will only poll it once the component changed
-            CoroState::Halted => {
-                self.state = CoroState::Running;
-                Poll::Ready(())
-            }
-            CoroState::Running => {
-                let c_id = self.fib.component_id::<T>();
-                self.state = CoroState::Halted;
-                self.fib.yield_sender.send(WaitingReason::Changed {
-                    from: self.from,
-                    component: c_id,
-                });
-                Poll::Pending
-            }
-        }
-    }
-}
-
-impl<'a, T: Component + Unpin> PrimitiveVoid<'a> for Change<'a, T> {
-    fn get_context(&self) -> &Fib {
-        self.fib
-    }
-}
-
-//impl<'a, T: Component> Change<'a, T> {
-//    pub fn with<C: 'static>(self) -> ChangeWith<'a, T> {
-//        ChangeWith {
-//            fib: self.fib,
-//            from: self.from,
-//            _phantom: PhantomData,
-//            with: vec![TypeId::of::<C>()],
-//            without: Vec::new(),
-//            state: self.state,
-//        }
-//    }
+//use bevy::prelude::Component;
+//use bevy::prelude::Entity;
+//
+//use crate::coroutine::{CoroState, WaitingReason};
+//
+//use std::future::Future;
+//use std::marker::PhantomData;
+//use std::pin::Pin;
+//use std::task::Context;
+//use std::task::Poll;
 //
-//    pub fn without<C: 'static>(self) -> ChangeWith<'a, T> {
-//        ChangeWith {
-//            fib: self.fib,
-//            from: self.from,
-//            _phantom: PhantomData,
-//            with: Vec::new(),
-//            without: vec![TypeId::of::<C>()],
-//            state: self.state,
-//        }
-//    }
-//}
 //
 //#[must_use = "futures do nothing unless you `.await` or poll them"]
-//pub struct ChangeWith<'a, T: Component> {
-//    fib: Fib,
+//pub struct Change<'a, T: Component> {
+//    fib: &'a Fib,
 //    from: Entity,
 //    _phantom: PhantomData<T>,
-//    // TODO: make that more efficient and more robust (and not rely on TypeId)
-//    with: Vec<TypeId>,
-//    without: Vec<TypeId>,
 //    state: CoroState,
-//    _phantom2: PhantomData<&'a ()>,
 //}
 //
-//impl<'a, T: Component> ChangeWith<'a, T> {
-//   pub(crate) fn new(fib: Fib, from: Entity, with:)
+//impl<'a, T: Component + Unpin> Change<'a, T> {
+//    pub(crate) fn new(fib: &'a Fib, from: Entity) -> Self {
+//        Change {
+//            fib,
+//            from,
+//            _phantom: PhantomData,
+//            state: CoroState::Running,
+//        }
+//    }
 //}
 //
-//impl<'a, T: Component + Unpin> Future for ChangeWith<'a, T> {
+//impl<'a, T: Component + Unpin> Future for Change<'a, T> {
 //    type Output = ();
 //
-//    fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+//    fn poll(mut self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
 //        match self.state {
+//            // We assume the executor will only poll it once the component changed
 //            CoroState::Halted => {
 //                self.state = CoroState::Running;
 //                Poll::Ready(())
 //            }
 //            CoroState::Running => {
 //                let c_id = self.fib.component_id::<T>();
-//                let with: Vec<ComponentId> = self
-//                    .with
-//                    .iter()
-//                    .map(|tid| self.fib.get_component_id(*tid))
-//                    .collect();
-//                let without: Vec<ComponentId> = self
-//                    .without
-//                    .iter()
-//                    .map(|tid| self.fib.get_component_id(*tid))
-//                    .collect();
 //                self.state = CoroState::Halted;
-//                self.fib.yield_sender.send(WaitingReason::ChangedWith {
+//                self.fib.yield_sender.send(WaitingReason::Changed {
 //                    from: self.from,
 //                    component: c_id,
-//                    with,
-//                    without,
 //                });
 //                Poll::Pending
 //            }
 //        }
 //    }
 //}
-//
-//impl<'a, T: Component> ChangeWith<'a, T> {
-//    pub fn with<C: 'static>(&mut self) -> &mut Self {
-//        self.with.push(TypeId::of::<C>());
-//        self
-//    }
-//
-//    pub fn without<C: 'static>(&mut self) -> &mut Self {
-//        self.without.push(TypeId::of::<C>());
-//        self
-//    }
-//}
diff --git a/src/executor/mod.rs b/src/executor/mod.rs
index 0ba5835..b0421e1 100644
--- a/src/executor/mod.rs
+++ b/src/executor/mod.rs
@@ -1,34 +1,21 @@
 use bevy::utils::HashMap;
 use bevy::{ecs::component::ComponentId, prelude::*};
-use core::task::Context;
-use coroutine::{Fib, WaitingReason};
-use std::cell::Cell;
+use coroutine::WaitingReason;
 use std::collections::VecDeque;
-use std::future::Future;
-use std::pin::Pin;
-use std::rc::Rc;
-use std::task::Poll;
-use waker::create;
 
-use crate::{coroutine, waker};
-use coroutine::grab::GrabReason;
-use msg_channel::Receiver;
-
-pub(crate) type CoroObject = Pin<Box<dyn Future<Output = ()> + Send + Sync>>;
+use crate::coroutine;
+use crate::coroutine::observable::ObservableId;
+use crate::coroutine::{CoroObject, CoroWrites, Coroutine, CoroutineResult};
 
 pub(crate) mod msg_channel;
 mod run_ctx;
-use run_ctx::RunContext;
-
-use self::run_ctx::SuspendedCoro;
+pub(crate) use run_ctx::RunContext;
 
 type CoroId = u32;
 
 #[derive(Resource)]
 pub struct Executor {
     coroutines: HashMap<CoroId, CoroObject>,
-    yield_msg: Receiver<WaitingReason>,
-    grab_msg: Receiver<GrabReason>,
     waiting_on_tick: VecDeque<CoroId>,
     waiting_on_duration: VecDeque<(Timer, CoroId)>,
     waiting_on_change: HashMap<(Entity, ComponentId), Vec<CoroId>>,
@@ -36,26 +23,24 @@ pub struct Executor {
     waiting_on_par_and: HashMap<CoroId, Vec<CoroId>>,
     is_awaited_by: HashMap<CoroId, CoroId>,
     own: HashMap<Entity, Vec<CoroId>>,
-    world_window: Rc<Cell<Option<*mut World>>>,
-    accesses: HashMap<CoroId, GrabReason>,
     next_id: CoroId,
 }
 
+impl Default for Executor {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 // SAFETY: This is safe because the only !Send and !Sync field (receiver) is only accessed
 // when calling run(), which is done in a single threaded context.
 unsafe impl Send for Executor {}
 unsafe impl Sync for Executor {}
 
-const ERR_WRONGAWAIT: &str = "A coroutine yielded without notifying the executor
-the reason. That is most likely because it awaits a
-future which is not part of this library.";
-
 impl Executor {
     pub fn new() -> Self {
         Executor {
             coroutines: HashMap::new(),
-            yield_msg: Receiver::new(),
-            grab_msg: Receiver::new(),
             waiting_on_tick: VecDeque::new(),
             waiting_on_duration: VecDeque::new(),
             waiting_on_change: HashMap::new(),
@@ -63,8 +48,6 @@ impl Executor {
             waiting_on_par_and: HashMap::new(),
             is_awaited_by: HashMap::new(),
             own: HashMap::new(),
-            world_window: Rc::new(Cell::new(None)),
-            accesses: HashMap::new(),
             next_id: 0,
         }
     }
@@ -77,39 +60,12 @@ impl Executor {
     }
 
     /// Add a coroutine to the executor.
-    pub fn add<C, F>(&mut self, closure: C)
-    where
-        F: Future<Output = ()> + 'static + Send + Sync,
-        C: FnOnce(Fib) -> F,
-    {
-        let fib = Fib {
-            yield_sender: self.yield_msg.sender(),
-            grab_sender: self.grab_msg.sender(),
-            owner: None,
-            world_window: Rc::clone(&self.world_window),
-        };
+    pub fn add(&mut self, mut coroutine: CoroObject) {
         let id = self.next_id();
-        self.coroutines.insert(id, Box::pin(closure(fib)));
+        let owner = coroutine.get().meta().owner;
+        self.coroutines.insert(id, coroutine);
         self.waiting_on_tick.push_back(id);
-    }
-
-    /// Add a coroutine owned by an [`Entity`] to the executor.
-    /// If the entity is removed, the coroutine is dropped.
-    pub fn add_to_entity<C, F>(&mut self, entity: Entity, closure: C)
-    where
-        F: Future<Output = ()> + 'static + Send + Sync,
-        C: FnOnce(Fib, Entity) -> F,
-    {
-        let fib = Fib {
-            yield_sender: self.yield_msg.sender(),
-            grab_sender: self.grab_msg.sender(),
-            owner: None,
-            world_window: Rc::clone(&self.world_window),
-        };
-        let id = self.next_id();
-        self.coroutines.insert(id, Box::pin(closure(fib, entity)));
-        self.waiting_on_tick.push_back(id);
-        self.own.entry(entity).or_default().push(id);
+        self.own.entry(owner).or_default().push(id);
     }
 
     /// Drop a coroutine from the executor.
@@ -161,7 +117,6 @@ impl Executor {
             self.waiting_on_change.retain(|(e, c), coro| {
                 if let Some(e) = w.get_entity(*e) {
                     if let Some(t) = e.get_change_ticks_by_id(*c) {
-                        // TODO: Make sure this is correct, I'm really not that confident, even though it works with a simple example
                         if t.is_changed(w.last_change_tick(), w.change_tick()) {
                             for c in coro {
                                 root_coros.push_back(*c);
@@ -180,107 +135,61 @@ impl Executor {
             }
         });
 
-        let mut run_cx: RunContext = RunContext::new();
-        let waker = create();
-        let mut context = Context::from_waker(&waker);
-
-        // TODO: Find maybe a safer abstraction ?
-        self.world_window.replace(Some(world as *mut _));
+        let mut run_cx = RunContext::new();
+        let mut ready_coro: VecDeque<(CoroId, usize)> = root_coros
+            .into_iter()
+            .map(|c_id| (c_id, run_cx.parent_table.add_root()))
+            .collect();
 
-        while let Some(coro) = root_coros.pop_front() {
-            let node = run_cx.parent_table.add_root();
-            self.run(coro, node, false, &mut run_cx, &mut context);
-        }
-
-        while let Some(SuspendedCoro { coro_id, node }) = run_cx.delayed.pop_front() {
-            self.run(coro_id, node, true, &mut run_cx, &mut context);
+        while let Some((c_id, node)) = ready_coro.pop_front() {
+            self.run(c_id, node, &mut run_cx, &mut ready_coro, world);
         }
     }
 
     /// Run a specific coroutine and it's children.
     fn run(
         &mut self,
-        coro: CoroId,
+        coro_id: CoroId,
         this_node: usize,
-        resumed: bool,
         run_cx: &mut RunContext,
-        cx: &mut Context,
+        ready_coro: &mut VecDeque<(CoroId, usize)>,
+        world: &mut World,
     ) {
-        if !self.coroutines.contains_key(&coro) {
+        if !self.coroutines.contains_key(&coro_id) {
             return;
         }
 
-        let accesses = self.accesses.get(&coro);
-        if let Some(accesses) = accesses {
-            {
-                let world = unsafe { &mut *self.world_window.get().unwrap() };
-                if !accesses.is_valid(world) {
-                    self.cancel(coro);
-                    return;
-                }
-            }
-
-            let mut has_conflicts = false;
-            let conflicters = run_cx.write_table.conflicts(accesses.writes());
-            for c in conflicters {
-                if !resumed || !run_cx.parent_table.is_parent(*c, this_node) {
-                    run_cx.parent_table.add_parent(*c, this_node);
-                    has_conflicts = true;
-                }
-            }
+        let coro = self.coroutines.get_mut(&coro_id).unwrap().get();
+        let meta = coro.meta().clone();
+        if !meta.is_valid(world) {
+            self.cancel(coro_id);
+            return;
+        }
 
-            if has_conflicts {
-                run_cx
-                    .delayed
-                    .push_back(SuspendedCoro::new(coro, this_node));
+        let result = Coroutine::resume(coro.as_mut(), world);
 
-                return;
-            }
-        }
-        // To make sure we can detect changes that just happened
-        {
-            let world = unsafe { &mut *self.world_window.get().unwrap() };
-            world.increment_change_tick();
-        }
+        let mut writes = world.resource_mut::<CoroWrites>();
 
-        let result = self.coroutines.get_mut(&coro).unwrap().as_mut().poll(cx);
-        let yield_msg = self.yield_msg.receive();
-        let next_access = self.grab_msg.receive();
-
-        if let Some(accesses) = accesses {
-            // SAFETY: No other coroutines a running right now, we have exclusive world access
-            let world = unsafe { &mut *self.world_window.get().unwrap() };
-            // TODO: Should probably find a better way
-            for write in accesses.writes().iter().filter(|(e, cid)| {
-                let tick = match world.get_entity(*e).unwrap().get_change_ticks_by_id(*cid) {
-                    Some(t) => t,
-                    None => {
-                        // The access was valid so that must be an optional field
-                        return false;
-                    }
-                };
-                tick.last_changed_tick() == world.change_tick()
-            }) {
-                run_cx.write_table.insert(*write, this_node);
-                if let Some(nexts) = self.waiting_on_change.remove(write) {
-                    for c in nexts {
-                        let node = match run_cx.current_node_map.remove(&c) {
-                            Some(n) => {
-                                run_cx.parent_table.add_parent(this_node, n);
-                                n
-                            }
-                            None => run_cx.parent_table.add_child(this_node),
-                        };
-                        self.run(c, node, false, run_cx, cx);
-                    }
+        while let Some((write, c_id)) = writes.0.pop_front() {
+            run_cx.write_table.insert((write, c_id), this_node);
+            if let Some(nexts) = self.waiting_on_change.remove(&(write, c_id)) {
+                for c in nexts {
+                    let node = match run_cx.current_node_map.remove(&c) {
+                        Some(n) => {
+                            run_cx.parent_table.add_parent(this_node, n);
+                            n
+                        }
+                        None => run_cx.parent_table.add_child(this_node),
+                    };
+                    ready_coro.push_back((c, node));
                 }
             }
         }
 
         match result {
-            Poll::Ready(_) => {
-                self.coroutines.remove(&coro);
-                if let Some(parent) = self.is_awaited_by.remove(&coro) {
+            CoroutineResult::Done(_) => {
+                self.coroutines.remove(&coro_id);
+                if let Some(parent) = self.is_awaited_by.remove(&coro_id) {
                     if let Some(others) = self.waiting_on_par_or.remove(&parent) {
                         // coro is the "winner", all the others are cancelled
                         for o in others {
@@ -291,7 +200,7 @@ impl Executor {
                         self.waiting_on_tick.push_back(parent);
                     }
                     if let Some(others) = self.waiting_on_par_and.get_mut(&parent) {
-                        let index = others.iter().position(|c| *c == coro).unwrap();
+                        let index = others.iter().position(|c| *c == coro_id).unwrap();
                         others.remove(index);
                         if others.is_empty() {
                             // TODO: should run immediatly
@@ -301,75 +210,74 @@ impl Executor {
                     }
                 }
             }
-            Poll::Pending => {
-                if let Some(grab) = next_access {
-                    self.accesses.insert(coro, grab);
-                }
-                match yield_msg.expect(ERR_WRONGAWAIT) {
-                    WaitingReason::Tick => self.waiting_on_tick.push_back(coro),
-                    WaitingReason::Duration(d) => self.waiting_on_duration.push_back((d, coro)),
-                    WaitingReason::Changed { from, component } => {
+            CoroutineResult::Yield(yield_msg) => match yield_msg {
+                WaitingReason::Tick => self.waiting_on_tick.push_back(coro_id),
+                WaitingReason::Duration(d) => self.waiting_on_duration.push_back((d, coro_id)),
+                WaitingReason::Changed(change_id) => match change_id {
+                    ObservableId::Component(from, component) => {
                         let next_node = run_cx.parent_table.add_child(this_node);
                         match run_cx.can_execute_now(next_node, &(from, component)) {
                             Some(writer) => {
                                 run_cx.parent_table.add_parent(writer, next_node);
-                                self.run(coro, next_node, false, run_cx, cx);
+                                ready_coro.push_back((coro_id, next_node));
                             }
                             None => {
                                 self.waiting_on_change
                                     .entry((from, component))
                                     .or_default()
-                                    .push(coro);
-                                run_cx.current_node_map.insert(coro, next_node);
+                                    .push(coro_id);
+                                run_cx.current_node_map.insert(coro_id, next_node);
                             }
                         }
                     }
-                    WaitingReason::ParOr { coroutines } => {
-                        let parent = coro;
-                        let mut all_ids = Vec::with_capacity(coroutines.len());
-                        for coroutine in coroutines {
-                            let id = self.next_id();
-                            self.coroutines.insert(id, coroutine);
-                            self.is_awaited_by.insert(id, parent);
-                            all_ids.push(id);
-                        }
+                    _ => todo!(),
+                },
+                WaitingReason::ParOr { coroutines } => {
+                    let parent = coro_id;
+                    let mut all_ids = Vec::with_capacity(coroutines.len());
+                    for coroutine in coroutines {
+                        let id = self.next_id();
+                        self.coroutines.insert(id, coroutine);
+                        self.is_awaited_by.insert(id, parent);
+                        all_ids.push(id);
+                    }
 
-                        self.waiting_on_par_or.insert(parent, all_ids.clone());
+                    self.waiting_on_par_or.insert(parent, all_ids.clone());
 
-                        for id in all_ids {
-                            let node = run_cx.parent_table.add_child(this_node);
-                            self.run(id, node, false, run_cx, cx);
-                        }
+                    for id in all_ids {
+                        let node = run_cx.parent_table.add_child(this_node);
+                        ready_coro.push_back((id, node));
+                    }
+                }
+                WaitingReason::ParAnd { coroutines } => {
+                    let parent = coro_id;
+                    let mut all_ids = Vec::with_capacity(coroutines.len());
+                    for coroutine in coroutines {
+                        let id = self.next_id();
+                        self.coroutines.insert(id, coroutine);
+                        self.is_awaited_by.insert(id, parent);
+                        all_ids.push(id);
                     }
-                    WaitingReason::ParAnd { coroutines } => {
-                        let parent = coro;
-                        let mut all_ids = Vec::with_capacity(coroutines.len());
-                        for coroutine in coroutines {
-                            let id = self.next_id();
-                            self.coroutines.insert(id, coroutine);
-                            self.is_awaited_by.insert(id, parent);
-                            all_ids.push(id);
-                        }
 
-                        self.waiting_on_par_and.insert(parent, all_ids.clone());
+                    self.waiting_on_par_and.insert(parent, all_ids.clone());
 
-                        for id in all_ids {
-                            let node = run_cx.parent_table.add_child(this_node);
-                            self.run(id, node, false, run_cx, cx);
-                        }
+                    for id in all_ids {
+                        let node = run_cx.parent_table.add_child(this_node);
+                        ready_coro.push_back((id, node));
                     }
                 }
-            }
+            },
         };
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::coroutine::Primitive;
+    use crate::{coroutine::CoroWrites, prelude::*};
 
     use super::Executor;
     use bevy::{
+        ecs::system::EntityCommand,
         prelude::{Component, Mut, World},
         time::Time,
     };
@@ -384,31 +292,35 @@ mod tests {
     #[test]
     fn par_or_despawn_correctly() {
         let mut world = World::new();
-        world.insert_resource(Executor::new());
+        let e = world.spawn_empty().id();
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
         world.insert_resource(Time::new(Instant::now()));
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(move |mut fib| async move {
-                fib.par_or(|mut fib| async move {
-                    fib.par_or(|mut fib| async move {
-                        loop {
-                            fib.next_tick().await;
-                        }
-                    })
-                    .with(|mut fib| async move {
-                        loop {
-                            fib.next_tick().await;
-                        }
-                    })
-                    .await;
+
+        coroutine(|fib: Fib| async move {
+            fib.par_or(|fib: Fib| async move {
+                fib.par_or(|fib: Fib| async move {
+                    loop {
+                        fib.next_tick().await;
+                    }
                 })
-                .with(|mut fib| async move {
-                    for _ in 0..4 {
+                .with(|fib: Fib| async move {
+                    loop {
                         fib.next_tick().await;
                     }
                 })
                 .await;
-            });
+            })
+            .with(|fib: Fib| async move {
+                for _ in 0..4 {
+                    fib.next_tick().await;
+                }
+            })
+            .await;
+        })
+        .apply(e, &mut world);
 
+        world.resource_scope(|w, mut executor: Mut<Executor>| {
             assert_eq!(executor.is_awaited_by.len(), 0);
             assert_eq!(executor.waiting_on_par_or.len(), 0);
             assert_eq!(executor.coroutines.len(), 1);
@@ -432,21 +344,26 @@ mod tests {
     #[test]
     fn waiting_on_change_cancel_when_components_not_present() {
         let mut world = World::new();
-        world.insert_resource(Executor::new());
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
         world.insert_resource(Time::new(Instant::now()));
         let e = world.spawn((ExampleComponent, ExampleComponentBar)).id();
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(|mut fib| async move {
-                loop {
-                    let _ex = fib.next_tick().then_grab::<&ExampleComponent>(e).await;
-                }
-            });
-            executor.add(|mut fib| async move {
-                loop {
-                    let _ex = fib.next_tick().then_grab::<&ExampleComponentBar>(e).await;
-                }
-            });
 
+        coroutine(|fib: Fib, _ex: R<ExampleComponent>| async move {
+            loop {
+                fib.next_tick().await;
+            }
+        })
+        .apply(e, &mut world);
+
+        coroutine(|fib: Fib, _ex: R<ExampleComponentBar>| async move {
+            loop {
+                fib.next_tick().await;
+            }
+        })
+        .apply(e, &mut world);
+
+        world.resource_scope(|w, mut executor: Mut<Executor>| {
             assert_eq!(executor.coroutines.len(), 2);
             executor.tick(w);
             assert_eq!(executor.coroutines.len(), 2);
@@ -459,34 +376,28 @@ mod tests {
         });
     }
 
-    #[test]
-    fn waiting_on_change_dont_cancel_on_optional() {
-        let mut world = World::new();
-        world.insert_resource(Executor::new());
-        world.insert_resource(Time::new(Instant::now()));
-        let e = world.spawn(ExampleComponent).id();
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(|mut fib| async move {
-                loop {
-                    let _ex = fib
-                        .next_tick()
-                        .then_grab::<Option<&ExampleComponent>>(e)
-                        .await;
-                }
-            });
-
-            assert_eq!(executor.coroutines.len(), 1);
-            executor.tick(w);
-            assert_eq!(executor.coroutines.len(), 1);
-            w.entity_mut(e).remove::<ExampleComponent>();
-            executor.tick(w);
-            assert_eq!(executor.coroutines.len(), 1);
-        });
-    }
-}
-
-impl Default for Executor {
-    fn default() -> Self {
-        Self::new()
-    }
+    //#[test]
+    //fn waiting_on_change_dont_cancel_on_optional() {
+    //    let mut world = World::new();
+    //    world.init_resource::<Executor>();
+    //    world.init_resource::<CoroWrites>();
+    //    world.insert_resource(Time::new(Instant::now()));
+    //    let e = world.spawn(ExampleComponent).id();
+    //    coroutine(
+    //        |mut fib: Fib, _ex: Option<R<ExampleComponent>>| async move {
+    //            loop {
+    //                fib.next_tick().await;
+    //            }
+    //        },
+    //    )
+    //    .apply(e, &mut world);
+    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
+    //        assert_eq!(executor.coroutines.len(), 1);
+    //        executor.tick(w);
+    //        assert_eq!(executor.coroutines.len(), 1);
+    //        w.entity_mut(e).remove::<ExampleComponent>();
+    //        executor.tick(w);
+    //        assert_eq!(executor.coroutines.len(), 1);
+    //    });
+    //}
 }
diff --git a/src/executor/run_ctx.rs b/src/executor/run_ctx.rs
index ab7a2b6..bf12d36 100644
--- a/src/executor/run_ctx.rs
+++ b/src/executor/run_ctx.rs
@@ -1,6 +1,10 @@
 use std::collections::VecDeque;
 
-use bevy::{ecs::component::ComponentId, prelude::Entity, utils::HashMap};
+use bevy::{
+    ecs::component::ComponentId,
+    prelude::{Entity, Resource},
+    utils::HashMap,
+};
 use tinyset::SetUsize;
 
 use super::CoroId;
@@ -20,14 +24,6 @@ impl<T> WriteTable<T> {
     pub(crate) fn insert(&mut self, location: (Entity, ComponentId), writer: T) -> Option<T> {
         self.table.insert(location, writer)
     }
-
-    /// Return all conflicters
-    pub(crate) fn conflicts<I>(&self, vals: I) -> impl Iterator<Item = &'_ T>
-    where
-        I: IntoIterator<Item = (Entity, ComponentId)>,
-    {
-        vals.into_iter().filter_map(|k| self.table.get(&k))
-    }
 }
 
 pub(crate) struct ParentTable {
@@ -52,8 +48,8 @@ impl ParentTable {
     }
 
     /// Return true if (and only if) `parent` is a parent of `child`.
-    /// It is useful to know if a write perform in a can
-    /// be reacted by b, which is the case if this returns
+    /// It is useful to know if a write performed by coroutine A can
+    /// be observed by coroutine B, which is the case if this returns
     /// false.
     pub(crate) fn is_parent(&self, parent: usize, child: usize) -> bool {
         self.table.get(child).unwrap().contains(parent)
@@ -67,21 +63,9 @@ impl ParentTable {
     }
 }
 
-pub(crate) struct SuspendedCoro {
-    pub(crate) coro_id: CoroId,
-    pub(crate) node: usize,
-}
-
-impl SuspendedCoro {
-    pub(crate) fn new(coro_id: CoroId, node: usize) -> Self {
-        Self { coro_id, node }
-    }
-}
-
 pub(crate) struct RunContext {
     pub(crate) write_table: WriteTable<usize>,
     pub(crate) parent_table: ParentTable,
-    pub(crate) delayed: VecDeque<SuspendedCoro>,
     pub(crate) current_node_map: HashMap<CoroId, usize>,
 }
 
@@ -90,7 +74,6 @@ impl RunContext {
         RunContext {
             write_table: WriteTable::new(),
             parent_table: ParentTable::new(),
-            delayed: VecDeque::new(),
             current_node_map: HashMap::new(),
         }
     }
diff --git a/src/lib.rs b/src/lib.rs
index 017e2d3..e3d1f64 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,14 +4,22 @@
 pub mod coroutine;
 pub mod executor;
 
+mod commands;
+mod plugin;
 mod waker;
 mod world_window;
 
 pub mod prelude {
     #[doc(hidden)]
-    pub use crate::coroutine::{Fib, Primitive, PrimitiveVoid};
+    pub use crate::commands::{coroutine, AddCoroutine};
+    #[doc(hidden)]
+    pub use crate::coroutine::coro_param::{R, W};
+    #[doc(hidden)]
+    pub use crate::coroutine::function_coroutine::Fib;
     #[doc(hidden)]
     pub use crate::executor::Executor;
+    #[doc(hidden)]
+    pub use crate::plugin::CorentinPlugin;
 }
 
 #[cfg(test)]
@@ -22,11 +30,12 @@ mod tests {
     };
 
     use bevy::{
+        ecs::system::EntityCommand,
         prelude::{Component, Mut, World},
         time::Time,
     };
 
-    use crate::{coroutine::Primitive, prelude::*};
+    use crate::{commands::coroutine, coroutine::CoroWrites, prelude::*};
 
     #[derive(Component)]
     struct ExampleComponent(u32);
@@ -34,18 +43,23 @@ mod tests {
     #[test]
     fn wait_on_tick() {
         let mut world = World::new();
-        world.insert_resource(Executor::new());
+        let e = world.spawn_empty().id();
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
         world.insert_resource(Time::new(Instant::now()));
+
+        let a = Arc::new(Mutex::new(0));
+        let b = Arc::clone(&a);
+        coroutine(|fib: Fib| async move {
+            *b.lock().unwrap() += 1;
+            fib.next_tick().await;
+            *b.lock().unwrap() += 1;
+            fib.next_tick().await;
+            *b.lock().unwrap() += 1;
+        })
+        .apply(e, &mut world);
+
         world.resource_scope(|w, mut executor: Mut<Executor>| {
-            let a = Arc::new(Mutex::new(0));
-            let b = Arc::clone(&a);
-            executor.add(move |mut fib| async move {
-                *b.lock().unwrap() += 1;
-                fib.next_tick().await;
-                *b.lock().unwrap() += 1;
-                fib.next_tick().await;
-                *b.lock().unwrap() += 1;
-            });
             executor.tick(w);
             assert_eq!(*a.lock().unwrap(), 1);
             executor.tick(w);
@@ -57,52 +71,57 @@ mod tests {
         });
     }
 
-    #[test]
-    fn wait_on_sub_coroutine() {
-        async fn sub_coro(mut fib: Fib) {
-            fib.next_tick().await;
-            fib.next_tick().await;
-        }
+    //#[test]
+    //fn wait_on_sub_coroutine() {
+    //    async fn sub_coro(mut fib: Fib) {
+    //        fib.next_tick().await;
+    //        fib.next_tick().await;
+    //    }
 
-        let mut world = World::new();
-        world.insert_resource(Executor::new());
-        world.insert_resource(Time::new(Instant::now()));
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            let a = Arc::new(Mutex::new(0));
-            let b = Arc::clone(&a);
-            executor.add(move |mut fib| async move {
-                *b.lock().unwrap() += 1;
-                fib.on(sub_coro).await;
-                *b.lock().unwrap() += 1;
-            });
-            executor.tick(w);
-            assert_eq!(*a.lock().unwrap(), 1);
-            executor.tick(w);
-            assert_eq!(*a.lock().unwrap(), 1);
-            executor.tick(w);
-            assert_eq!(*a.lock().unwrap(), 2);
-            executor.tick(w);
-            assert_eq!(*a.lock().unwrap(), 2);
-        });
-    }
+    //    let mut world = World::new();
+    //    let e = world.spawn_empty().id();
+    //    world.insert_resource(Executor::new());
+    //    world.insert_resource(Time::new(Instant::now()));
+    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
+    //        let a = Arc::new(Mutex::new(0));
+    //        let b = Arc::clone(&a);
+    //        executor.add_fn(e, move |mut fib: Fib| async move {
+    //            *b.lock().unwrap() += 1;
+    //            fib.on(sub_coro).await;
+    //            *b.lock().unwrap() += 1;
+    //        });
+    //        executor.tick(w);
+    //        assert_eq!(*a.lock().unwrap(), 1);
+    //        executor.tick(w);
+    //        assert_eq!(*a.lock().unwrap(), 1);
+    //        executor.tick(w);
+    //        assert_eq!(*a.lock().unwrap(), 2);
+    //        executor.tick(w);
+    //        assert_eq!(*a.lock().unwrap(), 2);
+    //    });
+    //}
 
     #[test]
-    fn wait_on_change() {
+    fn wait_on_external_change() {
         let mut world = World::new();
-        world.insert_resource(Executor::new());
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
         world.insert_resource(Time::new(Instant::now()));
+
+        let e = world.spawn(ExampleComponent(0)).id();
+        let a = Arc::new(Mutex::new(0));
+        let b = Arc::clone(&a);
+
+        coroutine(move |fib: Fib, ex: R<ExampleComponent>| async move {
+            fib.next_tick().await;
+            ex.on_change().await;
+            *b.lock().unwrap() += 1;
+        }).apply(e, &mut world);
+
         world.resource_scope(|w, mut executor: Mut<Executor>| {
-            let e = w.spawn(ExampleComponent(0)).id();
-            let a = Arc::new(Mutex::new(0));
-            let b = Arc::clone(&a);
-            executor.add(move |mut fib| async move {
-                fib.next_tick().await;
-                fib.change::<ExampleComponent>(e).await;
-                *b.lock().unwrap() += 1;
-            });
+            w.clear_trackers();
             executor.tick(w);
             assert_eq!(*a.lock().unwrap(), 0);
-            w.clear_trackers();
             executor.tick(w);
             assert_eq!(*a.lock().unwrap(), 0);
             executor.tick(w);
@@ -122,314 +141,317 @@ mod tests {
             std::future::pending::<()>().await;
         }
         let mut world = World::new();
-        world.insert_resource(Executor::new());
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
         world.insert_resource(Time::new(Instant::now()));
+
+        coroutine(|| async move {
+            external_future().await;
+        }).apply(world.spawn_empty().id(), &mut world);
+
         world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(move |_| async move {
-                external_future().await;
-            });
             executor.tick(w);
         });
     }
 
-    #[test]
-    fn waiting_on_par_or() {
-        let mut world = World::new();
-        world.insert_resource(Executor::new());
-        world.insert_resource(Time::new(Instant::now()));
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            let a = Arc::new(Mutex::new(0));
-            let b = Arc::clone(&a);
-            executor.add(move |mut fib| async move {
-                fib.par_or(|mut fib| async move {
-                    loop {
-                        fib.next_tick().await;
-                        *b.lock().unwrap() += 1;
-                    }
-                })
-                .with(|mut fib| async move {
-                    for _ in 0..4 {
-                        fib.next_tick().await;
-                    }
-                })
-                .await;
-            });
-
-            for i in 0..5 {
-                // Note that it works because the coroutine on the the top of the par_or,
-                // has priority over the one on the bottom, meaning its side effect will be
-                // seen on the last iteration. (Okay I just kind of gave)
-                executor.tick(w);
-                assert_eq!(*a.lock().unwrap(), i);
-            }
-        });
-    }
+    //#[test]
+    //fn waiting_on_par_or() {
+    //    let mut world = World::new();
+    //    world.insert_resource(Executor::new());
+    //    world.insert_resource(Time::new(Instant::now()));
+    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
+    //        let a = Arc::new(Mutex::new(0));
+    //        let b = Arc::clone(&a);
+    //        executor.add(move |mut fib| async move {
+    //            fib.par_or(|mut fib| async move {
+    //                loop {
+    //                    fib.next_tick().await;
+    //                    *b.lock().unwrap() += 1;
+    //                }
+    //            })
+    //            .with(|mut fib| async move {
+    //                for _ in 0..4 {
+    //                    fib.next_tick().await;
+    //                }
+    //            })
+    //            .await;
+    //        });
 
-    #[test]
-    fn waiting_on_par_and() {
-        let mut world = World::new();
-        world.insert_resource(Executor::new());
-        world.insert_resource(Time::new(Instant::now()));
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            let a = Arc::new(Mutex::new(0));
-            let b = Arc::clone(&a);
-            let c = Arc::clone(&a);
-            executor.add(move |mut fib| async move {
-                fib.par_and(|mut fib| async move {
-                    fib.next_tick().await;
-                    *b.lock().unwrap() += 1;
-                })
-                .with(|mut fib| async move {
-                    for _ in 0..2 {
-                        fib.next_tick().await;
-                        *c.lock().unwrap() += 1;
-                    }
-                })
-                .await;
-            });
+    //        for i in 0..5 {
+    //            // Note that it works because the coroutine on the the top of the par_or,
+    //            // has priority over the one on the bottom, meaning its side effect will be
+    //            // seen on the last iteration. (Okay I just kind of gave)
+    //            executor.tick(w);
+    //            assert_eq!(*a.lock().unwrap(), i);
+    //        }
+    //    });
+    //}
 
-            executor.tick(w);
-            assert_eq!(*a.lock().unwrap(), 0);
-            executor.tick(w);
-            assert_eq!(*a.lock().unwrap(), 2);
-            executor.tick(w);
-            assert_eq!(*a.lock().unwrap(), 3);
-            executor.tick(w);
-            assert_eq!(*a.lock().unwrap(), 3);
-        });
-    }
+    //#[test]
+    //fn waiting_on_par_and() {
+    //    let mut world = World::new();
+    //    world.insert_resource(Executor::new());
+    //    world.insert_resource(Time::new(Instant::now()));
+    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
+    //        let a = Arc::new(Mutex::new(0));
+    //        let b = Arc::clone(&a);
+    //        let c = Arc::clone(&a);
+    //        executor.add(move |mut fib| async move {
+    //            fib.par_and(|mut fib| async move {
+    //                fib.next_tick().await;
+    //                *b.lock().unwrap() += 1;
+    //            })
+    //            .with(|mut fib| async move {
+    //                for _ in 0..2 {
+    //                    fib.next_tick().await;
+    //                    *c.lock().unwrap() += 1;
+    //                }
+    //            })
+    //            .await;
+    //        });
 
-    #[test]
-    fn reading_components() {
-        let mut world = World::new();
-        world.insert_resource(Executor::new());
-        world.insert_resource(Time::new(Instant::now()));
-        let e = world.spawn(ExampleComponent(0)).id();
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(move |mut fib| async move {
-                for i in 0..5 {
-                    let (_, example) = fib.next_tick().then_grab::<&ExampleComponent>(e).await;
-                    assert_eq!(example.0, i);
-                }
-            });
-            executor.tick(w);
-            for _ in 0..5 {
-                executor.tick(w);
-                w.entity_mut(e).get_mut::<ExampleComponent>().unwrap().0 += 1;
-            }
-        });
-    }
+    //        executor.tick(w);
+    //        assert_eq!(*a.lock().unwrap(), 0);
+    //        executor.tick(w);
+    //        assert_eq!(*a.lock().unwrap(), 2);
+    //        executor.tick(w);
+    //        assert_eq!(*a.lock().unwrap(), 3);
+    //        executor.tick(w);
+    //        assert_eq!(*a.lock().unwrap(), 3);
+    //    });
+    //}
 
-    #[test]
-    fn writing_components() {
-        let mut world = World::new();
-        world.insert_resource(Executor::new());
-        world.insert_resource(Time::new(Instant::now()));
-        let e = world.spawn(ExampleComponent(0)).id();
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-                    example.0 += 1;
-                }
-            });
-            for i in 0..5 {
-                executor.tick(w);
-                assert_eq!(w.entity_mut(e).get::<ExampleComponent>().unwrap().0, i)
-            }
-        });
-    }
+    //#[test]
+    //fn reading_components() {
+    //    let mut world = World::new();
+    //    world.insert_resource(Executor::new());
+    //    world.insert_resource(Time::new(Instant::now()));
+    //    let e = world.spawn(ExampleComponent(0)).id();
+    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
+    //        executor.add(move |mut fib| async move {
+    //            for i in 0..5 {
+    //                let (_, example) = fib.next_tick().then_grab::<&ExampleComponent>(e).await;
+    //                assert_eq!(example.0, i);
+    //            }
+    //        });
+    //        executor.tick(w);
+    //        for _ in 0..5 {
+    //            executor.tick(w);
+    //            w.entity_mut(e).get_mut::<ExampleComponent>().unwrap().0 += 1;
+    //        }
+    //    });
+    //}
 
-    #[test]
-    fn waiting_on_internal_change() {
-        let mut world = World::new();
-        world.insert_resource(Executor::new());
-        world.insert_resource(Time::new(Instant::now()));
-        let e = world.spawn(ExampleComponent(0)).id();
-        let a = Arc::new(Mutex::new(0));
-        let b = Arc::clone(&a);
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-                    example.0 += 1;
-                }
-            });
-            executor.add(|mut fib| async move {
-                loop {
-                    fib.change::<ExampleComponent>(e).await;
-                    *a.lock().unwrap() += 1;
-                }
-            });
-
-            for i in 0..5 {
-                executor.tick(w);
-                assert_eq!(*b.lock().unwrap(), i);
-                w.clear_trackers();
-            }
-        });
-    }
+    //#[test]
+    //fn writing_components() {
+    //    let mut world = World::new();
+    //    world.insert_resource(Executor::new());
+    //    world.insert_resource(Time::new(Instant::now()));
+    //    let e = world.spawn(ExampleComponent(0)).id();
+    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
+    //        executor.add(move |mut fib| async move {
+    //            for _ in 0..5 {
+    //                let (_, mut example) =
+    //                    fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
+    //                example.0 += 1;
+    //            }
+    //        });
+    //        for i in 0..5 {
+    //            executor.tick(w);
+    //            assert_eq!(w.entity_mut(e).get::<ExampleComponent>().unwrap().0, i)
+    //        }
+    //    });
+    //}
 
-    #[test]
-    fn multiple_write_dont_override_too_soon() {
-        let mut world = World::new();
-        world.insert_resource(Executor::new());
-        world.insert_resource(Time::new(Instant::now()));
-        let e = world.spawn(ExampleComponent(0)).id();
-        let a = Arc::new(Mutex::new(0));
-        let b = Arc::clone(&a);
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-                    example.0 += 1;
-                }
-            });
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-                    example.0 += 1;
-                }
-            });
-            executor.add(|mut fib| async move {
-                loop {
-                    fib.change::<ExampleComponent>(e).await;
-                    *a.lock().unwrap() += 1;
-                }
-            });
-
-            for i in 0..5 {
-                executor.tick(w);
-                assert_eq!(*b.lock().unwrap(), i * 2);
-                w.clear_trackers();
-            }
-        });
-    }
+    //#[test]
+    //fn waiting_on_internal_change() {
+    //    let mut world = World::new();
+    //    world.insert_resource(Executor::new());
+    //    world.insert_resource(Time::new(Instant::now()));
+    //    let e = world.spawn(ExampleComponent(0)).id();
+    //    let a = Arc::new(Mutex::new(0));
+    //    let b = Arc::clone(&a);
+    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
+    //        executor.add(move |mut fib| async move {
+    //            for _ in 0..5 {
+    //                let (_, mut example) =
+    //                    fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
+    //                example.0 += 1;
+    //            }
+    //        });
+    //        executor.add(|mut fib| async move {
+    //            loop {
+    //                fib.change::<ExampleComponent>(e).await;
+    //                *a.lock().unwrap() += 1;
+    //            }
+    //        });
 
-    #[test]
-    fn waiting_on_internal_change_do_not_consume_twice_events() {
-        let mut world = World::new();
-        world.insert_resource(Executor::new());
-        world.insert_resource(Time::new(Instant::now()));
-        let e1 = world.spawn(ExampleComponent(0)).id();
-        let e2 = world.spawn(ExampleComponent(0)).id();
-        let a = Arc::new(Mutex::new(0));
-        let b = Arc::clone(&a);
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e1).await;
-                    example.0 += 1;
-                }
-            });
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e2).await;
-                    example.0 += 1;
-                }
-            });
-            executor.add(|mut fib| async move {
-                loop {
-                    fib.change::<ExampleComponent>(e1).await;
-                    *a.lock().unwrap() += 1;
-                    fib.change::<ExampleComponent>(e2).await;
-                    *a.lock().unwrap() += 1;
-                }
-            });
-
-            for i in 0..5 {
-                executor.tick(w);
-                assert_eq!(*b.lock().unwrap(), i * 2);
-                w.clear_trackers();
-            }
-        });
-    }
+    //        for i in 0..5 {
+    //            executor.tick(w);
+    //            assert_eq!(*b.lock().unwrap(), i);
+    //            w.clear_trackers();
+    //        }
+    //    });
+    //}
 
-    #[test]
-    fn not_writing_to_mut_component_has_no_effect() {
-        let mut world = World::new();
-        world.insert_resource(Executor::new());
-        world.insert_resource(Time::new(Instant::now()));
-        let e = world.spawn(ExampleComponent(0)).id();
-        let a = Arc::new(Mutex::new(0));
-        let b = Arc::clone(&a);
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-                    example.0 += 1;
-                }
-            });
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-                    if false {
-                        example.0 += 1;
-                    }
-                }
-            });
-            executor.add(|mut fib| async move {
-                loop {
-                    fib.change::<ExampleComponent>(e).await;
-                    *a.lock().unwrap() += 1;
-                }
-            });
-
-            for i in 0..5 {
-                executor.tick(w);
-                assert_eq!(*b.lock().unwrap(), i);
-                w.clear_trackers();
-            }
-        });
-    }
+    ////#[test]
+    ////fn multiple_write_dont_override_too_soon() {
+    ////    let mut world = World::new();
+    ////    world.insert_resource(Executor::new());
+    ////    world.insert_resource(Time::new(Instant::now()));
+    ////    let e = world.spawn(ExampleComponent(0)).id();
+    ////    let a = Arc::new(Mutex::new(0));
+    ////    let b = Arc::clone(&a);
+    ////    world.resource_scope(|w, mut executor: Mut<Executor>| {
+    ////        executor.add(move |mut fib| async move {
+    ////            for _ in 0..5 {
+    ////                let (_, mut example) =
+    ////                    fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
+    ////                example.0 += 1;
+    ////            }
+    ////        });
+    ////        executor.add(move |mut fib| async move {
+    ////            for _ in 0..5 {
+    ////                let (_, mut example) =
+    ////                    fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
+    ////                example.0 += 1;
+    ////            }
+    ////        });
+    ////        executor.add(|mut fib| async move {
+    ////            loop {
+    ////                fib.change::<ExampleComponent>(e).await;
+    ////                *a.lock().unwrap() += 1;
+    ////            }
+    ////        });
 
-    #[test]
-    fn waiting_on_internal_and_external_change_is_correct() {
-        let mut world = World::new();
-        world.insert_resource(Executor::new());
-        world.insert_resource(Time::new(Instant::now()));
-        let e = world.spawn(ExampleComponent(0)).id();
-        let a = Arc::new(Mutex::new(0));
-        let b = Arc::clone(&a);
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-                    example.0 += 1;
-                }
-            });
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-
-                    if false {
-                        example.0 += 1;
-                    }
-                }
-            });
-            executor.add(|mut fib| async move {
-                loop {
-                    fib.change::<ExampleComponent>(e).await;
-                    *a.lock().unwrap() += 1;
-                }
-            });
-
-            for i in 0..5 {
-                w.entity_mut(e).get_mut::<ExampleComponent>().unwrap().0 += 1;
-                executor.tick(w);
-                assert_eq!(*b.lock().unwrap(), i * 2);
-                w.clear_trackers();
-            }
-        });
-    }
+    ////        for i in 0..5 {
+    ////            executor.tick(w);
+    ////            assert_eq!(*b.lock().unwrap(), i * 2);
+    ////            w.clear_trackers();
+    ////        }
+    ////    });
+    ////}
+
+    //#[test]
+    //fn waiting_on_internal_change_do_not_consume_twice_events() {
+    //    let mut world = World::new();
+    //    world.insert_resource(Executor::new());
+    //    world.insert_resource(Time::new(Instant::now()));
+    //    let e1 = world.spawn(ExampleComponent(0)).id();
+    //    let e2 = world.spawn(ExampleComponent(0)).id();
+    //    let a = Arc::new(Mutex::new(0));
+    //    let b = Arc::clone(&a);
+    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
+    //        executor.add(move |mut fib| async move {
+    //            for _ in 0..5 {
+    //                let (_, mut example) =
+    //                    fib.next_tick().then_grab::<&mut ExampleComponent>(e1).await;
+    //                example.0 += 1;
+    //            }
+    //        });
+    //        executor.add(move |mut fib| async move {
+    //            for _ in 0..5 {
+    //                let (_, mut example) =
+    //                    fib.next_tick().then_grab::<&mut ExampleComponent>(e2).await;
+    //                example.0 += 1;
+    //            }
+    //        });
+    //        executor.add(|mut fib| async move {
+    //            loop {
+    //                fib.change::<ExampleComponent>(e1).await;
+    //                *a.lock().unwrap() += 1;
+    //                fib.change::<ExampleComponent>(e2).await;
+    //                *a.lock().unwrap() += 1;
+    //            }
+    //        });
+
+    //        for i in 0..5 {
+    //            executor.tick(w);
+    //            assert_eq!(*b.lock().unwrap(), i * 2);
+    //            w.clear_trackers();
+    //        }
+    //    });
+    //}
+
+    //#[test]
+    //fn not_writing_to_mut_component_has_no_effect() {
+    //    let mut world = World::new();
+    //    world.insert_resource(Executor::new());
+    //    world.insert_resource(Time::new(Instant::now()));
+    //    let e = world.spawn(ExampleComponent(0)).id();
+    //    let a = Arc::new(Mutex::new(0));
+    //    let b = Arc::clone(&a);
+    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
+    //        executor.add(move |mut fib| async move {
+    //            for _ in 0..5 {
+    //                let (_, mut example) =
+    //                    fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
+    //                example.0 += 1;
+    //            }
+    //        });
+    //        executor.add(move |mut fib| async move {
+    //            for _ in 0..5 {
+    //                let (_, mut example) =
+    //                    fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
+    //                if false {
+    //                    example.0 += 1;
+    //                }
+    //            }
+    //        });
+    //        executor.add(|mut fib| async move {
+    //            loop {
+    //                fib.change::<ExampleComponent>(e).await;
+    //                *a.lock().unwrap() += 1;
+    //            }
+    //        });
+
+    //        for i in 0..5 {
+    //            executor.tick(w);
+    //            assert_eq!(*b.lock().unwrap(), i);
+    //            w.clear_trackers();
+    //        }
+    //    });
+    //}
+
+    //#[test]
+    //fn waiting_on_internal_and_external_change_is_correct() {
+    //    let mut world = World::new();
+    //    world.insert_resource(Executor::new());
+    //    world.insert_resource(Time::new(Instant::now()));
+    //    let e = world.spawn(ExampleComponent(0)).id();
+    //    let a = Arc::new(Mutex::new(0));
+    //    let b = Arc::clone(&a);
+    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
+    //        executor.add(move |mut fib| async move {
+    //            for _ in 0..5 {
+    //                let (_, mut example) =
+    //                    fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
+    //                example.0 += 1;
+    //            }
+    //        });
+    //        executor.add(move |mut fib| async move {
+    //            for _ in 0..5 {
+    //                let (_, mut example) =
+    //                    fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
+
+    //                if false {
+    //                    example.0 += 1;
+    //                }
+    //            }
+    //        });
+    //        executor.add(|mut fib| async move {
+    //            loop {
+    //                fib.change::<ExampleComponent>(e).await;
+    //                *a.lock().unwrap() += 1;
+    //            }
+    //        });
+
+    //        for i in 0..5 {
+    //            w.entity_mut(e).get_mut::<ExampleComponent>().unwrap().0 += 1;
+    //            executor.tick(w);
+    //            assert_eq!(*b.lock().unwrap(), i * 2);
+    //            w.clear_trackers();
+    //        }
+    //    });
+    //}
 }
diff --git a/src/plugin.rs b/src/plugin.rs
new file mode 100644
index 0000000..1d72ddd
--- /dev/null
+++ b/src/plugin.rs
@@ -0,0 +1,19 @@
+use bevy::prelude::{Plugin, Update, World, Mut};
+
+use crate::{coroutine::CoroWrites, prelude::Executor};
+
+pub struct CorentinPlugin;
+
+impl Plugin for CorentinPlugin {
+    fn build(&self, app: &mut bevy::prelude::App) {
+        app.init_resource::<Executor>()
+            .init_resource::<CoroWrites>()
+            .add_systems(Update, run_coroutines);
+    }
+}
+
+fn run_coroutines(world: &mut World) {
+    world.resource_scope(|w, mut exec: Mut<Executor>| {
+        exec.tick(w);
+    })
+}

From 7724b6cedd08b51456e0384b9205886b3539ae90 Mon Sep 17 00:00:00 2001
From: Zacharie Tevaearai <zacharie.tevaearai@epfl.ch>
Date: Tue, 26 Sep 2023 17:18:50 +0200
Subject: [PATCH 02/11] run clippy

---
 examples/basic.rs                   |  2 +-
 src/coroutine/coro_param.rs         | 10 +++++-----
 src/coroutine/function_coroutine.rs |  4 ++--
 src/coroutine/observable.rs         |  5 ++---
 src/coroutine/par_and.rs            |  4 ++--
 src/executor/run_ctx.rs             |  4 ++--
 src/lib.rs                          |  1 -
 src/waker.rs                        | 15 ---------------
 8 files changed, 14 insertions(+), 31 deletions(-)
 delete mode 100644 src/waker.rs

diff --git a/examples/basic.rs b/examples/basic.rs
index f45f587..163c7e9 100644
--- a/examples/basic.rs
+++ b/examples/basic.rs
@@ -1,4 +1,4 @@
-use std::time::Duration;
+
 
 use bevy::{prelude::*, sprite::MaterialMesh2dBundle};
 use corentin::prelude::*;
diff --git a/src/coroutine/coro_param.rs b/src/coroutine/coro_param.rs
index dad14eb..d480b4b 100644
--- a/src/coroutine/coro_param.rs
+++ b/src/coroutine/coro_param.rs
@@ -36,7 +36,7 @@ pub struct WorldWindow(pub(crate) Rc<Cell<*mut World>>);
 unsafe impl Send for WorldWindow {}
 
 impl WorldWindow {
-    /// #Safety
+    /// # Safety
     /// The caller must ensure that the pointer points to a valid value. (the window should be
     /// "open").
     pub unsafe fn world_cell(&self) -> UnsafeWorldCell<'_> {
@@ -45,7 +45,7 @@ impl WorldWindow {
 
     /// Return the appropriate ComponentId, and initialize it if not present in the world
     ///
-    /// #Safety
+    /// # Safety
     /// The caller must ensure that the pointer points to a valid value. (the window should be
     /// "open"). And that it is called with exclusive world.
     pub unsafe fn component_id<T: Component>(&self) -> ComponentId {
@@ -113,7 +113,7 @@ impl<'a, T: Component> Deref for InGuard<'a, T> {
 }
 
 impl<T: Component> R<T> {
-    pub fn get<'a>(&'a self) -> InGuard<'a, T> {
+    pub fn get(&self) -> InGuard<'_, T> {
         unsafe {
             InGuard {
                 value: self
@@ -167,7 +167,7 @@ impl<'a, T: Component> DerefMut for InOutGuard<'a, T> {
 }
 
 impl<T: Component> W<T> {
-    pub fn get<'a>(&'a self) -> InGuard<'a, T> {
+    pub fn get(&self) -> InGuard<'_, T> {
         let value = unsafe {
             self.context.world_window
                 .world_cell()
@@ -183,7 +183,7 @@ impl<T: Component> W<T> {
         }
     }
 
-    pub fn get_mut<'a>(&'a mut self) -> InOutGuard<'a, T> {
+    pub fn get_mut(&mut self) -> InOutGuard<'_, T> {
         unsafe {
             let cell = self.context.world_window.world_cell();
             let c_id = cell.components().component_id::<T>().unwrap();
diff --git a/src/coroutine/function_coroutine.rs b/src/coroutine/function_coroutine.rs
index a27c60e..08f9995 100644
--- a/src/coroutine/function_coroutine.rs
+++ b/src/coroutine/function_coroutine.rs
@@ -1,8 +1,8 @@
-use std::marker::PhantomData;
+
 use std::time::Duration;
 use std::{cell::Cell, rc::Rc};
 
-use bevy::prelude::{Entity, Component};
+use bevy::prelude::{Entity};
 use bevy::prelude::World;
 use bevy::utils::all_tuples;
 use bevy::utils::synccell::SyncCell;
diff --git a/src/coroutine/observable.rs b/src/coroutine/observable.rs
index 53befc3..7f5ad00 100644
--- a/src/coroutine/observable.rs
+++ b/src/coroutine/observable.rs
@@ -1,16 +1,15 @@
 use std::{
     future::Future,
-    marker::PhantomData,
     pin::Pin,
     task::{Context, Poll},
 };
 
 use bevy::{
     ecs::component::ComponentId,
-    prelude::{Component, Entity, Mut, World},
+    prelude::{Entity},
 };
 
-use crate::{coroutine::WaitingReason, prelude::Fib, executor::msg_channel::Sender};
+use crate::{coroutine::WaitingReason};
 
 use super::{CoroState, coro_param::ParamContext};
 
diff --git a/src/coroutine/par_and.rs b/src/coroutine/par_and.rs
index 03459fc..1d38f76 100644
--- a/src/coroutine/par_and.rs
+++ b/src/coroutine/par_and.rs
@@ -8,8 +8,8 @@ use std::pin::Pin;
 use std::task::Context;
 use std::task::Poll;
 
-use super::IntoCoroutine;
-use super::{CoroObject, Coroutine, UninitCoroutine};
+
+use super::{CoroObject, UninitCoroutine};
 
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct ParAnd<'a> {
diff --git a/src/executor/run_ctx.rs b/src/executor/run_ctx.rs
index bf12d36..69b850f 100644
--- a/src/executor/run_ctx.rs
+++ b/src/executor/run_ctx.rs
@@ -1,8 +1,8 @@
-use std::collections::VecDeque;
+
 
 use bevy::{
     ecs::component::ComponentId,
-    prelude::{Entity, Resource},
+    prelude::{Entity},
     utils::HashMap,
 };
 use tinyset::SetUsize;
diff --git a/src/lib.rs b/src/lib.rs
index e3d1f64..adf72d6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -6,7 +6,6 @@ pub mod executor;
 
 mod commands;
 mod plugin;
-mod waker;
 mod world_window;
 
 pub mod prelude {
diff --git a/src/waker.rs b/src/waker.rs
deleted file mode 100644
index 631cd30..0000000
--- a/src/waker.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-use std::task::{RawWaker, RawWakerVTable, Waker};
-
-pub fn create() -> Waker {
-    // Safety: The waker points to a vtable with functions that do nothing. Doing
-    // nothing is memory-safe.
-    unsafe { Waker::from_raw(RAW_WAKER) }
-}
-
-const RAW_WAKER: RawWaker = RawWaker::new(std::ptr::null(), &VTABLE);
-const VTABLE: RawWakerVTable = RawWakerVTable::new(clone, do_nothing, do_nothing, do_nothing);
-
-unsafe fn clone(_: *const ()) -> RawWaker {
-    RAW_WAKER
-}
-unsafe fn do_nothing(_: *const ()) {}

From 07766019acda8cba91f275fc46eb1dea9709ce2d Mon Sep 17 00:00:00 2001
From: Zacharie Tevaearai <zacharie.tevaearai@epfl.ch>
Date: Tue, 26 Sep 2023 17:19:14 +0200
Subject: [PATCH 03/11] run fmt

---
 examples/basic.rs                   | 16 ++++++++--------
 src/coroutine/coro_param.rs         | 11 ++++++++---
 src/coroutine/function_coroutine.rs |  9 +++++----
 src/coroutine/mod.rs                | 22 +++++++++-------------
 src/coroutine/observable.rs         | 16 +++++++---------
 src/coroutine/par_and.rs            |  1 -
 src/executor/run_ctx.rs             |  8 +-------
 src/lib.rs                          |  6 ++++--
 src/plugin.rs                       |  2 +-
 9 files changed, 43 insertions(+), 48 deletions(-)

diff --git a/examples/basic.rs b/examples/basic.rs
index 163c7e9..4808d4e 100644
--- a/examples/basic.rs
+++ b/examples/basic.rs
@@ -1,5 +1,3 @@
-
-
 use bevy::{prelude::*, sprite::MaterialMesh2dBundle};
 use corentin::prelude::*;
 
@@ -25,10 +23,12 @@ fn setup_scene(
             transform: Transform::from_translation(Vec3::new(-150., 0., 0.)),
             ..default()
         })
-        .add(coroutine(|fib: Fib, mut transform: W<Transform>| async move {
-            loop {
-                let dt = fib.next_tick().await;
-                transform.get_mut().translation.x += 100.0 * dt.as_secs_f32();
-            }
-        }));
+        .add(coroutine(
+            |fib: Fib, mut transform: W<Transform>| async move {
+                loop {
+                    let dt = fib.next_tick().await;
+                    transform.get_mut().translation.x += 100.0 * dt.as_secs_f32();
+                }
+            },
+        ));
 }
diff --git a/src/coroutine/coro_param.rs b/src/coroutine/coro_param.rs
index d480b4b..a5ffe82 100644
--- a/src/coroutine/coro_param.rs
+++ b/src/coroutine/coro_param.rs
@@ -169,7 +169,8 @@ impl<'a, T: Component> DerefMut for InOutGuard<'a, T> {
 impl<T: Component> W<T> {
     pub fn get(&self) -> InGuard<'_, T> {
         let value = unsafe {
-            self.context.world_window
+            self.context
+                .world_window
                 .world_cell()
                 .get_entity(self.context.owner)
                 .unwrap()
@@ -192,7 +193,11 @@ impl<T: Component> W<T> {
                 .0
                 .push_back((self.context.owner, c_id));
 
-            let value = cell.get_entity(self.context.owner).unwrap().get_mut::<T>().unwrap();
+            let value = cell
+                .get_entity(self.context.owner)
+                .unwrap()
+                .get_mut::<T>()
+                .unwrap();
             InOutGuard {
                 value,
                 _phantom: PhantomData,
@@ -232,7 +237,7 @@ impl<T: Component> CoroParam for W<T> {
 
 // TODO: Later
 //impl<T: Component> CoroParam for Option<R<T>> {
-//    
+//
 //}
 
 macro_rules! impl_coro_param {
diff --git a/src/coroutine/function_coroutine.rs b/src/coroutine/function_coroutine.rs
index 08f9995..7df5fb1 100644
--- a/src/coroutine/function_coroutine.rs
+++ b/src/coroutine/function_coroutine.rs
@@ -1,8 +1,7 @@
-
 use std::time::Duration;
 use std::{cell::Cell, rc::Rc};
 
-use bevy::prelude::{Entity};
+use bevy::prelude::Entity;
 use bevy::prelude::World;
 use bevy::utils::all_tuples;
 use bevy::utils::synccell::SyncCell;
@@ -150,7 +149,8 @@ impl Fib {
     {
         // Safety: We are getting polled right now, therefore we have exclusive world access.
         unsafe {
-            if let Some(c) = coro.init(self.meta.owner, self.world_window.world_cell().world_mut()) {
+            if let Some(c) = coro.init(self.meta.owner, self.world_window.world_cell().world_mut())
+            {
                 return ParOr::new(self, vec![SyncCell::new(Box::pin(c))]);
             }
         }
@@ -164,7 +164,8 @@ impl Fib {
     {
         // Safety: We are getting polled right now, therefore we have exclusive world access.
         unsafe {
-            if let Some(c) = coro.init(self.meta.owner, self.world_window.world_cell().world_mut()) {
+            if let Some(c) = coro.init(self.meta.owner, self.world_window.world_cell().world_mut())
+            {
                 return ParAnd::new(self, vec![SyncCell::new(Box::pin(c))]);
             }
         }
diff --git a/src/coroutine/mod.rs b/src/coroutine/mod.rs
index 0d58cb0..ab43498 100644
--- a/src/coroutine/mod.rs
+++ b/src/coroutine/mod.rs
@@ -11,16 +11,15 @@ use tinyset::SetUsize;
 
 use self::observable::ObservableId;
 
-
-pub mod duration;
 pub mod coro_param;
+pub mod duration;
 pub mod function_coroutine;
 pub mod observable;
 pub mod on;
 pub mod par_and;
 pub mod par_or;
-mod when;
 mod waker;
+mod when;
 
 /// A coroutine that can be added to an [`Entity`](bevy::prelude::Entity)
 ///
@@ -43,7 +42,6 @@ pub(crate) struct CoroWrites(pub VecDeque<(Entity, ComponentId)>);
 /// A heap allocated Coroutine
 pub(crate) type CoroObject = SyncCell<Pin<Box<dyn Coroutine>>>;
 
-
 /// Metadata of a coroutine
 ///
 /// This includes
@@ -57,7 +55,11 @@ pub struct CoroMeta {
 
 impl CoroMeta {
     pub fn new(owner: Entity) -> Self {
-        Self {  owner, this_reads: SetUsize::default(), this_writes: SetUsize::default() }
+        Self {
+            owner,
+            this_reads: SetUsize::default(),
+            this_writes: SetUsize::default(),
+        }
     }
 
     /// Check if the values captured by the coroutine still exists.
@@ -82,7 +84,6 @@ impl CoroMeta {
     }
 }
 
-
 /// The result after resuming a `Coroutine`. Either it yields an intermediate value, or return the
 /// final result.
 pub enum CoroutineResult<Y, R> {
@@ -108,19 +109,14 @@ pub trait UninitCoroutine<Marker> {
     fn init(self, owner: Entity, world: &mut World) -> Option<Self::Coroutine>;
 }
 
-
 /// A [`Coroutine`] can only yield one of these messages Used by the [`Executor`] to know when to
 /// resume a coroutine.
 pub enum WaitingReason {
     Tick,
     Duration(Timer),
     Changed(ObservableId),
-    ParOr {
-        coroutines: Vec<CoroObject>,
-    },
-    ParAnd {
-        coroutines: Vec<CoroObject>,
-    },
+    ParOr { coroutines: Vec<CoroObject> },
+    ParAnd { coroutines: Vec<CoroObject> },
 }
 
 // TODO put that somewhere else
diff --git a/src/coroutine/observable.rs b/src/coroutine/observable.rs
index 7f5ad00..341d41d 100644
--- a/src/coroutine/observable.rs
+++ b/src/coroutine/observable.rs
@@ -4,14 +4,11 @@ use std::{
     task::{Context, Poll},
 };
 
-use bevy::{
-    ecs::component::ComponentId,
-    prelude::{Entity},
-};
+use bevy::{ecs::component::ComponentId, prelude::Entity};
 
-use crate::{coroutine::WaitingReason};
+use crate::coroutine::WaitingReason;
 
-use super::{CoroState, coro_param::ParamContext};
+use super::{coro_param::ParamContext, CoroState};
 
 /// Anything we can observe in the world will have one specific id
 #[derive(Copy, Clone)]
@@ -25,10 +22,9 @@ pub enum ObservableId {
 pub struct OnChange<'a> {
     state: CoroState,
     id: ObservableId,
-    context: &'a ParamContext
+    context: &'a ParamContext,
 }
 
-
 impl<'a> OnChange<'a> {
     pub(crate) fn new(context: &'a ParamContext, id: ObservableId) -> Self {
         Self {
@@ -50,7 +46,9 @@ impl<'a> Future for OnChange<'a> {
             }
             CoroState::Running => {
                 self.state = CoroState::Halted;
-                self.context.yield_sender.send(WaitingReason::Changed(self.id));
+                self.context
+                    .yield_sender
+                    .send(WaitingReason::Changed(self.id));
                 Poll::Pending
             }
         }
diff --git a/src/coroutine/par_and.rs b/src/coroutine/par_and.rs
index 1d38f76..7c9ca74 100644
--- a/src/coroutine/par_and.rs
+++ b/src/coroutine/par_and.rs
@@ -8,7 +8,6 @@ use std::pin::Pin;
 use std::task::Context;
 use std::task::Poll;
 
-
 use super::{CoroObject, UninitCoroutine};
 
 #[must_use = "futures do nothing unless you `.await` or poll them"]
diff --git a/src/executor/run_ctx.rs b/src/executor/run_ctx.rs
index 69b850f..10c4827 100644
--- a/src/executor/run_ctx.rs
+++ b/src/executor/run_ctx.rs
@@ -1,10 +1,4 @@
-
-
-use bevy::{
-    ecs::component::ComponentId,
-    prelude::{Entity},
-    utils::HashMap,
-};
+use bevy::{ecs::component::ComponentId, prelude::Entity, utils::HashMap};
 use tinyset::SetUsize;
 
 use super::CoroId;
diff --git a/src/lib.rs b/src/lib.rs
index adf72d6..d265f14 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -115,7 +115,8 @@ mod tests {
             fib.next_tick().await;
             ex.on_change().await;
             *b.lock().unwrap() += 1;
-        }).apply(e, &mut world);
+        })
+        .apply(e, &mut world);
 
         world.resource_scope(|w, mut executor: Mut<Executor>| {
             w.clear_trackers();
@@ -146,7 +147,8 @@ mod tests {
 
         coroutine(|| async move {
             external_future().await;
-        }).apply(world.spawn_empty().id(), &mut world);
+        })
+        .apply(world.spawn_empty().id(), &mut world);
 
         world.resource_scope(|w, mut executor: Mut<Executor>| {
             executor.tick(w);
diff --git a/src/plugin.rs b/src/plugin.rs
index 1d72ddd..030ce3f 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -1,4 +1,4 @@
-use bevy::prelude::{Plugin, Update, World, Mut};
+use bevy::prelude::{Mut, Plugin, Update, World};
 
 use crate::{coroutine::CoroWrites, prelude::Executor};
 

From 1b357c8d501e03e5d2617c2d0dff66e1b1e34829 Mon Sep 17 00:00:00 2001
From: Zacharie Tevaearai <zacharie.tevaearai@epfl.ch>
Date: Tue, 26 Sep 2023 17:59:40 +0200
Subject: [PATCH 04/11] Improve is_valid

---
 src/coroutine/coro_param.rs         | 21 ++++++++++++
 src/coroutine/function_coroutine.rs |  5 +--
 src/coroutine/mod.rs                | 27 ++-------------
 src/coroutine/when.rs               | 53 -----------------------------
 src/executor/mod.rs                 |  9 ++---
 5 files changed, 29 insertions(+), 86 deletions(-)
 delete mode 100644 src/coroutine/when.rs

diff --git a/src/coroutine/coro_param.rs b/src/coroutine/coro_param.rs
index a5ffe82..1115127 100644
--- a/src/coroutine/coro_param.rs
+++ b/src/coroutine/coro_param.rs
@@ -25,6 +25,9 @@ pub trait CoroParam: Sized + Send + 'static {
     ///
     /// Note: `world_window` is not yet open at that point, `world` should be used instead.
     fn init(context: ParamContext, world: &mut World, meta: &mut CoroMeta) -> Option<Self>;
+
+    /// Returns true if the parameter is still valid.
+    fn is_valid(owner: Entity, world: &World) -> bool;
 }
 
 /// A shared ref to a [`World`], it is "open" (meaning it points to a valid world) when the
@@ -96,6 +99,13 @@ impl<T: Component> CoroParam for R<T> {
             _phantom: PhantomData,
         })
     }
+
+    fn is_valid(owner: Entity, world: &World) -> bool {
+        match world.get_entity(owner) {
+            Some(e) => e.contains::<T>(),
+            _ => false,
+        }
+    }
 }
 
 /// A guarded readonly reference, cannot be hold accros awaiting points.
@@ -233,6 +243,13 @@ impl<T: Component> CoroParam for W<T> {
             context,
         })
     }
+
+    fn is_valid(owner: Entity, world: &World) -> bool {
+        match world.get_entity(owner) {
+            Some(e) => e.contains::<T>(),
+            _ => false,
+        }
+    }
 }
 
 // TODO: Later
@@ -250,6 +267,10 @@ macro_rules! impl_coro_param {
                 Some(($($param,)*))
 
             }
+
+            fn is_valid(owner: Entity, world: &World) -> bool {
+                true $(&& $param::is_valid(owner, world))*
+            }
         }
 
     };
diff --git a/src/coroutine/function_coroutine.rs b/src/coroutine/function_coroutine.rs
index 7df5fb1..8c9d91b 100644
--- a/src/coroutine/function_coroutine.rs
+++ b/src/coroutine/function_coroutine.rs
@@ -64,8 +64,9 @@ where
         }
     }
 
-    fn meta(&self) -> &CoroMeta {
-        &self.meta
+    fn is_valid(self: Pin<&mut Self>, world: &World) -> bool {
+        //TODO validate the window as well
+        F::Params::is_valid(self.meta.owner, world)
     }
 }
 
diff --git a/src/coroutine/mod.rs b/src/coroutine/mod.rs
index ab43498..303512c 100644
--- a/src/coroutine/mod.rs
+++ b/src/coroutine/mod.rs
@@ -19,7 +19,6 @@ pub mod on;
 pub mod par_and;
 pub mod par_or;
 mod waker;
-mod when;
 
 /// A coroutine that can be added to an [`Entity`](bevy::prelude::Entity)
 ///
@@ -31,8 +30,9 @@ pub trait Coroutine: Send + 'static {
     /// has terminate execution will panic.
     fn resume(self: Pin<&mut Self>, world: &mut World) -> CoroutineResult<WaitingReason, ()>;
 
-    /// Return the metadata of this coroutine, including - ComponentAccess
-    fn meta(&self) -> &CoroMeta;
+    /// Return true, if this coroutine is still valid. If it is not, it should be despawned. Should
+    /// be called before [`resume`], to avoid any panic.
+    fn is_valid(self: Pin<&mut Self>, world: &World) -> bool;
 }
 
 /// A shared list of modified values (observable), to easily notify the apropriate observers.
@@ -61,27 +61,6 @@ impl CoroMeta {
             this_writes: SetUsize::default(),
         }
     }
-
-    /// Check if the values captured by the coroutine still exists.
-    pub(crate) fn is_valid(&self, world: &World) -> bool {
-        if !world.entities().contains(self.owner) {
-            return false;
-        }
-
-        let e = world.entity(self.owner);
-        for r in self.this_reads.iter() {
-            if !e.contains_id(ComponentId::new(r)) {
-                return false;
-            }
-        }
-        for w in self.this_writes.iter() {
-            if !e.contains_id(ComponentId::new(w)) {
-                return false;
-            }
-        }
-
-        true
-    }
 }
 
 /// The result after resuming a `Coroutine`. Either it yields an intermediate value, or return the
diff --git a/src/coroutine/when.rs b/src/coroutine/when.rs
deleted file mode 100644
index 0e7d17e..0000000
--- a/src/coroutine/when.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-//use bevy::prelude::Component;
-//use bevy::prelude::Entity;
-//
-//use crate::coroutine::{CoroState, WaitingReason};
-//
-//use std::future::Future;
-//use std::marker::PhantomData;
-//use std::pin::Pin;
-//use std::task::Context;
-//use std::task::Poll;
-//
-//
-//#[must_use = "futures do nothing unless you `.await` or poll them"]
-//pub struct Change<'a, T: Component> {
-//    fib: &'a Fib,
-//    from: Entity,
-//    _phantom: PhantomData<T>,
-//    state: CoroState,
-//}
-//
-//impl<'a, T: Component + Unpin> Change<'a, T> {
-//    pub(crate) fn new(fib: &'a Fib, from: Entity) -> Self {
-//        Change {
-//            fib,
-//            from,
-//            _phantom: PhantomData,
-//            state: CoroState::Running,
-//        }
-//    }
-//}
-//
-//impl<'a, T: Component + Unpin> Future for Change<'a, T> {
-//    type Output = ();
-//
-//    fn poll(mut self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
-//        match self.state {
-//            // We assume the executor will only poll it once the component changed
-//            CoroState::Halted => {
-//                self.state = CoroState::Running;
-//                Poll::Ready(())
-//            }
-//            CoroState::Running => {
-//                let c_id = self.fib.component_id::<T>();
-//                self.state = CoroState::Halted;
-//                self.fib.yield_sender.send(WaitingReason::Changed {
-//                    from: self.from,
-//                    component: c_id,
-//                });
-//                Poll::Pending
-//            }
-//        }
-//    }
-//}
diff --git a/src/executor/mod.rs b/src/executor/mod.rs
index b0421e1..85ba6b4 100644
--- a/src/executor/mod.rs
+++ b/src/executor/mod.rs
@@ -22,7 +22,6 @@ pub struct Executor {
     waiting_on_par_or: HashMap<CoroId, Vec<CoroId>>,
     waiting_on_par_and: HashMap<CoroId, Vec<CoroId>>,
     is_awaited_by: HashMap<CoroId, CoroId>,
-    own: HashMap<Entity, Vec<CoroId>>,
     next_id: CoroId,
 }
 
@@ -47,7 +46,6 @@ impl Executor {
             waiting_on_par_or: HashMap::new(),
             waiting_on_par_and: HashMap::new(),
             is_awaited_by: HashMap::new(),
-            own: HashMap::new(),
             next_id: 0,
         }
     }
@@ -60,12 +58,10 @@ impl Executor {
     }
 
     /// Add a coroutine to the executor.
-    pub fn add(&mut self, mut coroutine: CoroObject) {
+    pub fn add(&mut self, coroutine: CoroObject) {
         let id = self.next_id();
-        let owner = coroutine.get().meta().owner;
         self.coroutines.insert(id, coroutine);
         self.waiting_on_tick.push_back(id);
-        self.own.entry(owner).or_default().push(id);
     }
 
     /// Drop a coroutine from the executor.
@@ -160,8 +156,7 @@ impl Executor {
         }
 
         let coro = self.coroutines.get_mut(&coro_id).unwrap().get();
-        let meta = coro.meta().clone();
-        if !meta.is_valid(world) {
+        if !coro.as_mut().is_valid(world) {
             self.cancel(coro_id);
             return;
         }

From e1ddca02f96aed0af27784aed3eb77ec89f93ba8 Mon Sep 17 00:00:00 2001
From: Zacharie Tevaearai <zacharie.tevaearai@epfl.ch>
Date: Wed, 27 Sep 2023 09:36:10 +0200
Subject: [PATCH 05/11] Jsp

---
 examples/basic.rs                   |   2 +-
 examples/read_write.rs              |  27 ++---
 src/coroutine/coro_param.rs         | 169 +++++++++++++++++++++-------
 src/coroutine/duration.rs           |   5 +-
 src/coroutine/function_coroutine.rs |  59 +++++-----
 src/coroutine/observable.rs         |   2 +-
 src/coroutine/par_and.rs            |   5 +-
 src/coroutine/par_or.rs             |   5 +-
 src/executor/mod.rs                 |   5 +-
 src/executor/msg_channel.rs         |  50 --------
 src/lib.rs                          |   5 +-
 src/world_window.rs                 |  30 -----
 12 files changed, 176 insertions(+), 188 deletions(-)
 delete mode 100644 src/executor/msg_channel.rs
 delete mode 100644 src/world_window.rs

diff --git a/examples/basic.rs b/examples/basic.rs
index 4808d4e..e9ac0fa 100644
--- a/examples/basic.rs
+++ b/examples/basic.rs
@@ -24,7 +24,7 @@ fn setup_scene(
             ..default()
         })
         .add(coroutine(
-            |fib: Fib, mut transform: W<Transform>| async move {
+            |fib: Fib, mut transform: Wr<Transform>| async move {
                 loop {
                     let dt = fib.next_tick().await;
                     transform.get_mut().translation.x += 100.0 * dt.as_secs_f32();
diff --git a/examples/read_write.rs b/examples/read_write.rs
index 8822c9d..ae1a9b1 100644
--- a/examples/read_write.rs
+++ b/examples/read_write.rs
@@ -1,22 +1,11 @@
-//use std::time::Duration;
-//
-//use bevy::ecs::system::EntityCommand;
-//use bevy::prelude::*;
-//use corentin::{
-//    coroutine::coro_param::{R, W},
-//    prelude::*,
-//};
-//
-//#[derive(Component)]
-//struct IsClicked(u32);
-//
-//fn main() {
-//    App::new()
-//        .add_plugins((DefaultPlugins, CorentinPlugin))
-//        .add_systems(Startup, setup_access)
-//        .run();
-//}
-//
+
+fn main() {
+    //App::new()
+    //    .add_plugins((DefaultPlugins, CorentinPlugin))
+    //    .add_systems(Startup, setup_access)
+    //    .run();
+}
+
 //fn setup_scene(
 //    mut meshes: ResMut<Assets<Mesh>>,
 //    mut materials: ResMut<Assets<ColorMaterial>>,
diff --git a/src/coroutine/coro_param.rs b/src/coroutine/coro_param.rs
index 1115127..2614b6c 100644
--- a/src/coroutine/coro_param.rs
+++ b/src/coroutine/coro_param.rs
@@ -5,17 +5,16 @@ use std::{
     rc::Rc,
 };
 
-use crate::executor::msg_channel::Sender;
-
 use super::{
     observable::{ObservableId, OnChange},
-    CoroMeta, CoroWrites, WaitingReason,
+    CoroWrites, WaitingReason,
 };
 use bevy::{
     ecs::{component::ComponentId, world::unsafe_world_cell::UnsafeWorldCell},
     prelude::{Component, Entity, Mut, World},
     utils::all_tuples,
 };
+use tinyset::SetUsize;
 
 /// Any async function that takes only [`CoroParam`] as arguments can
 /// automatically be turned into a [`Coroutine`].
@@ -24,21 +23,43 @@ pub trait CoroParam: Sized + Send + 'static {
     /// conflicting accesses) it will return None.
     ///
     /// Note: `world_window` is not yet open at that point, `world` should be used instead.
-    fn init(context: ParamContext, world: &mut World, meta: &mut CoroMeta) -> Option<Self>;
+    fn init(context: ParamContext, world: &mut World, access: &mut CoroAccess) -> Option<Self>;
 
     /// Returns true if the parameter is still valid.
     fn is_valid(owner: Entity, world: &World) -> bool;
 }
 
-/// A shared ref to a [`World`], it is "open" (meaning it points to a valid world) when the
-/// Coroutine is resumed.
+#[derive(Default)]
+pub struct CoroAccess {
+    this_reads: SetUsize,
+    this_writes: SetUsize,
+    //others: HashMap<>
+}
+
+/// A shared ref to a [`World`], it is "open" (meaning it points to a valid world with exclusive
+/// access) when the Coroutine is resumed. It is shared to all [`CoroParam`]s.
 #[derive(Clone)]
-pub struct WorldWindow(pub(crate) Rc<Cell<*mut World>>);
+pub struct WorldWindow(Rc<Cell<*mut World>>);
 
-// Safety: The window is only shared whith the coroutine itself
+// Safety: The window is only shared whith the coroutine itself, As with other similar construct,
+// if you start spawning thread inside a coroutine, or sending coroutine parameters via channels,
+// you may break the safety, therefore please don't do that. (thanks UwU)
 unsafe impl Send for WorldWindow {}
 
 impl WorldWindow {
+    pub fn closed_window() -> Self {
+        WorldWindow(Rc::new(Cell::new(std::ptr::null_mut())))
+    }
+
+    pub fn scope<T>(&mut self, world: &mut World, f: impl FnOnce() -> T) -> T {
+        self.0.replace(world as *mut _);
+        let res = f();
+        self.0.replace(std::ptr::null_mut());
+        res
+    }
+
+    /// Returns the world as an [`UnsafeWorldCell`].
+    ///
     /// # Safety
     /// The caller must ensure that the pointer points to a valid value. (the window should be
     /// "open").
@@ -50,7 +71,7 @@ impl WorldWindow {
     ///
     /// # Safety
     /// The caller must ensure that the pointer points to a valid value. (the window should be
-    /// "open"). And that it is called with exclusive world.
+    /// "open").
     pub unsafe fn component_id<T: Component>(&self) -> ComponentId {
         let cell = self.world_cell();
         cell.components()
@@ -59,40 +80,61 @@ impl WorldWindow {
     }
 }
 
+/// The channel throught each [`CoroParam`] can yield back to the coroutine.
+/// Which can then return the reason to the caller (the [`Executor`]).
+#[derive(Default, Clone)]
+pub struct YieldChannel(Rc<Cell<Option<WaitingReason>>>);
+
+impl YieldChannel {
+    pub(crate) fn new() -> Self {
+        Self::default()
+    }
+
+    pub(crate) fn receive(&self) -> Option<WaitingReason> {
+        self.0.replace(None)
+    }
+
+    pub(crate) fn send(&self, val: WaitingReason) {
+        self.0.replace(Some(val));
+    }
+}
+
+
+// Safety: Same as [`WorldWindow`].
+unsafe impl Send for YieldChannel {}
+
 /// All relevent values a [`CoroParam`] might need.
 #[derive(Clone)]
 pub struct ParamContext {
     pub(crate) owner: Entity,
     pub(crate) world_window: WorldWindow,
-    pub(crate) yield_sender: Sender<WaitingReason>,
+    pub(crate) yield_channel: YieldChannel,
 }
 
 /// Safety ? Who knows...
 unsafe impl Send for ParamContext {}
 unsafe impl Sync for ParamContext {}
 
-/// A readonly reference to a [`Component`] from the owning [`Entity`]
+/// A readonly reference to a [`Component`] from the owning [`Entity`].
 ///
 /// Note that a Coroutine with such parameter will be canceled if the entity does not have the
 /// relevent component.
-pub struct R<T: Component> {
+pub struct Rd<T: Component> {
     context: ParamContext,
     _phantom: PhantomData<T>,
 }
 
-unsafe impl<T: Component> Send for R<T> {}
-
-impl<T: Component> CoroParam for R<T> {
-    fn init(context: ParamContext, world: &mut World, meta: &mut CoroMeta) -> Option<Self> {
+impl<T: Component> CoroParam for Rd<T> {
+    fn init(context: ParamContext, world: &mut World, access: &mut CoroAccess) -> Option<Self> {
         let id = world
             .component_id::<T>()
             .unwrap_or(world.init_component::<T>());
 
-        if meta.this_writes.contains(id.index()) {
+        if access.this_writes.contains(id.index()) {
             return None;
         }
 
-        meta.this_reads.insert(id.index());
+        access.this_reads.insert(id.index());
 
         Some(Self {
             context,
@@ -109,12 +151,12 @@ impl<T: Component> CoroParam for R<T> {
 }
 
 /// A guarded readonly reference, cannot be hold accros awaiting points.
-pub struct InGuard<'a, T> {
+pub struct RdGuard<'a, T> {
     value: &'a T,
     _phantom: PhantomData<*const T>,
 }
 
-impl<'a, T: Component> Deref for InGuard<'a, T> {
+impl<'a, T: Component> Deref for RdGuard<'a, T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
@@ -122,10 +164,12 @@ impl<'a, T: Component> Deref for InGuard<'a, T> {
     }
 }
 
-impl<T: Component> R<T> {
-    pub fn get(&self) -> InGuard<'_, T> {
+impl<T: Component> Rd<T> {
+    /// Return the current value of the [`Component`]. The result ([`InGuard`]) cannot be held
+    /// accros any await.
+    pub fn get(&self) -> RdGuard<'_, T> {
         unsafe {
-            InGuard {
+            RdGuard {
                 value: self
                     .context
                     .world_window
@@ -139,6 +183,10 @@ impl<T: Component> R<T> {
         }
     }
 
+    /// Yields and resume when the `Component` is mutated.
+    ///
+    /// Note that it integrates with the regular change detection of Bevy, meaning that the
+    /// coroutine will be resumed, if a [`System`] mutates the value.
     pub fn on_change(&self) -> OnChange<'_> {
         unsafe {
             OnChange::new(
@@ -152,17 +200,17 @@ impl<T: Component> R<T> {
     }
 }
 
-pub struct W<T: Component> {
+pub struct Wr<T: Component> {
     _phantom: PhantomData<T>,
     context: ParamContext,
 }
 
-pub struct InOutGuard<'a, T> {
+pub struct WrGuard<'a, T> {
     value: Mut<'a, T>,
     _phantom: PhantomData<*const T>,
 }
 
-impl<'a, T: Component> Deref for InOutGuard<'a, T> {
+impl<'a, T: Component> Deref for WrGuard<'a, T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
@@ -170,14 +218,14 @@ impl<'a, T: Component> Deref for InOutGuard<'a, T> {
     }
 }
 
-impl<'a, T: Component> DerefMut for InOutGuard<'a, T> {
+impl<'a, T: Component> DerefMut for WrGuard<'a, T> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         self.value.deref_mut()
     }
 }
 
-impl<T: Component> W<T> {
-    pub fn get(&self) -> InGuard<'_, T> {
+impl<T: Component> Wr<T> {
+    pub fn get(&self) -> RdGuard<'_, T> {
         let value = unsafe {
             self.context
                 .world_window
@@ -188,13 +236,13 @@ impl<T: Component> W<T> {
                 .unwrap()
         };
 
-        InGuard {
+        RdGuard {
             value,
             _phantom: PhantomData,
         }
     }
 
-    pub fn get_mut(&mut self) -> InOutGuard<'_, T> {
+    pub fn get_mut(&mut self) -> WrGuard<'_, T> {
         unsafe {
             let cell = self.context.world_window.world_cell();
             let c_id = cell.components().component_id::<T>().unwrap();
@@ -208,7 +256,7 @@ impl<T: Component> W<T> {
                 .unwrap()
                 .get_mut::<T>()
                 .unwrap();
-            InOutGuard {
+            WrGuard {
                 value,
                 _phantom: PhantomData,
             }
@@ -228,15 +276,15 @@ impl<T: Component> W<T> {
     }
 }
 
-impl<T: Component> CoroParam for W<T> {
-    fn init(context: ParamContext, w: &mut World, meta: &mut CoroMeta) -> Option<Self> {
+impl<T: Component> CoroParam for Wr<T> {
+    fn init(context: ParamContext, w: &mut World, access: &mut CoroAccess) -> Option<Self> {
         let id = w.component_id::<T>().unwrap_or(w.init_component::<T>());
 
-        if !meta.this_reads.insert(id.index()) {
+        if !access.this_reads.insert(id.index()) {
             return None;
         }
 
-        meta.this_writes.insert(id.index());
+        access.this_writes.insert(id.index());
 
         Some(Self {
             _phantom: PhantomData,
@@ -252,17 +300,54 @@ impl<T: Component> CoroParam for W<T> {
     }
 }
 
-// TODO: Later
-//impl<T: Component> CoroParam for Option<R<T>> {
-//
-//}
+pub struct Opt<T> {
+    context: ParamContext,
+    inner: T,
+}
+
+impl<T: CoroParam> Opt<T> {
+    pub fn get(&self) -> Option<&T> {
+        unsafe {
+            if T::is_valid(self.context.owner, self.context.world_window.world_cell().world()) {
+                Some(&self.inner)
+            } else {
+                None
+            }
+        }
+    }
+
+    pub fn get_mut(&mut self) -> Option<&mut T> {
+        unsafe {
+            if T::is_valid(self.context.owner, self.context.world_window.world_cell().world()) {
+                Some(&mut self.inner)
+            } else {
+                None
+            }
+        }
+    }
+}
+
+impl<T: CoroParam> CoroParam for Opt<T> {
+    fn init(context: ParamContext, world: &mut World, access: &mut CoroAccess) -> Option<Self> {
+        let t = T::init(context.clone(), world, access)?;
+
+        Some(Self {
+            context,
+            inner: t
+        })
+    }
+
+    fn is_valid(owner: Entity, world: &World) -> bool {
+        true
+    }
+}
 
 macro_rules! impl_coro_param {
     ($($param: ident),*) => {
         #[allow(non_snake_case, unused_parens, unused_variables)]
         impl<$($param: CoroParam),*> CoroParam for ($($param,)*) {
-            fn init(context: ParamContext, world: &mut World, meta: &mut CoroMeta) -> Option<Self> {
-                $(let $param = $param::init(context.clone(), world, meta)?;)*
+            fn init(context: ParamContext, world: &mut World, access: &mut CoroAccess) -> Option<Self> {
+                $(let $param = $param::init(context.clone(), world, access)?;)*
 
                 Some(($($param,)*))
 
diff --git a/src/coroutine/duration.rs b/src/coroutine/duration.rs
index fbb2ce7..fd57a76 100644
--- a/src/coroutine/duration.rs
+++ b/src/coroutine/duration.rs
@@ -38,7 +38,7 @@ impl<'a> Future for NextTick<'a> {
 
                 // SAFETY: None lmao
                 let dt = unsafe {
-                    (self.fib.world_window.world_cell())
+                    (self.fib.context.world_window.world_cell())
                         .get_resource::<Time>()
                         .unwrap()
                         .delta()
@@ -47,7 +47,7 @@ impl<'a> Future for NextTick<'a> {
             }
             CoroState::Running => {
                 self.state = CoroState::Halted;
-                self.fib.yield_channel.send(WaitingReason::Tick);
+                self.fib.context.yield_channel.send(WaitingReason::Tick);
                 Poll::Pending
             }
         }
@@ -84,6 +84,7 @@ impl<'a> Future for DurationFuture<'a> {
             CoroState::Running => {
                 self.state = CoroState::Halted;
                 self.fib
+                    .context
                     .yield_channel
                     .send(WaitingReason::Duration(Timer::new(
                         self.duration,
diff --git a/src/coroutine/function_coroutine.rs b/src/coroutine/function_coroutine.rs
index 8c9d91b..6417d9b 100644
--- a/src/coroutine/function_coroutine.rs
+++ b/src/coroutine/function_coroutine.rs
@@ -1,5 +1,4 @@
 use std::time::Duration;
-use std::{cell::Cell, rc::Rc};
 
 use bevy::prelude::Entity;
 use bevy::prelude::World;
@@ -11,13 +10,9 @@ use std::pin::Pin;
 use std::task::Context;
 use std::task::Poll;
 
-use crate::coroutine::CoroMeta;
-use crate::executor::msg_channel::Receiver;
-use crate::executor::msg_channel::Sender;
-
-use super::coro_param::CoroParam;
 use super::coro_param::ParamContext;
 use super::coro_param::WorldWindow;
+use super::coro_param::{CoroAccess, CoroParam, YieldChannel};
 use super::duration::DurationFuture;
 use super::duration::NextTick;
 use super::par_and::ParAnd;
@@ -32,9 +27,9 @@ where
 {
     #[pin]
     future: F::Future,
-    yield_channel: Receiver<WaitingReason>,
-    world_window: Rc<Cell<*mut World>>,
-    meta: CoroMeta,
+    yield_channel: YieldChannel,
+    world_window: WorldWindow,
+    owner: Entity,
 }
 
 unsafe impl<Marker, F> Send for FunctionCoroutine<Marker, F> where F: CoroutineParamFunction<Marker> {}
@@ -53,9 +48,8 @@ where
         let mut cx = Context::from_waker(&waker);
 
         let this = self.project();
-        this.world_window.replace(world as *mut _);
-        let res = this.future.poll(&mut cx);
-        this.world_window.replace(std::ptr::null_mut());
+        let res = this.world_window.scope(world, || this.future.poll(&mut cx));
+
         match res {
             Poll::Ready(_) => CoroutineResult::Done(()),
             Poll::Pending => {
@@ -65,8 +59,8 @@ where
     }
 
     fn is_valid(self: Pin<&mut Self>, world: &World) -> bool {
-        //TODO validate the window as well
-        F::Params::is_valid(self.meta.owner, world)
+        //TODO validate the Fib as well
+        F::Params::is_valid(self.owner, world)
     }
 }
 
@@ -84,38 +78,33 @@ where
     type Coroutine = FunctionCoroutine<Marker, F>;
 
     fn init(self, owner: Entity, world: &mut World) -> Option<Self::Coroutine> {
-        let yield_channel = Receiver::default();
-        let world_window = Rc::new(Cell::new(std::ptr::null_mut()));
+        let yield_channel = YieldChannel::new();
+        let world_window = WorldWindow::closed_window();
 
         let context = ParamContext {
             owner,
-            world_window: WorldWindow(Rc::clone(&world_window)),
-            yield_sender: yield_channel.sender(),
+            world_window: world_window.clone(),
+            yield_channel: yield_channel.clone(),
         };
 
-        let mut meta = CoroMeta::new(owner);
+        let mut access = CoroAccess::default();
 
-        let params = F::Params::init(context, world, &mut meta)?;
-        let fib = Fib {
-            world_window: WorldWindow(Rc::clone(&world_window)),
-            yield_channel: yield_channel.sender(),
-            meta: meta.clone(),
-        };
+        let params = F::Params::init(context.clone(), world, &mut access)?;
+        let fib = Fib { context, access };
 
         Some(FunctionCoroutine {
             future: self.init(fib, params),
             yield_channel,
             world_window,
-            meta,
+            owner,
         })
     }
 }
 
 /// The `Fib` is the first param of a coroutine, all yielding is done througth it.
 pub struct Fib {
-    pub(crate) world_window: WorldWindow,
-    pub(crate) yield_channel: Sender<WaitingReason>,
-    pub(crate) meta: CoroMeta,
+    pub(crate) context: ParamContext,
+    pub(crate) access: CoroAccess,
 }
 
 // Safety: No idea....
@@ -150,8 +139,10 @@ impl Fib {
     {
         // Safety: We are getting polled right now, therefore we have exclusive world access.
         unsafe {
-            if let Some(c) = coro.init(self.meta.owner, self.world_window.world_cell().world_mut())
-            {
+            if let Some(c) = coro.init(
+                self.context.owner,
+                self.context.world_window.world_cell().world_mut(),
+            ) {
                 return ParOr::new(self, vec![SyncCell::new(Box::pin(c))]);
             }
         }
@@ -165,8 +156,10 @@ impl Fib {
     {
         // Safety: We are getting polled right now, therefore we have exclusive world access.
         unsafe {
-            if let Some(c) = coro.init(self.meta.owner, self.world_window.world_cell().world_mut())
-            {
+            if let Some(c) = coro.init(
+                self.context.owner,
+                self.context.world_window.world_cell().world_mut(),
+            ) {
                 return ParAnd::new(self, vec![SyncCell::new(Box::pin(c))]);
             }
         }
diff --git a/src/coroutine/observable.rs b/src/coroutine/observable.rs
index 341d41d..dd1196f 100644
--- a/src/coroutine/observable.rs
+++ b/src/coroutine/observable.rs
@@ -47,7 +47,7 @@ impl<'a> Future for OnChange<'a> {
             CoroState::Running => {
                 self.state = CoroState::Halted;
                 self.context
-                    .yield_sender
+                    .yield_channel
                     .send(WaitingReason::Changed(self.id));
                 Poll::Pending
             }
diff --git a/src/coroutine/par_and.rs b/src/coroutine/par_and.rs
index 7c9ca74..d4dbccf 100644
--- a/src/coroutine/par_and.rs
+++ b/src/coroutine/par_and.rs
@@ -41,6 +41,7 @@ impl<'a> Future for ParAnd<'a> {
                 self.state = CoroState::Halted;
                 let coroutines = std::mem::take(&mut self.coroutines);
                 self.fib
+                    .context
                     .yield_channel
                     .send(WaitingReason::ParAnd { coroutines });
                 Poll::Pending
@@ -58,8 +59,8 @@ impl<'a> ParAnd<'a> {
         // Safety: We are getting polled right now, therefore we have exclusive world access.
         unsafe {
             if let Some(c) = coro.init(
-                self.fib.meta.owner,
-                self.fib.world_window.world_cell().world_mut(),
+                self.fib.context.owner,
+                self.fib.context.world_window.world_cell().world_mut(),
             ) {
                 self.coroutines.push(SyncCell::new(Box::pin(c)));
             }
diff --git a/src/coroutine/par_or.rs b/src/coroutine/par_or.rs
index e0a61a3..4ecb5ba 100644
--- a/src/coroutine/par_or.rs
+++ b/src/coroutine/par_or.rs
@@ -42,6 +42,7 @@ impl<'a> Future for ParOr<'a> {
                 self.state = CoroState::Halted;
                 let coroutines = std::mem::take(&mut self.coroutines);
                 self.fib
+                    .context
                     .yield_channel
                     .send(WaitingReason::ParOr { coroutines });
                 Poll::Pending
@@ -59,8 +60,8 @@ impl<'a> ParOr<'a> {
         // Safety: We are getting polled right now, therefore we have exclusive world access.
         unsafe {
             if let Some(c) = coro.init(
-                self.fib.meta.owner,
-                self.fib.world_window.world_cell().world_mut(),
+                self.fib.context.owner,
+                self.fib.context.world_window.world_cell().world_mut(),
             ) {
                 self.coroutines.push(SyncCell::new(Box::pin(c)));
             }
diff --git a/src/executor/mod.rs b/src/executor/mod.rs
index 85ba6b4..4ee8e6e 100644
--- a/src/executor/mod.rs
+++ b/src/executor/mod.rs
@@ -7,7 +7,6 @@ use crate::coroutine;
 use crate::coroutine::observable::ObservableId;
 use crate::coroutine::{CoroObject, CoroWrites, Coroutine, CoroutineResult};
 
-pub(crate) mod msg_channel;
 mod run_ctx;
 pub(crate) use run_ctx::RunContext;
 
@@ -344,14 +343,14 @@ mod tests {
         world.insert_resource(Time::new(Instant::now()));
         let e = world.spawn((ExampleComponent, ExampleComponentBar)).id();
 
-        coroutine(|fib: Fib, _ex: R<ExampleComponent>| async move {
+        coroutine(|fib: Fib, _ex: Rd<ExampleComponent>| async move {
             loop {
                 fib.next_tick().await;
             }
         })
         .apply(e, &mut world);
 
-        coroutine(|fib: Fib, _ex: R<ExampleComponentBar>| async move {
+        coroutine(|fib: Fib, _ex: Rd<ExampleComponentBar>| async move {
             loop {
                 fib.next_tick().await;
             }
diff --git a/src/executor/msg_channel.rs b/src/executor/msg_channel.rs
deleted file mode 100644
index 6826df3..0000000
--- a/src/executor/msg_channel.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-use std::{cell::Cell, rc::Rc};
-
-// A simple single receiver, multiple sender channel (will probably change later)
-// with a capacity of 1 (Mostly here for code clarity)
-
-pub(crate) struct Receiver<T> {
-    channel: Rc<Cell<Option<T>>>,
-}
-
-impl<T> Default for Receiver<T> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-pub(crate) struct Sender<T> {
-    channel: Rc<Cell<Option<T>>>,
-}
-
-impl<T> Clone for Sender<T> {
-    fn clone(&self) -> Self {
-        Self {
-            channel: Rc::clone(&self.channel),
-        }
-    }
-}
-
-impl<T> Receiver<T> {
-    pub(crate) fn new() -> Self {
-        Self {
-            channel: Rc::new(Cell::new(None)),
-        }
-    }
-
-    pub(crate) fn receive(&self) -> Option<T> {
-        self.channel.replace(None)
-    }
-
-    pub(crate) fn sender(&self) -> Sender<T> {
-        Sender {
-            channel: Rc::clone(&self.channel),
-        }
-    }
-}
-
-impl<T> Sender<T> {
-    pub(crate) fn send(&self, val: T) {
-        self.channel.replace(Some(val));
-    }
-}
diff --git a/src/lib.rs b/src/lib.rs
index d265f14..a4e40ad 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -6,13 +6,12 @@ pub mod executor;
 
 mod commands;
 mod plugin;
-mod world_window;
 
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::commands::{coroutine, AddCoroutine};
     #[doc(hidden)]
-    pub use crate::coroutine::coro_param::{R, W};
+    pub use crate::coroutine::coro_param::{Rd, Wr};
     #[doc(hidden)]
     pub use crate::coroutine::function_coroutine::Fib;
     #[doc(hidden)]
@@ -111,7 +110,7 @@ mod tests {
         let a = Arc::new(Mutex::new(0));
         let b = Arc::clone(&a);
 
-        coroutine(move |fib: Fib, ex: R<ExampleComponent>| async move {
+        coroutine(move |fib: Fib, ex: Rd<ExampleComponent>| async move {
             fib.next_tick().await;
             ex.on_change().await;
             *b.lock().unwrap() += 1;
diff --git a/src/world_window.rs b/src/world_window.rs
deleted file mode 100644
index 099fab5..0000000
--- a/src/world_window.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//use std::ops::{Deref, DerefMut};
-//
-//use bevy::prelude::Component;
-//
-//// TODO change detection (isn't this what Mut is already doing in Bevy ? Damn looks like I'm tired...)
-//pub struct ComponentGuard<'a, T: Component>(&'a T);
-//
-//impl<'a, T: Component> Deref for ComponentGuard<'a, T> {
-//    type Target = T;
-//
-//    fn deref(&self) -> &Self::Target {
-//        self.0
-//    }
-//}
-//
-//pub struct ComponentGuardMut<'a, T: Component>(&'a mut T);
-//
-//impl<'a, T: Component> Deref for ComponentGuardMut<'a, T> {
-//    type Target = T;
-//
-//    fn deref(&self) -> &Self::Target {
-//        self.0
-//    }
-//}
-//
-//impl<'a, T: Component> DerefMut for ComponentGuardMut<'a, T> {
-//    fn deref_mut(&mut self) -> &mut Self::Target {
-//        self.0
-//    }
-//}

From 2dc6773eaaef1bad1b67ac3d386437c9cbca92ed Mon Sep 17 00:00:00 2001
From: Zacharie Tevaearai <zacharie.tevaearai@epfl.ch>
Date: Wed, 27 Sep 2023 09:46:41 +0200
Subject: [PATCH 06/11] Run clippy + fmt

---
 examples/read_write.rs              |  1 -
 src/coroutine/coro_param.rs         | 18 ++++++++++--------
 src/coroutine/function_coroutine.rs |  9 +++++++--
 src/coroutine/mod.rs                | 27 +++++----------------------
 4 files changed, 22 insertions(+), 33 deletions(-)

diff --git a/examples/read_write.rs b/examples/read_write.rs
index ae1a9b1..d24ade7 100644
--- a/examples/read_write.rs
+++ b/examples/read_write.rs
@@ -1,4 +1,3 @@
-
 fn main() {
     //App::new()
     //    .add_plugins((DefaultPlugins, CorentinPlugin))
diff --git a/src/coroutine/coro_param.rs b/src/coroutine/coro_param.rs
index 2614b6c..276dc5b 100644
--- a/src/coroutine/coro_param.rs
+++ b/src/coroutine/coro_param.rs
@@ -99,7 +99,6 @@ impl YieldChannel {
     }
 }
 
-
 // Safety: Same as [`WorldWindow`].
 unsafe impl Send for YieldChannel {}
 
@@ -308,7 +307,10 @@ pub struct Opt<T> {
 impl<T: CoroParam> Opt<T> {
     pub fn get(&self) -> Option<&T> {
         unsafe {
-            if T::is_valid(self.context.owner, self.context.world_window.world_cell().world()) {
+            if T::is_valid(
+                self.context.owner,
+                self.context.world_window.world_cell().world(),
+            ) {
                 Some(&self.inner)
             } else {
                 None
@@ -318,7 +320,10 @@ impl<T: CoroParam> Opt<T> {
 
     pub fn get_mut(&mut self) -> Option<&mut T> {
         unsafe {
-            if T::is_valid(self.context.owner, self.context.world_window.world_cell().world()) {
+            if T::is_valid(
+                self.context.owner,
+                self.context.world_window.world_cell().world(),
+            ) {
                 Some(&mut self.inner)
             } else {
                 None
@@ -331,13 +336,10 @@ impl<T: CoroParam> CoroParam for Opt<T> {
     fn init(context: ParamContext, world: &mut World, access: &mut CoroAccess) -> Option<Self> {
         let t = T::init(context.clone(), world, access)?;
 
-        Some(Self {
-            context,
-            inner: t
-        })
+        Some(Self { context, inner: t })
     }
 
-    fn is_valid(owner: Entity, world: &World) -> bool {
+    fn is_valid(_owner: Entity, _world: &World) -> bool {
         true
     }
 }
diff --git a/src/coroutine/function_coroutine.rs b/src/coroutine/function_coroutine.rs
index 6417d9b..d784389 100644
--- a/src/coroutine/function_coroutine.rs
+++ b/src/coroutine/function_coroutine.rs
@@ -30,6 +30,7 @@ where
     yield_channel: YieldChannel,
     world_window: WorldWindow,
     owner: Entity,
+    access: CoroAccess,
 }
 
 unsafe impl<Marker, F> Send for FunctionCoroutine<Marker, F> where F: CoroutineParamFunction<Marker> {}
@@ -62,6 +63,10 @@ where
         //TODO validate the Fib as well
         F::Params::is_valid(self.owner, world)
     }
+
+    fn access(&self) -> &CoroAccess {
+        &self.access
+    }
 }
 
 pub trait CoroutineParamFunction<Marker>: Send + 'static {
@@ -90,13 +95,14 @@ where
         let mut access = CoroAccess::default();
 
         let params = F::Params::init(context.clone(), world, &mut access)?;
-        let fib = Fib { context, access };
+        let fib = Fib { context };
 
         Some(FunctionCoroutine {
             future: self.init(fib, params),
             yield_channel,
             world_window,
             owner,
+            access,
         })
     }
 }
@@ -104,7 +110,6 @@ where
 /// The `Fib` is the first param of a coroutine, all yielding is done througth it.
 pub struct Fib {
     pub(crate) context: ParamContext,
-    pub(crate) access: CoroAccess,
 }
 
 // Safety: No idea....
diff --git a/src/coroutine/mod.rs b/src/coroutine/mod.rs
index 303512c..1a8a349 100644
--- a/src/coroutine/mod.rs
+++ b/src/coroutine/mod.rs
@@ -7,8 +7,8 @@ use bevy::prelude::Resource;
 use bevy::prelude::Timer;
 use bevy::prelude::World;
 use bevy::utils::synccell::SyncCell;
-use tinyset::SetUsize;
 
+use self::coro_param::CoroAccess;
 use self::observable::ObservableId;
 
 pub mod coro_param;
@@ -33,6 +33,10 @@ pub trait Coroutine: Send + 'static {
     /// Return true, if this coroutine is still valid. If it is not, it should be despawned. Should
     /// be called before [`resume`], to avoid any panic.
     fn is_valid(self: Pin<&mut Self>, world: &World) -> bool;
+
+    /// Returns which part of the [`World`] are accessed by this [`Coroutine`].
+    /// Useful if the [`Executor`] is multithreaded.
+    fn access(&self) -> &CoroAccess;
 }
 
 /// A shared list of modified values (observable), to easily notify the apropriate observers.
@@ -42,27 +46,6 @@ pub(crate) struct CoroWrites(pub VecDeque<(Entity, ComponentId)>);
 /// A heap allocated Coroutine
 pub(crate) type CoroObject = SyncCell<Pin<Box<dyn Coroutine>>>;
 
-/// Metadata of a coroutine
-///
-/// This includes
-/// - Which components are read and written to
-#[derive(Clone)]
-pub struct CoroMeta {
-    pub(crate) this_reads: SetUsize,
-    pub(crate) this_writes: SetUsize,
-    pub(crate) owner: Entity,
-}
-
-impl CoroMeta {
-    pub fn new(owner: Entity) -> Self {
-        Self {
-            owner,
-            this_reads: SetUsize::default(),
-            this_writes: SetUsize::default(),
-        }
-    }
-}
-
 /// The result after resuming a `Coroutine`. Either it yields an intermediate value, or return the
 /// final result.
 pub enum CoroutineResult<Y, R> {

From 6ca36507105de125412b503ecfd73632739a209b Mon Sep 17 00:00:00 2001
From: Zacharie Tevaearai <zacharie.tevaearai@epfl.ch>
Date: Wed, 27 Sep 2023 10:07:44 +0200
Subject: [PATCH 07/11] Fix overwirte bug + uncomment some tests

---
 src/coroutine/function_coroutine.rs |   2 +-
 src/executor/mod.rs                 |  55 +++---
 src/lib.rs                          | 291 +++++++++++++++-------------
 3 files changed, 187 insertions(+), 161 deletions(-)

diff --git a/src/coroutine/function_coroutine.rs b/src/coroutine/function_coroutine.rs
index d784389..26d238c 100644
--- a/src/coroutine/function_coroutine.rs
+++ b/src/coroutine/function_coroutine.rs
@@ -155,7 +155,7 @@ impl Fib {
     }
 
     ///// Returns a coroutine that resolve once all of the underlying coroutine finishes.
-    pub fn par_and<C, Marker>(&mut self, coro: C) -> ParAnd<'_>
+    pub fn par_and<C, Marker>(&self, coro: C) -> ParAnd<'_>
     where
         C: UninitCoroutine<Marker>,
     {
diff --git a/src/executor/mod.rs b/src/executor/mod.rs
index 4ee8e6e..94a84a7 100644
--- a/src/executor/mod.rs
+++ b/src/executor/mod.rs
@@ -164,9 +164,12 @@ impl Executor {
 
         let mut writes = world.resource_mut::<CoroWrites>();
 
-        while let Some((write, c_id)) = writes.0.pop_front() {
-            run_cx.write_table.insert((write, c_id), this_node);
-            if let Some(nexts) = self.waiting_on_change.remove(&(write, c_id)) {
+        while let Some((to_entity, component)) = writes.0.pop_front() {
+            if let Some(prev_writer) = run_cx.write_table.insert((to_entity, component), this_node)
+            {
+                run_cx.parent_table.add_parent(prev_writer, this_node);
+            }
+            if let Some(nexts) = self.waiting_on_change.remove(&(to_entity, component)) {
                 for c in nexts {
                     let node = match run_cx.current_node_map.remove(&c) {
                         Some(n) => {
@@ -370,28 +373,26 @@ mod tests {
         });
     }
 
-    //#[test]
-    //fn waiting_on_change_dont_cancel_on_optional() {
-    //    let mut world = World::new();
-    //    world.init_resource::<Executor>();
-    //    world.init_resource::<CoroWrites>();
-    //    world.insert_resource(Time::new(Instant::now()));
-    //    let e = world.spawn(ExampleComponent).id();
-    //    coroutine(
-    //        |mut fib: Fib, _ex: Option<R<ExampleComponent>>| async move {
-    //            loop {
-    //                fib.next_tick().await;
-    //            }
-    //        },
-    //    )
-    //    .apply(e, &mut world);
-    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
-    //        assert_eq!(executor.coroutines.len(), 1);
-    //        executor.tick(w);
-    //        assert_eq!(executor.coroutines.len(), 1);
-    //        w.entity_mut(e).remove::<ExampleComponent>();
-    //        executor.tick(w);
-    //        assert_eq!(executor.coroutines.len(), 1);
-    //    });
-    //}
+    #[test]
+    fn waiting_on_change_dont_cancel_on_optional() {
+        let mut world = World::new();
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
+        world.insert_resource(Time::new(Instant::now()));
+        let e = world.spawn(ExampleComponent).id();
+        coroutine(|fib: Fib, _ex: Opt<Rd<ExampleComponent>>| async move {
+            loop {
+                fib.next_tick().await;
+            }
+        })
+        .apply(e, &mut world);
+        world.resource_scope(|w, mut executor: Mut<Executor>| {
+            assert_eq!(executor.coroutines.len(), 1);
+            executor.tick(w);
+            assert_eq!(executor.coroutines.len(), 1);
+            w.entity_mut(e).remove::<ExampleComponent>();
+            executor.tick(w);
+            assert_eq!(executor.coroutines.len(), 1);
+        });
+    }
 }
diff --git a/src/lib.rs b/src/lib.rs
index a4e40ad..f1fc721 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -11,7 +11,7 @@ pub mod prelude {
     #[doc(hidden)]
     pub use crate::commands::{coroutine, AddCoroutine};
     #[doc(hidden)]
-    pub use crate::coroutine::coro_param::{Rd, Wr};
+    pub use crate::coroutine::coro_param::{Opt, Rd, Wr};
     #[doc(hidden)]
     pub use crate::coroutine::function_coroutine::Fib;
     #[doc(hidden)]
@@ -154,145 +154,170 @@ mod tests {
         });
     }
 
-    //#[test]
-    //fn waiting_on_par_or() {
-    //    let mut world = World::new();
-    //    world.insert_resource(Executor::new());
-    //    world.insert_resource(Time::new(Instant::now()));
-    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
-    //        let a = Arc::new(Mutex::new(0));
-    //        let b = Arc::clone(&a);
-    //        executor.add(move |mut fib| async move {
-    //            fib.par_or(|mut fib| async move {
-    //                loop {
-    //                    fib.next_tick().await;
-    //                    *b.lock().unwrap() += 1;
-    //                }
-    //            })
-    //            .with(|mut fib| async move {
-    //                for _ in 0..4 {
-    //                    fib.next_tick().await;
-    //                }
-    //            })
-    //            .await;
-    //        });
+    #[test]
+    fn waiting_on_par_or() {
+        let mut world = World::new();
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
+        world.insert_resource(Time::new(Instant::now()));
 
-    //        for i in 0..5 {
-    //            // Note that it works because the coroutine on the the top of the par_or,
-    //            // has priority over the one on the bottom, meaning its side effect will be
-    //            // seen on the last iteration. (Okay I just kind of gave)
-    //            executor.tick(w);
-    //            assert_eq!(*a.lock().unwrap(), i);
-    //        }
-    //    });
-    //}
+        let e = world.spawn_empty().id();
+        let a = Arc::new(Mutex::new(0));
+        let b = Arc::clone(&a);
 
-    //#[test]
-    //fn waiting_on_par_and() {
-    //    let mut world = World::new();
-    //    world.insert_resource(Executor::new());
-    //    world.insert_resource(Time::new(Instant::now()));
-    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
-    //        let a = Arc::new(Mutex::new(0));
-    //        let b = Arc::clone(&a);
-    //        let c = Arc::clone(&a);
-    //        executor.add(move |mut fib| async move {
-    //            fib.par_and(|mut fib| async move {
-    //                fib.next_tick().await;
-    //                *b.lock().unwrap() += 1;
-    //            })
-    //            .with(|mut fib| async move {
-    //                for _ in 0..2 {
-    //                    fib.next_tick().await;
-    //                    *c.lock().unwrap() += 1;
-    //                }
-    //            })
-    //            .await;
-    //        });
+        coroutine(move |fib: Fib| async move {
+            fib.par_or(|fib: Fib| async move {
+                loop {
+                    fib.next_tick().await;
+                    *b.lock().unwrap() += 1;
+                }
+            })
+            .with(|fib: Fib| async move {
+                for _ in 0..4 {
+                    fib.next_tick().await;
+                }
+            })
+            .await;
+        })
+        .apply(e, &mut world);
 
-    //        executor.tick(w);
-    //        assert_eq!(*a.lock().unwrap(), 0);
-    //        executor.tick(w);
-    //        assert_eq!(*a.lock().unwrap(), 2);
-    //        executor.tick(w);
-    //        assert_eq!(*a.lock().unwrap(), 3);
-    //        executor.tick(w);
-    //        assert_eq!(*a.lock().unwrap(), 3);
-    //    });
-    //}
+        world.resource_scope(|w, mut executor: Mut<Executor>| {
+            for i in 0..5 {
+                // Note that it works because the coroutine on the the top of the par_or,
+                // has priority over the one on the bottom, meaning its side effect will be
+                // seen on the last iteration. (Okay I just kind of gave)
+                executor.tick(w);
+                assert_eq!(*a.lock().unwrap(), i);
+            }
+        });
+    }
 
-    //#[test]
-    //fn reading_components() {
-    //    let mut world = World::new();
-    //    world.insert_resource(Executor::new());
-    //    world.insert_resource(Time::new(Instant::now()));
-    //    let e = world.spawn(ExampleComponent(0)).id();
-    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
-    //        executor.add(move |mut fib| async move {
-    //            for i in 0..5 {
-    //                let (_, example) = fib.next_tick().then_grab::<&ExampleComponent>(e).await;
-    //                assert_eq!(example.0, i);
-    //            }
-    //        });
-    //        executor.tick(w);
-    //        for _ in 0..5 {
-    //            executor.tick(w);
-    //            w.entity_mut(e).get_mut::<ExampleComponent>().unwrap().0 += 1;
-    //        }
-    //    });
-    //}
+    #[test]
+    fn waiting_on_par_and() {
+        let mut world = World::new();
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
+        world.insert_resource(Time::new(Instant::now()));
 
-    //#[test]
-    //fn writing_components() {
-    //    let mut world = World::new();
-    //    world.insert_resource(Executor::new());
-    //    world.insert_resource(Time::new(Instant::now()));
-    //    let e = world.spawn(ExampleComponent(0)).id();
-    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
-    //        executor.add(move |mut fib| async move {
-    //            for _ in 0..5 {
-    //                let (_, mut example) =
-    //                    fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-    //                example.0 += 1;
-    //            }
-    //        });
-    //        for i in 0..5 {
-    //            executor.tick(w);
-    //            assert_eq!(w.entity_mut(e).get::<ExampleComponent>().unwrap().0, i)
-    //        }
-    //    });
-    //}
+        let e = world.spawn_empty().id();
+        let a = Arc::new(Mutex::new(0));
+        let b = Arc::clone(&a);
+        let c = Arc::clone(&a);
 
-    //#[test]
-    //fn waiting_on_internal_change() {
-    //    let mut world = World::new();
-    //    world.insert_resource(Executor::new());
-    //    world.insert_resource(Time::new(Instant::now()));
-    //    let e = world.spawn(ExampleComponent(0)).id();
-    //    let a = Arc::new(Mutex::new(0));
-    //    let b = Arc::clone(&a);
-    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
-    //        executor.add(move |mut fib| async move {
-    //            for _ in 0..5 {
-    //                let (_, mut example) =
-    //                    fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-    //                example.0 += 1;
-    //            }
-    //        });
-    //        executor.add(|mut fib| async move {
-    //            loop {
-    //                fib.change::<ExampleComponent>(e).await;
-    //                *a.lock().unwrap() += 1;
-    //            }
-    //        });
+        coroutine(|fib: Fib| async move {
+            fib.par_and(|fib: Fib| async move {
+                fib.next_tick().await;
+                *b.lock().unwrap() += 1;
+            })
+            .with(|fib: Fib| async move {
+                for _ in 0..2 {
+                    fib.next_tick().await;
+                    *c.lock().unwrap() += 1;
+                }
+            })
+            .await;
+        })
+        .apply(e, &mut world);
 
-    //        for i in 0..5 {
-    //            executor.tick(w);
-    //            assert_eq!(*b.lock().unwrap(), i);
-    //            w.clear_trackers();
-    //        }
-    //    });
-    //}
+        world.resource_scope(|w, mut executor: Mut<Executor>| {
+            executor.tick(w);
+            assert_eq!(*a.lock().unwrap(), 0);
+            executor.tick(w);
+            assert_eq!(*a.lock().unwrap(), 2);
+            executor.tick(w);
+            assert_eq!(*a.lock().unwrap(), 3);
+            executor.tick(w);
+            assert_eq!(*a.lock().unwrap(), 3);
+        });
+    }
+
+    #[test]
+    fn reading_components() {
+        let mut world = World::new();
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
+        world.insert_resource(Time::new(Instant::now()));
+
+        let e = world.spawn(ExampleComponent(0)).id();
+
+        coroutine(|fib: Fib, example: Rd<ExampleComponent>| async move {
+            for i in 0..5 {
+                fib.next_tick().await;
+                assert_eq!(example.get().0, i);
+            }
+        })
+        .apply(e, &mut world);
+
+        world.resource_scope(|w, mut executor: Mut<Executor>| {
+            executor.tick(w);
+            for _ in 0..5 {
+                executor.tick(w);
+                w.entity_mut(e).get_mut::<ExampleComponent>().unwrap().0 += 1;
+            }
+        });
+    }
+
+    #[test]
+    fn writing_components() {
+        let mut world = World::new();
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
+        world.insert_resource(Time::new(Instant::now()));
+
+        let e = world.spawn(ExampleComponent(0)).id();
+
+        coroutine(|fib: Fib, mut example: Wr<ExampleComponent>| async move {
+            for _ in 0..5 {
+                fib.next_tick().await;
+                example.get_mut().0 += 1;
+            }
+        })
+        .apply(e, &mut world);
+
+        world.resource_scope(|w, mut executor: Mut<Executor>| {
+            for i in 0..5 {
+                executor.tick(w);
+                assert_eq!(w.entity_mut(e).get::<ExampleComponent>().unwrap().0, i)
+            }
+        });
+    }
+
+    #[test]
+    fn waiting_on_internal_change() {
+        let mut world = World::new();
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
+        world.insert_resource(Time::new(Instant::now()));
+
+        let e = world.spawn(ExampleComponent(0)).id();
+
+        let a = Arc::new(Mutex::new(0));
+        let b = Arc::clone(&a);
+
+        coroutine(|fib: Fib, mut example: Wr<ExampleComponent>| async move {
+            for _ in 0..5 {
+                fib.next_tick().await;
+                example.get_mut().0 += 1;
+            }
+        })
+        .apply(e, &mut world);
+
+        coroutine(|example: Rd<ExampleComponent>| async move {
+            for _ in 0..5 {
+                example.on_change().await;
+                *b.lock().unwrap() += 1;
+            }
+        })
+        .apply(e, &mut world);
+
+        world.resource_scope(|w, mut executor: Mut<Executor>| {
+            for i in 0..5 {
+                executor.tick(w);
+                assert_eq!(*a.lock().unwrap(), i);
+                w.clear_trackers();
+            }
+        });
+    }
 
     ////#[test]
     ////fn multiple_write_dont_override_too_soon() {

From 3344f196e3237958a7995bed4ac04e4d91f6c14e Mon Sep 17 00:00:00 2001
From: Zacharie Tevaearai <zacharie.tevaearai@epfl.ch>
Date: Wed, 27 Sep 2023 10:33:12 +0200
Subject: [PATCH 08/11] Turn Fib into a coro param

---
 src/coroutine/coro_param.rs         |   6 +-
 src/coroutine/duration.rs           |  33 ++++-----
 src/coroutine/function_coroutine.rs | 109 ++++++----------------------
 src/coroutine/par_and.rs            |  55 +++++++-------
 src/coroutine/par_or.rs             |  55 +++++++-------
 5 files changed, 91 insertions(+), 167 deletions(-)

diff --git a/src/coroutine/coro_param.rs b/src/coroutine/coro_param.rs
index 276dc5b..cc554d0 100644
--- a/src/coroutine/coro_param.rs
+++ b/src/coroutine/coro_param.rs
@@ -45,6 +45,7 @@ pub struct WorldWindow(Rc<Cell<*mut World>>);
 // if you start spawning thread inside a coroutine, or sending coroutine parameters via channels,
 // you may break the safety, therefore please don't do that. (thanks UwU)
 unsafe impl Send for WorldWindow {}
+unsafe impl Sync for WorldWindow {}
 
 impl WorldWindow {
     pub fn closed_window() -> Self {
@@ -101,6 +102,7 @@ impl YieldChannel {
 
 // Safety: Same as [`WorldWindow`].
 unsafe impl Send for YieldChannel {}
+unsafe impl Sync for YieldChannel {}
 
 /// All relevent values a [`CoroParam`] might need.
 #[derive(Clone)]
@@ -110,10 +112,6 @@ pub struct ParamContext {
     pub(crate) yield_channel: YieldChannel,
 }
 
-/// Safety ? Who knows...
-unsafe impl Send for ParamContext {}
-unsafe impl Sync for ParamContext {}
-
 /// A readonly reference to a [`Component`] from the owning [`Entity`].
 ///
 /// Note that a Coroutine with such parameter will be canceled if the entity does not have the
diff --git a/src/coroutine/duration.rs b/src/coroutine/duration.rs
index fd57a76..4fc630f 100644
--- a/src/coroutine/duration.rs
+++ b/src/coroutine/duration.rs
@@ -9,25 +9,25 @@ use std::task::Context;
 use std::task::Poll;
 use std::time::Duration;
 
+use super::coro_param::ParamContext;
 use super::CoroState;
-use crate::coroutine::function_coroutine::Fib;
 
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct NextTick<'a> {
-    fib: &'a Fib,
+pub struct NextTick {
+    context: ParamContext,
     state: CoroState,
 }
 
-impl<'a> NextTick<'a> {
-    pub(crate) fn new(fib: &'a Fib) -> Self {
+impl NextTick {
+    pub(crate) fn new(context: ParamContext) -> Self {
         NextTick {
-            fib,
+            context,
             state: CoroState::Running,
         }
     }
 }
 
-impl<'a> Future for NextTick<'a> {
+impl Future for NextTick {
     type Output = Duration;
 
     fn poll(mut self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
@@ -38,7 +38,7 @@ impl<'a> Future for NextTick<'a> {
 
                 // SAFETY: None lmao
                 let dt = unsafe {
-                    (self.fib.context.world_window.world_cell())
+                    (self.context.world_window.world_cell())
                         .get_resource::<Time>()
                         .unwrap()
                         .delta()
@@ -47,7 +47,7 @@ impl<'a> Future for NextTick<'a> {
             }
             CoroState::Running => {
                 self.state = CoroState::Halted;
-                self.fib.context.yield_channel.send(WaitingReason::Tick);
+                self.context.yield_channel.send(WaitingReason::Tick);
                 Poll::Pending
             }
         }
@@ -55,23 +55,23 @@ impl<'a> Future for NextTick<'a> {
 }
 
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct DurationFuture<'a> {
-    fib: &'a Fib,
+pub struct DurationFuture {
+    context: ParamContext,
     duration: Duration,
     state: CoroState,
 }
 
-impl<'a> DurationFuture<'a> {
-    pub(crate) fn new(fib: &'a Fib, duration: Duration) -> Self {
+impl DurationFuture {
+    pub(crate) fn new(context: ParamContext, duration: Duration) -> Self {
         DurationFuture {
-            fib,
+            context,
             duration,
             state: CoroState::Running,
         }
     }
 }
 
-impl<'a> Future for DurationFuture<'a> {
+impl Future for DurationFuture {
     type Output = ();
 
     fn poll(mut self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
@@ -83,8 +83,7 @@ impl<'a> Future for DurationFuture<'a> {
             }
             CoroState::Running => {
                 self.state = CoroState::Halted;
-                self.fib
-                    .context
+                self.context
                     .yield_channel
                     .send(WaitingReason::Duration(Timer::new(
                         self.duration,
diff --git a/src/coroutine/function_coroutine.rs b/src/coroutine/function_coroutine.rs
index 26d238c..0ac3449 100644
--- a/src/coroutine/function_coroutine.rs
+++ b/src/coroutine/function_coroutine.rs
@@ -3,7 +3,6 @@ use std::time::Duration;
 use bevy::prelude::Entity;
 use bevy::prelude::World;
 use bevy::utils::all_tuples;
-use bevy::utils::synccell::SyncCell;
 use pin_project::pin_project;
 use std::future::Future;
 use std::pin::Pin;
@@ -60,7 +59,6 @@ where
     }
 
     fn is_valid(self: Pin<&mut Self>, world: &World) -> bool {
-        //TODO validate the Fib as well
         F::Params::is_valid(self.owner, world)
     }
 
@@ -73,7 +71,7 @@ pub trait CoroutineParamFunction<Marker>: Send + 'static {
     type Future: Future<Output = ()> + Send + 'static;
     type Params: CoroParam;
 
-    fn init(self, fib: Fib, params: Self::Params) -> Self::Future;
+    fn init(self, params: Self::Params) -> Self::Future;
 }
 
 impl<Marker: 'static, F> UninitCoroutine<Marker> for F
@@ -95,10 +93,9 @@ where
         let mut access = CoroAccess::default();
 
         let params = F::Params::init(context.clone(), world, &mut access)?;
-        let fib = Fib { context };
 
         Some(FunctionCoroutine {
-            future: self.init(fib, params),
+            future: self.init(params),
             yield_channel,
             world_window,
             owner,
@@ -107,123 +104,60 @@ where
     }
 }
 
-/// The `Fib` is the first param of a coroutine, all yielding is done througth it.
+/// The fib is a parameter througth which a coroutine can wait on various elementary construct.
+/// such as waiting until the next tick, waiting on multiple sub-coroutines.
 pub struct Fib {
     pub(crate) context: ParamContext,
 }
 
-// Safety: No idea....
-unsafe impl Send for Fib {}
-unsafe impl Sync for Fib {}
-
 impl Fib {
     /// Returns coroutine that resolve the next time the [`Executor`] is ticked (via
     /// [`run`][crate::executor::Executor::run] for instance). It returns the duration
     /// of the last frame (delta time).
     ///
     /// [`Executor`]: crate::executor::Executor
-    pub fn next_tick(&self) -> NextTick<'_> {
-        NextTick::new(self)
+    pub fn next_tick(&self) -> NextTick {
+        NextTick::new(self.context.clone())
     }
 
     ///// Returns a coroutine that resolve after a certain [`Duration`]. Note that if the duration
     ///// is smaller than the time between two tick of the [`Executor`] it won't be compensated.
     /////
     ///// [`Executor`]: crate::executor::Executor
-    pub fn duration(&self, duration: Duration) -> DurationFuture<'_> {
-        DurationFuture::new(self, duration)
+    pub fn duration(&self, duration: Duration) -> DurationFuture {
+        DurationFuture::new(self.context.clone(), duration)
     }
 
     ///// Returns a coroutine that resolve once any of the underlying coroutine finishes. Note that
     ///// once this is done, all the others are dropped. The coroutines are resumed from top to
     ///// bottom, in case multiple of them are ready to make progress at the same time.
-    pub fn par_or<C, Marker: 'static>(&self, coro: C) -> ParOr<'_>
+    pub fn par_or<C, Marker>(&self, coro: C) -> ParOr
     where
         C: UninitCoroutine<Marker>,
-        C::Coroutine: 'static,
     {
-        // Safety: We are getting polled right now, therefore we have exclusive world access.
-        unsafe {
-            if let Some(c) = coro.init(
-                self.context.owner,
-                self.context.world_window.world_cell().world_mut(),
-            ) {
-                return ParOr::new(self, vec![SyncCell::new(Box::pin(c))]);
-            }
-        }
-        ParOr::new(self, vec![])
+        ParOr::new(self.context.clone()).with(coro)
     }
 
     ///// Returns a coroutine that resolve once all of the underlying coroutine finishes.
-    pub fn par_and<C, Marker>(&self, coro: C) -> ParAnd<'_>
+    pub fn par_and<C, Marker>(&self, coro: C) -> ParAnd
     where
         C: UninitCoroutine<Marker>,
     {
-        // Safety: We are getting polled right now, therefore we have exclusive world access.
-        unsafe {
-            if let Some(c) = coro.init(
-                self.context.owner,
-                self.context.world_window.world_cell().world_mut(),
-            ) {
-                return ParAnd::new(self, vec![SyncCell::new(Box::pin(c))]);
-            }
-        }
-        ParAnd::new(self, vec![])
+        ParAnd::new(self.context.clone()).with(coro)
     }
-
-    ///// Returns a coroutine that resolve once the underlying coroutine finishes,
-    ///// in order to reuse coroutines, because the following won't compile:
-    ///// ```compile_fail
-    /////# use corentin::prelude::*;
-    /////async fn sub_coro(mut fib: Fib) { }
-    /////async fn main_coro(mut fib: Fib) {
-    /////  sub_coro(fib).await;
-    /////  sub_coro(fib).await;
-    /////}
-    /////```
-    ///// But the following will:
-    /////```
-    /////# use corentin::prelude::*;
-    /////async fn sub_coro(mut fib: Fib) { }
-    /////async fn main_coro(mut fib: Fib) {
-    /////  fib.on(sub_coro).await;
-    /////  fib.on(sub_coro).await;
-    /////}
-    /////```
-    //pub fn on<C, Marker>(&mut self, coro: C) -> On<C::Coroutine>
-    //where
-    //    C: UninitCoroutine<Marker>,
-    //{
-    //    unsafe {
-    //        if let Some(c) = coro.init(self.owner, self.world_window.world_cell().world_mut()) {
-    //            return On::new(self, c);
-    //        }
-    //    }
-    //    panic!()
-    //}
 }
 
-macro_rules! impl_coro_function {
-    ($($param: ident),*) => {
-        #[allow(non_snake_case, unused_mut, unused_variables, unused_parens)]
-        impl<Func, Fut, $($param: CoroParam),*> CoroutineParamFunction<fn(Fib, $($param,)*) -> Fut> for Func
-        where
-            Func: FnOnce(Fib, $($param),*) -> Fut + Send + 'static,
-            Fut: Future<Output = ()> + Send + 'static,
-        {
-
-            type Future = Fut;
-            type Params = ($($param),*);
+impl CoroParam for Fib {
+    fn init(context: ParamContext, _world: &mut World, _access: &mut CoroAccess) -> Option<Self> {
+        Some(Self { context })
+    }
 
-            fn init(self, fib: Fib, params: Self::Params) -> Self::Future {
-                let ($(($param)),*) = params;
-                self(fib, $($param),*)
-            }
-        }
-    };
+    fn is_valid(_owner: Entity, _world: &World) -> bool {
+        true
+    }
 }
 
-macro_rules! impl_coro_no_fib_function {
+macro_rules! impl_coro_function {
     ($($param: ident),*) => {
         #[allow(non_snake_case, unused_mut, unused_variables, unused_parens)]
         impl<Func, Fut, $($param: CoroParam),*> CoroutineParamFunction<fn($($param,)*) -> Fut> for Func
@@ -235,7 +169,7 @@ macro_rules! impl_coro_no_fib_function {
             type Future = Fut;
             type Params = ($($param),*);
 
-            fn init(self, _fib: Fib, params: Self::Params) -> Self::Future {
+            fn init(self, params: Self::Params) -> Self::Future {
                 let ($(($param)),*) = params;
                 self($($param),*)
             }
@@ -244,4 +178,3 @@ macro_rules! impl_coro_no_fib_function {
 }
 
 all_tuples!(impl_coro_function, 0, 16, P);
-all_tuples!(impl_coro_no_fib_function, 0, 16, P);
diff --git a/src/coroutine/par_and.rs b/src/coroutine/par_and.rs
index d4dbccf..8eb7036 100644
--- a/src/coroutine/par_and.rs
+++ b/src/coroutine/par_and.rs
@@ -1,33 +1,50 @@
 use bevy::utils::synccell::SyncCell;
 
 use crate::coroutine::{CoroState, WaitingReason};
-use crate::prelude::Fib;
 
 use std::future::Future;
 use std::pin::Pin;
 use std::task::Context;
 use std::task::Poll;
 
+use super::coro_param::ParamContext;
 use super::{CoroObject, UninitCoroutine};
 
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct ParAnd<'a> {
-    fib: &'a Fib,
+pub struct ParAnd {
+    context: ParamContext,
     coroutines: Vec<CoroObject>,
     state: CoroState,
 }
 
-impl<'a> ParAnd<'a> {
-    pub(crate) fn new(fib: &'a Fib, coroutines: Vec<CoroObject>) -> Self {
+impl ParAnd {
+    pub(crate) fn new(context: ParamContext) -> Self {
         ParAnd {
-            fib,
-            coroutines,
+            context,
+            coroutines: vec![],
             state: CoroState::Running,
         }
     }
+
+    /// Add a new coroutine to this [`ParAnd`].
+    pub fn with<C, Marker>(mut self, coro: C) -> Self
+    where
+        C: UninitCoroutine<Marker>,
+    {
+        // Safety: We are getting polled right now, therefore we have exclusive world access.
+        unsafe {
+            if let Some(c) = coro.init(
+                self.context.owner,
+                self.context.world_window.world_cell().world_mut(),
+            ) {
+                self.coroutines.push(SyncCell::new(Box::pin(c)));
+            }
+        }
+        self
+    }
 }
 
-impl<'a> Future for ParAnd<'a> {
+impl Future for ParAnd {
     type Output = ();
 
     fn poll(mut self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
@@ -40,8 +57,7 @@ impl<'a> Future for ParAnd<'a> {
             CoroState::Running => {
                 self.state = CoroState::Halted;
                 let coroutines = std::mem::take(&mut self.coroutines);
-                self.fib
-                    .context
+                self.context
                     .yield_channel
                     .send(WaitingReason::ParAnd { coroutines });
                 Poll::Pending
@@ -49,22 +65,3 @@ impl<'a> Future for ParAnd<'a> {
         }
     }
 }
-
-impl<'a> ParAnd<'a> {
-    /// Add a new coroutine to this [`ParAnd`].
-    pub fn with<C, Marker>(&mut self, coro: C) -> &mut Self
-    where
-        C: UninitCoroutine<Marker>,
-    {
-        // Safety: We are getting polled right now, therefore we have exclusive world access.
-        unsafe {
-            if let Some(c) = coro.init(
-                self.fib.context.owner,
-                self.fib.context.world_window.world_cell().world_mut(),
-            ) {
-                self.coroutines.push(SyncCell::new(Box::pin(c)));
-            }
-        }
-        self
-    }
-}
diff --git a/src/coroutine/par_or.rs b/src/coroutine/par_or.rs
index 4ecb5ba..87fb116 100644
--- a/src/coroutine/par_or.rs
+++ b/src/coroutine/par_or.rs
@@ -7,28 +7,45 @@ use std::pin::Pin;
 use std::task::Context;
 use std::task::Poll;
 
-use super::function_coroutine::Fib;
+use super::coro_param::ParamContext;
 use super::CoroObject;
 use super::UninitCoroutine;
 
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct ParOr<'a> {
-    fib: &'a Fib,
+pub struct ParOr {
+    context: ParamContext,
     coroutines: Vec<CoroObject>,
     state: CoroState,
 }
 
-impl<'a> ParOr<'a> {
-    pub(crate) fn new(fib: &'a Fib, coroutines: Vec<CoroObject>) -> Self {
+impl ParOr {
+    pub(crate) fn new(context: ParamContext) -> Self {
         ParOr {
-            fib,
-            coroutines,
+            context,
+            coroutines: vec![],
             state: CoroState::Running,
         }
     }
+
+    /// Add a new coroutine to this [`ParOr`].
+    pub fn with<C, Marker>(mut self, coro: C) -> Self
+    where
+        C: UninitCoroutine<Marker>,
+    {
+        // Safety: We are getting polled right now, therefore we have exclusive world access.
+        unsafe {
+            if let Some(c) = coro.init(
+                self.context.owner,
+                self.context.world_window.world_cell().world_mut(),
+            ) {
+                self.coroutines.push(SyncCell::new(Box::pin(c)));
+            }
+        }
+        self
+    }
 }
 
-impl<'a> Future for ParOr<'a> {
+impl Future for ParOr {
     type Output = ();
 
     fn poll(mut self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
@@ -41,8 +58,7 @@ impl<'a> Future for ParOr<'a> {
             CoroState::Running => {
                 self.state = CoroState::Halted;
                 let coroutines = std::mem::take(&mut self.coroutines);
-                self.fib
-                    .context
+                self.context
                     .yield_channel
                     .send(WaitingReason::ParOr { coroutines });
                 Poll::Pending
@@ -50,22 +66,3 @@ impl<'a> Future for ParOr<'a> {
         }
     }
 }
-
-impl<'a> ParOr<'a> {
-    /// Add a new coroutine to this [`ParOr`].
-    pub fn with<C, Marker: 'static>(&mut self, coro: C) -> &mut Self
-    where
-        C: UninitCoroutine<Marker>,
-    {
-        // Safety: We are getting polled right now, therefore we have exclusive world access.
-        unsafe {
-            if let Some(c) = coro.init(
-                self.fib.context.owner,
-                self.fib.context.world_window.world_cell().world_mut(),
-            ) {
-                self.coroutines.push(SyncCell::new(Box::pin(c)));
-            }
-        }
-        self
-    }
-}

From becb8a70861de2d5eea50c6d8cdeff5b573cb51f Mon Sep 17 00:00:00 2001
From: Zacharie Tevaearai <zacharie.tevaearai@epfl.ch>
Date: Wed, 27 Sep 2023 12:26:08 +0200
Subject: [PATCH 09/11] Reorganize code

---
 src/coroutine/coro_param.rs           | 364 --------------------------
 src/coroutine/coro_param/component.rs | 194 ++++++++++++++
 src/coroutine/coro_param/mod.rs       | 165 ++++++++++++
 src/coroutine/function_coroutine.rs   |   3 +-
 src/coroutine/mod.rs                  |  50 +++-
 src/lib.rs                            |   7 +-
 6 files changed, 413 insertions(+), 370 deletions(-)
 delete mode 100644 src/coroutine/coro_param.rs
 create mode 100644 src/coroutine/coro_param/component.rs
 create mode 100644 src/coroutine/coro_param/mod.rs

diff --git a/src/coroutine/coro_param.rs b/src/coroutine/coro_param.rs
deleted file mode 100644
index cc554d0..0000000
--- a/src/coroutine/coro_param.rs
+++ /dev/null
@@ -1,364 +0,0 @@
-use std::{
-    cell::Cell,
-    marker::PhantomData,
-    ops::{Deref, DerefMut},
-    rc::Rc,
-};
-
-use super::{
-    observable::{ObservableId, OnChange},
-    CoroWrites, WaitingReason,
-};
-use bevy::{
-    ecs::{component::ComponentId, world::unsafe_world_cell::UnsafeWorldCell},
-    prelude::{Component, Entity, Mut, World},
-    utils::all_tuples,
-};
-use tinyset::SetUsize;
-
-/// Any async function that takes only [`CoroParam`] as arguments can
-/// automatically be turned into a [`Coroutine`].
-pub trait CoroParam: Sized + Send + 'static {
-    /// Initialize the parameter and register any access, if it is invalid (for instance
-    /// conflicting accesses) it will return None.
-    ///
-    /// Note: `world_window` is not yet open at that point, `world` should be used instead.
-    fn init(context: ParamContext, world: &mut World, access: &mut CoroAccess) -> Option<Self>;
-
-    /// Returns true if the parameter is still valid.
-    fn is_valid(owner: Entity, world: &World) -> bool;
-}
-
-#[derive(Default)]
-pub struct CoroAccess {
-    this_reads: SetUsize,
-    this_writes: SetUsize,
-    //others: HashMap<>
-}
-
-/// A shared ref to a [`World`], it is "open" (meaning it points to a valid world with exclusive
-/// access) when the Coroutine is resumed. It is shared to all [`CoroParam`]s.
-#[derive(Clone)]
-pub struct WorldWindow(Rc<Cell<*mut World>>);
-
-// Safety: The window is only shared whith the coroutine itself, As with other similar construct,
-// if you start spawning thread inside a coroutine, or sending coroutine parameters via channels,
-// you may break the safety, therefore please don't do that. (thanks UwU)
-unsafe impl Send for WorldWindow {}
-unsafe impl Sync for WorldWindow {}
-
-impl WorldWindow {
-    pub fn closed_window() -> Self {
-        WorldWindow(Rc::new(Cell::new(std::ptr::null_mut())))
-    }
-
-    pub fn scope<T>(&mut self, world: &mut World, f: impl FnOnce() -> T) -> T {
-        self.0.replace(world as *mut _);
-        let res = f();
-        self.0.replace(std::ptr::null_mut());
-        res
-    }
-
-    /// Returns the world as an [`UnsafeWorldCell`].
-    ///
-    /// # Safety
-    /// The caller must ensure that the pointer points to a valid value. (the window should be
-    /// "open").
-    pub unsafe fn world_cell(&self) -> UnsafeWorldCell<'_> {
-        (*self.0.get()).as_unsafe_world_cell()
-    }
-
-    /// Return the appropriate ComponentId, and initialize it if not present in the world
-    ///
-    /// # Safety
-    /// The caller must ensure that the pointer points to a valid value. (the window should be
-    /// "open").
-    pub unsafe fn component_id<T: Component>(&self) -> ComponentId {
-        let cell = self.world_cell();
-        cell.components()
-            .component_id::<T>()
-            .unwrap_or_else(|| cell.world_mut().init_component::<T>())
-    }
-}
-
-/// The channel throught each [`CoroParam`] can yield back to the coroutine.
-/// Which can then return the reason to the caller (the [`Executor`]).
-#[derive(Default, Clone)]
-pub struct YieldChannel(Rc<Cell<Option<WaitingReason>>>);
-
-impl YieldChannel {
-    pub(crate) fn new() -> Self {
-        Self::default()
-    }
-
-    pub(crate) fn receive(&self) -> Option<WaitingReason> {
-        self.0.replace(None)
-    }
-
-    pub(crate) fn send(&self, val: WaitingReason) {
-        self.0.replace(Some(val));
-    }
-}
-
-// Safety: Same as [`WorldWindow`].
-unsafe impl Send for YieldChannel {}
-unsafe impl Sync for YieldChannel {}
-
-/// All relevent values a [`CoroParam`] might need.
-#[derive(Clone)]
-pub struct ParamContext {
-    pub(crate) owner: Entity,
-    pub(crate) world_window: WorldWindow,
-    pub(crate) yield_channel: YieldChannel,
-}
-
-/// A readonly reference to a [`Component`] from the owning [`Entity`].
-///
-/// Note that a Coroutine with such parameter will be canceled if the entity does not have the
-/// relevent component.
-pub struct Rd<T: Component> {
-    context: ParamContext,
-    _phantom: PhantomData<T>,
-}
-
-impl<T: Component> CoroParam for Rd<T> {
-    fn init(context: ParamContext, world: &mut World, access: &mut CoroAccess) -> Option<Self> {
-        let id = world
-            .component_id::<T>()
-            .unwrap_or(world.init_component::<T>());
-
-        if access.this_writes.contains(id.index()) {
-            return None;
-        }
-
-        access.this_reads.insert(id.index());
-
-        Some(Self {
-            context,
-            _phantom: PhantomData,
-        })
-    }
-
-    fn is_valid(owner: Entity, world: &World) -> bool {
-        match world.get_entity(owner) {
-            Some(e) => e.contains::<T>(),
-            _ => false,
-        }
-    }
-}
-
-/// A guarded readonly reference, cannot be hold accros awaiting points.
-pub struct RdGuard<'a, T> {
-    value: &'a T,
-    _phantom: PhantomData<*const T>,
-}
-
-impl<'a, T: Component> Deref for RdGuard<'a, T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        self.value
-    }
-}
-
-impl<T: Component> Rd<T> {
-    /// Return the current value of the [`Component`]. The result ([`InGuard`]) cannot be held
-    /// accros any await.
-    pub fn get(&self) -> RdGuard<'_, T> {
-        unsafe {
-            RdGuard {
-                value: self
-                    .context
-                    .world_window
-                    .world_cell()
-                    .get_entity(self.context.owner)
-                    .unwrap()
-                    .get::<T>()
-                    .unwrap(),
-                _phantom: PhantomData,
-            }
-        }
-    }
-
-    /// Yields and resume when the `Component` is mutated.
-    ///
-    /// Note that it integrates with the regular change detection of Bevy, meaning that the
-    /// coroutine will be resumed, if a [`System`] mutates the value.
-    pub fn on_change(&self) -> OnChange<'_> {
-        unsafe {
-            OnChange::new(
-                &self.context,
-                ObservableId::Component(
-                    self.context.owner,
-                    self.context.world_window.component_id::<T>(),
-                ),
-            )
-        }
-    }
-}
-
-pub struct Wr<T: Component> {
-    _phantom: PhantomData<T>,
-    context: ParamContext,
-}
-
-pub struct WrGuard<'a, T> {
-    value: Mut<'a, T>,
-    _phantom: PhantomData<*const T>,
-}
-
-impl<'a, T: Component> Deref for WrGuard<'a, T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        self.value.deref()
-    }
-}
-
-impl<'a, T: Component> DerefMut for WrGuard<'a, T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        self.value.deref_mut()
-    }
-}
-
-impl<T: Component> Wr<T> {
-    pub fn get(&self) -> RdGuard<'_, T> {
-        let value = unsafe {
-            self.context
-                .world_window
-                .world_cell()
-                .get_entity(self.context.owner)
-                .unwrap()
-                .get::<T>()
-                .unwrap()
-        };
-
-        RdGuard {
-            value,
-            _phantom: PhantomData,
-        }
-    }
-
-    pub fn get_mut(&mut self) -> WrGuard<'_, T> {
-        unsafe {
-            let cell = self.context.world_window.world_cell();
-            let c_id = cell.components().component_id::<T>().unwrap();
-            cell.get_resource_mut::<CoroWrites>()
-                .unwrap()
-                .0
-                .push_back((self.context.owner, c_id));
-
-            let value = cell
-                .get_entity(self.context.owner)
-                .unwrap()
-                .get_mut::<T>()
-                .unwrap();
-            WrGuard {
-                value,
-                _phantom: PhantomData,
-            }
-        }
-    }
-
-    pub fn on_change(&self) -> OnChange<'_> {
-        unsafe {
-            OnChange::new(
-                &self.context,
-                ObservableId::Component(
-                    self.context.owner,
-                    self.context.world_window.component_id::<T>(),
-                ),
-            )
-        }
-    }
-}
-
-impl<T: Component> CoroParam for Wr<T> {
-    fn init(context: ParamContext, w: &mut World, access: &mut CoroAccess) -> Option<Self> {
-        let id = w.component_id::<T>().unwrap_or(w.init_component::<T>());
-
-        if !access.this_reads.insert(id.index()) {
-            return None;
-        }
-
-        access.this_writes.insert(id.index());
-
-        Some(Self {
-            _phantom: PhantomData,
-            context,
-        })
-    }
-
-    fn is_valid(owner: Entity, world: &World) -> bool {
-        match world.get_entity(owner) {
-            Some(e) => e.contains::<T>(),
-            _ => false,
-        }
-    }
-}
-
-pub struct Opt<T> {
-    context: ParamContext,
-    inner: T,
-}
-
-impl<T: CoroParam> Opt<T> {
-    pub fn get(&self) -> Option<&T> {
-        unsafe {
-            if T::is_valid(
-                self.context.owner,
-                self.context.world_window.world_cell().world(),
-            ) {
-                Some(&self.inner)
-            } else {
-                None
-            }
-        }
-    }
-
-    pub fn get_mut(&mut self) -> Option<&mut T> {
-        unsafe {
-            if T::is_valid(
-                self.context.owner,
-                self.context.world_window.world_cell().world(),
-            ) {
-                Some(&mut self.inner)
-            } else {
-                None
-            }
-        }
-    }
-}
-
-impl<T: CoroParam> CoroParam for Opt<T> {
-    fn init(context: ParamContext, world: &mut World, access: &mut CoroAccess) -> Option<Self> {
-        let t = T::init(context.clone(), world, access)?;
-
-        Some(Self { context, inner: t })
-    }
-
-    fn is_valid(_owner: Entity, _world: &World) -> bool {
-        true
-    }
-}
-
-macro_rules! impl_coro_param {
-    ($($param: ident),*) => {
-        #[allow(non_snake_case, unused_parens, unused_variables)]
-        impl<$($param: CoroParam),*> CoroParam for ($($param,)*) {
-            fn init(context: ParamContext, world: &mut World, access: &mut CoroAccess) -> Option<Self> {
-                $(let $param = $param::init(context.clone(), world, access)?;)*
-
-                Some(($($param,)*))
-
-            }
-
-            fn is_valid(owner: Entity, world: &World) -> bool {
-                true $(&& $param::is_valid(owner, world))*
-            }
-        }
-
-    };
-}
-
-all_tuples!(impl_coro_param, 0, 16, P);
diff --git a/src/coroutine/coro_param/component.rs b/src/coroutine/coro_param/component.rs
new file mode 100644
index 0000000..84bddcc
--- /dev/null
+++ b/src/coroutine/coro_param/component.rs
@@ -0,0 +1,194 @@
+use std::{
+    marker::PhantomData,
+    ops::{Deref, DerefMut},
+};
+
+use bevy::prelude::{Component, Entity, Mut, World};
+
+use crate::coroutine::{
+    observable::{ObservableId, OnChange},
+    CoroAccess, CoroWrites, SourceId,
+};
+
+use super::{CoroParam, ParamContext};
+
+/// A readonly reference to a [`Component`] from the owning [`Entity`].
+///
+/// Note that a Coroutine with such parameter will be canceled if the entity does not have the
+/// relevent component.
+pub struct Rd<T: Component> {
+    context: ParamContext,
+    _phantom: PhantomData<T>,
+}
+
+impl<T: Component> CoroParam for Rd<T> {
+    fn init(context: ParamContext, world: &mut World, access: &mut CoroAccess) -> Option<Self> {
+        let id = world
+            .component_id::<T>()
+            .unwrap_or(world.init_component::<T>());
+
+        if !access.add_read(SourceId::Entity(context.owner), id) {
+            return None;
+        }
+
+        Some(Self {
+            context,
+            _phantom: PhantomData,
+        })
+    }
+
+    fn is_valid(owner: Entity, world: &World) -> bool {
+        match world.get_entity(owner) {
+            Some(e) => e.contains::<T>(),
+            _ => false,
+        }
+    }
+}
+
+/// A guarded readonly reference, cannot be hold accros awaiting points.
+pub struct RdGuard<'a, T> {
+    value: &'a T,
+    _phantom: PhantomData<*const T>,
+}
+
+impl<'a, T: Component> Deref for RdGuard<'a, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.value
+    }
+}
+
+impl<T: Component> Rd<T> {
+    /// Return the current value of the [`Component`]. The result ([`InGuard`]) cannot be held
+    /// accros any await.
+    pub fn get(&self) -> RdGuard<'_, T> {
+        unsafe {
+            RdGuard {
+                value: self
+                    .context
+                    .world_window
+                    .world_cell()
+                    .get_entity(self.context.owner)
+                    .unwrap()
+                    .get::<T>()
+                    .unwrap(),
+                _phantom: PhantomData,
+            }
+        }
+    }
+
+    /// Yields and resume when the `Component` is mutated.
+    ///
+    /// Note that it integrates with the regular change detection of Bevy, meaning that the
+    /// coroutine will be resumed, if a [`System`] mutates the value.
+    pub fn on_change(&self) -> OnChange<'_> {
+        unsafe {
+            OnChange::new(
+                &self.context,
+                ObservableId::Component(
+                    self.context.owner,
+                    self.context.world_window.component_id::<T>(),
+                ),
+            )
+        }
+    }
+}
+
+pub struct Wr<T: Component> {
+    _phantom: PhantomData<T>,
+    context: ParamContext,
+}
+
+impl<T: Component> CoroParam for Wr<T> {
+    fn init(context: ParamContext, w: &mut World, access: &mut CoroAccess) -> Option<Self> {
+        let id = w.component_id::<T>().unwrap_or(w.init_component::<T>());
+
+        if !access.add_write(SourceId::Entity(context.owner), id) {
+            return None;
+        }
+
+        Some(Self {
+            _phantom: PhantomData,
+            context,
+        })
+    }
+
+    fn is_valid(owner: Entity, world: &World) -> bool {
+        match world.get_entity(owner) {
+            Some(e) => e.contains::<T>(),
+            _ => false,
+        }
+    }
+}
+
+pub struct WrGuard<'a, T> {
+    value: Mut<'a, T>,
+    _phantom: PhantomData<*const T>,
+}
+
+impl<'a, T: Component> Deref for WrGuard<'a, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.value.deref()
+    }
+}
+
+impl<'a, T: Component> DerefMut for WrGuard<'a, T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.value.deref_mut()
+    }
+}
+
+impl<T: Component> Wr<T> {
+    pub fn get(&self) -> RdGuard<'_, T> {
+        let value = unsafe {
+            self.context
+                .world_window
+                .world_cell()
+                .get_entity(self.context.owner)
+                .unwrap()
+                .get::<T>()
+                .unwrap()
+        };
+
+        RdGuard {
+            value,
+            _phantom: PhantomData,
+        }
+    }
+
+    pub fn get_mut(&mut self) -> WrGuard<'_, T> {
+        unsafe {
+            let cell = self.context.world_window.world_cell();
+            let c_id = cell.components().component_id::<T>().unwrap();
+            cell.get_resource_mut::<CoroWrites>()
+                .unwrap()
+                .0
+                .push_back((self.context.owner, c_id));
+
+            let value = cell
+                .get_entity(self.context.owner)
+                .unwrap()
+                .get_mut::<T>()
+                .unwrap();
+            WrGuard {
+                value,
+                _phantom: PhantomData,
+            }
+        }
+    }
+
+    pub fn on_change(&self) -> OnChange<'_> {
+        unsafe {
+            OnChange::new(
+                &self.context,
+                ObservableId::Component(
+                    self.context.owner,
+                    self.context.world_window.component_id::<T>(),
+                ),
+            )
+        }
+    }
+}
diff --git a/src/coroutine/coro_param/mod.rs b/src/coroutine/coro_param/mod.rs
new file mode 100644
index 0000000..6414b18
--- /dev/null
+++ b/src/coroutine/coro_param/mod.rs
@@ -0,0 +1,165 @@
+use std::{cell::Cell, rc::Rc};
+
+use super::{CoroAccess, WaitingReason};
+use bevy::{
+    ecs::{component::ComponentId, world::unsafe_world_cell::UnsafeWorldCell},
+    prelude::{Component, Entity, World},
+    utils::all_tuples,
+};
+
+pub mod component;
+
+/// Any async function that takes only [`CoroParam`] as arguments can
+/// automatically be turned into a [`Coroutine`].
+pub trait CoroParam: Sized + Send + 'static {
+    /// Initialize the parameter and register any access, if it is invalid (for instance
+    /// conflicting accesses) it will return None.
+    ///
+    /// Note: `world_window` is not yet open at that point, `world` should be used instead.
+    fn init(context: ParamContext, world: &mut World, access: &mut CoroAccess) -> Option<Self>;
+
+    /// Returns true if the parameter is still valid.
+    fn is_valid(owner: Entity, world: &World) -> bool;
+}
+
+/// A shared ref to a [`World`], it is "open" (meaning it points to a valid world with exclusive
+/// access) when the Coroutine is resumed. It is shared to all [`CoroParam`]s.
+#[derive(Clone)]
+pub struct WorldWindow(Rc<Cell<*mut World>>);
+
+// Safety: The window is only shared whith the coroutine itself, As with other similar construct,
+// if you start spawning thread inside a coroutine, or sending coroutine parameters via channels,
+// you may break the safety, therefore please don't do that. (thanks UwU)
+unsafe impl Send for WorldWindow {}
+unsafe impl Sync for WorldWindow {}
+
+impl WorldWindow {
+    pub fn closed_window() -> Self {
+        WorldWindow(Rc::new(Cell::new(std::ptr::null_mut())))
+    }
+
+    pub fn scope<T>(&mut self, world: &mut World, f: impl FnOnce() -> T) -> T {
+        self.0.replace(world as *mut _);
+        let res = f();
+        self.0.replace(std::ptr::null_mut());
+        res
+    }
+
+    /// Returns the world as an [`UnsafeWorldCell`].
+    ///
+    /// # Safety
+    /// The caller must ensure that the pointer points to a valid value. (the window should be
+    /// "open").
+    pub unsafe fn world_cell(&self) -> UnsafeWorldCell<'_> {
+        (*self.0.get()).as_unsafe_world_cell()
+    }
+
+    /// Return the appropriate ComponentId, and initialize it if not present in the world
+    ///
+    /// # Safety
+    /// The caller must ensure that the pointer points to a valid value. (the window should be
+    /// "open").
+    pub unsafe fn component_id<T: Component>(&self) -> ComponentId {
+        let cell = self.world_cell();
+        cell.components()
+            .component_id::<T>()
+            .unwrap_or_else(|| cell.world_mut().init_component::<T>())
+    }
+}
+
+/// The channel throught each [`CoroParam`] can yield back to the coroutine.
+/// Which can then return the reason to the caller (the [`Executor`]).
+#[derive(Default, Clone)]
+pub struct YieldChannel(Rc<Cell<Option<WaitingReason>>>);
+
+impl YieldChannel {
+    pub(crate) fn new() -> Self {
+        Self::default()
+    }
+
+    pub(crate) fn receive(&self) -> Option<WaitingReason> {
+        self.0.replace(None)
+    }
+
+    pub(crate) fn send(&self, val: WaitingReason) {
+        self.0.replace(Some(val));
+    }
+}
+
+// Safety: Same as [`WorldWindow`].
+unsafe impl Send for YieldChannel {}
+unsafe impl Sync for YieldChannel {}
+
+/// All relevent values a [`CoroParam`] might need.
+#[derive(Clone)]
+pub struct ParamContext {
+    pub(crate) owner: Entity,
+    pub(crate) world_window: WorldWindow,
+    pub(crate) yield_channel: YieldChannel,
+}
+
+pub struct Opt<T> {
+    context: ParamContext,
+    inner: T,
+}
+
+impl<T: CoroParam> Opt<T> {
+    pub fn get(&self) -> Option<&T> {
+        unsafe {
+            if T::is_valid(
+                self.context.owner,
+                self.context.world_window.world_cell().world(),
+            ) {
+                Some(&self.inner)
+            } else {
+                None
+            }
+        }
+    }
+
+    pub fn get_mut(&mut self) -> Option<&mut T> {
+        unsafe {
+            if T::is_valid(
+                self.context.owner,
+                self.context.world_window.world_cell().world(),
+            ) {
+                Some(&mut self.inner)
+            } else {
+                None
+            }
+        }
+    }
+}
+
+impl<T: CoroParam> CoroParam for Opt<T> {
+    fn init(context: ParamContext, world: &mut World, access: &mut CoroAccess) -> Option<Self> {
+        let t = T::init(context.clone(), world, access)?;
+
+        Some(Self { context, inner: t })
+    }
+
+    fn is_valid(_owner: Entity, _world: &World) -> bool {
+        true
+    }
+}
+
+macro_rules! impl_coro_param {
+    ($($param: ident),*) => {
+        #[allow(non_snake_case, unused_parens, unused_variables)]
+        impl<$($param: CoroParam),*> CoroParam for ($($param,)*) {
+            fn init(context: ParamContext, world: &mut World, access: &mut CoroAccess) -> Option<Self> {
+                $(let $param = $param::init(context.clone(), world, access)?;)*
+
+                Some(($($param,)*))
+
+            }
+
+            fn is_valid(owner: Entity, world: &World) -> bool {
+                true $(&& $param::is_valid(owner, world))*
+            }
+        }
+
+    };
+}
+
+all_tuples!(impl_coro_param, 0, 16, P);
diff --git a/src/coroutine/function_coroutine.rs b/src/coroutine/function_coroutine.rs
index 0ac3449..74a6d6f 100644
--- a/src/coroutine/function_coroutine.rs
+++ b/src/coroutine/function_coroutine.rs
@@ -11,11 +11,12 @@ use std::task::Poll;
 
 use super::coro_param::ParamContext;
 use super::coro_param::WorldWindow;
-use super::coro_param::{CoroAccess, CoroParam, YieldChannel};
+use super::coro_param::{CoroParam, YieldChannel};
 use super::duration::DurationFuture;
 use super::duration::NextTick;
 use super::par_and::ParAnd;
 use super::par_or::ParOr;
+use super::CoroAccess;
 use super::UninitCoroutine;
 use super::{waker, Coroutine, CoroutineResult, WaitingReason};
 
diff --git a/src/coroutine/mod.rs b/src/coroutine/mod.rs
index 1a8a349..2a120df 100644
--- a/src/coroutine/mod.rs
+++ b/src/coroutine/mod.rs
@@ -7,8 +7,9 @@ use bevy::prelude::Resource;
 use bevy::prelude::Timer;
 use bevy::prelude::World;
 use bevy::utils::synccell::SyncCell;
+use bevy::utils::HashMap;
+use tinyset::SetUsize;
 
-use self::coro_param::CoroAccess;
 use self::observable::ObservableId;
 
 pub mod coro_param;
@@ -40,9 +41,56 @@ pub trait Coroutine: Send + 'static {
 }
 
 /// A shared list of modified values (observable), to easily notify the apropriate observers.
+/// TODO: Find something better
 #[derive(Resource, Default)]
 pub(crate) struct CoroWrites(pub VecDeque<(Entity, ComponentId)>);
 
+#[derive(Default, Clone)]
+pub struct CoroAccess {
+    this_reads: HashMap<SourceId, SetUsize>,
+    this_writes: HashMap<SourceId, SetUsize>,
+}
+
+impl CoroAccess {
+    /// Add a write access. Returns false if there is a conflict.
+    /// The access is updated only when no conflicts are found.
+    pub fn add_write(&mut self, to: SourceId, component: ComponentId) -> bool {
+        if let Some(reads) = self.this_reads.get(&to) {
+            if reads.contains(component.index()) {
+                return false;
+            }
+        }
+
+        self.this_writes
+            .entry(to)
+            .or_default()
+            .insert(component.index())
+    }
+
+    /// Add a read access. Returns false if there is a conflict.
+    /// The access is updated only when no conflicts are found.
+    pub fn add_read(&mut self, to: SourceId, component: ComponentId) -> bool {
+        if let Some(reads) = self.this_writes.get(&to) {
+            if reads.contains(component.index()) {
+                return false;
+            }
+        }
+
+        self.this_reads
+            .entry(to)
+            .or_default()
+            .insert(component.index());
+        true
+    }
+}
+
+#[derive(PartialEq, Eq, Clone, Copy, Hash)]
+pub enum SourceId {
+    Entity(Entity),
+    AllEntities,
+    World,
+}
+
 /// A heap allocated Coroutine
 pub(crate) type CoroObject = SyncCell<Pin<Box<dyn Coroutine>>>;
 
diff --git a/src/lib.rs b/src/lib.rs
index f1fc721..9a8c868 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,17 +1,16 @@
 //! A coroutine library for the [bevy](https://github.com/bevyengine/bevy) game engine.
 //!
 //! TODO: Show example
+pub mod commands;
 pub mod coroutine;
 pub mod executor;
-
-mod commands;
-mod plugin;
+pub mod plugin;
 
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::commands::{coroutine, AddCoroutine};
     #[doc(hidden)]
-    pub use crate::coroutine::coro_param::{Opt, Rd, Wr};
+    pub use crate::coroutine::coro_param::{component::Rd, component::Wr, Opt};
     #[doc(hidden)]
     pub use crate::coroutine::function_coroutine::Fib;
     #[doc(hidden)]

From 996e4c831d8f4a931ece14ee89ee6e58debff2db Mon Sep 17 00:00:00 2001
From: Zacharie Tevaearai <zacharie.tevaearai@epfl.ch>
Date: Wed, 27 Sep 2023 14:17:18 +0200
Subject: [PATCH 10/11] Add resource access

---
 src/coroutine/coro_param/component.rs |  66 +++---------
 src/coroutine/coro_param/mod.rs       |  62 +++++++++++-
 src/coroutine/coro_param/resource.rs  | 139 ++++++++++++++++++++++++++
 src/lib.rs                            |   4 +-
 4 files changed, 216 insertions(+), 55 deletions(-)
 create mode 100644 src/coroutine/coro_param/resource.rs

diff --git a/src/coroutine/coro_param/component.rs b/src/coroutine/coro_param/component.rs
index 84bddcc..2c2687c 100644
--- a/src/coroutine/coro_param/component.rs
+++ b/src/coroutine/coro_param/component.rs
@@ -1,16 +1,13 @@
-use std::{
-    marker::PhantomData,
-    ops::{Deref, DerefMut},
-};
+use std::marker::PhantomData;
 
-use bevy::prelude::{Component, Entity, Mut, World};
+use bevy::prelude::{Component, Entity, World};
 
 use crate::coroutine::{
     observable::{ObservableId, OnChange},
     CoroAccess, CoroWrites, SourceId,
 };
 
-use super::{CoroParam, ParamContext};
+use super::{CoroParam, ParamContext, RdGuard, WrGuard};
 
 /// A readonly reference to a [`Component`] from the owning [`Entity`].
 ///
@@ -45,36 +42,20 @@ impl<T: Component> CoroParam for Rd<T> {
     }
 }
 
-/// A guarded readonly reference, cannot be hold accros awaiting points.
-pub struct RdGuard<'a, T> {
-    value: &'a T,
-    _phantom: PhantomData<*const T>,
-}
-
-impl<'a, T: Component> Deref for RdGuard<'a, T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        self.value
-    }
-}
-
 impl<T: Component> Rd<T> {
     /// Return the current value of the [`Component`]. The result ([`InGuard`]) cannot be held
     /// accros any await.
     pub fn get(&self) -> RdGuard<'_, T> {
         unsafe {
-            RdGuard {
-                value: self
-                    .context
+            RdGuard::new(
+                self.context
                     .world_window
                     .world_cell()
                     .get_entity(self.context.owner)
                     .unwrap()
                     .get::<T>()
                     .unwrap(),
-                _phantom: PhantomData,
-            }
+            )
         }
     }
 
@@ -95,6 +76,10 @@ impl<T: Component> Rd<T> {
     }
 }
 
+/// A read-write exclusive reference to a [`Component`] from the owning [`Entity`].
+///
+/// Note that a Coroutine with such parameter will be canceled if the entity does not have the
+/// relevent component.
 pub struct Wr<T: Component> {
     _phantom: PhantomData<T>,
     context: ParamContext,
@@ -122,25 +107,6 @@ impl<T: Component> CoroParam for Wr<T> {
     }
 }
 
-pub struct WrGuard<'a, T> {
-    value: Mut<'a, T>,
-    _phantom: PhantomData<*const T>,
-}
-
-impl<'a, T: Component> Deref for WrGuard<'a, T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        self.value.deref()
-    }
-}
-
-impl<'a, T: Component> DerefMut for WrGuard<'a, T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        self.value.deref_mut()
-    }
-}
-
 impl<T: Component> Wr<T> {
     pub fn get(&self) -> RdGuard<'_, T> {
         let value = unsafe {
@@ -153,10 +119,7 @@ impl<T: Component> Wr<T> {
                 .unwrap()
         };
 
-        RdGuard {
-            value,
-            _phantom: PhantomData,
-        }
+        RdGuard::new(value)
     }
 
     pub fn get_mut(&mut self) -> WrGuard<'_, T> {
@@ -166,6 +129,7 @@ impl<T: Component> Wr<T> {
             cell.get_resource_mut::<CoroWrites>()
                 .unwrap()
                 .0
+                // TODO fix write
                 .push_back((self.context.owner, c_id));
 
             let value = cell
@@ -173,10 +137,8 @@ impl<T: Component> Wr<T> {
                 .unwrap()
                 .get_mut::<T>()
                 .unwrap();
-            WrGuard {
-                value,
-                _phantom: PhantomData,
-            }
+
+            WrGuard::new(value)
         }
     }
 
diff --git a/src/coroutine/coro_param/mod.rs b/src/coroutine/coro_param/mod.rs
index 6414b18..4e97cdf 100644
--- a/src/coroutine/coro_param/mod.rs
+++ b/src/coroutine/coro_param/mod.rs
@@ -1,13 +1,19 @@
-use std::{cell::Cell, rc::Rc};
+use std::{
+    cell::Cell,
+    marker::PhantomData,
+    ops::{Deref, DerefMut},
+    rc::Rc,
+};
 
 use super::{CoroAccess, WaitingReason};
 use bevy::{
     ecs::{component::ComponentId, world::unsafe_world_cell::UnsafeWorldCell},
-    prelude::{Component, Entity, World},
+    prelude::{Component, Entity, Mut, World},
     utils::all_tuples,
 };
 
 pub mod component;
+pub mod resource;
 
 /// Any async function that takes only [`CoroParam`] as arguments can
 /// automatically be turned into a [`Coroutine`].
@@ -98,6 +104,58 @@ pub struct ParamContext {
     pub(crate) yield_channel: YieldChannel,
 }
 
+/// A guarded readonly reference, cannot be held accros awaiting points.
+pub struct RdGuard<'a, T> {
+    value: &'a T,
+    _phantom: PhantomData<*const T>,
+}
+
+impl<'a, T> RdGuard<'a, T> {
+    pub fn new(value: &'a T) -> Self {
+        Self {
+            value,
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<'a, T> Deref for RdGuard<'a, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.value
+    }
+}
+
+/// A guarded exclusive write reference, cannot be held accros awaiting points.
+pub struct WrGuard<'a, T> {
+    value: Mut<'a, T>,
+    _phantom: PhantomData<*const T>,
+}
+
+impl<'a, T> WrGuard<'a, T> {
+    pub fn new(value: Mut<'a, T>) -> Self {
+        Self {
+            value,
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<'a, T> Deref for WrGuard<'a, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.value.deref()
+    }
+}
+
+impl<'a, T> DerefMut for WrGuard<'a, T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.value.deref_mut()
+    }
+}
+
 pub struct Opt<T> {
     context: ParamContext,
     inner: T,
diff --git a/src/coroutine/coro_param/resource.rs b/src/coroutine/coro_param/resource.rs
new file mode 100644
index 0000000..38869dd
--- /dev/null
+++ b/src/coroutine/coro_param/resource.rs
@@ -0,0 +1,139 @@
+use std::marker::PhantomData;
+
+use bevy::{
+    ecs::component::ComponentId,
+    prelude::{self, Resource, World},
+};
+
+use crate::coroutine::{
+    observable::{ObservableId, OnChange},
+    SourceId,
+};
+
+use super::{CoroParam, ParamContext, RdGuard, WrGuard};
+
+/// A readonly reference to a [`Resource`] in the [`World`].
+///
+/// Note that a Coroutine with such parameter will be canceled if the resource is removed.
+pub struct RdRes<R: Resource> {
+    context: ParamContext,
+    id: ComponentId,
+    _phantom: PhantomData<R>,
+}
+
+impl<R: Resource> CoroParam for RdRes<R> {
+    fn init(
+        context: ParamContext,
+        world: &mut World,
+        access: &mut crate::coroutine::CoroAccess,
+    ) -> Option<Self> {
+        let id = world.components().resource_id::<R>()?;
+        if access.add_read(SourceId::World, id) {
+            return None;
+        }
+
+        Some(RdRes {
+            context,
+            id,
+            _phantom: PhantomData,
+        })
+    }
+
+    fn is_valid(_owner: prelude::Entity, world: &World) -> bool {
+        world.contains_resource::<R>()
+    }
+}
+
+impl<R: Resource> RdRes<R> {
+    /// Return the current value of the [`Resource`]. The result ([`RdGuard`]) cannot be held
+    /// accros any await.
+    pub fn get(&self) -> RdGuard<'_, R> {
+        unsafe {
+            RdGuard::new(
+                self.context
+                    .world_window
+                    .world_cell()
+                    .get_resource::<R>()
+                    .unwrap(),
+            )
+        }
+    }
+
+    /// Yields and resume when the [`Resource`] is mutated.
+    ///
+    /// Note that it integrates with the regular change detection of Bevy, meaning that the
+    /// coroutine will be resumed, if a [`System`] mutates the value.
+    pub fn on_change(&self) -> OnChange<'_> {
+        OnChange::new(&self.context, ObservableId::Resource(self.id))
+    }
+}
+
+/// A read-write exclusive reference to a [`Resource`] in the [`World`].
+///
+/// Note that a Coroutine with such parameter will be canceled if the resource is removed.
+pub struct WrRes<R: Resource> {
+    context: ParamContext,
+    id: ComponentId,
+    _phantom: PhantomData<R>,
+}
+
+impl<R: Resource> CoroParam for WrRes<R> {
+    fn init(
+        context: ParamContext,
+        world: &mut World,
+        access: &mut crate::coroutine::CoroAccess,
+    ) -> Option<Self> {
+        let id = world.components().resource_id::<R>()?;
+        if access.add_write(SourceId::World, id) {
+            return None;
+        }
+
+        Some(WrRes {
+            context,
+            id,
+            _phantom: PhantomData,
+        })
+    }
+
+    fn is_valid(_owner: prelude::Entity, world: &World) -> bool {
+        world.contains_resource::<R>()
+    }
+}
+
+impl<R: Resource> WrRes<R> {
+    /// Return the current value of the [`Resource`]. The result ([`RdGuard`]) cannot be held
+    /// accros any await.
+    pub fn get(&self) -> RdGuard<'_, R> {
+        unsafe {
+            RdGuard::new(
+                self.context
+                    .world_window
+                    .world_cell()
+                    .get_resource::<R>()
+                    .unwrap(),
+            )
+        }
+    }
+
+    /// Return the current value of the [`Resource`]. The result ([`RdGuard`]) cannot be held
+    /// accros any await.
+    pub fn get_mut(&mut self) -> WrGuard<'_, R> {
+        unsafe {
+            WrGuard::new(
+                self.context
+                    .world_window
+                    .world_cell()
+                    .get_resource_mut::<R>()
+                    .unwrap(),
+            )
+        }
+    }
+
+    /// Yields and resume when the [`Resource`] is mutated.
+    ///
+    /// Note that it integrates with the regular change detection of Bevy, meaning that the
+    /// coroutine will be resumed, if a [`System`] mutates the value.
+    pub fn on_change(&self) -> OnChange<'_> {
+        OnChange::new(&self.context, ObservableId::Resource(self.id))
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 9a8c868..c6ff80a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -10,7 +10,9 @@ pub mod prelude {
     #[doc(hidden)]
     pub use crate::commands::{coroutine, AddCoroutine};
     #[doc(hidden)]
-    pub use crate::coroutine::coro_param::{component::Rd, component::Wr, Opt};
+    pub use crate::coroutine::coro_param::{
+        component::Rd, component::Wr, resource::RdRes, resource::WrRes, Opt,
+    };
     #[doc(hidden)]
     pub use crate::coroutine::function_coroutine::Fib;
     #[doc(hidden)]

From 4ef4dc4c6495935a3944237b42aed9506140fddf Mon Sep 17 00:00:00 2001
From: Zacharie Tevaearai <zacharie.tevaearai@epfl.ch>
Date: Wed, 27 Sep 2023 17:11:15 +0200
Subject: [PATCH 11/11] Fix tests

---
 src/lib.rs | 226 +++++++++--------------------------------------------
 1 file changed, 36 insertions(+), 190 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index c6ff80a..c4a3f6c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -70,36 +70,6 @@ mod tests {
         });
     }
 
-    //#[test]
-    //fn wait_on_sub_coroutine() {
-    //    async fn sub_coro(mut fib: Fib) {
-    //        fib.next_tick().await;
-    //        fib.next_tick().await;
-    //    }
-
-    //    let mut world = World::new();
-    //    let e = world.spawn_empty().id();
-    //    world.insert_resource(Executor::new());
-    //    world.insert_resource(Time::new(Instant::now()));
-    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
-    //        let a = Arc::new(Mutex::new(0));
-    //        let b = Arc::clone(&a);
-    //        executor.add_fn(e, move |mut fib: Fib| async move {
-    //            *b.lock().unwrap() += 1;
-    //            fib.on(sub_coro).await;
-    //            *b.lock().unwrap() += 1;
-    //        });
-    //        executor.tick(w);
-    //        assert_eq!(*a.lock().unwrap(), 1);
-    //        executor.tick(w);
-    //        assert_eq!(*a.lock().unwrap(), 1);
-    //        executor.tick(w);
-    //        assert_eq!(*a.lock().unwrap(), 2);
-    //        executor.tick(w);
-    //        assert_eq!(*a.lock().unwrap(), 2);
-    //    });
-    //}
-
     #[test]
     fn wait_on_external_change() {
         let mut world = World::new();
@@ -320,164 +290,40 @@ mod tests {
         });
     }
 
-    ////#[test]
-    ////fn multiple_write_dont_override_too_soon() {
-    ////    let mut world = World::new();
-    ////    world.insert_resource(Executor::new());
-    ////    world.insert_resource(Time::new(Instant::now()));
-    ////    let e = world.spawn(ExampleComponent(0)).id();
-    ////    let a = Arc::new(Mutex::new(0));
-    ////    let b = Arc::clone(&a);
-    ////    world.resource_scope(|w, mut executor: Mut<Executor>| {
-    ////        executor.add(move |mut fib| async move {
-    ////            for _ in 0..5 {
-    ////                let (_, mut example) =
-    ////                    fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-    ////                example.0 += 1;
-    ////            }
-    ////        });
-    ////        executor.add(move |mut fib| async move {
-    ////            for _ in 0..5 {
-    ////                let (_, mut example) =
-    ////                    fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-    ////                example.0 += 1;
-    ////            }
-    ////        });
-    ////        executor.add(|mut fib| async move {
-    ////            loop {
-    ////                fib.change::<ExampleComponent>(e).await;
-    ////                *a.lock().unwrap() += 1;
-    ////            }
-    ////        });
-
-    ////        for i in 0..5 {
-    ////            executor.tick(w);
-    ////            assert_eq!(*b.lock().unwrap(), i * 2);
-    ////            w.clear_trackers();
-    ////        }
-    ////    });
-    ////}
-
-    //#[test]
-    //fn waiting_on_internal_change_do_not_consume_twice_events() {
-    //    let mut world = World::new();
-    //    world.insert_resource(Executor::new());
-    //    world.insert_resource(Time::new(Instant::now()));
-    //    let e1 = world.spawn(ExampleComponent(0)).id();
-    //    let e2 = world.spawn(ExampleComponent(0)).id();
-    //    let a = Arc::new(Mutex::new(0));
-    //    let b = Arc::clone(&a);
-    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
-    //        executor.add(move |mut fib| async move {
-    //            for _ in 0..5 {
-    //                let (_, mut example) =
-    //                    fib.next_tick().then_grab::<&mut ExampleComponent>(e1).await;
-    //                example.0 += 1;
-    //            }
-    //        });
-    //        executor.add(move |mut fib| async move {
-    //            for _ in 0..5 {
-    //                let (_, mut example) =
-    //                    fib.next_tick().then_grab::<&mut ExampleComponent>(e2).await;
-    //                example.0 += 1;
-    //            }
-    //        });
-    //        executor.add(|mut fib| async move {
-    //            loop {
-    //                fib.change::<ExampleComponent>(e1).await;
-    //                *a.lock().unwrap() += 1;
-    //                fib.change::<ExampleComponent>(e2).await;
-    //                *a.lock().unwrap() += 1;
-    //            }
-    //        });
-
-    //        for i in 0..5 {
-    //            executor.tick(w);
-    //            assert_eq!(*b.lock().unwrap(), i * 2);
-    //            w.clear_trackers();
-    //        }
-    //    });
-    //}
-
-    //#[test]
-    //fn not_writing_to_mut_component_has_no_effect() {
-    //    let mut world = World::new();
-    //    world.insert_resource(Executor::new());
-    //    world.insert_resource(Time::new(Instant::now()));
-    //    let e = world.spawn(ExampleComponent(0)).id();
-    //    let a = Arc::new(Mutex::new(0));
-    //    let b = Arc::clone(&a);
-    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
-    //        executor.add(move |mut fib| async move {
-    //            for _ in 0..5 {
-    //                let (_, mut example) =
-    //                    fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-    //                example.0 += 1;
-    //            }
-    //        });
-    //        executor.add(move |mut fib| async move {
-    //            for _ in 0..5 {
-    //                let (_, mut example) =
-    //                    fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-    //                if false {
-    //                    example.0 += 1;
-    //                }
-    //            }
-    //        });
-    //        executor.add(|mut fib| async move {
-    //            loop {
-    //                fib.change::<ExampleComponent>(e).await;
-    //                *a.lock().unwrap() += 1;
-    //            }
-    //        });
-
-    //        for i in 0..5 {
-    //            executor.tick(w);
-    //            assert_eq!(*b.lock().unwrap(), i);
-    //            w.clear_trackers();
-    //        }
-    //    });
-    //}
-
-    //#[test]
-    //fn waiting_on_internal_and_external_change_is_correct() {
-    //    let mut world = World::new();
-    //    world.insert_resource(Executor::new());
-    //    world.insert_resource(Time::new(Instant::now()));
-    //    let e = world.spawn(ExampleComponent(0)).id();
-    //    let a = Arc::new(Mutex::new(0));
-    //    let b = Arc::clone(&a);
-    //    world.resource_scope(|w, mut executor: Mut<Executor>| {
-    //        executor.add(move |mut fib| async move {
-    //            for _ in 0..5 {
-    //                let (_, mut example) =
-    //                    fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-    //                example.0 += 1;
-    //            }
-    //        });
-    //        executor.add(move |mut fib| async move {
-    //            for _ in 0..5 {
-    //                let (_, mut example) =
-    //                    fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-
-    //                if false {
-    //                    example.0 += 1;
-    //                }
-    //            }
-    //        });
-    //        executor.add(|mut fib| async move {
-    //            loop {
-    //                fib.change::<ExampleComponent>(e).await;
-    //                *a.lock().unwrap() += 1;
-    //            }
-    //        });
-
-    //        for i in 0..5 {
-    //            w.entity_mut(e).get_mut::<ExampleComponent>().unwrap().0 += 1;
-    //            executor.tick(w);
-    //            assert_eq!(*b.lock().unwrap(), i * 2);
-    //            w.clear_trackers();
-    //        }
-    //    });
-    //}
+    #[test]
+    fn waiting_on_internal_and_external_change_is_correct() {
+        let mut world = World::new();
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
+        world.insert_resource(Time::new(Instant::now()));
+        let e = world.spawn(ExampleComponent(0)).id();
+
+        let a = Arc::new(Mutex::new(0));
+        let b = Arc::clone(&a);
+
+        coroutine(|ex: Rd<ExampleComponent>| async move {
+            loop {
+                ex.on_change().await;
+                *b.lock().unwrap() += 1;
+            }
+        })
+        .apply(e, &mut world);
+
+        coroutine(|fib: Fib, mut ex: Wr<ExampleComponent>| async move {
+            loop {
+                fib.next_tick().await;
+                ex.get_mut().0 += 1;
+            }
+        })
+        .apply(e, &mut world);
+
+        world.resource_scope(|w, mut executor: Mut<Executor>| {
+            for i in 0..5 {
+                w.entity_mut(e).get_mut::<ExampleComponent>().unwrap().0 += 1;
+                executor.tick(w);
+                assert_eq!(*a.lock().unwrap(), i * 2);
+                w.clear_trackers();
+            }
+        });
+    }
 }