I'm trying to read a file, decrypt it, and return the data. Because the file is potentially very big, I want to do this in a stream.

I cannot find a good pattern to implement the stream. I'm trying to do something like this: 

```
let stream = stream::unfold(decrypted_init_length, |decrypted_length| async move {
    if decrypted_length < start + length {
        let mut encrypted_chunk = vec![0u8; encrypted_block_size];
        match f.read(&mut encrypted_chunk[..]) {
            Ok(size) => {
                if size > 0 {
                    let decrypted = my_decrypt_fn(&encrypted_chunk[..]);
                    let updated_decrypted_length = decrypted_length + decrypted.len();
                    Some((decrypted, updated_decrypted_length))
                } else {
                    None
                }
            }
            Err(e) => {
                println!("Error {}", e);
                None
            }
        }
    } else {
        None
    }
});

```

The problem is that `f.read` is not allowed in the above async closure with the following error:

```none
89  | |             match f.read(&mut encrypted_chunk[..]) {
    | |                   -
    | |                   |
    | |                   move occurs because `f` has type `std::fs::File`, which does not implement the `Copy` trait
    | |                   move occurs due to use in generator

```

I don't want to open `f` inside the closure itself. Is there any better way to fix this? I am OK with using a different crate or trait, or method (i.e. not `stream::unfold`).