Replace EdgeCondition with an Option<..> + other code cleanup

milli/src/search/new/interner.rs

@@ -25,6 +25,8 @@ impl<T> Interned<T> {
 /// be copied, compared, and hashed efficiently. An immutable reference to the original value
 /// can be retrieved using `self.get(interned)`. A set of values within the interner can be
 /// efficiently managed using [`SmallBitmap<T>`](super::small_bitmap::SmallBitmap).
+///
+/// A dedup-interner can contain a maximum of `u16::MAX` values.
 #[derive(Clone)]
 pub struct DedupInterner<T> {
     stable_store: Vec<T>,
@@ -36,7 +38,8 @@ impl<T> Default for DedupInterner<T> {
     }
 }
 impl<T> DedupInterner<T> {
-    ///
+    /// Convert the dedup-interner into a fixed-size interner, such that new
+    /// elements cannot be added to it anymore.
     pub fn freeze(self) -> FixedSizeInterner<T> {
         FixedSizeInterner { stable_store: self.stable_store }
     }
@@ -46,6 +49,8 @@ impl<T> DedupInterner<T>
 where
     T: Clone + Eq + Hash,
 {
+    /// Insert the given value into the dedup-interner, and return
+    /// its index.
     pub fn insert(&mut self, s: T) -> Interned<T> {
         if let Some(interned) = self.lookup.get(&s) {
             *interned
@@ -57,35 +62,21 @@ where
             interned
         }
     }
+    /// Get a reference to the interned value.
     pub fn get(&self, interned: Interned<T>) -> &T {
         &self.stable_store[interned.idx as usize]
     }
 }
-#[derive(Clone)]
-pub struct Interner<T> {
-    stable_store: Vec<T>,
-}
-impl<T> Default for Interner<T> {
-    fn default() -> Self {
-        Self { stable_store: Default::default() }
-    }
-}
-impl<T> Interner<T> {
-    pub fn freeze(self) -> FixedSizeInterner<T> {
-        FixedSizeInterner { stable_store: self.stable_store }
-    }
-    pub fn push(&mut self, s: T) -> Interned<T> {
-        assert!(self.stable_store.len() < u16::MAX as usize);
-        self.stable_store.push(s);
-        Interned::from_raw(self.stable_store.len() as u16 - 1)
-    }
-}
 
+/// A fixed-length store for values of type `T`, where each value is identified
+/// by an index of type [`Interned<T>`].
 #[derive(Clone)]
 pub struct FixedSizeInterner<T> {
     stable_store: Vec<T>,
 }
 impl<T: Clone> FixedSizeInterner<T> {
+    /// Create a fixed-size interner of the given length containing
+    /// clones of the given value.
     pub fn new(length: u16, value: T) -> Self {
         Self { stable_store: vec![value; length as usize] }
     }
@@ -105,7 +96,6 @@ impl<T> FixedSizeInterner<T> {
     pub fn len(&self) -> u16 {
         self.stable_store.len() as u16
     }
-
     pub fn map<U>(&self, map_f: impl Fn(&T) -> U) -> MappedInterner<U, T> {
         MappedInterner {
             stable_store: self.stable_store.iter().map(map_f).collect(),
@@ -122,6 +112,12 @@ impl<T> FixedSizeInterner<T> {
         self.stable_store.iter_mut().enumerate().map(|(i, x)| (Interned::from_raw(i as u16), x))
     }
 }
+
+/// A store of values of type `T`, each linked to a value of type `From`
+/// stored in another interner. To create a mapped interner, use the
+/// `map` method on [`FixedSizeInterner`] or [`MappedInterner`].
+///
+/// Values in this interner are indexed with [`Interned<From>`].
 #[derive(Clone)]
 pub struct MappedInterner<T, From> {
     stable_store: Vec<T>,