feat(polychem): allow more modification conversions

Added more `From` impls for modification kinds and wrappers, and also
refactored `SignedCount` -> `Charge`, and added blanket impls for refs
and to automatically derive the `Mz` trait.

Author: TheLostLambda

crates/polychem/src/atoms/chemical_composition.rs

@@ -6,9 +6,7 @@ use rust_decimal::Decimal;
 
 // Local Crate Imports
 use super::{atomic_database::AtomicDatabase, chemical_composition_parser::chemical_composition};
-use crate::{
-    Charge, Charged, ChemicalComposition, Count, Element, Massive, Mz, Result, SignedCount,
-};
+use crate::{Charge, Charged, ChemicalComposition, Count, Element, Massive, Result};
 
 // Public API ==========================================================================================================
 
@@ -36,16 +34,14 @@ impl Charged for ChemicalComposition<'_> {
         self.particle_offset
             .as_ref()
             .map(|(k, c, p)| {
-                let sign = SignedCount::from(*k);
+                let sign = Charge::from(*k);
                 let c = Charge::from(*c);
                 sign * c * p.charge()
             })
             .unwrap_or_default()
     }
 }
 
-impl Mz for ChemicalComposition<'_> {}
-
 // Display and Hash Trait Implementations ==============================================================================
 
 impl Display for ChemicalComposition<'_> {

crates/polychem/src/atoms/offset_kind.rs

@@ -2,7 +2,7 @@ use std::fmt::{self, Display, Formatter};
 
 use rust_decimal::Decimal;
 
-use crate::{OffsetKind, SignedCount};
+use crate::{Charge, OffsetKind};
 
 impl Display for OffsetKind {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
@@ -19,11 +19,11 @@ impl Display for OffsetKind {
 
 impl From<OffsetKind> for Decimal {
     fn from(value: OffsetKind) -> Self {
-        SignedCount::from(value).into()
+        Charge::from(value).into()
     }
 }
 
-impl From<OffsetKind> for SignedCount {
+impl From<OffsetKind> for Charge {
     fn from(value: OffsetKind) -> Self {
         match value {
             OffsetKind::Add => 1,
@@ -47,11 +47,11 @@ mod tests {
     }
 
     #[test]
-    fn into_signed_count() {
+    fn into_charge() {
         let add = OffsetKind::Add;
-        assert_eq!(SignedCount::from(add), 1);
+        assert_eq!(Charge::from(add), 1);
         let remove = OffsetKind::Remove;
-        assert_eq!(SignedCount::from(remove), -1);
+        assert_eq!(Charge::from(remove), -1);
     }
 
     #[test]

crates/polychem/src/atoms/particle.rs

@@ -2,7 +2,7 @@ use std::fmt::{self, Display, Formatter};
 
 use rust_decimal::Decimal;
 
-use crate::{Charge, Charged, Massive, Mz, Particle};
+use crate::{Charge, Charged, Massive, Particle};
 
 use super::{
     atomic_database::{AtomicDatabase, ParticleDescription},
@@ -51,8 +51,6 @@ impl Charged for Particle<'_> {
     }
 }
 
-impl Mz for Particle<'_> {}
-
 #[cfg(test)]
 mod tests {
     use insta::assert_debug_snapshot;

crates/polychem/src/lib.rs

@@ -62,8 +62,6 @@ pub struct Modification<K> {
     pub kind: K,
 }
 
-type SignedCount = i64;
-
 // ---------------------------------------------------------------------------------------------------------------------
 
 #[derive(Clone, PartialEq, Eq, Debug, Serialize)]
@@ -162,16 +160,52 @@ pub trait Charged {
 
 pub trait Mz: Massive + Charged {
     fn monoisotopic_mz(&self) -> Option<Decimal> {
-        let charge = self.charge().abs();
-        (charge != 0).then(|| self.monoisotopic_mass() / Decimal::from(charge))
+        let charge = Decimal::from(self.charge()).abs();
+        (!charge.is_zero()).then(|| self.monoisotopic_mass() / charge)
     }
 
     fn average_mz(&self) -> Option<Decimal> {
-        let charge = self.charge().abs();
-        (charge != 0).then(|| self.average_mass() / Decimal::from(charge))
+        let charge = Decimal::from(self.charge()).abs();
+        (!charge.is_zero()).then(|| self.average_mass() / charge)
     }
 }
 
+// Blanket impls
+
+macro_rules! massive_ref_impls {
+    ($($ref_type:ty),+ $(,)?) => {
+        $(
+            impl<T: Massive> Massive for $ref_type {
+                fn monoisotopic_mass(&self) -> Decimal {
+                    (**self).monoisotopic_mass()
+                }
+
+                fn average_mass(&self) -> Decimal {
+                    (**self).average_mass()
+                }
+            }
+        )+
+    };
+}
+
+massive_ref_impls!(&T, &mut T, Box<T>);
+
+macro_rules! charged_ref_impls {
+    ($($ref_type:ty),+ $(,)?) => {
+        $(
+            impl<T: Charged> Charged for $ref_type {
+                fn charge(&self) -> Charge {
+                    (**self).charge()
+                }
+            }
+        )+
+    };
+}
+
+charged_ref_impls!(&T, &mut T, Box<T>);
+
+impl<T: Massive + Charged> Mz for T {}
+
 pub type Result<T, E = Box<PolychemError>> = std::result::Result<T, E>;
 
 // FIXME: Maybe there are too many layers of things being wrapped here!

crates/polychem/src/polymers/any_mod.rs

@@ -1,8 +1,8 @@
 use rust_decimal::Decimal;
 
 use crate::{
-    atoms::atomic_database::AtomicDatabase, AnyMod, Charge, Charged, Massive, Mz, NamedMod,
-    OffsetKind, OffsetMod, Result,
+    atoms::atomic_database::AtomicDatabase, AnyMod, AnyModification, Charge, Charged, Massive,
+    Modification, NamedMod, OffsetKind, OffsetMod, Result,
 };
 
 use super::polymer_database::PolymerDatabase;
@@ -21,6 +21,24 @@ impl<'a, 'p> AnyMod<'a, 'p> {
     }
 }
 
+impl<'a, 'p> From<NamedMod<'a, 'p>> for AnyMod<'a, 'p> {
+    fn from(value: NamedMod<'a, 'p>) -> Self {
+        Self::Named(value)
+    }
+}
+
+impl<'a, 'p> From<OffsetMod<'a>> for AnyMod<'a, 'p> {
+    fn from(value: OffsetMod<'a>) -> Self {
+        Self::Offset(value)
+    }
+}
+
+impl<'a, 'p, K: Into<AnyMod<'a, 'p>>> From<K> for AnyModification<'a, 'p> {
+    fn from(value: K) -> Self {
+        Modification::new(1, value.into())
+    }
+}
+
 // NOTE: There are crates for automating more of this code generation, but odds are that I'll only need to do this sort
 // of enum dispatch for AnyMod — it doesn't seem worth a dependency and cluttering lib.rs with attributes
 macro_rules! dispatch {
@@ -48,26 +66,12 @@ impl Charged for AnyMod<'_, '_> {
     }
 }
 
-impl Mz for AnyMod<'_, '_> {}
-
-impl<'a, 'p> From<NamedMod<'a, 'p>> for AnyMod<'a, 'p> {
-    fn from(value: NamedMod<'a, 'p>) -> Self {
-        Self::Named(value)
-    }
-}
-
-impl<'a, 'p> From<OffsetMod<'a>> for AnyMod<'a, 'p> {
-    fn from(value: OffsetMod<'a>) -> Self {
-        Self::Offset(value)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use once_cell::sync::Lazy;
     use rust_decimal_macros::dec;
 
-    use crate::testing_tools::assert_miette_snapshot;
+    use crate::{testing_tools::assert_miette_snapshot, Mz};
 
     use super::*;
 
@@ -94,6 +98,43 @@ mod tests {
         assert_miette_snapshot!(water_lost);
     }
 
+    #[test]
+    fn from_impls() {
+        let named_mod = NamedMod::new(&POLYMER_DB, "Am").unwrap();
+        let named_any_mod: AnyMod = named_mod.into();
+        let named_any_modification: AnyModification = named_mod.into();
+        let named_any_any_modification: AnyModification = named_any_mod.clone().into();
+        assert_eq!(
+            named_mod.monoisotopic_mass(),
+            named_any_mod.monoisotopic_mass()
+        );
+        assert_eq!(
+            named_mod.monoisotopic_mass(),
+            named_any_modification.monoisotopic_mass()
+        );
+        assert_eq!(
+            named_mod.monoisotopic_mass(),
+            named_any_any_modification.monoisotopic_mass()
+        );
+
+        let offset_mod = OffsetMod::new(&ATOMIC_DB, OffsetKind::Add, "H2O").unwrap();
+        let offset_any_mod: AnyMod = offset_mod.clone().into();
+        let offset_any_modification: AnyModification = offset_mod.clone().into();
+        let offset_any_any_modification: AnyModification = offset_any_mod.clone().into();
+        assert_eq!(
+            offset_mod.monoisotopic_mass(),
+            offset_any_mod.monoisotopic_mass()
+        );
+        assert_eq!(
+            offset_mod.monoisotopic_mass(),
+            offset_any_modification.monoisotopic_mass()
+        );
+        assert_eq!(
+            offset_mod.monoisotopic_mass(),
+            offset_any_any_modification.monoisotopic_mass()
+        );
+    }
+
     #[test]
     fn monoisotopic_mass() {
         // Masses checked against https://www.unimod.org/modifications_list.php

crates/polychem/src/polymers/bond.rs

@@ -1,6 +1,6 @@
 use rust_decimal::Decimal;
 
-use crate::{Bond, BondTarget, Charge, Charged, Massive, Mz, PolychemError, Result};
+use crate::{Bond, BondTarget, Charge, Charged, Massive, PolychemError, Result};
 
 use super::polymer_database::{BondDescription, PolymerDatabase};
 
@@ -45,14 +45,12 @@ impl Charged for Bond<'_, '_> {
     }
 }
 
-impl Mz for Bond<'_, '_> {}
-
 #[cfg(test)]
 mod tests {
     use once_cell::sync::Lazy;
     use rust_decimal_macros::dec;
 
-    use crate::{testing_tools::assert_miette_snapshot, AtomicDatabase, FunctionalGroup};
+    use crate::{testing_tools::assert_miette_snapshot, AtomicDatabase, FunctionalGroup, Mz};
 
     use super::*;
 

crates/polychem/src/polymers/modification.rs

@@ -1,6 +1,6 @@
 use rust_decimal::prelude::Decimal;
 
-use crate::{Charge, Charged, Count, Massive, Modification, Mz, SignedCount};
+use crate::{Charge, Charged, Count, Massive, Modification};
 
 impl<K> Modification<K> {
     // FIXME: Maybe make this `new_with_multiplier`, and make `new(k)` = `new_with_multiplier(1, k)` — depends on if
@@ -30,20 +30,18 @@ impl<K: Massive> Massive for Modification<K> {
 
 impl<K: Charged> Charged for Modification<K> {
     fn charge(&self) -> Charge {
-        SignedCount::from(self.multiplier) * self.kind.charge()
+        Charge::from(self.multiplier) * self.kind.charge()
     }
 }
 
-impl<K: Mz> Mz for Modification<K> {}
-
 #[cfg(test)]
 mod tests {
     use once_cell::sync::Lazy;
     use rust_decimal_macros::dec;
 
     use crate::{
         atoms::atomic_database::AtomicDatabase, polymers::polymer_database::PolymerDatabase,
-        AnyMod, NamedMod, OffsetKind, OffsetMod,
+        AnyMod, Mz, NamedMod, OffsetKind, OffsetMod,
     };
 
     use super::*;

crates/polychem/src/polymers/named_mod.rs

@@ -1,6 +1,6 @@
 use rust_decimal::Decimal;
 
-use crate::{Charge, Charged, Massive, Mz, NamedMod, PolychemError, Result};
+use crate::{Charge, Charged, Massive, Modification, NamedMod, PolychemError, Result};
 
 use super::polymer_database::{ModificationDescription, PolymerDatabase};
 
@@ -36,6 +36,12 @@ impl<'a, 'p> NamedMod<'a, 'p> {
     }
 }
 
+impl<'a, 'p> From<NamedMod<'a, 'p>> for Modification<NamedMod<'a, 'p>> {
+    fn from(value: NamedMod<'a, 'p>) -> Self {
+        Modification::new(1, value)
+    }
+}
+
 impl Massive for NamedMod<'_, '_> {
     fn monoisotopic_mass(&self) -> Decimal {
         self.gained.monoisotopic_mass() - self.lost.monoisotopic_mass()
@@ -52,14 +58,12 @@ impl Charged for NamedMod<'_, '_> {
     }
 }
 
-impl Mz for NamedMod<'_, '_> {}
-
 #[cfg(test)]
 mod tests {
     use once_cell::sync::Lazy;
     use rust_decimal_macros::dec;
 
-    use crate::{testing_tools::assert_miette_snapshot, AtomicDatabase};
+    use crate::{testing_tools::assert_miette_snapshot, AtomicDatabase, Mz};
 
     use super::*;
 
@@ -82,6 +86,16 @@ mod tests {
         assert_miette_snapshot!(potassium);
     }
 
+    #[test]
+    fn from_impls() {
+        let named_mod = NamedMod::new(&POLYMER_DB, "Am").unwrap();
+        let named_modification: Modification<NamedMod> = named_mod.into();
+        assert_eq!(
+            named_mod.monoisotopic_mass(),
+            named_modification.monoisotopic_mass()
+        );
+    }
+
     #[test]
     fn monoisotopic_mass() {
         // Masses checked against https://www.unimod.org/modifications_list.php