passing around a VCF query

[brentp]

Hi, this is yet another basic(-ish) rust question/request, but I'm struggling to have a query struct and pass it to/from functions. I understand why my code in the example here doesn't work, but not how to fix.

Does anyone have example code for this?

Updating noodles-util/examples/util_variant_query.rs to pass the Query around would be helpful here.

[zaeleus]

There are two main Rust issues here.

First, the default lifetime of Box<T> is 'static, i.e., Box<T + 'static>; however, the query iterator has a lifetime of 'r, which is the lifetime of the reader.

Second, Rust disallows mutable aliasing, even if you just want a reference afterward. This means you cannot hold a mutable reference of reader in the query iterator and a reference in QueryHolder. Since there's no usage of QueryHolder in the example, I'm not sure if you actually need to hold a reference to the reader (or header). I removed the reader from the struct.

util_212.rs

use noodles::core::Region;
use noodles::vcf;
use noodles_util::variant;
use std::io;

struct QueryHolder<'r, 'h: 'r> {
    query: Box<dyn Iterator<Item = io::Result<vcf::Record>> + 'r>,
    header: &'h vcf::Header,
}

fn get_qh<'r, 'h: 'r>(
    reader: &'r mut variant::IndexedReader<std::fs::File>,
    header: &'h vcf::Header,
    region: &Region,
) -> Result<QueryHolder<'r, 'h>, Box<dyn std::error::Error>> {
    let q = reader.query(header, region)?;
    let qh = QueryHolder {
        query: Box::new(q),
        header,
    };
    Ok(qh)
}

pub fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = std::env::args().skip(1);
    let vcf_path = args.next().expect("missing vcf path");
    let mut reader = variant::indexed_reader::Builder::default().build_from_path(vcf_path)?;
    let header = reader.read_header()?;

    let region = "chr1".parse()?;

    let qh = get_qh(&mut reader, &header, &region)?;

    Ok(())
}

Updating noodles-util/examples/util_variant_query.rs to pass the Query around would be helpful here.

Query should be treated as an implementation of Iterator, like you are in your example. You can then use any of the definitions explained in The Rust Programming Language § 10.2 "Traits: Defining Shared Behavior". E.g.,

fn f<I>(records: I) -> io::Reuslt<()>
where
    I: Iterator<Item = io::Result<vcf::Record>>
{
    for result in records {
        let record = result?;
        // ...
    }

    Ok(())
}