具有较高排名特征绑定参数的异步函数参数不起作用，一种类型比另一种类型更通用

Question

我正在尝试将函数指针作为参数中的回调函数传递，这是迄今为止我的代码中的一个剥离示例：

Rust 游乐场代码

use std::{
    fs::File,
    io::{self, BufRead, BufReader},
    path::Path,
};

use futures::{executor, Future}; // 0.3.8

type DigestCallback<R> = fn(&[u8]) -> R;

async fn consume<T>(
    path: T,
    chunk_size: usize,
    digest: DigestCallback<impl Future<Output = ()>>,
) -> io::Result<()>
where
    T: AsRef<Path>,
{
    let file = File::open(path)?;
    let mut reader = BufReader::with_capacity(chunk_size, file);
    loop {
        let buffer = reader.fill_buf()?;
        let length = buffer.len();

        if length == 0 {
            break;
        }

        digest(buffer).await;
        reader.consume(length);
    }

    Ok(())
}

async fn digest_callback(chunk: &[u8]) -> () {
    ()
}

fn main() {
    executor::block_on(consume("my_file.bin", 64, digest_callback));
}

我收到这个错误

use std::{
    fs::File,
    io::{self, BufRead, BufReader},
    path::Path,
};

use futures::{executor, Future}; // 0.3.8

type DigestCallback<R> = fn(&[u8]) -> R;

async fn consume<T>(
    path: T,
    chunk_size: usize,
    digest: DigestCallback<impl Future<Output = ()>>,
) -> io::Result<()>
where
    T: AsRef<Path>,
{
    let file = File::open(path)?;
    let mut reader = BufReader::with_capacity(chunk_size, file);
    loop {
        let buffer = reader.fill_buf()?;
        let length = buffer.len();

        if length == 0 {
            break;
        }

        digest(buffer).await;
        reader.consume(length);
    }

    Ok(())
}

async fn digest_callback(chunk: &[u8]) -> () {
    ()
}

fn main() {
    executor::block_on(consume("my_file.bin", 64, digest_callback));
}

当我将其变成 a 时它可以工作，Vec<u8>但我担心性能问题，因为我正在处理潜在的巨大文件。有人可以帮助我理解我做错了什么吗？我应该如何在 Rust 中做到这一点？有更好的方法来实现这一目标吗？

更新：如果我删除Future和异步函数，并将函数类型更改为type DigestCallback = for<'a> fn(&'a [u8]) -> ();它似乎可以工作。但还不知道如何让它与异步函数一起工作

Rust 游乐场代码

use std::{
  fs::File,
  io::{self, BufRead, BufReader},
  path::Path,
};

type DigestCallback = for<'a> fn(&'a [u8]) -> ();

fn consume<T>(
  path: T,
  chunk_size: usize,
  digest: DigestCallback,
) -> io::Result<()>
where
  T: AsRef<Path>,
{
  let file = File::open(path)?;
  let mut reader = BufReader::with_capacity(chunk_size, file);
  loop {
    let buffer = reader.fill_buf()?;
    let length = buffer.len();
    
    if length == 0 {
      break;
    }
    
    digest(buffer);
    reader.consume(length);
  }

  Ok(())
}

fn digest_callback(_chunk: &[u8]) -> () {()}

fn main() {
  let _ = consume("my_file.bin", 64, digest_callback);
}

Answer 1

你可以尝试

 fn consume<T, F >(
  path: T,
  chunk_size: usize,
  digest: F,
) -> io::Result<()>
where
  T: AsRef<Path>,
  F: for <'c> Fn(&'c mut Vec<u8>)->Pin<Box<dyn Future<Output = ()> + 'c>>