steel-core, steel-parser: remove dependency on num crate

just use the needed dependencies directly

Author: m4rch3n1ng

Cargo.lock

@@ -41,8 +41,10 @@ chrono = { version = "0.4.23", default-features = false, features = ["std", "clo
 weak-table = "0.3.2"
 # TODO: Consider whether rand needs to be here
 rand = "0.9.0"
-# TODO: Consider only depending on the sub crate
-num = "0.4.0"
+num-bigint = "0.4.6"
+num-rational = "0.4.2"
+num-traits = "0.2.19"
+num-integer = "0.1.46"
 radix_fmt = "1.0.0"
 
 # For structs

crates/steel-core/Cargo.toml

@@ -19,7 +19,8 @@ use crate::{
     rvals::IntoSteelVal,
 };
 
-use num::{BigInt, BigRational, Rational32};
+use num_bigint::BigInt;
+use num_rational::{BigRational, Rational32};
 use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, convert::TryInto, time::SystemTime};
 use steel_parser::tokens::{IntLiteral, NumberLiteral, RealLiteral};

crates/steel-core/src/compiler/program.rs

@@ -1,7 +1,7 @@
 use crate::rvals::{IntoSteelVal, SteelComplex, SteelString};
 use crate::{parser::tokens::TokenType::*, rvals::FromSteelVal};
 
-use num::BigRational;
+use num_rational::BigRational;
 use std::borrow::Cow;
 use std::str;
 use std::sync::{Arc, Mutex};

crates/steel-core/src/parser/parser.rs

@@ -51,7 +51,9 @@ pub use fs::{fs_module, fs_module_sandbox};
 pub use io::IoFunctions;
 pub use lists::UnRecoverableResult;
 pub use meta_ops::MetaOperations;
-use num::{BigInt, BigRational, Rational32, ToPrimitive};
+use num_bigint::BigInt;
+use num_rational::{BigRational, Rational32};
+use num_traits::ToPrimitive;
 pub use numbers::{add_primitive, divide_primitive, multiply_primitive, subtract_primitive};
 pub use ports::port_module;
 use std::convert::TryFrom;

crates/steel-core/src/primitives.rs

@@ -1,9 +1,9 @@
 use crate::rvals::{IntoSteelVal, Result, SteelComplex, SteelVal};
 use crate::{steelerr, stop};
-use num::Zero;
-use num::{
-    pow::Pow, BigInt, BigRational, CheckedAdd, CheckedMul, Integer, Rational32, Signed, ToPrimitive,
-};
+use num_bigint::BigInt;
+use num_integer::Integer;
+use num_rational::{BigRational, Rational32};
+use num_traits::{pow::Pow, CheckedAdd, CheckedMul, Signed, ToPrimitive, Zero};
 use std::ops::Neg;
 
 /// Checks if the given value is a number
@@ -957,8 +957,8 @@ fn expt(left: &SteelVal, right: &SteelVal) -> Result<SteelVal> {
 
             let expt = BigInt::from(*l).pow(r.magnitude());
             match r.sign() {
-                num::bigint::Sign::Plus | num::bigint::Sign::NoSign => expt.into_steelval(),
-                num::bigint::Sign::Minus => {
+                num_bigint::Sign::Plus | num_bigint::Sign::NoSign => expt.into_steelval(),
+                num_bigint::Sign::Minus => {
                     BigRational::new_raw(BigInt::from(1), expt).into_steelval()
                 }
             }
@@ -1003,8 +1003,8 @@ fn expt(left: &SteelVal, right: &SteelVal) -> Result<SteelVal> {
         (SteelVal::BigNum(l), SteelVal::BigNum(r)) => {
             let expt = l.as_ref().clone().pow(r.magnitude());
             match r.sign() {
-                num::bigint::Sign::NoSign | num::bigint::Sign::Plus => expt.into_steelval(),
-                num::bigint::Sign::Minus => {
+                num_bigint::Sign::NoSign | num_bigint::Sign::Plus => expt.into_steelval(),
+                num_bigint::Sign::Minus => {
                     BigRational::new_raw(BigInt::from(1), expt).into_steelval()
                 }
             }
@@ -1412,7 +1412,7 @@ fn exact_integer_sqrt(number: &SteelVal) -> Result<SteelVal> {
 
 fn exact_integer_impl<'a, N>(target: &'a N) -> (N, N)
 where
-    N: num::integer::Roots + Clone,
+    N: num_integer::Roots + Clone,
     &'a N: std::ops::Mul<&'a N, Output = N>,
     N: std::ops::Sub<N, Output = N>,
 {
@@ -1862,7 +1862,7 @@ mod num_op_tests {
             )
             .unwrap()
             .to_string(),
-            BigRational(Gc::new(num::BigRational::new(
+            BigRational(Gc::new(num_rational::BigRational::new(
                 BigInt::from(1),
                 BigInt::from_str("18446744073709551616").unwrap()
             )))
@@ -2014,7 +2014,7 @@ mod num_op_tests {
         )
         .is_err());
         assert!(exact_integer_sqrt(
-            &num::BigRational::new(
+            &num_rational::BigRational::new(
                 BigInt::from_str("-10000000000000000000000000000000000001").unwrap(),
                 BigInt::from_str("2").unwrap()
             )

crates/steel-core/src/primitives/numbers.rs

@@ -5,7 +5,8 @@ use crate::rvals::{RestArgsIter, Result, SteelByteVector, SteelString, SteelVal}
 use crate::steel_vm::builtin::BuiltInModule;
 use crate::{stop, Vector};
 
-use num::{BigInt, Num};
+use num_bigint::BigInt;
+use num_traits::Num;
 use steel_derive::{function, native};
 
 /// Strings in Steel are immutable, fixed length arrays of characters. They are heap allocated, and

crates/steel-core/src/primitives/strings.rs

@@ -109,7 +109,7 @@ fn current_milliseconds() -> SteelVal {
             let ms = n.as_millis();
             match isize::try_from(ms) {
                 Ok(inner) => SteelVal::IntV(inner),
-                _ => SteelVal::BigNum(Gc::new(num::BigInt::from(ms))),
+                _ => SteelVal::BigNum(Gc::new(num_bigint::BigInt::from(ms))),
             }
         }
         Err(_) => panic!("SystemTime before UNIX EPOCH!"),
@@ -128,7 +128,7 @@ fn current_seconds() -> SteelVal {
             let ms = n.as_secs();
             match isize::try_from(ms) {
                 Ok(inner) => SteelVal::IntV(inner),
-                _ => SteelVal::BigNum(Gc::new(num::BigInt::from(ms))),
+                _ => SteelVal::BigNum(Gc::new(num_bigint::BigInt::from(ms))),
             }
         }
         Err(_) => panic!("SystemTime before UNIX EPOCH!"),

crates/steel-core/src/primitives/time.rs

@@ -77,9 +77,9 @@ use futures_util::future::Shared;
 use futures_util::FutureExt;
 
 use crate::values::lists::List;
-use num::{
-    bigint::ToBigInt, BigInt, BigRational, FromPrimitive, Rational32, Signed, ToPrimitive, Zero,
-};
+use num_bigint::{BigInt, ToBigInt};
+use num_rational::{BigRational, Rational32};
+use num_traits::{FromPrimitive, Signed, ToPrimitive, Zero};
 use steel_parser::tokens::{IntLiteral, RealLiteral};
 
 use self::cycles::{CycleDetector, IterativeDropHandler};
@@ -2117,7 +2117,7 @@ fn integer_float_equality(int: isize, float: f64) -> bool {
     }
 }
 
-fn bignum_float_equality(bigint: &Gc<num::BigInt>, float: f64) -> bool {
+fn bignum_float_equality(bigint: &Gc<BigInt>, float: f64) -> bool {
     if float.fract() == 0.0 {
         if let Some(promoted) = bigint.to_f64() {
             promoted == float
@@ -2188,13 +2188,13 @@ impl PartialOrd for SteelVal {
                 // the common ground
                 #[cfg(target_pointer_width = "32")]
                 {
-                    let x_rational = num::Rational32::new_raw(*x as i32, 1);
+                    let x_rational = num_rational::Rational32::new_raw(*x as i32, 1);
                     x_rational.partial_cmp(y)
                 }
                 #[cfg(target_pointer_width = "64")]
                 {
-                    let x_rational = num::Rational64::new_raw(*x as i64, 1);
-                    x_rational.partial_cmp(&num::Rational64::new_raw(
+                    let x_rational = num_rational::Rational64::new_raw(*x as i64, 1);
+                    x_rational.partial_cmp(&num_rational::Rational64::new_raw(
                         *y.numer() as i64,
                         *y.denom() as i64,
                     ))
@@ -2240,13 +2240,13 @@ impl PartialOrd for SteelVal {
                 // Same as before, but opposite direction
                 #[cfg(target_pointer_width = "32")]
                 {
-                    let y_rational = num::Rational32::new_raw(*y as i32, 1);
+                    let y_rational = num_rational::Rational32::new_raw(*y as i32, 1);
                     x.partial_cmp(&y_rational)
                 }
                 #[cfg(target_pointer_width = "64")]
                 {
-                    let y_rational = num::Rational64::new_raw(*y as i64, 1);
-                    num::Rational64::new_raw(*x.numer() as i64, *x.denom() as i64)
+                    let y_rational = num_rational::Rational64::new_raw(*y as i64, 1);
+                    num_rational::Rational64::new_raw(*x.numer() as i64, *x.denom() as i64)
                         .partial_cmp(&y_rational)
                 }
             }

crates/steel-core/src/rvals.rs

@@ -1,7 +1,7 @@
 use crate::gc::shared::{MutableContainer, ShareableMut};
 use crate::steel_vm::{builtin::get_function_name, vm::Continuation, vm::ContinuationMark};
 use crate::values::lists::Pair;
-use num::BigInt;
+use num_bigint::BigInt;
 use std::{cell::Cell, collections::VecDeque};
 
 use super::*;