Trait ChunkApply

pub trait ChunkApply<'a, T> {
    type FuncRet;

    // Required methods
    fn apply_values<F>(&'a self, f: F) -> Self
       where F: Fn(T) -> Self::FuncRet + Copy;
    fn apply<F>(&'a self, f: F) -> Self
       where F: Fn(Option<T>) -> Option<Self::FuncRet> + Copy;
    fn apply_to_slice<F, S>(&'a self, f: F, slice: &mut [S])
       where F: Fn(Option<T>, &S) -> S;
}

Fastest way to do elementwise operations on a ChunkedArray<T> when the operation is cheaper than branching due to null checking.

Required Associated Types

type FuncRet

Required Methods

fn apply_values<F>(&'a self, f: F) -> Self

where F: Fn(T) -> Self::FuncRet + Copy,

Apply a closure elementwise. This is fastest when the null check branching is more expensive than the closure application. Often it is.

Null values remain null.

Example

use polars_core::prelude::*;
fn double(ca: &UInt32Chunked) -> UInt32Chunked {
    ca.apply_values(|v| v * 2)
}

fn apply<F>(&'a self, f: F) -> Self

where F: Fn(Option<T>) -> Option<Self::FuncRet> + Copy,

Apply a closure elementwise including null values.

fn apply_to_slice<F, S>(&'a self, f: F, slice: &mut [S])

where F: Fn(Option<T>, &S) -> S,

Apply a closure elementwise and write results to a mutable slice.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'a> ChunkApply<'a, &'a str> for StringChunked

type FuncRet = Cow<'a, str>

impl<'a> ChunkApply<'a, &'a [u8]> for BinaryChunked

type FuncRet = Cow<'a, [u8]>

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

type FuncRet = bool

impl<'a> ChunkApply<'a, Series> for ListChunked

type FuncRet = Series

impl<'a, T> ChunkApply<'a, <T as PolarsNumericType>::Native> for ChunkedArray<T>

where T: PolarsNumericType,

type FuncRet = <T as PolarsNumericType>::Native

impl<'a, T> ChunkApply<'a, &'a T> for ObjectChunked<T>

where T: PolarsObject,

Available on crate feature object only.

type FuncRet = T