Use f64 for all numbers (#203)

Use f64 for all numbers instead of switching between isize rational,
bignum rational and f64. The dependencies for the rationals and bignum
are also removed, which should be nice for the build times.

Author: kaj

rsass/Cargo.toml

@@ -17,10 +17,6 @@ arc-swap = "1.5.0"
 fastrand = "2.0"
 lazy_static = "1.0"
 nom = "7.0"
-num-bigint = { version = "0.4.0", default-features = false, features = ["std"] }
-num-integer = "0.1.42"
-num-rational = { version = "0.4.0", default-features = false, features = ["num-bigint"] }
-num-traits = "^0.2.0"
 tracing = "0.1.34"
 
 [badges]

rsass/src/css/value.rs

@@ -6,7 +6,7 @@ use crate::sass::Function;
 use crate::value::{Color, ListSeparator, Number, Numeric, Operator};
 
 /// A css value.
-#[derive(Clone, Debug, Eq, PartialOrd)]
+#[derive(Clone, Debug, PartialOrd)]
 pub enum Value {
     /// A special kind of escape.  Only really used for !important.
     Bang(String),
@@ -311,6 +311,7 @@ impl PartialEq for Value {
         }
     }
 }
+impl Eq for Value {}
 
 impl From<bool> for Value {
     fn from(v: bool) -> Self {

rsass/src/parser/value.rs

@@ -10,19 +10,19 @@ use super::{
     input_to_string, list_or_single, position, sass_string, PResult, Span,
 };
 use crate::sass::{BinOp, SassString, Value};
-use crate::value::{ListSeparator, Number, Numeric, Operator, Rgba};
+use crate::value::{ListSeparator, Numeric, Operator, Rgba};
 use nom::branch::alt;
 use nom::bytes::complete::{tag, tag_no_case};
 use nom::character::complete::{
-    alphanumeric1, char, multispace0, multispace1, one_of,
+    alphanumeric1, char, digit1, multispace0, multispace1, one_of,
 };
 use nom::combinator::{
-    cut, into, map, map_res, not, opt, peek, recognize, value, verify,
+    cut, into, map, map_opt, map_res, not, opt, peek, recognize, value,
+    verify,
 };
 use nom::error::context;
-use nom::multi::{fold_many0, fold_many1, many0, many_m_n, separated_list1};
+use nom::multi::{fold_many0, many0, many_m_n, separated_list1};
 use nom::sequence::{delimited, pair, preceded, terminated, tuple};
-use num_traits::Zero;
 use std::str::from_utf8;
 
 pub fn value_expression(input: Span) -> PResult<Value> {
@@ -326,86 +326,23 @@ pub fn bracket_list(input: Span) -> PResult<Value> {
     ))
 }
 
-fn sign_prefix(input: Span) -> PResult<Option<&[u8]>> {
-    opt(alt((tag("-"), tag("+"))))(input)
-        .map(|(r, s)| (r, s.map(|s| s.fragment())))
-}
-
 pub fn numeric(input: Span) -> PResult<Numeric> {
     map(pair(number, unit), |(number, unit)| {
         Numeric::new(number, unit)
     })(input)
 }
 
-pub fn number(input: Span) -> PResult<Number> {
-    map(
-        tuple((
-            sign_prefix,
+pub fn number(input: Span) -> PResult<f64> {
+    map_opt(
+        recognize(delimited(
+            opt(one_of("+-")),
             alt((
-                map(pair(decimal_integer, decimal_decimals), |(n, d)| n + d),
-                decimal_decimals,
-                decimal_integer,
-            )),
-            opt(preceded(
-                alt((tag("e"), tag("E"))),
-                tuple((sign_prefix, decimal_i32)),
+                terminated(digit1, opt(terminated(char('.'), digit1))),
+                preceded(char('.'), digit1),
             )),
+            opt(delimited(one_of("eE"), opt(one_of("+-")), digit1)),
         )),
-        |(sign, num, exp)| {
-            let value = if sign == Some(b"-") {
-                // Only f64-based Number can represent negative zero.
-                if num.is_zero() {
-                    (-0.0).into()
-                } else {
-                    -num
-                }
-            } else {
-                num
-            };
-            if let Some((e_sign, e_val)) = exp {
-                let e_val = if e_sign == Some(b"-") { -e_val } else { e_val };
-                // Note: powi sounds right, but looses some precision.
-                value * Number::from(10f64.powf(e_val.into()))
-            } else {
-                value
-            }
-        },
-    )(input)
-}
-
-pub fn decimal_integer(input: Span) -> PResult<Number> {
-    fold_many1(
-        // Note: We should use bytes directly, one_of returns a char.
-        one_of("0123456789"),
-        || Number::from(0),
-        |r, d| (r * 10) + Number::from(i64::from(d as u8 - b'0')),
-    )(input)
-}
-pub fn decimal_i32(input: Span) -> PResult<i32> {
-    fold_many1(
-        // Note: We should use bytes directly, one_of returns a char.
-        one_of("0123456789"),
-        || 0,
-        |r, d| (r * 10) + i32::from(d as u8 - b'0'),
-    )(input)
-}
-
-pub fn decimal_decimals(input: Span) -> PResult<Number> {
-    map(
-        preceded(
-            tag("."),
-            fold_many1(
-                one_of("0123456789"),
-                || (Number::from(0), Number::from(1)),
-                |(r, n), d| {
-                    (
-                        (r * 10) + Number::from(i64::from(d as u8 - b'0')),
-                        n * 10,
-                    )
-                },
-            ),
-        ),
-        |(r, d)| r / d,
+        |s: Span| from_utf8(s.fragment()).ok()?.parse().ok(),
     )(input)
 }
 
@@ -595,43 +532,38 @@ mod test {
     use super::*;
     use crate::sass::CallArgs;
     use crate::sass::Value::{Color, List, Literal, Map, Paren};
-    use crate::value::Rational;
     use crate::ScopeRef;
 
     #[test]
     fn simple_number() {
-        check_expr("4;", number(4, 1))
+        check_expr("4;", Value::scalar(4.))
     }
 
     #[test]
     fn simple_number_neg() {
-        check_expr("-4;", number(-4, 1))
+        check_expr("-4;", Value::scalar(-4.))
     }
 
     #[test]
     fn simple_number_pos() {
-        check_expr("+4;", Value::scalar(4))
+        check_expr("+4;", Value::scalar(4.))
     }
 
     #[test]
     fn simple_number_dec() {
-        check_expr("4.34;", number(434, 100))
+        check_expr("4.34;", Value::scalar(4.34))
     }
     #[test]
     fn simple_number_onlydec() {
-        check_expr(".34;", number(34, 100))
+        check_expr(".34;", Value::scalar(0.34))
     }
     #[test]
     fn simple_number_onlydec_neg() {
-        check_expr("-.34;", number(-34, 100))
+        check_expr("-.34;", Value::scalar(-0.34))
     }
     #[test]
     fn simple_number_onlydec_pos() {
-        check_expr("+.34;", number(34, 100))
-    }
-
-    fn number(nom: i64, denom: i64) -> Value {
-        Value::scalar(Rational::new(nom, denom))
+        check_expr("+.34;", Value::scalar(0.34))
     }
 
     #[test]

rsass/src/sass/functions/color/mod.rs

@@ -8,7 +8,6 @@ use crate::output::Format;
 use crate::sass::{FormalArgs, Name};
 use crate::value::{ListSeparator, Numeric, Quotes, Unit};
 use crate::Scope;
-use num_traits::{one, zero};
 mod channels;
 mod hsl;
 mod hwb;
@@ -63,7 +62,7 @@ pub fn expose(m: &Scope, global: &mut FunctionMap) {
 /// Special perk: Defaults to 1.0 if the value is null.
 fn check_alpha(v: Value) -> Result<f64, String> {
     Ok(match v {
-        Value::Null => one(),
+        Value::Null => 1.0,
         v => {
             let num = Numeric::try_from(v)?;
             num.as_unit(Unit::None)
@@ -77,15 +76,15 @@ fn check_alpha(v: Value) -> Result<f64, String> {
 /// Get a rational number in the 0..1 range.
 fn check_alpha_range(v: Value) -> Result<f64, String> {
     let v = Numeric::try_from(v)?;
-    if v.value < zero() || v.value > one() {
+    if v.value < 0.into() || v.value > 1.into() {
         Err(expected_to(v, "be within 0 and 1"))
     } else {
         Ok(v.value.into())
     }
 }
 fn check_alpha_pm(v: Value) -> Result<f64, String> {
     let v = Numeric::try_from(v)?;
-    if v.value.abs() > one() {
+    if v.value.abs() > 1.into() {
         Err(expected_to(v, "be within -1 and 1"))
     } else {
         Ok(v.value.into())
@@ -140,7 +139,7 @@ fn check_expl_pct(v: Value) -> Result<f64, String> {
     if !val.unit.is_percent() {
         return Err(expected_to(val, "have unit \"%\""));
     }
-    if val.value < zero() || val.value > 100.into() {
+    if val.value < 0.into() || val.value > 100.into() {
         Err(expected_to(val, "be within 0% and 100%"))
     } else {
         Ok(f64::from(val.value) / 100.)
@@ -149,7 +148,7 @@ fn check_expl_pct(v: Value) -> Result<f64, String> {
 
 fn check_pct_range(v: Value) -> Result<f64, String> {
     let val = check_pct(v)?;
-    if val < zero() || val > one() {
+    if val < 0.into() || val > 1.into() {
         Err(expected_to(
             Numeric::percentage(val),
             "be within 0% and 100%",
@@ -161,7 +160,7 @@ fn check_pct_range(v: Value) -> Result<f64, String> {
 
 fn check_amount(v: Value) -> Result<f64, String> {
     let val = check_pct(v)?;
-    if val < zero() || val > one() {
+    if val < 0.into() || val > 1.into() {
         Err(expected_to(
             Value::scalar(val * 100.),
             "be within 0 and 100",
@@ -177,10 +176,10 @@ fn check_channel(v: Value) -> Result<f64, String> {
 fn check_channel_range(v: Value) -> Result<f64, String> {
     let v = Numeric::try_from(v)?;
     let r = num2chan(&v)?;
-    if r > 255. || r < zero() {
-        Err(expected_to(v, "be within 0 and 255"))
-    } else {
+    if (0. ..=255.).contains(&r) {
         Ok(r)
+    } else {
+        Err(expected_to(v, "be within 0 and 255"))
     }
 }
 fn check_channel_pm(v: Value) -> Result<f64, String> {

rsass/src/sass/value.rs

@@ -4,7 +4,6 @@ use crate::input::SourcePos;
 use crate::output::Format;
 use crate::value::{BadOp, ListSeparator, Number, Numeric, Operator, Rgba};
 use crate::{css, Error, Invalid, ScopeRef};
-use num_traits::Zero;
 use std::fmt::{self, Write};
 
 /// A sass value.
@@ -169,7 +168,7 @@ impl Value {
                 let value = v.do_evaluate(scope, true)?;
                 match (op, value) {
                     (Operator::Not, css::Value::Numeric(v, _)) => {
-                        v.value.is_zero().into()
+                        (v.value == 0.into()).into()
                     }
                     (Operator::Not, css::Value::True) => css::Value::False,
                     (Operator::Not, css::Value::False) => css::Value::True,

rsass/src/value/mod.rs

@@ -11,7 +11,7 @@ mod unitset;
 
 pub use self::colors::{Color, Hsla, Hwba, RgbFormat, Rgba};
 pub use self::list_separator::ListSeparator;
-pub use self::number::{BadNumber, Number, Rational};
+pub use self::number::Number;
 pub use self::numeric::Numeric;
 pub use self::operator::{BadOp, Operator};
 pub use self::quotes::Quotes;