refactor: add minor code clean-up (#83)

* refactor: add minor code clean-up

* style: adjust code to project convention

* style: unmerge std imports in SmallVec

* style: rename option args to `maybe_*`

Author: tranzystorekk

src/internal/partial_solution.rs

@@ -179,7 +179,7 @@ impl<P: Package, V: Version> PartialSolution<P, V> {
         incompat: &Incompatibility<P, V>,
         store: &Arena<Incompatibility<P, V>>,
     ) -> (&Assignment<P, V>, DecisionLevel, DecisionLevel) {
-        let satisfier_map = Self::find_satisfier(incompat, self.history.as_slice(), store);
+        let satisfier_map = Self::find_satisfier(incompat, &self.history, store);
         assert_eq!(
             satisfier_map.len(),
             incompat.len(),

src/internal/small_vec.rs

@@ -1,4 +1,5 @@
 use std::fmt;
+use std::ops::Deref;
 
 #[derive(Clone)]
 pub enum SmallVec<T> {
@@ -38,7 +39,7 @@ impl<T> SmallVec<T> {
         }
     }
 
-    pub fn iter(&self) -> impl Iterator<Item = &T> {
+    pub fn iter(&self) -> std::slice::Iter<'_, T> {
         self.as_slice().iter()
     }
 }
@@ -49,10 +50,28 @@ impl<T> Default for SmallVec<T> {
     }
 }
 
-impl<T: PartialEq> Eq for SmallVec<T> {}
+impl<T> Deref for SmallVec<T> {
+    type Target = [T];
 
-impl<T: PartialEq> PartialEq<SmallVec<T>> for SmallVec<T> {
-    fn eq(&self, other: &SmallVec<T>) -> bool {
+    fn deref(&self) -> &Self::Target {
+        self.as_slice()
+    }
+}
+
+impl<'a, T> IntoIterator for &'a SmallVec<T> {
+    type Item = &'a T;
+
+    type IntoIter = std::slice::Iter<'a, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+impl<T: Eq> Eq for SmallVec<T> {}
+
+impl<T: PartialEq> PartialEq for SmallVec<T> {
+    fn eq(&self, other: &Self) -> bool {
         self.as_slice() == other.as_slice()
     }
 }

src/range.rs

@@ -93,7 +93,7 @@ impl<V: Version> Range<V> {
 
     /// Compute the complement set of versions.
     pub fn negate(&self) -> Self {
-        match self.segments.as_slice().first() {
+        match self.segments.first() {
             None => Self::any(), // Complement of ∅  is *
 
             // First high bound is +∞
@@ -110,9 +110,9 @@ impl<V: Version> Range<V> {
             // First high bound is not +∞
             Some((v1, Some(v2))) => {
                 if v1 == &V::lowest() {
-                    Self::negate_segments(v2.clone(), &self.segments.as_slice()[1..])
+                    Self::negate_segments(v2.clone(), &self.segments[1..])
                 } else {
-                    Self::negate_segments(V::lowest(), &self.segments.as_slice())
+                    Self::negate_segments(V::lowest(), &self.segments)
                 }
             }
         }
@@ -125,11 +125,11 @@ impl<V: Version> Range<V> {
     fn negate_segments(start: V, segments: &[Interval<V>]) -> Range<V> {
         let mut complement_segments = SmallVec::empty();
         let mut start = Some(start);
-        for (v1, some_v2) in segments.iter() {
+        for (v1, maybe_v2) in segments {
             // start.unwrap() is fine because `segments` is not exposed,
             // and our usage guaranties that only the last segment may contain a None.
             complement_segments.push((start.unwrap(), Some(v1.to_owned())));
-            start = some_v2.to_owned();
+            start = maybe_v2.to_owned();
         }
         if let Some(last) = start {
             complement_segments.push((last, None));
@@ -144,7 +144,7 @@ impl<V: Version> Range<V> {
 
     /// Compute the union of two sets of versions.
     pub fn union(&self, other: &Self) -> Self {
-        (self.negate().intersection(&other.negate())).negate()
+        self.negate().intersection(&other.negate()).negate()
     }
 
     /// Compute the intersection of two sets of versions.
@@ -241,8 +241,8 @@ impl<V: Version> Range<V> {
 impl<V: Version> Range<V> {
     /// Check if a range contains a given version.
     pub fn contains(&self, version: &V) -> bool {
-        for (v1, some_v2) in self.segments.iter() {
-            match some_v2 {
+        for (v1, maybe_v2) in &self.segments {
+            match maybe_v2 {
                 None => return v1 <= version,
                 Some(v2) => {
                     if version < v1 {
@@ -258,11 +258,7 @@ impl<V: Version> Range<V> {
 
     /// Return the lowest version in the range (if there is one).
     pub fn lowest_version(&self) -> Option<V> {
-        self.segments
-            .as_slice()
-            .first()
-            .map(|(start, _)| start)
-            .cloned()
+        self.segments.first().map(|(start, _)| start).cloned()
     }
 }
 
@@ -288,10 +284,10 @@ impl<V: Version> fmt::Display for Range<V> {
     }
 }
 
-fn interval_to_string<V: Version>(interval: &Interval<V>) -> String {
-    match interval {
-        (start, Some(end)) => format!("[ {}, {} [", start, end),
-        (start, None) => format!("[ {}, ∞ [", start),
+fn interval_to_string<V: Version>((start, maybe_end): &Interval<V>) -> String {
+    match maybe_end {
+        Some(end) => format!("[ {}, {} [", start, end),
+        None => format!("[ {}, ∞ [", start),
     }
 }
 

src/report.rs

@@ -4,6 +4,7 @@
 //! dependency solving failed.
 
 use std::fmt;
+use std::ops::{Deref, DerefMut};
 
 use crate::package::Package;
 use crate::range::Range;
@@ -75,7 +76,7 @@ impl<P: Package, V: Version> DerivationTree<P, V> {
         match self {
             DerivationTree::External(_) => {}
             DerivationTree::Derived(derived) => {
-                match (&mut *derived.cause1, &mut *derived.cause2) {
+                match (derived.cause1.deref_mut(), derived.cause2.deref_mut()) {
                     (DerivationTree::External(External::NoVersions(p, r)), ref mut cause2) => {
                         cause2.collapse_no_versions();
                         *self = cause2
@@ -208,7 +209,7 @@ impl DefaultStringReporter {
     }
 
     fn build_recursive_helper<P: Package, V: Version>(&mut self, current: &Derived<P, V>) {
-        match (&*current.cause1, &*current.cause2) {
+        match (current.cause1.deref(), current.cause2.deref()) {
             (DerivationTree::External(external1), DerivationTree::External(external2)) => {
                 // Simplest case, we just combine two external incompatibilities.
                 self.lines.push(Self::explain_both_external(
@@ -309,7 +310,7 @@ impl DefaultStringReporter {
         external: &External<P, V>,
         current_terms: &Map<P, Term<V>>,
     ) {
-        match (&*derived.cause1, &*derived.cause2) {
+        match (derived.cause1.deref(), derived.cause2.deref()) {
             // If the derived cause has itself one external prior cause,
             // we can chain the external explanations.
             (DerivationTree::Derived(prior_derived), DerivationTree::External(prior_external)) => {
@@ -478,7 +479,7 @@ impl<P: Package, V: Version> Reporter<P, V> for DefaultStringReporter {
             DerivationTree::Derived(derived) => {
                 let mut reporter = Self::new();
                 reporter.build_recursive(derived);
-                reporter.lines[..].join("\n")
+                reporter.lines.join("\n")
             }
         }
     }

src/term.rs

@@ -149,7 +149,7 @@ impl<'a, V: 'a + Version> Term<V> {
     /// Check if a set of terms satisfies or contradicts a given term.
     /// Otherwise the relation is inconclusive.
     pub(crate) fn relation_with(&self, other_terms_intersection: &Term<V>) -> Relation {
-        let full_intersection = self.intersection(other_terms_intersection.as_ref());
+        let full_intersection = self.intersection(other_terms_intersection);
         if &full_intersection == other_terms_intersection {
             Relation::Satisfied
         } else if full_intersection == Self::empty() {

tests/sat_dependency_provider.rs

@@ -34,8 +34,8 @@ fn sat_at_most_one(solver: &mut impl varisat::ExtendFormula, vars: &[varisat::Va
     // https://www.it.uu.se/research/group/astra/ModRef10/papers/Alan%20M.%20Frisch%20and%20Paul%20A.%20Giannoros.%20SAT%20Encodings%20of%20the%20At-Most-k%20Constraint%20-%20ModRef%202010.pdf
     let bits: Vec<varisat::Var> = solver.new_var_iter(log_bits(vars.len())).collect();
     for (i, p) in vars.iter().enumerate() {
-        for b in 0..bits.len() {
-            solver.add_clause(&[p.negative(), bits[b].lit(((1 << b) & i) > 0)]);
+        for (j, &bit) in bits.iter().enumerate() {
+            solver.add_clause(&[p.negative(), bit.lit(((1 << j) & i) > 0)]);
         }
     }
 }
@@ -79,7 +79,7 @@ impl<P: Package, V: Version> SatResolve<P, V> {
                 Dependencies::Unknown => panic!(),
                 Dependencies::Known(d) => d,
             };
-            for (p1, range) in deps.iter() {
+            for (p1, range) in &deps {
                 let empty_vec = vec![];
                 let mut matches: Vec<varisat::Lit> = all_versions_by_p
                     .get(&p1)