Convert str to NaiveDate datatype in rust polars

I need to convert a Series of str values to Polars Date format.

Using the documentation as inspiration: https://pola-rs.github.io/polars-book/user-guide/concepts/data-structures/#dataframe, I've written the following function:

pub fn convert_str_to_date(s: Series) -> Option<Series> {
    Some(
        s.iter()
            .map(|v| {
                let date = v.to_string().replace(",", "").replace("\"", "");
                let year = &date[0..4];
                let month = &date[4..6];
                let day = &date[6..8];
                NaiveDate::from_ymd_opt(year.parse::<i32>().unwrap(), month.parse::<u32>().unwrap(), day.parse::<u32>().unwrap()).unwrap()
            }).collect()
    )
}

To validate the function is working, I've written this test:

    #[test]
    fn test_convert_str_to_date() {
        let test_s = Series::new("", &["20230101", "20230630", "20220229"]);
        let transformed_s = convert_str_to_date(test_s).unwrap();
        let expected_s = Series::new(
            "",
            &[NaiveDate::from_ymd_opt(2023, 1, 1).unwrap(), NaiveDate::from_ymd_opt(2023, 6, 30).unwrap(), NaiveDate::from_ymd_opt(2022, 2, 29).unwrap()],            
        );
        assert_eq!(transformed_s, expected_s);
    }

I expect the test to pass. However, I receive the following error from the compiler:

error[E0277]: a value of type `polars::prelude::Series` cannot be built from an iterator over elements of type `NaiveDate`
    --> src/transform.rs:106:16
     |
106  |             }).collect()
     |                ^^^^^^^ value of type `polars::prelude::Series` cannot be built from `std::iter::Iterator<Item=NaiveDate>`
     |
     = help: the trait `FromIterator<NaiveDate>` is not implemented for `polars::prelude::Series`
     = help: the following other types implement trait `FromIterator<A>`:
               <polars::prelude::Series as FromIterator<&'a bool>>
               <polars::prelude::Series as FromIterator<&'a f32>>
               <polars::prelude::Series as FromIterator<&'a f64>>
               <polars::prelude::Series as FromIterator<&'a i32>>
               <polars::prelude::Series as FromIterator<&'a i64>>
               <polars::prelude::Series as FromIterator<&'a str>>
               <polars::prelude::Series as FromIterator<&'a u32>>
               <polars::prelude::Series as FromIterator<&'a u64>>
             and 15 others
note: the method call chain might not have had the expected associated types

polars does not have a FromIterator implementation on Series from an iterator of NaiveDates.

From<Logical<DateType, Int32Type>> is implemented on Series so you can pass the iterator to Logical::from_naive_date and then convert it to a Series:

pub fn convert_str_to_date(s: Series) -> Option<Series> {
    Some(
        Logical::from_naive_date(
            "column_name",
            s.iter().map(|v| {
                let date = v.to_string().replace(",", "").replace("\"", "");
                let year = &date[0..4];
                let month = &date[4..6];
                let day = &date[6..8];
                NaiveDate::from_ymd_opt(
                    year.parse::<i32>().unwrap(),
                    month.parse::<u32>().unwrap(),
                    day.parse::<u32>().unwrap(),
                )
                .unwrap()
            }),
        )
        .into(),
    )
}

Alternatively, you can collect the NaiveDates into a Vec, and then use Series::new to construct the Series:

pub fn convert_str_to_date2(s: Series) -> Option<Series> {
    let naive_dates: Vec<_> = s
        .iter()
        .map(|v| {
            let date = v.to_string().replace(",", "").replace("\"", "");
            let year = &date[0..4];
            let month = &date[4..6];
            let day = &date[6..8];
            NaiveDate::from_ymd_opt(
                year.parse::<i32>().unwrap(),
                month.parse::<u32>().unwrap(),
                day.parse::<u32>().unwrap(),
            )
            .unwrap()
        })
        .collect();
    Some(Series::new("column_name", &naive_dates))
}

Simpler than the accepted answer:

pub fn convert_str_to_date(s: &Series) -> Result<Series, PolarsError> {
    let mut s = s
        .utf8()?
        .replace_all(r#",|""#, "")?
        .as_date(Some("%Y%m%d"), true)?
        .into_series();
    s.rename("column_name");
    Ok(s)
}

fn main() {
    let test_s = Series::new("", &["2023,0101", "202306,30", "20220229"]);
    let transformed_s = convert_str_to_date(&test_s).unwrap();

    println!("{:?}", transformed_s);
}

shape: (3,)
Series: 'column_name' [date]
[
        2023-01-01
        2023-06-30
        null
]