feat: Make FieldNames comparison more ergonomic (#4239)

Just been playing around with select exprs recently, and I think this
would make it nicer to work with field names.

Signed-off-by: Adam Gutglick <[email protected]>

Author: AdamGS

vortex-array/src/arrays/struct_/mod.rs

@@ -531,7 +531,7 @@ mod test {
             [0i64, 1, 2, 3, 4]
         );
 
-        assert_eq!(struct_a.names(), &[FieldName::from("ys")].into());
+        assert_eq!(struct_a.names(), &["ys"]);
         assert_eq!(struct_a.fields.len(), 1);
         assert_eq!(struct_a.len(), 5);
         assert_eq!(
@@ -550,7 +550,7 @@ mod test {
             empty.is_none(),
             "Expected None when removing non-existent column"
         );
-        assert_eq!(struct_a.names(), &[FieldName::from("ys")].into());
+        assert_eq!(struct_a.names(), &["ys"]);
     }
 
     #[test]

vortex-dtype/src/dtype.rs

@@ -23,6 +23,48 @@ pub type FieldName = Arc<str>;
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct FieldNames(Arc<[FieldName]>);
 
+impl PartialEq<&FieldNames> for FieldNames {
+    fn eq(&self, other: &&FieldNames) -> bool {
+        self == *other
+    }
+}
+
+impl PartialEq<&[&str]> for FieldNames {
+    fn eq(&self, other: &&[&str]) -> bool {
+        self.len() == other.len() && self.iter().zip_eq(other.iter()).all(|(l, r)| &**l == *r)
+    }
+}
+
+impl PartialEq<&[&str]> for &FieldNames {
+    fn eq(&self, other: &&[&str]) -> bool {
+        *self == other
+    }
+}
+
+impl<const N: usize> PartialEq<[&str; N]> for FieldNames {
+    fn eq(&self, other: &[&str; N]) -> bool {
+        self == other.as_slice()
+    }
+}
+
+impl<const N: usize> PartialEq<[&str; N]> for &FieldNames {
+    fn eq(&self, other: &[&str; N]) -> bool {
+        *self == other.as_slice()
+    }
+}
+
+impl PartialEq<&[FieldName]> for FieldNames {
+    fn eq(&self, other: &&[FieldName]) -> bool {
+        self.0.as_ref() == *other
+    }
+}
+
+impl PartialEq<&[FieldName]> for &FieldNames {
+    fn eq(&self, other: &&[FieldName]) -> bool {
+        self.0.as_ref() == *other
+    }
+}
+
 impl FieldNames {
     /// Returns the number of elements.
     pub fn len(&self) -> usize {
@@ -457,4 +499,40 @@ mod tests {
         assert_eq!(iter.next(), Some("b".into()));
         assert_eq!(iter.next(), None);
     }
+
+    #[test]
+    fn test_field_names_equality() {
+        let field_names = FieldNames::from(["field1", "field2", "field3"]);
+
+        // FieldNames == &FieldNames
+        let field_names_ref = &field_names;
+        assert_eq!(field_names, field_names_ref);
+
+        // FieldNames == &[&str]
+        let str_slice = &["field1", "field2", "field3"][..];
+        assert_eq!(field_names, str_slice);
+
+        // &FieldNames == &[&str]
+        assert_eq!(&field_names, str_slice);
+
+        // FieldNames == [&str; N] (array)
+        assert_eq!(field_names, ["field1", "field2", "field3"]);
+
+        // &FieldNames == [&str; N] (array)
+        assert_eq!(&field_names, ["field1", "field2", "field3"]);
+
+        // FieldNames == &[FieldName]
+        let field_name_vec: Vec<FieldName> =
+            vec!["field1".into(), "field2".into(), "field3".into()];
+        let field_name_slice = field_name_vec.as_slice();
+        assert_eq!(field_names, field_name_slice);
+
+        // &FieldNames == &[FieldName]
+        assert_eq!(&field_names, field_name_slice);
+
+        // Test inequality cases
+        assert_ne!(field_names, &["field1", "field2"][..]);
+        assert_ne!(field_names, ["different", "fields", "here"]);
+        assert_ne!(field_names, &["field1", "field2", "field3", "extra"][..]);
+    }
 }

vortex-dtype/src/struct_.rs

@@ -436,23 +436,21 @@ mod test {
         let sdt = dtype.as_struct().unwrap();
         assert_eq!(sdt.names().len(), 2);
         assert_eq!(sdt.fields().len(), 2);
-        assert_eq!(sdt.names()[0], "A".into());
-        assert_eq!(sdt.names()[1], "B".into());
+        assert_eq!(sdt.names(), ["A", "B"]);
         assert_eq!(sdt.field_by_index(0).unwrap(), a_type);
         assert_eq!(sdt.field_by_index(1).unwrap(), b_type);
 
         let proj = sdt.project(&["B".into(), "A".into()]).unwrap();
-        assert_eq!(proj.names()[0], "B".into());
+        assert_eq!(proj.names(), ["B", "A"]);
         assert_eq!(proj.field_by_index(0).unwrap(), b_type);
-        assert_eq!(proj.names()[1], "A".into());
         assert_eq!(proj.field_by_index(1).unwrap(), a_type);
 
         assert_eq!(sdt.find("A").unwrap(), 0);
         assert_eq!(sdt.find("B").unwrap(), 1);
         assert!(sdt.find("C").is_none());
 
         let without_a = sdt.without_field(0).unwrap();
-        assert_eq!(without_a.names()[0], "B".into());
+        assert_eq!(without_a.names(), ["B"]);
         assert_eq!(without_a.field_by_index(0).unwrap(), b_type);
         assert_eq!(without_a.nfields(), 1);
     }
@@ -478,7 +476,7 @@ mod test {
         let sdt = StructFields::from_iter([("A", a_type), ("B", b_type.clone())]);
 
         let without_a = sdt.without_field(0).unwrap();
-        assert_eq!(without_a.names()[0], "B".into());
+        assert_eq!(without_a.names(), ["B"]);
         assert_eq!(without_a.field_by_index(0).unwrap(), b_type);
         assert_eq!(without_a.nfields(), 1);
     }
@@ -494,7 +492,7 @@ mod test {
         let sf2 = StructFields::from_iter([("C", child_c.clone())]);
 
         let merged = StructFields::disjoint_merge(&sf1, &sf2).unwrap();
-        assert_eq!(merged.names(), &FieldNames::from_iter(["A", "B", "C"]));
+        assert_eq!(merged.names(), ["A", "B", "C"]);
         assert_eq!(
             merged.fields().collect_vec(),
             vec![child_a, child_b, child_c]

vortex-expr/src/exprs/merge.rs

@@ -262,7 +262,7 @@ mod tests {
 
         assert_eq!(
             actual_array.as_struct_typed().names(),
-            &["a", "b", "c", "d", "e"].into()
+            ["a", "b", "c", "d", "e"]
         );
 
         assert_eq!(
@@ -402,7 +402,7 @@ mod tests {
             .to_struct()
             .unwrap();
 
-        assert_eq!(actual_array.names(), &["a", "c", "b", "d"].into());
+        assert_eq!(actual_array.names(), ["a", "c", "b", "d"]);
     }
 
     #[test]

vortex-expr/src/exprs/pack.rs

@@ -274,8 +274,8 @@ mod tests {
             .unwrap()
             .to_struct()
             .unwrap();
-        let expected_names: FieldNames = ["one", "two", "three"].into();
-        assert_eq!(actual_array.names(), &expected_names);
+
+        assert_eq!(actual_array.names(), ["one", "two", "three"]);
         assert_eq!(actual_array.validity(), &Validity::NonNullable);
 
         assert_eq!(
@@ -322,8 +322,8 @@ mod tests {
             .unwrap()
             .to_struct()
             .unwrap();
-        let expected_names = FieldNames::from(["one", "two", "three"]);
-        assert_eq!(actual_array.names(), &expected_names);
+
+        assert_eq!(actual_array.names(), ["one", "two", "three"]);
 
         assert_eq!(
             primitive_field(actual_array.as_ref(), &["one"])
@@ -365,8 +365,8 @@ mod tests {
             .unwrap()
             .to_struct()
             .unwrap();
-        let expected_names: FieldNames = ["one", "two", "three"].into();
-        assert_eq!(actual_array.names(), &expected_names);
+
+        assert_eq!(actual_array.names(), ["one", "two", "three"]);
         assert_eq!(actual_array.validity(), &Validity::AllValid);
     }
 }

vortex-python/src/scalar/factory.rs

@@ -107,7 +107,7 @@ fn scalar_helper_inner(value: &Bound<'_, PyAny>, dtype: Option<&DType>) -> PyRes
             .into();
 
         if let Some(DType::Struct(dtype, nullability)) = dtype {
-            if &names != dtype.names() {
+            if names != dtype.names() {
                 return Err(PyValueError::new_err(format!(
                     "Dictionary field names {:?} do not match target dtype names {:?}",
                     &names,

vortex-scalar/src/struct_.rs

@@ -511,11 +511,11 @@ mod tests {
         let projected_struct = projected.as_struct();
 
         assert_eq!(projected_struct.names().len(), 1);
-        assert_eq!(projected_struct.names()[0], "b".into());
+        assert_eq!(projected_struct.names()[0].as_ref(), "b");
 
         let fields = projected_struct.fields().unwrap();
         assert_eq!(fields.len(), 1);
-        assert_eq!(fields[0].as_utf8().value().unwrap(), "hello".into());
+        assert_eq!(fields[0].as_utf8().value().unwrap().as_str(), "hello");
     }
 
     #[test]