diff --git a/lattices/src/collections.rs b/lattices/src/collections.rs
index 13494e6fe915..42bc8ec24cf8 100644
--- a/lattices/src/collections.rs
+++ b/lattices/src/collections.rs
@@ -84,7 +84,8 @@ impl<T> Len for VecSet<T> {
     }
 }
 impl<T> CollectionRef for VecSet<T> {
-    type ItemRef<'a> = &'a Self::Item
+    type ItemRef<'a>
+        = &'a Self::Item
     where
         Self: 'a;
 
@@ -103,7 +104,8 @@ where
     }
 }
 impl<T> CollectionMut for VecSet<T> {
-    type ItemMut<'a> = &'a mut Self::Item
+    type ItemMut<'a>
+        = &'a mut Self::Item
     where
         Self: 'a;
 
@@ -119,7 +121,8 @@ where
     }
 }
 impl<T> Iter for VecSet<T> {
-    type Iter<'a> = std::slice::Iter<'a, T>
+    type Iter<'a>
+        = std::slice::Iter<'a, T>
     where
         Self: 'a;
 
@@ -128,7 +131,8 @@ impl<T> Iter for VecSet<T> {
     }
 }
 impl<T> IterMut for VecSet<T> {
-    type IterMut<'a> = std::slice::IterMut<'a, T>
+    type IterMut<'a>
+        = std::slice::IterMut<'a, T>
     where
         Self: 'a;
 
@@ -176,7 +180,8 @@ impl<K, V> Len for VecMap<K, V> {
     }
 }
 impl<K, V> CollectionRef for VecMap<K, V> {
-    type ItemRef<'a> = &'a Self::Item
+    type ItemRef<'a>
+        = &'a Self::Item
     where
         Self: 'a;
 
@@ -198,7 +203,8 @@ where
     }
 }
 impl<K, V> CollectionMut for VecMap<K, V> {
-    type ItemMut<'a> = &'a mut Self::Item
+    type ItemMut<'a>
+        = &'a mut Self::Item
     where
         Self: 'a;
 
@@ -220,7 +226,8 @@ impl<K, V> Keyed for VecMap<K, V> {
     type Key = K;
 }
 impl<K, V> KeyedRef for VecMap<K, V> {
-    type KeyRef<'a> = &'a Self::Key
+    type KeyRef<'a>
+        = &'a Self::Key
     where
         Self: 'a;
 
@@ -254,18 +261,20 @@ impl<K, V> SimpleKeyedRef for VecMap<K, V> {
     simple_keyed_ref!();
 }
 impl<K, V> MapIter for VecMap<K, V> {
-    type Iter<'a> = std::iter::Zip<std::slice::Iter<'a, K>, std::slice::Iter<'a, V>>
-	where
-		Self: 'a;
+    type Iter<'a>
+        = std::iter::Zip<std::slice::Iter<'a, K>, std::slice::Iter<'a, V>>
+    where
+        Self: 'a;
 
     fn iter(&self) -> Self::Iter<'_> {
         self.keys.iter().zip(self.vals.iter())
     }
 }
 impl<K, V> MapIterMut for VecMap<K, V> {
-    type IterMut<'a> = std::iter::Zip<std::slice::Iter<'a, K>, std::slice::IterMut<'a, V>>
-	where
-		Self: 'a;
+    type IterMut<'a>
+        = std::iter::Zip<std::slice::Iter<'a, K>, std::slice::IterMut<'a, V>>
+    where
+        Self: 'a;
 
     fn iter_mut(&mut self) -> Self::IterMut<'_> {
         self.keys.iter().zip(self.vals.iter_mut())
@@ -307,7 +316,10 @@ impl<T> Collection for EmptySet<T> {
 }
 
 impl<T> CollectionRef for EmptySet<T> {
-    type ItemRef<'a> = &'a Self::Item where Self::Item: 'a;
+    type ItemRef<'a>
+        = &'a Self::Item
+    where
+        Self::Item: 'a;
 
     covariant_item_ref!();
 }
@@ -328,7 +340,10 @@ impl<T> Len for EmptySet<T> {
 }
 
 impl<T> Iter for EmptySet<T> {
-    type Iter<'a> = std::iter::Empty<&'a T> where T: 'a;
+    type Iter<'a>
+        = std::iter::Empty<&'a T>
+    where
+        T: 'a;
 
     fn iter(&self) -> Self::Iter<'_> {
         std::iter::empty()
@@ -371,7 +386,8 @@ impl<T> Len for SingletonSet<T> {
     }
 }
 impl<T> CollectionRef for SingletonSet<T> {
-    type ItemRef<'a> = &'a Self::Item
+    type ItemRef<'a>
+        = &'a Self::Item
     where
         Self: 'a;
 
@@ -390,7 +406,8 @@ where
     }
 }
 impl<T> CollectionMut for SingletonSet<T> {
-    type ItemMut<'a> = &'a mut T
+    type ItemMut<'a>
+        = &'a mut T
     where
         Self: 'a;
 
@@ -406,16 +423,18 @@ where
     }
 }
 impl<T> Iter for SingletonSet<T> {
-    type Iter<'a> = std::iter::Once<&'a T>
-	where
-		Self: 'a;
+    type Iter<'a>
+        = std::iter::Once<&'a T>
+    where
+        Self: 'a;
 
     fn iter(&self) -> Self::Iter<'_> {
         std::iter::once(&self.0)
     }
 }
 impl<T> IterMut for SingletonSet<T> {
-    type IterMut<'a> = std::iter::Once<&'a mut T>
+    type IterMut<'a>
+        = std::iter::Once<&'a mut T>
     where
         Self: 'a;
 
@@ -457,7 +476,8 @@ impl<K, V> Len for EmptyMap<K, V> {
     }
 }
 impl<K, V> CollectionRef for EmptyMap<K, V> {
-    type ItemRef<'a> = &'a Self::Item
+    type ItemRef<'a>
+        = &'a Self::Item
     where
         Self: 'a;
 
@@ -476,7 +496,8 @@ where
     }
 }
 impl<K, V> CollectionMut for EmptyMap<K, V> {
-    type ItemMut<'a> = &'a mut Self::Item
+    type ItemMut<'a>
+        = &'a mut Self::Item
     where
         Self: 'a;
 
@@ -495,9 +516,10 @@ impl<K, V> Keyed for EmptyMap<K, V> {
     type Key = K;
 }
 impl<K, V> KeyedRef for EmptyMap<K, V> {
-    type KeyRef<'a> = &'a Self::Key
-	where
-		Self: 'a;
+    type KeyRef<'a>
+        = &'a Self::Key
+    where
+        Self: 'a;
 
     covariant_key_ref!();
 }
@@ -520,9 +542,10 @@ where
     }
 }
 impl<K, V> Iter for EmptyMap<K, V> {
-    type Iter<'a> = std::iter::Empty<&'a V>
-	where
-		Self: 'a;
+    type Iter<'a>
+        = std::iter::Empty<&'a V>
+    where
+        Self: 'a;
 
     fn iter(&self) -> Self::Iter<'_> {
         std::iter::empty()
@@ -532,18 +555,20 @@ impl<K, V> SimpleKeyedRef for EmptyMap<K, V> {
     simple_keyed_ref!();
 }
 impl<K, V> MapIter for EmptyMap<K, V> {
-    type Iter<'a> = std::iter::Empty<(&'a K, &'a V)>
-	where
-		Self: 'a;
+    type Iter<'a>
+        = std::iter::Empty<(&'a K, &'a V)>
+    where
+        Self: 'a;
 
     fn iter(&self) -> Self::Iter<'_> {
         std::iter::empty()
     }
 }
 impl<K, V> MapIterMut for EmptyMap<K, V> {
-    type IterMut<'a> = std::iter::Empty<(&'a K, &'a mut V)>
-	where
-		Self: 'a;
+    type IterMut<'a>
+        = std::iter::Empty<(&'a K, &'a mut V)>
+    where
+        Self: 'a;
 
     fn iter_mut(&mut self) -> Self::IterMut<'_> {
         std::iter::empty()
@@ -576,7 +601,8 @@ impl<K, V> Len for SingletonMap<K, V> {
     }
 }
 impl<K, V> CollectionRef for SingletonMap<K, V> {
-    type ItemRef<'a> = &'a Self::Item
+    type ItemRef<'a>
+        = &'a Self::Item
     where
         Self: 'a;
 
@@ -595,7 +621,8 @@ where
     }
 }
 impl<K, V> CollectionMut for SingletonMap<K, V> {
-    type ItemMut<'a> = &'a mut Self::Item
+    type ItemMut<'a>
+        = &'a mut Self::Item
     where
         Self: 'a;
 
@@ -614,9 +641,10 @@ impl<K, V> Keyed for SingletonMap<K, V> {
     type Key = K;
 }
 impl<K, V> KeyedRef for SingletonMap<K, V> {
-    type KeyRef<'a> = &'a Self::Key
-	where
-		Self: 'a;
+    type KeyRef<'a>
+        = &'a Self::Key
+    where
+        Self: 'a;
 
     covariant_key_ref!();
 }
@@ -639,9 +667,10 @@ where
     }
 }
 impl<K, V> Iter for SingletonMap<K, V> {
-    type Iter<'a> = std::iter::Once<&'a V>
-	where
-		Self: 'a;
+    type Iter<'a>
+        = std::iter::Once<&'a V>
+    where
+        Self: 'a;
 
     fn iter(&self) -> Self::Iter<'_> {
         std::iter::once(&self.1)
@@ -651,18 +680,20 @@ impl<K, V> SimpleKeyedRef for SingletonMap<K, V> {
     simple_keyed_ref!();
 }
 impl<K, V> MapIter for SingletonMap<K, V> {
-    type Iter<'a> = std::iter::Once<(&'a K, &'a V)>
-	where
-		Self: 'a;
+    type Iter<'a>
+        = std::iter::Once<(&'a K, &'a V)>
+    where
+        Self: 'a;
 
     fn iter(&self) -> Self::Iter<'_> {
         std::iter::once((&self.0, &self.1))
     }
 }
 impl<K, V> MapIterMut for SingletonMap<K, V> {
-    type IterMut<'a> = std::iter::Once<(&'a K, &'a mut V)>
-	where
-		Self: 'a;
+    type IterMut<'a>
+        = std::iter::Once<(&'a K, &'a mut V)>
+    where
+        Self: 'a;
 
     fn iter_mut(&mut self) -> Self::IterMut<'_> {
         std::iter::once((&self.0, &mut self.1))
@@ -716,7 +747,8 @@ impl<T> Len for OptionSet<T> {
     }
 }
 impl<T> CollectionRef for OptionSet<T> {
-    type ItemRef<'a> = &'a Self::Item
+    type ItemRef<'a>
+        = &'a Self::Item
     where
         Self: 'a;
 
@@ -735,7 +767,8 @@ where
     }
 }
 impl<T> CollectionMut for OptionSet<T> {
-    type ItemMut<'a> = &'a mut T
+    type ItemMut<'a>
+        = &'a mut T
     where
         Self: 'a;
 
@@ -751,16 +784,18 @@ where
     }
 }
 impl<T> Iter for OptionSet<T> {
-    type Iter<'a> = std::option::Iter<'a, T>
-	where
-		Self: 'a;
+    type Iter<'a>
+        = std::option::Iter<'a, T>
+    where
+        Self: 'a;
 
     fn iter(&self) -> Self::Iter<'_> {
         self.0.iter()
     }
 }
 impl<T> IterMut for OptionSet<T> {
-    type IterMut<'a> = std::option::IterMut<'a, T>
+    type IterMut<'a>
+        = std::option::IterMut<'a, T>
     where
         Self: 'a;
 
@@ -803,7 +838,8 @@ impl<K, V> Len for OptionMap<K, V> {
     }
 }
 impl<K, V> CollectionRef for OptionMap<K, V> {
-    type ItemRef<'a> = &'a Self::Item
+    type ItemRef<'a>
+        = &'a Self::Item
     where
         Self: 'a;
 
@@ -825,7 +861,8 @@ where
     }
 }
 impl<K, V> CollectionMut for OptionMap<K, V> {
-    type ItemMut<'a> = &'a mut Self::Item
+    type ItemMut<'a>
+        = &'a mut Self::Item
     where
         Self: 'a;
 
@@ -847,9 +884,10 @@ impl<K, V> Keyed for OptionMap<K, V> {
     type Key = K;
 }
 impl<K, V> KeyedRef for OptionMap<K, V> {
-    type KeyRef<'a> = &'a Self::Key
-	where
-		Self: 'a;
+    type KeyRef<'a>
+        = &'a Self::Key
+    where
+        Self: 'a;
 
     covariant_key_ref!();
 }
@@ -878,9 +916,10 @@ where
     }
 }
 impl<K, V> Iter for OptionMap<K, V> {
-    type Iter<'a> = std::option::IntoIter<&'a V>
-	where
-		Self: 'a;
+    type Iter<'a>
+        = std::option::IntoIter<&'a V>
+    where
+        Self: 'a;
 
     fn iter(&self) -> Self::Iter<'_> {
         self.0.as_ref().map(|(_k, v)| v).into_iter()
@@ -890,18 +929,20 @@ impl<K, V> SimpleKeyedRef for OptionMap<K, V> {
     simple_keyed_ref!();
 }
 impl<K, V> MapIter for OptionMap<K, V> {
-    type Iter<'a> = std::option::IntoIter<(&'a K, &'a V)>
-	where
-		Self: 'a;
+    type Iter<'a>
+        = std::option::IntoIter<(&'a K, &'a V)>
+    where
+        Self: 'a;
 
     fn iter(&self) -> Self::Iter<'_> {
         self.0.as_ref().map(|(k, v)| (k, v)).into_iter()
     }
 }
 impl<K, V> MapIterMut for OptionMap<K, V> {
-    type IterMut<'a> = std::option::IntoIter<(&'a K, &'a mut V)>
-	where
-		Self: 'a;
+    type IterMut<'a>
+        = std::option::IntoIter<(&'a K, &'a mut V)>
+    where
+        Self: 'a;
 
     fn iter_mut(&mut self) -> Self::IterMut<'_> {
         self.0.as_mut().map(|(k, v)| (&*k, v)).into_iter()
@@ -945,7 +986,8 @@ impl<T, const N: usize> Len for ArraySet<T, N> {
     }
 }
 impl<T, const N: usize> CollectionRef for ArraySet<T, N> {
-    type ItemRef<'a> = &'a T
+    type ItemRef<'a>
+        = &'a T
     where
         Self: 'a;
 
@@ -967,7 +1009,8 @@ where
     }
 }
 impl<T, const N: usize> CollectionMut for ArraySet<T, N> {
-    type ItemMut<'a> = &'a mut T
+    type ItemMut<'a>
+        = &'a mut T
     where
         Self: 'a;
 
@@ -986,9 +1029,10 @@ where
     }
 }
 impl<T, const N: usize> Iter for ArraySet<T, N> {
-    type Iter<'a> = std::slice::Iter<'a, T>
-	where
-		Self: 'a;
+    type Iter<'a>
+        = std::slice::Iter<'a, T>
+    where
+        Self: 'a;
 
     fn iter(&self) -> Self::Iter<'_> {
         self.0.iter()
@@ -1035,7 +1079,8 @@ impl<K, V, const N: usize> Len for ArrayMap<K, V, N> {
     }
 }
 impl<K, V, const N: usize> CollectionRef for ArrayMap<K, V, N> {
-    type ItemRef<'a> = &'a Self::Item
+    type ItemRef<'a>
+        = &'a Self::Item
     where
         Self: 'a;
 
@@ -1057,7 +1102,8 @@ where
     }
 }
 impl<K, V, const N: usize> CollectionMut for ArrayMap<K, V, N> {
-    type ItemMut<'a> = &'a mut Self::Item
+    type ItemMut<'a>
+        = &'a mut Self::Item
     where
         Self: 'a;
 
@@ -1079,9 +1125,10 @@ impl<K, V, const N: usize> Keyed for ArrayMap<K, V, N> {
     type Key = K;
 }
 impl<K, V, const N: usize> KeyedRef for ArrayMap<K, V, N> {
-    type KeyRef<'a> = &'a Self::Key
-	where
-		Self: 'a;
+    type KeyRef<'a>
+        = &'a Self::Key
+    where
+        Self: 'a;
 
     covariant_key_ref!();
 }
@@ -1110,9 +1157,10 @@ where
     }
 }
 impl<K, V, const N: usize> Iter for ArrayMap<K, V, N> {
-    type Iter<'a> = std::slice::Iter<'a, V>
-	where
-		Self: 'a;
+    type Iter<'a>
+        = std::slice::Iter<'a, V>
+    where
+        Self: 'a;
 
     fn iter(&self) -> Self::Iter<'_> {
         self.vals.iter()
@@ -1122,18 +1170,20 @@ impl<K, V, const N: usize> SimpleKeyedRef for ArrayMap<K, V, N> {
     simple_keyed_ref!();
 }
 impl<K, V, const N: usize> MapIter for ArrayMap<K, V, N> {
-    type Iter<'a> = std::iter::Zip<std::slice::Iter<'a, K>, std::slice::Iter<'a, V>>
-	where
-		Self: 'a;
+    type Iter<'a>
+        = std::iter::Zip<std::slice::Iter<'a, K>, std::slice::Iter<'a, V>>
+    where
+        Self: 'a;
 
     fn iter(&self) -> Self::Iter<'_> {
         self.keys.iter().zip(self.vals.iter())
     }
 }
 impl<K, V, const N: usize> MapIterMut for ArrayMap<K, V, N> {
-    type IterMut<'a> = std::iter::Zip<std::slice::Iter<'a, K>, std::slice::IterMut<'a, V>>
-	where
-		Self: 'a;
+    type IterMut<'a>
+        = std::iter::Zip<std::slice::Iter<'a, K>, std::slice::IterMut<'a, V>>
+    where
+        Self: 'a;
 
     fn iter_mut(&mut self) -> Self::IterMut<'_> {
         self.keys.iter().zip(self.vals.iter_mut())
diff --git a/lattices/src/ght_lattice.rs b/lattices/src/ght_lattice.rs
index 93e80b8f3360..4469677df9a0 100644
--- a/lattices/src/ght_lattice.rs
+++ b/lattices/src/ght_lattice.rs
@@ -1,3 +1,5 @@
+//! Lattice traits for GHT
+
 use core::cmp::Ordering::{Equal, Greater, Less};
 use std::cmp::Ordering;
 use std::collections::HashMap;
@@ -9,10 +11,6 @@ use variadics::{var_expr, var_type, CloneVariadic, PartialEqVariadic, SplitBySuf
 use crate::ght::{GeneralizedHashTrieNode, GhtGet, GhtInner, GhtLeaf};
 use crate::{IsBot, IsTop, LatticeBimorphism, LatticeOrd, Merge};
 
-//////////////////////////
-/// Lattice traits for GHT
-//////////////////////////
-
 impl<Head, Node> Merge<GhtInner<Head, Node>> for GhtInner<Head, Node>
 where
     Node: GeneralizedHashTrieNode + Merge<Node>,
diff --git a/variadics/src/lib.rs b/variadics/src/lib.rs
index bd0de27a1a3f..ad08b9fe0a9b 100644
--- a/variadics/src/lib.rs
+++ b/variadics/src/lib.rs
@@ -209,7 +209,10 @@ where
 {
     const LEN: usize = 1 + Rest::LEN;
 
-    type Extend<Suffix> = (Item, Rest::Extend<Suffix>) where Suffix: VariadicExt;
+    type Extend<Suffix>
+        = (Item, Rest::Extend<Suffix>)
+    where
+        Suffix: VariadicExt;
     fn extend<Suffix>(self, suffix: Suffix) -> Self::Extend<Suffix>
     where
         Suffix: VariadicExt,
@@ -232,7 +235,8 @@ where
         out2
     }
 
-    type AsRefVar<'a> = (&'a Item, Rest::AsRefVar<'a>)
+    type AsRefVar<'a>
+        = (&'a Item, Rest::AsRefVar<'a>)
     where
         Self: 'a;
     fn as_ref_var(&self) -> Self::AsRefVar<'_> {
@@ -240,7 +244,8 @@ where
         (item, rest.as_ref_var())
     }
 
-    type AsMutVar<'a> = (&'a mut Item, Rest::AsMutVar<'a>)
+    type AsMutVar<'a>
+        = (&'a mut Item, Rest::AsMutVar<'a>)
     where
         Self: 'a;
     fn as_mut_var(&mut self) -> Self::AsMutVar<'_> {
@@ -248,7 +253,8 @@ where
         (item, rest.as_mut_var())
     }
 
-    type IterAnyRef<'a> = std::iter::Chain<std::iter::Once<&'a dyn Any>, Rest::IterAnyRef<'a>>
+    type IterAnyRef<'a>
+        = std::iter::Chain<std::iter::Once<&'a dyn Any>, Rest::IterAnyRef<'a>>
     where
         Self: 'static;
     fn iter_any_ref(&self) -> Self::IterAnyRef<'_>
@@ -260,7 +266,8 @@ where
         std::iter::once(item).chain(rest.iter_any_ref())
     }
 
-    type IterAnyMut<'a> = std::iter::Chain<std::iter::Once<&'a mut dyn Any>, Rest::IterAnyMut<'a>>
+    type IterAnyMut<'a>
+        = std::iter::Chain<std::iter::Once<&'a mut dyn Any>, Rest::IterAnyMut<'a>>
     where
         Self: 'static;
     fn iter_any_mut(&mut self) -> Self::IterAnyMut<'_>
@@ -289,7 +296,10 @@ where
 impl VariadicExt for () {
     const LEN: usize = 0;
 
-    type Extend<Suffix> = Suffix where Suffix: VariadicExt;
+    type Extend<Suffix>
+        = Suffix
+    where
+        Suffix: VariadicExt;
     fn extend<Suffix>(self, suffix: Suffix) -> Self::Extend<Suffix>
     where
         Suffix: VariadicExt,
@@ -307,7 +317,8 @@ impl VariadicExt for () {
     type AsMutVar<'a> = ();
     fn as_mut_var(&mut self) -> Self::AsMutVar<'_> {}
 
-    type IterAnyRef<'a> = std::iter::Empty<&'a dyn Any>
+    type IterAnyRef<'a>
+        = std::iter::Empty<&'a dyn Any>
     where
         Self: 'static;
     fn iter_any_ref(&self) -> Self::IterAnyRef<'_>
@@ -317,7 +328,8 @@ impl VariadicExt for () {
         std::iter::empty()
     }
 
-    type IterAnyMut<'a> = std::iter::Empty<&'a mut dyn Any>
+    type IterAnyMut<'a>
+        = std::iter::Empty<&'a mut dyn Any>
     where
         Self: 'static;
     fn iter_any_mut(&mut self) -> Self::IterAnyMut<'_>
@@ -820,7 +832,10 @@ where
         std::iter::zip(this, rest.into_zip())
     }
 
-    type Drain<'a> = std::iter::Zip<std::vec::Drain<'a, Item>, Rest::Drain<'a>> where Self: 'a;
+    type Drain<'a>
+        = std::iter::Zip<std::vec::Drain<'a, Item>, Rest::Drain<'a>>
+    where
+        Self: 'a;
     fn drain<R>(&mut self, range: R) -> Self::Drain<'_>
     where
         R: std::ops::RangeBounds<usize> + Clone,
@@ -849,7 +864,10 @@ impl VecVariadic for var_type!() {
         std::iter::repeat(var_expr!())
     }
 
-    type Drain<'a> = std::iter::Repeat<var_type!()> where Self: 'a;
+    type Drain<'a>
+        = std::iter::Repeat<var_type!()>
+    where
+        Self: 'a;
     fn drain<R>(&mut self, _range: R) -> Self::Drain<'_>
     where
         R: std::ops::RangeBounds<usize>,
diff --git a/variadics/tests/boxed_refed.rs b/variadics/tests/boxed_refed.rs
index 17366b177dc5..8d7e44fc9f5c 100644
--- a/variadics/tests/boxed_refed.rs
+++ b/variadics/tests/boxed_refed.rs
@@ -29,7 +29,8 @@ impl<Item, Rest> Refed for (Item, Rest)
 where
     Rest: Refed,
 {
-    type Refed<'a> = (&'a Item, Rest::Refed<'a>)
+    type Refed<'a>
+        = (&'a Item, Rest::Refed<'a>)
     where
         Self: 'a;
     fn refed(&self) -> Self::Refed<'_> {