Does tokio have a trait like 'Fn' that passes an asynchronous closure function as an argument

[xiashaohua]

I want to use a task executor to execute cycletasks. It is fine to execute synchronous functions, but passing in asynchronous functions will give an error。the error is :

error[E0277]: expected a `Fn<()>` closure, found `impl std::future::Future`
   --> tests\test_job.rs:130:79
    |
130 |     tm.register_task(CRON, "1/5 * * * * *".to_string(), "test3".to_string(),  async {test2().await;});
    |                                                                               ^^^^^^^^^^^^^^^^^^^^^^ expected an `Fn<()>` closure, found `impl std::future::Future`
    |
    = help: the trait `Fn<()>` is not implemented for `impl std::future::Future`
    = note: wrap the `impl std::future::Future` in a closure with no arguments: `|| { /* code */ }`

Then i add the Future,The error report is the same as before:

error[E0277]: expected a `Fn<()>` closure, found `impl std::future::Future`
   --> tests\test_job.rs:130:79
    |
130 |     tm.register_task(CRON, "1/5 * * * * *".to_string(), "test3".to_string(),  async {test2().await;});
    |                                                                               ^^^^^^^^^^^^^^^^^^^^^^ expected an `Fn<()>` closure, found `impl std::future::Future`
    |
    = help: the trait `Fn<()>` is not implemented for `impl std::future::Future`
    = note: wrap the `impl std::future::Future` in a closure with no arguments: `|| { /* code */ }`

[Darksonn]

The trait bound you are looking for is probably something like:

fn register_task<F, Fut>(..., func: F)
where
    F: Fn() -> Fut,
    Fut: Future<Output = ()>,

You would then be able to call it with

tm.register_task(CRON, "1/5 * * * * *".to_string(), "test3".to_string(),  || async {test2().await;});

or even

tm.register_task(CRON, "1/5 * * * * *".to_string(), "test3".to_string(),  || test2());

Note that you need both the || and the async block, in that order. (If you try to do async || { ... }, you get an error about unstable features. Just swap them and it will work.)

[Darksonn]

First change the job type to

pub type JobFn = Box<dyn Send + Sync + Fn() -> Pin<Box<dyn Send + Future<Output = ()>>>>;

struct TaskManager {
    jobs: Vec<ClientTaskInfo>,
    scheduler_instance: JobScheduler,
    test : Vec<JobFn>,
}

You should now be able to do:

pub fn register_task<F, Fut>(&mut self, schedule_type: i8, task_interval: String, task_name: String, task: F)
where
    F: Fn() -> Fut,
    Fut: Future<Output = ()>,
    F: 'static + Send + Sync,
    Fut: 'static + Send,
{
    let mut self_w = self.0.write().unwrap();
    self_w.test.push(Box::new(move || Box::pin(task())));
    ...
}

[xiashaohua]

it works fine, thanks a lot

[xiashaohua]

I am sorry to trouble you again, but when i start it with tokio::spawn,it works wrong。error is :

future cannot be sent between threads safely
   --> tests\test_job_execute.rs:155:9
    |
155 |         tokio::spawn(async move
    |         ^^^^^^^^^^^^ future created by async block is not `Send`
    | 
   ::: C:\Users\xiashaohua\.cargo\registry\src\mirrors.ustc.edu.cn-12df342d903acd47\tokio-1.4.0\src\task\spawn.rs:129:21
    |
129 |         T: Future + Send + 'static,
    |                     ---- required by this bound in `tokio::spawn`
    |
    = help: within `impl std::future::Future`, the trait `Send` is not implemented for `std::sync::RwLockReadGuard<'_, TaskManager>`
note: future is not `Send` as this value is used across an await
   --> tests\test_job_execute.rs:159:17
    |
158 |             for task in &self.0.read().unwrap().test {
    |                          ----------------------    - `self.0.read().unwrap()` is later dropped here
    |                          |
    |                          has type `std::sync::RwLockReadGuard<'_, TaskManager>` which is not `Send`
159 |                 task().await;
    |                 ^^^^^^^^^^^^ await occurs here, with `self.0.read().unwrap()` maybe used later

my test code is

    pub async fn start_test(& self) {
        let l = self.clone();

        tokio::spawn(async move
        {
            //let mut self_w = &self.0.lock().unwrap();

            for task in l.0.read().unwrap().test {
                task().await;
            }
        });
    }

[xiashaohua]

I replaced std::sync::RwLockwith tokio::sync::RwLock,it works 。

[Darksonn]

That error is covered in this chapter of the Tokio tutorial.