chore: Consitent naming for display functions (#3871)

Signed-off-by: Robert Kruszewski <github@robertk.io>

Author: robert3005

encodings/dict/src/display.rs

@@ -20,7 +20,7 @@ mod test {
         .into_array();
 
         assert_eq!(
-            x.display().to_string(),
+            x.display_values().to_string(),
             "[\"Hello\", \"Hello\", \"Hello\", \"你好\", \"Hello\", \"Hola\"]"
         )
     }
@@ -42,7 +42,7 @@ mod test {
         .into_array();
 
         assert_eq!(
-            elements.display().to_string(),
+            elements.display_values().to_string(),
             "[\"Hello\", \"Hello\", \"Hello\", \"你好\", \"Hello\", \"Bonjour\", \"Bonjour\", null]"
         );
 
@@ -57,7 +57,7 @@ mod test {
         .into_array();
 
         assert_eq!(
-            lists.display().to_string(),
+            lists.display_values().to_string(),
             "[[\"Hello\"], [], null, [\"Hello\", \"Hello\"], null, [\"你好\", \"Hello\"], [\"Bonjour\", \"Bonjour\", null]]"
         );
 
@@ -66,7 +66,7 @@ mod test {
             .into_array();
 
         assert_eq!(
-            x.display().to_string(),
+            x.display_values().to_string(),
             "[[\"Bonjour\", \"Bonjour\", null], [\"你好\", \"Hello\"], null, [\"Hello\", \"Hello\"], null, []]"
         )
     }

fuzz/fuzz_targets/array_ops.rs

@@ -72,7 +72,7 @@ fuzz_target!(|fuzz_action: FuzzArrayAction| -> Corpus {
                 if let Err(e) = assert_array_eq(&expected.array(), &compare_result, i) {
                     vortex_panic!(
                         "Failed to compare {}with {op} {v}\nError: {e}",
-                        current_array.tree_display()
+                        current_array.display_tree()
                     )
                 }
                 current_array = compare_result;
@@ -82,7 +82,7 @@ fuzz_target!(|fuzz_action: FuzzArrayAction| -> Corpus {
                 if let Err(e) = assert_array_eq(&expected.array(), &cast_result, i) {
                     vortex_panic!(
                         "Failed to cast {} to dtype {to}\nError: {e}",
-                        current_array.tree_display()
+                        current_array.display_tree()
                     )
                 }
                 current_array = cast_result;

fuzz/fuzz_targets/file_io.rs

@@ -110,8 +110,8 @@ fuzz_target!(|fuzz: FuzzFileAction| -> Corpus {
             {
                 vortex_panic!(
                     "Failed to match original array {}with{}",
-                    expected_array.tree_display(),
-                    output_array.tree_display()
+                    expected_array.display_tree(),
+                    output_array.display_tree()
                 );
             }
         }
@@ -134,8 +134,8 @@ fn compare_struct(expected: ArrayRef, actual: ArrayRef) {
         comparison_result.count_set_bits(),
         arrow_expected.len(),
         "\nEXPECTED: {}ACTUAL: {}",
-        expected.tree_display(),
-        actual.tree_display()
+        expected.display_tree(),
+        actual.display_tree()
     );
 }
 

fuzz/src/error.rs

@@ -10,7 +10,7 @@ use vortex_error::VortexError;
 use vortex_scalar::Scalar;
 
 fn tree_display(arr: &ArrayRef) -> impl Display {
-    arr.tree_display()
+    arr.display_tree()
 }
 
 #[derive(thiserror::Error)]

vortex-array/src/array/display/mod.rs

@@ -12,41 +12,11 @@ use vortex_error::VortexExpect as _;
 
 use crate::Array;
 
-/// A shim used to display the logical contents of an array.
-///
-/// For example, an `i16` typed array containing the first five non-negative integers is displayed
-/// as: `[0i16, 1i16, 2i16, 3i16, 4i16]`.
-///
-/// # Examples
-///
-/// ```
-/// # use vortex_array::IntoArray;
-/// # use vortex_buffer::buffer;
-/// let array = buffer![0_i16, 1, 2, 3, 4].into_array();
-/// assert_eq!(
-///     format!("{}", array.display()),
-///     "[0i16, 1i16, 2i16, 3i16, 4i16]",
-/// )
-/// ```
-///
-/// See also:
-/// [Array::display](http://localhost:8000/doc/vortex_array/trait.Array.html#method.display),
-/// [Array::display_as](http://localhost:8000/doc/vortex_array/trait.Array.html#method.display_as),
-/// [DisplayArrayAs], and [DisplayOptions].
-pub struct DisplayArray<'a>(pub &'a dyn Array);
-
-impl Display for DisplayArray<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.0.fmt_as(f, &DisplayOptions::default())
-    }
-}
-
 /// Describe how to convert an array to a string.
 ///
 /// See also:
-/// [Array::display](http://localhost:8000/doc/vortex_array/trait.Array.html#method.display),
-/// [Array::display_as](http://localhost:8000/doc/vortex_array/trait.Array.html#method.display_as),
-/// [DisplayArray], and [DisplayArrayAs].
+/// [Array::display_as](../trait.Array.html#method.display_as)
+/// and [DisplayArrayAs].
 pub enum DisplayOptions {
     /// Only the top-level encoding id and limited metadata: `vortex.primitive(i16, len=5)`.
     ///
@@ -55,9 +25,8 @@ pub enum DisplayOptions {
     /// # use vortex_array::IntoArray;
     /// # use vortex_buffer::buffer;
     /// let array = buffer![0_i16, 1, 2, 3, 4].into_array();
-    /// let opts = DisplayOptions::MetadataOnly;
     /// assert_eq!(
-    ///     format!("{}", array.display_as(&opts)),
+    ///     format!("{}", array.display_as(DisplayOptions::MetadataOnly)),
     ///     "vortex.primitive(i16, len=5)",
     /// );
     /// ```
@@ -69,53 +38,50 @@ pub enum DisplayOptions {
     /// # use vortex_array::IntoArray;
     /// # use vortex_buffer::buffer;
     /// let array = buffer![0_i16, 1, 2, 3, 4].into_array();
-    /// let opts = DisplayOptions::default();
     /// assert_eq!(
-    ///     format!("{}", array.display_as(&opts)),
+    ///     format!("{}", array.display_as(DisplayOptions::default())),
     ///     "[0i16, 1i16, 2i16, 3i16, 4i16]",
     /// );
     /// assert_eq!(
-    ///     format!("{}", array.display_as(&opts)),
-    ///     format!("{}", array.display()),
+    ///     format!("{}", array.display_as(DisplayOptions::default())),
+    ///     format!("{}", array.display_values()),
     /// );
     /// ```
-    CommaSeparatedScalars { space_after_comma: bool },
+    CommaSeparatedScalars { omit_comma_after_space: bool },
     /// The tree of encodings and all metadata but no values.
     ///
     /// ```
     /// # use vortex_array::display::DisplayOptions;
     /// # use vortex_array::IntoArray;
     /// # use vortex_buffer::buffer;
     /// let array = buffer![0_i16, 1, 2, 3, 4].into_array();
-    /// let opts = DisplayOptions::TreeDisplay;
     /// let expected = "root: vortex.primitive(i16, len=5) nbytes=10 B (100.00%)
     ///   metadata: EmptyMetadata
     ///   buffer (align=2): 10 B (100.00%)
     /// ";
-    /// assert_eq!(format!("{}", array.display_as(&opts)), expected);
+    /// assert_eq!(format!("{}", array.display_as(DisplayOptions::TreeDisplay)), expected);
     /// ```
     TreeDisplay,
 }
 
 impl Default for DisplayOptions {
     fn default() -> Self {
         Self::CommaSeparatedScalars {
-            space_after_comma: true,
+            omit_comma_after_space: false,
         }
     }
 }
 
 /// A shim used to display an array as specified in the options.
 ///
 /// See also:
-/// [Array::display](http://localhost:8000/doc/vortex_array/trait.Array.html#method.display),
-/// [Array::display_as](http://localhost:8000/doc/vortex_array/trait.Array.html#method.display_as),
-/// [DisplayArray], and [DisplayOptions].
-pub struct DisplayArrayAs<'a>(pub &'a dyn Array, pub &'a DisplayOptions);
+/// [Array::display_as](../trait.Array.html#method.display_as)
+/// and [DisplayOptions].
+pub struct DisplayArrayAs<'a>(pub &'a dyn Array, pub DisplayOptions);
 
 impl Display for DisplayArrayAs<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.0.fmt_as(f, self.1)
+        self.0.fmt_as(f, &self.1)
     }
 }
 
@@ -138,7 +104,10 @@ impl Display for dyn Array + '_ {
 }
 
 impl dyn Array + '_ {
-    /// Display the logical values of the array.
+    /// Display logical values of the array
+    ///
+    /// For example, an `i16` typed array containing the first five non-negative integers is displayed
+    /// as: `[0i16, 1i16, 2i16, 3i16, 4i16]`.
     ///
     /// # Examples
     ///
@@ -147,27 +116,35 @@ impl dyn Array + '_ {
     /// # use vortex_buffer::buffer;
     /// let array = buffer![0_i16, 1, 2, 3, 4].into_array();
     /// assert_eq!(
-    ///     format!("{}", array.display()),
+    ///     format!("{}", array.display_values()),
     ///     "[0i16, 1i16, 2i16, 3i16, 4i16]",
     /// )
     /// ```
-    pub fn display(&self) -> DisplayArray {
-        DisplayArray(self)
+    ///
+    /// See also:
+    /// [Array::display_as](..//trait.Array.html#method.display_as),
+    /// [DisplayArrayAs], and [DisplayOptions].
+    pub fn display_values(&self) -> DisplayArrayAs<'_> {
+        DisplayArrayAs(
+            self,
+            DisplayOptions::CommaSeparatedScalars {
+                omit_comma_after_space: false,
+            },
+        )
     }
 
     /// Display the array as specified by the options.
     ///
     /// See [DisplayOptions] for examples.
-    pub fn display_as<'a>(&'a self, options: &'a DisplayOptions) -> DisplayArrayAs<'a> {
+    pub fn display_as(&self, options: DisplayOptions) -> DisplayArrayAs<'_> {
         DisplayArrayAs(self, options)
     }
 
     /// Display the tree of encodings of this array as an indented lists.
     ///
     /// While some metadata (such as length, bytes and validity-rate) are included, the logical
     /// values of the array are not displayed. To view the logical values see
-    /// [Array::display](http://localhost:8000/doc/vortex_array/trait.Array.html#method.display),
-    /// [Array::display_as](http://localhost:8000/doc/vortex_array/trait.Array.html#method.display_as),
+    /// [Array::display_as](../trait.Array.html#method.display_as)
     /// and [DisplayOptions].
     ///
     /// # Examples
@@ -176,25 +153,17 @@ impl dyn Array + '_ {
     /// # use vortex_array::IntoArray;
     /// # use vortex_buffer::buffer;
     /// let array = buffer![0_i16, 1, 2, 3, 4].into_array();
-    /// let opts = DisplayOptions::TreeDisplay;
     /// let expected = "root: vortex.primitive(i16, len=5) nbytes=10 B (100.00%)
     ///   metadata: EmptyMetadata
     ///   buffer (align=2): 10 B (100.00%)
     /// ";
-    /// assert_eq!(format!("{}", array.display_as(&opts)), expected);
+    /// assert_eq!(format!("{}", array.display_tree()), expected);
     /// ```
-    pub fn tree_display(&self) -> impl Display {
-        TreeDisplayWrapper(self.to_array())
+    pub fn display_tree(&self) -> impl Display {
+        DisplayArrayAs(self, DisplayOptions::TreeDisplay)
     }
 
-    /// Format an array as specified by the options.
-    ///
-    /// See [DisplayOptions] for examples.
-    pub fn fmt_as(
-        &self,
-        f: &mut std::fmt::Formatter,
-        options: &DisplayOptions,
-    ) -> std::fmt::Result {
+    fn fmt_as(&self, f: &mut std::fmt::Formatter, options: &DisplayOptions) -> std::fmt::Result {
         match options {
             DisplayOptions::MetadataOnly => {
                 write!(
@@ -205,9 +174,11 @@ impl dyn Array + '_ {
                     self.len()
                 )
             }
-            DisplayOptions::CommaSeparatedScalars { space_after_comma } => {
+            DisplayOptions::CommaSeparatedScalars {
+                omit_comma_after_space,
+            } => {
                 write!(f, "[")?;
-                let sep = if *space_after_comma { ", " } else { "," };
+                let sep = if *omit_comma_after_space { "," } else { ", " };
                 write!(
                     f,
                     "{}",
@@ -234,13 +205,13 @@ mod test {
     #[test]
     fn test_primitive() {
         let x = Buffer::<u32>::empty().into_array();
-        assert_eq!(x.display().to_string(), "[]");
+        assert_eq!(x.display_values().to_string(), "[]");
 
         let x = buffer![1].into_array();
-        assert_eq!(x.display().to_string(), "[1i32]");
+        assert_eq!(x.display_values().to_string(), "[1i32]");
 
         let x = buffer![1, 2, 3, 4].into_array();
-        assert_eq!(x.display().to_string(), "[1i32, 2i32, 3i32, 4i32]");
+        assert_eq!(x.display_values().to_string(), "[1i32, 2i32, 3i32, 4i32]");
     }
 
     #[test]
@@ -253,7 +224,7 @@ mod test {
         )
         .unwrap()
         .into_array();
-        assert_eq!(s.display().to_string(), "[{}, null, {}]");
+        assert_eq!(s.display_values().to_string(), "[{}, null, {}]");
     }
 
     #[test]
@@ -265,7 +236,7 @@ mod test {
         .unwrap()
         .into_array();
         assert_eq!(
-            s.display().to_string(),
+            s.display_values().to_string(),
             "[{x: 1i32, y: -1i32}, {x: 2i32, y: -2i32}, {x: 3i32, y: -3i32}, {x: 4i32, y: -4i32}]"
         );
     }
@@ -280,7 +251,7 @@ mod test {
         .unwrap()
         .into_array();
         assert_eq!(
-            x.display().to_string(),
+            x.display_values().to_string(),
             "[[], [1i32], null, [2i32], [3i32, 4i32]]"
         );
     }

vortex-array/src/array/display/tree.rs

@@ -6,6 +6,7 @@ use std::fmt::{self};
 use humansize::{DECIMAL, format_size};
 
 use crate::arrays::ChunkedEncoding;
+use crate::display::DisplayOptions;
 use crate::{Array, ArrayRef, ArrayVisitor};
 
 pub(super) struct TreeDisplayWrapper(pub(super) ArrayRef);
@@ -35,7 +36,7 @@ impl<'a, 'b: 'a> TreeFormatter<'a, 'b> {
             self,
             "{}: {} nbytes={} ({:.2}%)",
             name,
-            array,
+            array.display_as(DisplayOptions::MetadataOnly),
             format_size(nbytes, DECIMAL),
             100_f64 * nbytes as f64 / total_size as f64
         )?;

vortex-array/src/arrow/compute/to_arrow/canonical.rs

@@ -280,7 +280,7 @@ fn to_arrow_struct(array: StructArray, fields: &[FieldRef]) -> VortexResult<Arro
                 vortex_bail!(
                     "Field {} is non-nullable but has nulls {}",
                     field,
-                    arr.tree_display()
+                    arr.display_tree()
                 );
             }
 

vortex-array/src/compute/mod.rs

@@ -123,7 +123,7 @@ impl ComputeFn {
                 args.inputs
                     .iter()
                     .filter_map(|input| input.array())
-                    .format_with(",", |array, f| f(&array.tree_display()))
+                    .format_with(",", |array, f| f(&array.display_tree()))
             );
         }
         if output.len() != expected_len {

vortex-btrblocks/src/float.rs

@@ -385,6 +385,6 @@ mod tests {
 
         let floats = values.into_array().to_primitive().unwrap();
         let compressed = FloatCompressor::compress(&floats, false, MAX_CASCADE, &[]).unwrap();
-        println!("compressed: {}", compressed.tree_display())
+        println!("compressed: {}", compressed.display_tree())
     }
 }