Converting an async function into a trait object

Hi there Rustaceans!
Ive been attempting to implement a basic async ECS using Rust as a toy project to help me understand the subject better.
My idea is that i want to accept both simple (async) functions and complex structs as systems.
I thought this wouldnt be a problem, since i run the systems using trait objects (dynamic dispatch) anyway.
These are the basic trait definitions i have so far:

pub trait System: Send + Sync {
    type Data: SystemData;
    async fn run(&mut self, data: Self::Data);

impl<D: SystemData, O> System for fn(D) -> O
where O: Future<Output = ()> + Send
    type Data = D;
    async fn run(&mut self, data: Self::Data) {

pub trait IntoDynSystem {
    fn into_dyn_system(self) -> Box<dyn DynSystem>;

impl<D: SystemData + 'static, O: Future<Output = ()> + Send + 'static> IntoDynSystem for fn(D) -> O {
    fn into_dyn_system(self) -> Box<dyn DynSystem> {

pub trait DynSystem {
    async fn dyn_run(&mut self, world: &World);

impl<S: System> DynSystem for S {
    async fn dyn_run(&mut self, world: &World) {

System itself is intended for defining the systems, while a trait object of DynSystem will be used to actually run them. However, during this basic test:

async fn run_basic_system<S: IntoDynSystem>(sys: S) {
    let system_box: Box<dyn DynSystem> = sys.into_dyn_system();

async fn basic_system(_args: ()) {
    println!("Basic system!");

async fn test_basic_system() {

I get a type mismatch error like this:

the trait bound `fn(()) -> impl std::future::Future<Output = ()> {basic_system}: messy_ecs::system::IntoDynSystem` is not satisfied
the following implementations were found:
  <fn(D) -> O as messy_ecs::system::IntoDynSystem>

What am i missing and/or fundamentally misunderstanding in my approach here?
Any help would be greatly appreciated. I would assume impl Future<Output = ()> would be caught by the trait constraints.