fix: parquet rle boolean decoder

crates/polars-parquet/src/arrow/read/deserialize/boolean/basic.rs

@@ -144,7 +144,6 @@ impl<'a> Decoder<'a> for BooleanDecoder {
                 let iter = hybrid_rle::Decoder::new(values, 1);
                 let values = HybridDecoderBitmapIter::new(iter, page.num_values());
                 let values = HybridRleBooleanIter::new(values);
-
                 Ok(State::RleOptional(optional, values))
             },
             _ => Err(utils::not_implemented(page)),

crates/polars-parquet/src/parquet/deserialize/hybrid_rle.rs

@@ -143,14 +143,33 @@ where
 
 impl<'a, I> HybridRleBooleanIter<'a, I>
 where
-    I: Iterator<Item = Result<HybridEncoded<'a>, Error>>,
+    I: HybridRleRunsIterator<'a>,
 {
     pub fn new(iter: I) -> Self {
         Self {
             iter,
             current_run: None,
         }
     }
+
+    fn set_new_run(
+        &mut self,
+        run: Result<HybridEncoded<'a>, Error>,
+    ) -> Option<Result<bool, Error>> {
+        let run = run.map(|run| match run {
+            HybridEncoded::Bitmap(bitmap, length) => {
+                HybridBooleanState::Bitmap(BitmapIter::new(bitmap, 0, length))
+            },
+            HybridEncoded::Repeated(value, length) => HybridBooleanState::Repeated(value, length),
+        });
+        match run {
+            Ok(run) => {
+                self.current_run = Some(run);
+                self.next()
+            },
+            Err(e) => Some(Err(e)),
+        }
+    }
 }
 
 impl<'a, I> Iterator for HybridRleBooleanIter<'a, I>
@@ -163,31 +182,25 @@ where
     fn next(&mut self) -> Option<Self::Item> {
         if let Some(run) = &mut self.current_run {
             match run {
-                HybridBooleanState::Bitmap(bitmap) => bitmap.next().map(Ok),
-                HybridBooleanState::Repeated(value, remaining) => if *remaining == 0 {
-                    None
-                } else {
-                    *remaining -= 1;
-                    Some(*value)
-                }
-                .map(Ok),
-            }
-        } else if let Some(run) = self.iter.next() {
-            let run = run.map(|run| match run {
-                HybridEncoded::Bitmap(bitmap, length) => {
-                    HybridBooleanState::Bitmap(BitmapIter::new(bitmap, 0, length))
+                HybridBooleanState::Bitmap(bitmap) => match bitmap.next() {
+                    Some(val) => Some(Ok(val)),
+                    None => {
+                        let run = self.iter.next()?;
+                        self.set_new_run(run)
+                    },
                 },
-                HybridEncoded::Repeated(value, length) => {
-                    HybridBooleanState::Repeated(value, length)
+                HybridBooleanState::Repeated(value, remaining) => {
+                    if *remaining == 0 {
+                        let run = self.iter.next()?;
+                        self.set_new_run(run)
+                    } else {
+                        *remaining -= 1;
+                        Some(Ok(*value))
+                    }
                 },
-            });
-            match run {
-                Ok(run) => {
-                    self.current_run = Some(run);
-                    self.next()
-                },
-                Err(e) => Some(Err(e)),
             }
+        } else if let Some(run) = self.iter.next() {
+            self.set_new_run(run)
         } else {
             None
         }