Method try_unary_mut

arrow-array/src/array/primitive_array.rs:1012–1035

Applies a unary fallible function to all valid values in a mutable primitive array. # Null Handling See [`Self::try_unary`] for more information on null handling. # Buffer Reuse See [`Self::unary_mut`] for more information on buffer reuse. This returns an `Err` when the input array is shared buffer with other array. In the case, returned `Err` wraps input array. If the function encounters an

(
        self,
        op: F,
    )

    ///
    /// Note: LLVM is currently unable to effectively vectorize fallible operations
    pub fn try_unary_mut<F, E>(
        self,
        op: F,
    ) -> Result<Result<PrimitiveArray<T>, E>, PrimitiveArray<T>>
    where
        F: Fn(T::Native) -> Result<T::Native, E>,
    {
        let len = self.len();
        let null_count = self.null_count();
        let mut builder = self.into_builder()?;

        let (slice, null_buffer) = builder.slices_mut();

        let r = try_for_each_valid_idx(len, 0, null_count, null_buffer.as_deref(), |idx| {
            unsafe { *slice.get_unchecked_mut(idx) = op(*slice.get_unchecked(idx))? };
            Ok::<_, E>(())
        });

        if let Err(err) = r {
            return Ok(Err(err));
        }

        Ok(Ok(builder.finish()))
    }

    /// Applies a unary and nullable function to all valid values in a primitive array
    ///