Trait polars_core::prelude::IntoSeries

pub unsafe trait IntoSeries {
    fn into_series(self) -> Series
    where
        Self: Sized;

    fn is_series() -> bool { ... }
}

Used to convert a ChunkedArray, &dyn SeriesTrait and Series into a Series.

Safety

This trait is marked unsafe as the is_series return is used to transmute to Series. This must always return false except for Series structs.

Required Methods

fn into_series(self) -> Serieswhere
    Self: Sized,

Provided Methods

fn is_series() -> bool

Examples found in repository

src/frame/mod.rs (line 237)

    pub fn new<S: IntoSeries>(columns: Vec<S>) -> PolarsResult<Self> {
        let mut first_len = None;

        let shape_err = |s: &[Series]| {
            let msg = format!(
                "Could not create a new DataFrame from Series. \
            The Series have different lengths. \
            Got {s:?}",
            );
            Err(PolarsError::ShapeMisMatch(msg.into()))
        };

        let series_cols = if S::is_series() {
            // Safety:
            // we are guarded by the type system here.
            #[allow(clippy::transmute_undefined_repr)]
            let series_cols = unsafe { std::mem::transmute::<Vec<S>, Vec<Series>>(columns) };
            let mut names = PlHashSet::with_capacity(series_cols.len());

            for s in &series_cols {
                match first_len {
                    Some(len) => {
                        if s.len() != len {
                            return shape_err(&series_cols);
                        }
                    }
                    None => first_len = Some(s.len()),
                }
                let name = s.name();

                if names.contains(name) {
                    _duplicate_err(name)?
                }

                names.insert(name);
            }
            // we drop early as the brchk thinks the &str borrows are used when calling the drop
            // of both `series_cols` and `names`
            drop(names);
            series_cols
        } else {
            let mut series_cols = Vec::with_capacity(columns.len());
            let mut names = PlHashSet::with_capacity(columns.len());

            // check for series length equality and convert into series in one pass
            for s in columns {
                let series = s.into_series();
                match first_len {
                    Some(len) => {
                        if series.len() != len {
                            return shape_err(&series_cols);
                        }
                    }
                    None => first_len = Some(series.len()),
                }
                // we have aliasing borrows so we must allocate a string
                let name = series.name().to_string();

                if names.contains(&name) {
                    _duplicate_err(&name)?
                }

                series_cols.push(series);
                names.insert(name);
            }
            drop(names);
            series_cols
        };

        Ok(DataFrame {
            columns: series_cols,
        })
    }

Implementors

impl IntoSeries for CategoricalChunked

impl IntoSeries for Series

impl IntoSeries for Arc<dyn SeriesTrait>

impl<T: PolarsDataType + 'static> IntoSeries for ChunkedArray<T>where
    SeriesWrap<ChunkedArray<T>>: SeriesTrait,