Method try_unary

arrow-array/src/array/primitive_array.rs:969–993

Applies a unary fallible function to all valid values in a primitive array, producing a new array of potentially different type. Applies `op` to only rows that are valid, which is often significantly slower than [`Self::unary`], which should be preferred if `op` is fallible. Note: LLVM is currently unable to effectively vectorize fallible operations

(&self, op: F)

    ///
    /// Note: LLVM is currently unable to effectively vectorize fallible operations
    pub fn try_unary<F, O, E>(&self, op: F) -> Result<PrimitiveArray<O>, E>
    where
        O: ArrowPrimitiveType,
        F: Fn(T::Native) -> Result<O::Native, E>,
    {
        let len = self.len();

        let nulls = self.nulls().cloned();
        let mut buffer = BufferBuilder::<O::Native>::new(len);
        buffer.append_n_zeroed(len);
        let slice = buffer.as_slice_mut();

        let f = |idx| {
            unsafe { *slice.get_unchecked_mut(idx) = op(self.value_unchecked(idx))? };
            Ok::<_, E>(())
        };

        match &nulls {
            Some(nulls) => nulls.try_for_each_valid_idx(f)?,
            None => (0..len).try_for_each(f)?,
        }

        let values = buffer.finish().into();
        Ok(PrimitiveArray::new(values, nulls))
    }

    /// Applies a unary fallible function to all valid values in a mutable
    /// primitive array.