You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: function.rs
    path of file: ./repos/turbo/crates/turbo-tasks/src/task
    
    the code of the file until where you have to start completion: //! # Function tasks
//!
//! This module contains the trait definitions and implementations that are
//! necessary for accepting functions as tasks when using the
//! `turbo_tasks::function` macro.
//!
//! This system is inspired by Bevy's Systems and Axum's Handlers.
//!
//! The original principle is somewhat simple: a function is accepted if all
//! of its arguments implement `TaskInput` and its return type implements
//! `TaskOutput`. There are a few hoops one needs to jump through to make this
//! work, but they are described in this blog post:
//! h
    
            fn functor(&self, inputs: &[ConcreteTaskInput]) -> Result<NativeTaskFn> {
                let task_fn = self.clone();
                let mut iter = inputs.iter();

                $(
                    let $arg = iter.next().context(format!("task is missing argument {}", stringify!($arg)))?;
                )*

                if iter.next().is_some() {
                    bail!("task was called with too many arguments");
                }

                $(
                    let $arg = $arg::try_from_concrete($arg)?;
                )*

                Ok(Box::new(move || {
                    let task_fn = task_fn.clone();
                    $(
                        let $arg = $arg.clone();
                    )*

                    Box::pin(async move {
                        Output::try_into_raw_vc((task_fn)($($arg),*).await)
                    })
                }))
            }