simplify unit in quantity, remove once_cell and either dependency

Author: Zheoni

Cargo.lock

@@ -15,12 +15,10 @@ bitflags = { version = "2", features = ["serde"] }
 serde = { version = "1", features = ["derive", "rc"] }
 strum = { version = "0.26.1", features = ["derive"] }
 thiserror = "2"
-once_cell = "1"
 enum-map = { version = "2", features = ["serde"] }
 tracing = "0.1"
 codesnake = "0.2.1"
 unicode-width = "0.2"
-either = "1.8"
 finl_unicode = { version = "1.2", features = ["categories"], default-features = false }
 smallvec = { version = "1" }
 unicase = "2.7.0"

Cargo.toml

@@ -176,7 +176,7 @@ trait Amountable {
 
 impl Amountable for OriginalQuantity<OriginalScalableValue> {
     fn extract_amount(&self) -> Amount {
-        let quantity = extract_quantity(&self.value);
+        let quantity = extract_quantity(self.value());
 
         let units = self.unit().as_ref().map(|u| u.to_string());
 

bindings/src/model.rs

@@ -195,7 +195,7 @@ fn generate_bundled() {
         })
         .unwrap_or_else(none);
 
-    let extend = if let Some(_) = uf.get("extend") {
+    let extend = if uf.get("extend").is_some() {
         unimplemented!("base units.toml does not have extend");
     } else {
         quote! { None }

build.rs

@@ -9,7 +9,7 @@ use crate::parser::{
     self, BlockKind, Event, IntermediateData, IntermediateRefMode, IntermediateTargetKind,
     Modifiers,
 };
-use crate::quantity::{Quantity, QuantityValue, ScalableValue, UnitInfo, Value};
+use crate::quantity::{Quantity, QuantityValue, ScalableValue, Value};
 use crate::span::Span;
 use crate::text::Text;
 use crate::{model::*, Extensions, ParseOptions};
@@ -653,14 +653,15 @@ impl<'i> RecipeCollector<'i, '_> {
                                 .unwrap_or(new_q_loc.span());
 
                             let (main_label, support_label) = match &e {
-                                crate::quantity::IncompatibleUnits::MissingUnit { found } => {
+                                crate::quantity::IncompatibleUnits::MissingUnit { lhs, .. } => {
                                     let m = "value missing unit";
                                     let f = "found unit";
-                                    match found {
+                                    if *lhs {
                                         // new is mising
-                                        either::Either::Left(_) => (label!(new, m), label!(old, f)),
+                                        (label!(new, m), label!(old, f))
+                                    } else {
                                         // old is missing
-                                        either::Either::Right(_) => (label!(new, f), label!(old, m)),
+                                        (label!(new, f), label!(old, m))
                                     }
                                 }
                                 crate::quantity::IncompatibleUnits::DifferentPhysicalQuantities {
@@ -723,8 +724,8 @@ impl<'i> RecipeCollector<'i, '_> {
             if let Some((ref_q, def_q)) =
                 &new_igr.quantity.as_ref().zip(definition.quantity.as_ref())
             {
-                let ref_is_text = ref_q.value.is_text();
-                let def_is_text = def_q.value.is_text();
+                let ref_is_text = ref_q.value().is_text();
+                let def_is_text = def_q.value().is_text();
 
                 if ref_is_text != def_is_text {
                     let ref_q_loc = located_ingredient.quantity.as_ref().unwrap().span();
@@ -974,16 +975,16 @@ impl<'i> RecipeCollector<'i, '_> {
             let quantity = self.quantity(q, false);
             if self.extensions.contains(Extensions::ADVANCED_UNITS) {
                 let located_quantity = located_timer.quantity.as_ref().unwrap();
-                if quantity.value.is_text() {
+                if quantity.value().is_text() {
                     self.ctx.error(error!(
-                        format!("Timer value is text: {}", quantity.value),
+                        format!("Timer value is text: {}", quantity.value()),
                         label!(located_quantity.value.span(), "expected a number here")
                     ));
                 }
-                if let Some(unit) = quantity.unit() {
+                if let Some(unit_text) = quantity.unit() {
                     let unit_span = located_quantity.unit.as_ref().unwrap().span();
-                    match unit.unit_info_or_parse(self.converter) {
-                        UnitInfo::Known(unit) => {
+                    match quantity.unit_info(self.converter) {
+                        Some(unit) => {
                             if unit.physical_quantity != PhysicalQuantity::Time {
                                 self.ctx.error(error!(
                                     format!("Timer unit is not time: {unit}"),
@@ -995,8 +996,8 @@ impl<'i> RecipeCollector<'i, '_> {
                                 ));
                             }
                         }
-                        UnitInfo::Unknown => self.ctx.error(error!(
-                            format!("Unknown timer unit: {unit}"),
+                        None => self.ctx.error(error!(
+                            format!("Unknown timer unit: {unit_text}"),
                             label!(unit_span, "expected time unit")
                         )),
                     }
@@ -1377,7 +1378,7 @@ fn find_inline_quantity<'a>(
 
     fn eat_word<'a>(text: &'a str, i: &mut usize) -> Option<&'a str> {
         let s = &text[*i..];
-        let offset = s.find(|c: char| c.is_whitespace()).or_else(|| {
+        let offset = s.find(|c: char| c.is_whitespace()).or({
             // if no whitespace until the end if there is anything left
             if !s.is_empty() {
                 Some(s.len())
@@ -1439,16 +1440,15 @@ fn find_inline_quantity<'a>(
         let Ok(mut number) = number.parse::<f64>() else {
             continue;
         };
-        let Some(parsed_unit) = converter.find_unit(unit) else {
+        if converter.find_unit(unit).is_none() {
             continue;
         };
 
         if neg {
             number = -number;
         }
 
-        let q =
-            Quantity::with_text_and_known_unit(Value::from(number), unit.to_string(), parsed_unit);
+        let q = Quantity::new(Value::from(number), Some(unit.to_string()));
         return Some((before, q, after));
     }
 

src/analysis/event_consumer.rs

@@ -13,7 +13,7 @@ use thiserror::Error;
 
 use crate::{
     quantity::{Number, Quantity, ScaledQuantity, Value},
-    ScaledRecipe, UnitInfo,
+    ScaledRecipe,
 };
 
 pub use builder::{ConverterBuilder, ConverterBuilderError};
@@ -463,24 +463,27 @@ impl ScaledQuantity {
 
     #[tracing::instrument(level = "trace", name = "convert", skip_all)]
     fn convert_impl(&mut self, to: ConvertTo, converter: &Converter) -> Result<(), ConvertError> {
-        let unit_info = self.unit().map(|u| u.unit_info_or_parse(converter));
+        if self.unit().is_none() {
+            return Err(ConvertError::NoUnit(self.clone()));
+        }
+
+        let unit_info = self.unit_info(converter);
         let original_system;
         let unit = match unit_info {
-            Some(UnitInfo::Known(ref u)) => {
+            Some(ref u) => {
                 original_system = u.system;
                 ConvertUnit::Unit(u)
             }
-            Some(UnitInfo::Unknown) => {
+            None => {
                 return Err(ConvertError::UnknownUnit(UnknownUnit(
-                    self.unit_text().unwrap().to_string(),
+                    self.unit().unwrap().to_string(),
                 )))
             }
-            None => return Err(ConvertError::NoUnit(self.clone())),
         };
-        let value = ConvertValue::try_from(&self.value)?;
+        let value = ConvertValue::try_from(self.value())?;
 
         let (new_value, new_unit) = converter.convert(value, unit, to)?;
-        *self = Quantity::with_known_unit(new_value.into(), Arc::clone(&new_unit));
+        *self = Quantity::new(new_value.into(), Some(new_unit.symbol().to_string()));
         match to {
             ConvertTo::Unit(_) => {
                 self.try_fraction(converter);
@@ -501,8 +504,7 @@ impl ScaledQuantity {
     #[tracing::instrument(level = "trace", skip_all)]
     pub fn fit(&mut self, converter: &Converter) -> Result<(), ConvertError> {
         // only known units can be fitted
-        let Some(UnitInfo::Known(unit)) = self.unit().map(|u| u.unit_info_or_parse(converter))
-        else {
+        let Some(unit) = self.unit_info(converter) else {
             return Ok(());
         };
 
@@ -540,7 +542,7 @@ impl ScaledQuantity {
             return Ok(self.try_fraction(converter)); // no system, just keep the same unit
         };
 
-        let value = match self.value {
+        let value = match self.value() {
             Value::Number(n) => n.value(),
             Value::Range { start, .. } => start.value(),
             Value::Text(ref t) => return Err(ConvertError::TextValue(t.clone())),
@@ -581,7 +583,7 @@ impl ScaledQuantity {
             return Ok(false);
         };
 
-        let new_value = match self.value {
+        let new_value = match self.value() {
             Value::Number(_) => Value::Number(new_value),
             Value::Range { end, .. } => {
                 let end = converter.convert_f64(end.value(), unit, new_unit);
@@ -594,7 +596,7 @@ impl ScaledQuantity {
             }
             Value::Text(_) => unreachable!(),
         };
-        *self = Quantity::with_known_unit(new_value, Arc::clone(new_unit));
+        *self = Quantity::new(new_value, Some(new_unit.symbol().to_string()));
         Ok(true)
     }
 
@@ -604,8 +606,7 @@ impl ScaledQuantity {
     #[tracing::instrument(level = "trace", skip_all)]
     pub fn try_fraction(&mut self, converter: &Converter) -> bool {
         // only known units can be fitted
-        let Some(UnitInfo::Known(unit)) = self.unit().map(|u| u.unit_info_or_parse(converter))
-        else {
+        let Some(unit) = self.unit_info(converter) else {
             return false;
         };
 
@@ -614,7 +615,7 @@ impl ScaledQuantity {
             return false;
         }
 
-        match &mut self.value {
+        match self.value_mut() {
             Value::Number(n) => n.try_approx(cfg.accuracy, cfg.max_denominator, cfg.max_whole),
             Value::Range { start, end } => {
                 start.try_approx(cfg.accuracy, cfg.max_denominator, cfg.max_whole)

src/convert/mod.rs

@@ -96,8 +96,7 @@ pub use metadata::Metadata;
 pub use model::*;
 pub use parser::Modifiers;
 pub use quantity::{
-    GroupedQuantity, Quantity, QuantityUnit, ScalableQuantity, ScalableValue, ScaledQuantity,
-    UnitInfo, Value,
+    GroupedQuantity, Quantity, ScalableQuantity, ScalableValue, ScaledQuantity, Value,
 };
 pub use span::Span;
 pub use text::Text;

src/lib.rs

@@ -613,7 +613,7 @@ impl NameAndUrl {
     pub fn parse(s: &str) -> Self {
         if let Some(s) = s.trim_ascii_end().strip_suffix('>') {
             if let Some((name, url)) = s.split_once('<') {
-                if !url.trim().is_empty() && !url.contains(&['<', '>']) {
+                if !url.trim().is_empty() && !url.contains(['<', '>']) {
                     return Self::new(Some(name), Some(url));
                 }
             }
@@ -753,7 +753,7 @@ fn parse_common_time_format(s: &str) -> Option<u32> {
     if it.next().is_some() {
         return None;
     }
-    return Some(total_minutes);
+    Some(total_minutes)
 }
 
 fn parse_time_with_units(s: &str, converter: &Converter) -> Result<u32, ParseTimeError> {