Misc patches — heartwood

These are misc patches I found while browsing the source code. The individual patches are not related.

     }
     pub fn is_success(&self) -> bool {
         match self {
             Self::Success { .. } => true,
             Self::Failed { .. } => false,
         }
         std::matches!(self, Self::Success { .. })
     }
 }

     }
     /// Return a line with a single space between the given labels.
     ///
     /// TODO: Make this impl trivial once Iterator::intersperse() is stable
     pub fn spaced(items: impl IntoIterator<Item = Label>) -> Self {
         let mut line = Self::default();
         for item in items.into_iter() {
             // Don't create spaces around empty labels.
             if item.is_blank() {
                 continue;
             }
         let iter = items.into_iter();
         let mut line = Self {
             items: Vec::with_capacity({
                 let (min, max) = iter.size_hint();
                 let likely = max.unwrap_or(min);
                 // technically (likely + (likely - 1), but we push the last space before
                 // we pop it again, so we need that additional space anyways
                 likely * 2
             }),
         };
         // Don't create spaces around empty labels.
         for item in iter.filter(|i| !i.is_blank()) {
             line.push(item);
             line.push(Label::space());
         }

         let line = Line::new("❤️");
         assert_eq!(line.width(), 2, "{line}");
     }
     #[test]
     fn test_spaced() {
         let line = Line::spaced(["banana", "peach", "apple"].into_iter().map(Label::new));
         let iterated: Vec<_> = line.into_iter().collect();
         assert_eq!(
             iterated
                 .into_iter()
                 .map(|l| l.to_string())
                 .collect::<Vec<_>>(),
             ["banana", " ", "peach", " ", "apple"]
         );
     }
 }

     }
     /// Add multiple elements to the stack.
     pub fn children<I>(self, children: I) -> Self
     pub fn children<I>(mut self, children: I) -> Self
     where
         I: IntoIterator<Item = Box<dyn Element>>,
     {
         let mut vstack = self;
         for child in children.into_iter() {
             vstack = vstack.child(child);
         }
         vstack
         self.rows
             .extend(children.into_iter().map(|e| Row::Element(Box::new(e))));
         self
     }
     /// Merge with another `VStack`.

     /// Return a shuffled iterator.
     pub fn shuffled(&self) -> std::vec::IntoIter<(&K, &V)> {
         let mut items = self.inner.iter().collect::<Vec<_>>();
         items.sort_by_key(|(k, _)| *k);
         self.rng.borrow_mut().shuffle(&mut items);
         items.into_iter()

     }
     pub fn peers(&self) -> impl Iterator<Item = NodeId> + '_ {
         self.connect.iter().cloned().map(|p| p.id)
         self.connect.iter().map(|p| p.0.id)
     }
     pub fn is_persistent(&self, id: &NodeId) -> bool {