New granges map integration tests, handling missing BED5 values, etc.

 - New `Option<f64>` support for BED5 files with '.' missing data.
 - `parse_optional()` for handling parsing generic values with possible
    missing data.
 - More documentation changes.
 - `test_against_bedtools_map()` integration tests between granges and bedtools.

benches/bedtools_comparison.rs

@@ -187,12 +187,11 @@ fn bench_windows(c: &mut Criterion) {
     });
 }
 
-
 criterion_group!(
     benches,
     bench_filter_adjustment,
     bench_range_adjustment,
     bench_flank,
     bench_windows,
-    );
+);
 criterion_main!(benches);

src/commands.rs

@@ -455,7 +455,7 @@ pub fn granges_map(
     // Process all the overlaps.
     let result_gr = left_join_gr.map_over_joins(|join_data| {
         // Get the "right data" -- the BED5 scores.
-        let overlap_scores = join_data.right_data;
+        let overlap_scores: Vec<f64> = join_data.right_data.into_iter().filter_map(|x| x).collect();
 
         // Run all operations on the scores.
         operations

src/data/operations.rs

@@ -77,7 +77,7 @@ impl Operation {
                     .iter()
                     .map(|num| num.to_string())
                     .collect::<Vec<_>>()
-                    .join(", ");
+                    .join(",");
                 DatumType::String(collapsed)
             }
         }

src/granges.rs

@@ -33,47 +33,6 @@
 //! will have associated data or not. The special [`GRangesEmpty`] type represents (and wraps)
 //! [`GRanges<R, T>`] objects that do not have data.
 //!
-//!
-//!
-//!
-//! TODO
-//!
-//! **High-level data types**: A key feature of GRanges design is that a single type of ranges are
-//! contained in the range containers. By knowing that every range in a range container either has
-//! an index to a data element in the data container or it does not ahead of time simplifies
-//! downstream ergonomics tremendously.
-//!
-//! **Emphasis on compile-time**: For this, let's consider a common problem: a bioinformatics tool
-//! needs to read in a BED-like file that has a variable, unknown at compile time, number of
-//! columns.
-//!
-//! This is an important concept when working with [`GRanges<R, T>`] types:
-//!
-//! **High-level data types**: A key feature of GRanges design is that a single type of ranges are
-//! contained in the range containers. By knowing that every range in a range container either has
-//! an index to a data element in the data container or it does not ahead of time simplifies
-//! downstream ergonomics tremendously.
-//!
-//! **Emphasis on compile-time**: For this, let's consider a common problem: a bioinformatics tool
-//! needs to read in a BED-like file that has a variable, unknown at compile time, number of
-//! columns.
-//!
-//! In Rust, this could be handled in one of two ways. First, it could be handled at *runtime*, by
-//! leveraging Rust's dynamic trait system. For example, imagine loading in one of two possible BED
-//! formats:
-//!
-//!  1. *Data-less BED3*: The appropriate `GRanges` object here would be a `GRanges<VecRangesEmpty,
-//!     ()>`.
-//!
-//!  2. *BED-like with data*: Here, we'd need a `GRanges<VecRangesIndexed, Vec<U>>`, where the
-//!     `Vec<U>` is data container containing just-loaded-in data.
-//!
-//! Suppose your code doesn't know, when you're writing it, which of these two cases it will
-//! encounter.
-//!
-//! Because at compile-time, the types *need* to be known, there are a few options here.
-//!
-//!
 //! [`Bed3Iterator`]: crate::io::parsers::Bed3Iterator
 //! [`BedlikeIterator`]: crate::io::parsers::BedlikeIterator
 //! [`GRanges::into_coitrees`]: crate::granges::GRanges::into_coitrees
@@ -216,6 +175,9 @@ where
     pub fn take_data(&mut self) -> Result<T, GRangesError> {
         std::mem::take(&mut self.data).ok_or(GRangesError::NoDataContainer)
     }
+    pub fn take_ranges(&mut self) -> GenomeMap<C> {
+        std::mem::take(&mut self.ranges)
+    }
 }
 
 impl<'a, T> GenomicRangesTsvSerialize<'a, VecRangesIndexed> for GRanges<VecRangesIndexed, T>
@@ -386,6 +348,12 @@ impl<R: GenericRange> GRangesEmpty<VecRanges<R>> {
     }
 }
 
+impl<C> GRangesEmpty<C> {
+    pub fn take_ranges(&mut self) -> GenomeMap<C> {
+        std::mem::take(&mut self.0.ranges)
+    }
+}
+
 impl GRangesEmpty<VecRangesEmpty> {
     /// Make a [`GRangesEmpty<VecRanges>`] with ranges from (possibly overlapping) windows.
     ///

src/io/parsers.rs

@@ -79,17 +79,16 @@ use std::collections::HashSet;
 use std::io::{BufRead, BufReader};
 use std::marker::PhantomData;
 use std::path::{Path, PathBuf};
+use std::str::FromStr;
 
-use crate::data::DatumType;
 use crate::error::GRangesError;
 use crate::io::file::InputStream;
 use crate::ranges::{GenomicRangeEmptyRecord, GenomicRangeRecord};
-use crate::traits::{
-    GeneralRangeRecordIterator, GenomicRangeRecordUnwrappable, Selection, TsvSerialize,
-};
+use crate::traits::{GeneralRangeRecordIterator, GenomicRangeRecordUnwrappable, TsvSerialize};
 use crate::Position;
 
 use super::tsv::TsvConfig;
+use super::BED_TSV;
 
 // FEATURE/TODO: hints? if not performance cost
 // use lazy_static::lazy_static;
@@ -405,30 +404,42 @@ impl TsvSerialize for Option<Strand> {
 #[derive(Clone, Debug)]
 pub struct Bed5Addition {
     pub name: String,
-    pub score: f64,
+    pub score: Option<f64>,
 }
 
-impl Selection for &Bed5Addition {
-    fn select_by_name(&self, name: &str) -> DatumType {
-        match name {
-            "name" => DatumType::String(self.name.clone()),
-            "score" => DatumType::Float64(self.score),
-            _ => panic!("No item named '{}'", name),
-        }
-    }
-}
+//impl Selection for &Bed5Addition {
+//    fn select_by_name(&self, name: &str) -> DatumType {
+//        match name {
+//            "name" => DatumType::String(self.name.clone()),
+//            "score" => DatumType::Float64(self.score),
+//            _ => panic!("No item named '{}'", name),
+//        }
+//    }
+//}
 
 impl TsvSerialize for &Bed5Addition {
     #![allow(unused_variables)]
     fn to_tsv(&self, config: &TsvConfig) -> String {
-        format!("{}\t{}", self.name, self.score)
+        format!(
+            "{}\t{}",
+            self.name,
+            self.score
+                .as_ref()
+                .map_or(config.no_value_string.clone(), |x| x.to_string())
+        )
     }
 }
 
 impl TsvSerialize for Bed5Addition {
     #![allow(unused_variables)]
     fn to_tsv(&self, config: &TsvConfig) -> String {
-        format!("{}\t{}", self.name, self.score)
+        format!(
+            "{}\t{}",
+            self.name,
+            self.score
+                .as_ref()
+                .map_or(config.no_value_string.clone(), |x| x.to_string())
+        )
     }
 }
 
@@ -899,10 +910,34 @@ fn parse_strand(symbol: char) -> Result<Option<Strand>, GRangesError> {
     }
 }
 
+/// Parses a string to an `Option<T>`, where `T` implements `FromStr`.
+/// Returns `None` if the input string is a specified placeholder (e.g., "."),
+/// otherwise attempts to parse the string into `T`.
+///
+/// # Arguments
+///
+/// * `input` - The input string to parse.
+/// * `placeholder` - The placeholder string representing `None`.
+///
+/// # Returns
+///
+/// Returns `Ok(None)` if `input` is equal to `placeholder`, `Ok(Some(value))`
+/// if `input` can be parsed into `T`, or an error if parsing fails.
+pub fn parse_optional<T: FromStr>(input: &str, config: &TsvConfig) -> Result<Option<T>, T::Err> {
+    if input == config.no_value_string {
+        Ok(None)
+    } else {
+        input.parse().map(Some)
+    }
+}
+
 /// Parses a BED5 format line into the three columns defining the range, and additional
 /// columns
 ///
+/// Warning: this currently does *not* properly handle converting the missing data `.`
+/// character to `None` values.
 pub fn parse_bed5(line: &str) -> Result<GenomicRangeRecord<Bed5Addition>, GRangesError> {
+    // TODO FIXME
     let columns: Vec<&str> = line.splitn(6, '\t').collect();
     if columns.len() < 5 {
         return Err(GRangesError::BedTooFewColumns(
@@ -917,7 +952,7 @@ pub fn parse_bed5(line: &str) -> Result<GenomicRangeRecord<Bed5Addition>, GRange
     let end: Position = parse_column(columns[2], line)?;
 
     let name = parse_column(columns[3], line)?;
-    let score: f64 = parse_column(columns[4], line)?;
+    let score: Option<f64> = parse_optional(columns[4], &BED_TSV)?;
 
     let data = Bed5Addition { name, score };
 
@@ -929,6 +964,32 @@ pub fn parse_bed5(line: &str) -> Result<GenomicRangeRecord<Bed5Addition>, GRange
     })
 }
 
+// mostly for internal tests
+pub fn parse_record_with_score(
+    line: &str,
+) -> Result<GenomicRangeRecord<Option<f64>>, GRangesError> {
+    // Split the line into columns
+    let columns: Vec<&str> = line.split('\t').collect();
+    if columns.len() < 4 {
+        return Err(GRangesError::BedTooFewColumns(
+            columns.len(),
+            4,
+            line.to_string(),
+        ));
+    }
+
+    // Parse the range columns
+    let seqname: String = parse_column(columns[0], line)?;
+    let start: Position = parse_column(columns[1], line)?;
+    let end: Position = parse_column(columns[2], line)?;
+
+    // Parse the fourth column as Option<f64>
+    let score: Option<f64> = parse_optional(columns[3], &BED_TSV)?;
+
+    // Construct and return the GenomicRangeRecord with score as data
+    Ok(GenomicRangeRecord::new(seqname, start, end, score))
+}
+
 // TODO
 ///// Parses a BED6 format line into the three columns defining the range, and additional
 ///// columns

src/io/tsv.rs

@@ -18,15 +18,13 @@ pub struct TsvConfig {
 }
 
 impl TsvSerialize for &String {
-    #![allow(unused_variables)]
-    fn to_tsv(&self, config: &TsvConfig) -> String {
+    fn to_tsv(&self, _config: &TsvConfig) -> String {
         self.to_string()
     }
 }
 
 impl TsvSerialize for String {
-    #![allow(unused_variables)]
-    fn to_tsv(&self, config: &TsvConfig) -> String {
+    fn to_tsv(&self, _config: &TsvConfig) -> String {
         self.to_string()
     }
 }
@@ -57,61 +55,53 @@ impl TsvSerialize for &Vec<DatumType> {
 }
 
 impl TsvSerialize for &f64 {
-    #![allow(unused_variables)]
-    fn to_tsv(&self, config: &TsvConfig) -> String {
+    fn to_tsv(&self, _config: &TsvConfig) -> String {
         // TODO precision from config
         format!("{}", self).to_string()
     }
 }
 
 impl TsvSerialize for f64 {
-    #![allow(unused_variables)]
-    fn to_tsv(&self, config: &TsvConfig) -> String {
+    fn to_tsv(&self, _config: &TsvConfig) -> String {
         // TODO precision from config
         format!("{}", self).to_string()
     }
 }
 
 impl TsvSerialize for &f32 {
-    #![allow(unused_variables)]
-    fn to_tsv(&self, config: &TsvConfig) -> String {
+    fn to_tsv(&self, _config: &TsvConfig) -> String {
         // TODO precision from config
         format!("{}", self).to_string()
     }
 }
 
 impl TsvSerialize for f32 {
-    #![allow(unused_variables)]
-    fn to_tsv(&self, config: &TsvConfig) -> String {
+    fn to_tsv(&self, _config: &TsvConfig) -> String {
         // TODO precision from config
         format!("{}", self).to_string()
     }
 }
 
 impl TsvSerialize for &i64 {
-    #![allow(unused_variables)]
-    fn to_tsv(&self, config: &TsvConfig) -> String {
+    fn to_tsv(&self, _config: &TsvConfig) -> String {
         format!("{}", self).to_string()
     }
 }
 
 impl TsvSerialize for i64 {
-    #![allow(unused_variables)]
-    fn to_tsv(&self, config: &TsvConfig) -> String {
+    fn to_tsv(&self, _config: &TsvConfig) -> String {
         format!("{}", self).to_string()
     }
 }
 
 impl TsvSerialize for &i32 {
-    #![allow(unused_variables)]
-    fn to_tsv(&self, config: &TsvConfig) -> String {
+    fn to_tsv(&self, _config: &TsvConfig) -> String {
         format!("{}", self).to_string()
     }
 }
 
 impl TsvSerialize for i32 {
-    #![allow(unused_variables)]
-    fn to_tsv(&self, config: &TsvConfig) -> String {
+    fn to_tsv(&self, _config: &TsvConfig) -> String {
         format!("{}", self).to_string()
     }
 }