docs: use Arrow array type names

Signed-off-by: cl <cailue@apache.org>

Author: ClSlaid

encodings/fsst/src/canonical.rs

@@ -68,6 +68,7 @@ pub(crate) fn fsst_decode_bytes(
         len == total_size,
         "FSST decoded {len} bytes, expected {total_size}"
     );
+    // SAFETY: `decompress_into` initialized the first `len` bytes.
     unsafe { uncompressed_bytes.set_len(len) };
     Ok((uncompressed_bytes, uncompressed_lens_array))
 }

vortex-array/src/arrays/varbin/builder.rs

@@ -191,11 +191,11 @@ impl<O: IntegerPType> VarBinBuilder<O> {
     }
 }
 
-/// Builder for offset-based UTF-8 and binary arrays with either 32-bit or 64-bit offsets.
+/// Builder for UTF-8 and binary [`VarBinArray`] values.
 ///
-/// Unlike [`crate::builders::VarBinViewBuilder`], this builder produces a [`VarBinArray`].
-/// Encodings can downcast an [`ArrayBuilder`] to this type and decode directly into Arrow's
-/// offset-based physical representation without first materializing a view array.
+/// Unlike [`crate::builders::VarBinViewBuilder`], this builder stores 32-bit or 64-bit offsets.
+/// Encodings can decode into this builder without first creating a
+/// [`VarBinViewArray`](crate::arrays::VarBinViewArray).
 pub struct VarBinBufferBuilder {
     dtype: DType,
     storage: TypedBuilder,
@@ -270,7 +270,7 @@ impl VarBinBufferBuilder {
         Ok(())
     }
 
-    /// Appends an existing offset-based Vortex array without constructing views.
+    /// Appends an existing [`VarBinArray`] without constructing views.
     pub fn append_varbin(
         &mut self,
         array: crate::ArrayView<'_, VarBin>,
@@ -296,7 +296,7 @@ impl VarBinBufferBuilder {
         Ok(())
     }
 
-    /// Appends a Vortex view array into the offset-based output.
+    /// Appends a [`VarBinViewArray`](crate::arrays::VarBinViewArray).
     pub fn append_varbinview(
         &mut self,
         array: crate::ArrayView<'_, VarBinView>,

vortex-python/python/vortex/file.py

@@ -216,8 +216,8 @@ def to_arrow(
         batch_size : :class:`int` | None
             The number of rows to read per chunk.
         schema : :class:`pyarrow.Schema` | None
-            The Arrow physical schema to return. Use ``pyarrow.string()`` and
-            ``pyarrow.binary()`` fields to request offset-based arrays instead of view arrays.
+            The Arrow schema to return. Use ``pyarrow.string()`` for ``StringArray`` fields.
+            Use ``pyarrow.binary()`` for ``BinaryArray`` fields.
 
         """
         return self._file.to_arrow(

vortex-python/src/arrays/mod.rs

@@ -435,8 +435,8 @@ impl PyArray {
     /// Parameters
     /// ----------
     /// arrow_type : :class:`pyarrow.DataType`, optional
-    ///     The Arrow physical type to return. When omitted, Vortex chooses its preferred type,
-    ///     including ``string_view`` and ``binary_view`` for UTF-8 and binary arrays.
+    ///     The Arrow type to return. By default, UTF-8 data returns a ``StringViewArray`` and
+    ///     binary data returns a ``BinaryViewArray``.
     ///
     /// Returns
     /// -------
@@ -457,7 +457,7 @@ impl PyArray {
     ///   3
     /// ]
     /// ```
-    /// Export an offset-based Arrow string array instead of the default string-view array:
+    /// Export a ``StringArray`` instead of a ``StringViewArray``:
     ///
     /// ```python
     /// >>> import pyarrow