Trait polars_core::chunked_array::ops::ChunkSet

pub trait ChunkSet<'a, A, B> {
    fn set_at_idx<I: IntoIterator<Item = usize>>(
        &'a self, 
        idx: I, 
        opt_value: Option<A>
    ) -> Result<Self>
    where
        Self: Sized;
    fn set_at_idx_with<I: IntoIterator<Item = usize>, F>(
        &'a self, 
        idx: I, 
        f: F
    ) -> Result<Self>
    where
        Self: Sized,
        F: Fn(Option<A>) -> Option<B>;
    fn set(
        &'a self, 
        mask: &BooleanChunked, 
        opt_value: Option<A>
    ) -> Result<Self>
    where
        Self: Sized;
    fn set_with<F>(&'a self, mask: &BooleanChunked, f: F) -> Result<Self>
    where
        Self: Sized,
        F: Fn(Option<A>) -> Option<B>;
}

Create a ChunkedArray with new values by index or by boolean mask. Note that these operations clone data. This is however the only way we can modify at mask or index level as the underlying Arrow arrays are immutable.

Required methods

fn set_at_idx<I: IntoIterator<Item = usize>>(
    &'a self,
    idx: I,
    opt_value: Option<A>
) -> Result<Self> where
    Self: Sized, 

Set the values at indexes idx to some optional value Option<T>.

Example

let ca = Int32Chunked::new_from_slice("a", &[1, 2, 3]);
let new = ca.set_at_idx(vec![0, 1], Some(10)).unwrap();

assert_eq!(Vec::from(&new), &[Some(10), Some(10), Some(3)]);

fn set_at_idx_with<I: IntoIterator<Item = usize>, F>(
    &'a self,
    idx: I,
    f: F
) -> Result<Self> where
    Self: Sized,
    F: Fn(Option<A>) -> Option<B>, 

Set the values at indexes idx by applying a closure to these values.

Example

let ca = Int32Chunked::new_from_slice("a", &[1, 2, 3]);
let new = ca.set_at_idx_with(vec![0, 1], |opt_v| opt_v.map(|v| v - 5)).unwrap();

assert_eq!(Vec::from(&new), &[Some(-4), Some(-3), Some(3)]);

fn set(&'a self, mask: &BooleanChunked, opt_value: Option<A>) -> Result<Self> where
    Self: Sized, 

Set the values where the mask evaluates to true to some optional value Option<T>.

Example

let ca = Int32Chunked::new_from_slice("a", &[1, 2, 3]);
let mask = BooleanChunked::new_from_slice("mask", &[false, true, false]);
let new = ca.set(&mask, Some(5)).unwrap();
assert_eq!(Vec::from(&new), &[Some(1), Some(5), Some(3)]);

fn set_with<F>(&'a self, mask: &BooleanChunked, f: F) -> Result<Self> where
    Self: Sized,
    F: Fn(Option<A>) -> Option<B>, 

Set the values where the mask evaluates to true by applying a closure to these values.

Example

let ca = Int32Chunked::new_from_slice("a", &[1, 2, 3]);
let mask = BooleanChunked::new_from_slice("mask", &[false, true, false]);
let new = ca.set_with(&mask, |opt_v| opt_v.map(
    |v| v * 2
)).unwrap();
assert_eq!(Vec::from(&new), &[Some(1), Some(4), Some(3)]);

Implementors

impl<'a> ChunkSet<'a, &'a str, String> for Utf8Chunked

fn set_at_idx<I: IntoIterator<Item = usize>>(
    &'a self,
    idx: I,
    opt_value: Option<&'a str>
) -> Result<Self> where
    Self: Sized, 

fn set_at_idx_with<I: IntoIterator<Item = usize>, F>(
    &'a self,
    idx: I,
    f: F
) -> Result<Self> where
    Self: Sized,
    F: Fn(Option<&'a str>) -> Option<String>, 

fn set(&'a self, mask: &BooleanChunked, value: Option<&'a str>) -> Result<Self> where
    Self: Sized, 

fn set_with<F>(&'a self, mask: &BooleanChunked, f: F) -> Result<Self> where
    Self: Sized,
    F: Fn(Option<&'a str>) -> Option<String>, 

impl<'a> ChunkSet<'a, bool, bool> for BooleanChunked

fn set_at_idx<I: IntoIterator<Item = usize>>(
    &'a self,
    idx: I,
    value: Option<bool>
) -> Result<Self>

fn set_at_idx_with<I: IntoIterator<Item = usize>, F>(
    &'a self,
    idx: I,
    f: F
) -> Result<Self> where
    F: Fn(Option<bool>) -> Option<bool>, 

fn set(&'a self, mask: &BooleanChunked, value: Option<bool>) -> Result<Self>

fn set_with<F>(&'a self, mask: &BooleanChunked, f: F) -> Result<Self> where
    F: Fn(Option<bool>) -> Option<bool>, 

impl<'a, T> ChunkSet<'a, <T as ArrowPrimitiveType>::Native, <T as ArrowPrimitiveType>::Native> for ChunkedArray<T> where
    T: PolarsNumericType, 

fn set_at_idx<I: IntoIterator<Item = usize>>(
    &'a self,
    idx: I,
    value: Option<T::Native>
) -> Result<Self>

fn set_at_idx_with<I: IntoIterator<Item = usize>, F>(
    &'a self,
    idx: I,
    f: F
) -> Result<Self> where
    F: Fn(Option<T::Native>) -> Option<T::Native>, 

fn set(
    &'a self,
    mask: &BooleanChunked,
    value: Option<T::Native>
) -> Result<Self>

fn set_with<F>(&'a self, mask: &BooleanChunked, f: F) -> Result<Self> where
    F: Fn(Option<T::Native>) -> Option<T::Native>,