Create an async SAM reader from stdin or file

[mbhall88]

I can't seem to get this working to create an AsyncReader from either stdin or file.

use tokio::fs::File;
use tokio::io::BufReader;
use noodles_sam as sam;

let input = // command line positional argument

let mut reader = if input == "-" {
    sam::AsyncReader::new(BufReader::new(tokio::io::stdin()))
} else {
    File::open(input)
        .await
        .map(BufReader::new)
        .map(sam::AsyncReader::new)?
};

this give the error

error[E0308]: `if` and `else` have incompatible types
  --> src/main.rs:36:9
   |
33 |        let mut reader = if input == "-" {
   |  _______________________-
34 | |          sam::AsyncReader::new(BufReader::new(tokio::io::stdin()))
   | |          --------------------------------------------------------- expected because of this
35 | |      } else {
36 | |/         File::open(input)
37 | ||             .await
38 | ||             .map(BufReader::new)
39 | ||             .map(sam::AsyncReader::new)?
   | ||________________________________________^ expected `AsyncReader<BufReader<Stdin>>`, found `AsyncReader<BufReader<File>>`
40 | |      };
   | |______- `if` and `else` have incompatible types
   |
   = note: expected struct `AsyncReader<tokio::io::BufReader<tokio::io::Stdin>>`
              found struct `AsyncReader<tokio::io::BufReader<tokio::fs::File>>`

This code was essentially the same for the sync version (and compiled fine), I just changed the use to tokio and AsyncReader.

In addition, to save me going down a deadend, I am converting this codebase from sync to async. The important part is that I want to be able to gather some information about records as they come in and every n records I want to send said information to an API. Currently the compiler is telling me

error[E0277]: `(dyn noodles_sam::alignment::Record + 'static)` cannot be sent between threads safely
   --> src/main.rs:56:55
    |
56  |         sender.send(SenderEvent::Record(record)).await?;
    |                                                       ^ `(dyn noodles_sam::alignment::Record + 'static)` cannot be sent between threads safely
    |
    = help: the trait `Send` is not implemented for `(dyn noodles_sam::alignment::Record + 'static)`, which is required by `Result<(), _>: FromResidual<Result<Infallible, tokio::sync::mpsc::error::SendError<SenderEvent>>>`
    = help: the following other types implement trait `FromResidual<R>`:
              <Result<T, F> as FromResidual<Result<Infallible, E>>>
              <Result<T, F> as FromResidual<Yeet<E>>>
    = note: required for `Unique<(dyn noodles_sam::alignment::Record + 'static)>` to implement `Send`
note: required because it appears within the type `Box<(dyn noodles_sam::alignment::Record + 'static)>`

but is this just because I am not currently using the AsyncReader. Will this all go away when I successfully get the AsyncReader working? Or will this still be impossible with the AsyncReader?

[zaeleus]

I can't seem to get this working to create an AsyncReader from either stdin or file.

All branches of an if expression must return the same type. This is hinted by the error message "if and else have incompatible types", i.e., the inner readers tokio::io::Stdin and tokio::fs::File are of two different types. Given both readers implement AsyncBufRead, you can cast them to boxed trait objects to return a homogeneous type. (Most tokio I/O extension operations do not assume the reader is address-sensitive, so we also require Unpin.)

let reader: Box<dyn AsyncBufRead + Unpin> = if src == "-" {
    Box::new(BufReader::new(io::stdin()))
} else {
    File::open(src).await.map(BufReader::new).map(Box::new)?
};

let mut reader = sam::r#async::io::Reader::new(reader);
// => sam::r#async::io::Reader<Box<dyn AsyncBufRead + Unpin>>

error[E0277]: `(dyn noodles_sam::alignment::Record + 'static)` cannot be sent between threads safely

If record is a concrete record (sam::Record or sam::alignment::RecordBuf), when you create the boxed trait object, add the Send marker, e.g.,

let record = reader.records().try_next().await?.expect("missing record");
let record: Box<dyn sam::alignment::Record + Send> = Box::new(record);
sender.send(SenderEvent::Record(record)).await?;

[mbhall88]

Incredibly informative as always. I feel like I need to sponsor you in some way as I have learned so much about Rust through interacting with you on here. I don't pretend to full understand all of these traits and how they interact but I am (hopefully) getting there slowly with your patient responses and the resources you link to. Thank you very much.