Formatting + pleasing clippy

benches/arrays.rs

@@ -3,7 +3,7 @@ use std::rc::Rc;
 use criterion::{criterion_main, Criterion};
 use nickel_lang::term::{
     array::{Array, ArrayAttrs},
-    RichTerm, Term,
+    RichTerm, Term, Number
 };
 use nickel_lang_utilities::{ncl_bench_group, EvalMode};
 use pprof::criterion::{Output, PProfProfiler};
@@ -20,7 +20,7 @@ fn ncl_random_array(len: usize) -> String {
 
     for _ in 0..len {
         acc = (a * acc + c) % m;
-        numbers.push(RichTerm::from(Term::Num(acc as f64)));
+        numbers.push(RichTerm::from(Term::Num(Number::from(acc))));
     }
 
     let xs = RichTerm::from(Term::Array(

src/deserialize.rs

@@ -34,15 +34,10 @@ macro_rules! deserialize_number {
 /// An error occurred during deserialization to Rust.
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum RustDeserializationError {
-    InvalidType {
-        expected: String,
-        occurred: String,
-    },
+    InvalidType { expected: String, occurred: String },
     MissingValue,
     EmptyRecordField,
-    UnimplementedType {
-        occurred: String,
-    },
+    UnimplementedType { occurred: String },
     InvalidRecordLength(usize),
     InvalidArrayLength(usize),
     Other(String),

src/eval/operation.rs

@@ -1066,7 +1066,7 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
             }
             UnaryOp::NumFromStr() => {
                 if let Term::Str(s) = &*t {
-                    let n = parse_rational(&s).map_err(|_| {
+                    let n = parse_rational(s).map_err(|_| {
                         EvalError::Other(format!("num_from_string: invalid num literal `{s}`"), pos)
                     })?;
                     Ok(Closure::atomic_closure(RichTerm::new(

src/parser/tests.rs

@@ -298,7 +298,7 @@ fn record_terms() {
                 .collect()
             ),
             vec![(
-                StrChunks(vec![StrChunk::expr(RichTerm::from(mk_term::integer(123)))]).into(),
+                StrChunks(vec![StrChunk::expr(mk_term::integer(123))]).into(),
                 Field::from(mk_app!(
                     mk_term::op1(UnaryOp::Ite(), mk_term::integer(4)),
                     mk_term::integer(5),

src/parser/utils.rs

@@ -18,9 +18,9 @@ use crate::{
     position::{RawSpan, TermPos},
     term::{
         make as mk_term,
-        Rational,
         record::{Field, FieldMetadata, RecordAttrs, RecordData},
-        BinaryOp, LabeledType, LetMetadata, RichTerm, StrChunk, Term, TypeAnnotation, UnaryOp,
+        BinaryOp, LabeledType, LetMetadata, Rational, RichTerm, StrChunk, Term, TypeAnnotation,
+        UnaryOp,
     },
     types::{TypeF, Types},
 };

src/serialize.rs

@@ -88,10 +88,8 @@ where
             if let Ok(n_as_integer) = i64::try_from(n) {
                 return n_as_integer.serialize(serializer);
             }
-        } else {
-            if let Ok(n_as_uinteger) = u64::try_from(n) {
-                return n_as_uinteger.serialize(serializer);
-            }
+        } else if let Ok(n_as_uinteger) = u64::try_from(n) {
+            return n_as_uinteger.serialize(serializer);
         }
     }
 

src/term/mod.rs

@@ -240,10 +240,8 @@ pub fn number_approx_to_string(n: &Number) -> String {
             if let Ok(n_as_integer) = i64::try_from(n) {
                 return n_as_integer.to_string();
             }
-        } else {
-            if let Ok(n_as_uinteger) = u64::try_from(n) {
-                return n_as_uinteger.to_string();
-            }
+        } else if let Ok(n_as_uinteger) = u64::try_from(n) {
+            return n_as_uinteger.to_string();
         }
     }