265 Intermediate

265: Conditional Skipping with skip_while()

Functional Programming

Tutorial

The Problem

Data streams often begin with a preamble, header, or leading values that should be ignored before processing begins. Log files start with timestamps; CSV files may have metadata rows; sorted lists may have leading zeros. The skip_while() adapter solves this by discarding elements from the front of an iterator until the predicate first returns false, then yielding all remaining elements unconditionally — including any that would again match the original predicate.

🎯 Learning Outcomes

• Understand that skip_while(pred) discards elements until predicate first fails, then yields everything after

• Distinguish skip_while() from filter(): later matching elements are still included

• Use skip_while() to skip headers, leading whitespace, or sentinel values

• Combine skip_while() with take_while() to extract a middle segment of a sequence

Code Example

#![allow(clippy::all)]
//! 265. Conditional skipping with skip_while()
//!
//! `skip_while(pred)` discards elements until predicate first returns false, then yields all remaining.

#[cfg(test)]
mod tests {
    #[test]
    fn test_skip_while_basic() {
        let result: Vec<i32> = [1, 2, 3, 4, 5]
            .iter()
            .copied()
            .skip_while(|&x| x < 3)
            .collect();
        assert_eq!(result, vec![3, 4, 5]);
    }

    #[test]
    fn test_skip_while_includes_later_matches() {
        let result: Vec<i32> = [0i32, 0, 1, 0]
            .iter()
            .copied()
            .skip_while(|&x| x == 0)
            .collect();
        assert_eq!(result, vec![1, 0]);
    }

    #[test]
    fn test_skip_while_all() {
        let result: Vec<i32> = [1, 2, 3].iter().copied().skip_while(|&x| x < 10).collect();
        assert!(result.is_empty());
    }

    #[test]
    fn test_skip_while_none() {
        let result: Vec<i32> = [1, 2, 3].iter().copied().skip_while(|&x| x > 10).collect();
        assert_eq!(result, vec![1, 2, 3]);
    }
}

(* 265. Conditional skipping with skip_while() - OCaml *)

let rec skip_while pred = function
  | [] -> []
  | x :: xs as lst ->
    if pred x then skip_while pred xs else lst

let () =
  let nums = [1; 2; 3; 4; 5; 4; 3; 2; 1] in
  let from_4 = skip_while (fun x -> x < 4) nums in
  Printf.printf "Skip <4: %s\n"
    (String.concat ", " (List.map string_of_int from_4));

  let tokens = [' '; ' '; 'h'; 'e'; 'l'; 'l'; 'o'] in
  let stripped = skip_while (fun c -> c = ' ') tokens in
  Printf.printf "Stripped: '%s'\n"
    (String.concat "" (List.map (String.make 1) stripped));

  let with_zeros = [0; 0; 0; 1; 2; 3; 0; 4] in
  let no_leading = skip_while (fun x -> x = 0) with_zeros in
  Printf.printf "No leading zeros: %s\n"
    (String.concat ", " (List.map string_of_int no_leading))

Key Differences

"Then all": Both languages' skip_while yield everything after the first false, including later matches — this is by design for ordered prefix stripping.

Standard library: Built into Rust's Iterator; OCaml's standard List module lacks it (third-party Base provides List.drop_while).

**Complementary to take_while**: Together they split a sequence: take_while(p) takes the prefix, skip_while(p) takes the suffix.

Stateful termination: Like take_while, it is stateful and not equivalent to a filter — order matters.

OCaml Approach

OCaml's List.drop_while (in Base/Core) or a recursive equivalent serves this role:

let rec skip_while pred = function
  | [] -> []
  | x :: xs -> if pred x then skip_while pred xs else x :: xs

Seq.drop_while provides the lazy equivalent for sequences, identical semantically to Rust's skip_while.

Full Source

#![allow(clippy::all)]
//! 265. Conditional skipping with skip_while()
//!
//! `skip_while(pred)` discards elements until predicate first returns false, then yields all remaining.

#[cfg(test)]
mod tests {
    #[test]
    fn test_skip_while_basic() {
        let result: Vec<i32> = [1, 2, 3, 4, 5]
            .iter()
            .copied()
            .skip_while(|&x| x < 3)
            .collect();
        assert_eq!(result, vec![3, 4, 5]);
    }

    #[test]
    fn test_skip_while_includes_later_matches() {
        let result: Vec<i32> = [0i32, 0, 1, 0]
            .iter()
            .copied()
            .skip_while(|&x| x == 0)
            .collect();
        assert_eq!(result, vec![1, 0]);
    }

    #[test]
    fn test_skip_while_all() {
        let result: Vec<i32> = [1, 2, 3].iter().copied().skip_while(|&x| x < 10).collect();
        assert!(result.is_empty());
    }

    #[test]
    fn test_skip_while_none() {
        let result: Vec<i32> = [1, 2, 3].iter().copied().skip_while(|&x| x > 10).collect();
        assert_eq!(result, vec![1, 2, 3]);
    }
}

(* 265. Conditional skipping with skip_while() - OCaml *)

let rec skip_while pred = function
  | [] -> []
  | x :: xs as lst ->
    if pred x then skip_while pred xs else lst

let () =
  let nums = [1; 2; 3; 4; 5; 4; 3; 2; 1] in
  let from_4 = skip_while (fun x -> x < 4) nums in
  Printf.printf "Skip <4: %s\n"
    (String.concat ", " (List.map string_of_int from_4));

  let tokens = [' '; ' '; 'h'; 'e'; 'l'; 'l'; 'o'] in
  let stripped = skip_while (fun c -> c = ' ') tokens in
  Printf.printf "Stripped: '%s'\n"
    (String.concat "" (List.map (String.make 1) stripped));

  let with_zeros = [0; 0; 0; 1; 2; 3; 0; 4] in
  let no_leading = skip_while (fun x -> x = 0) with_zeros in
  Printf.printf "No leading zeros: %s\n"
    (String.concat ", " (List.map string_of_int no_leading))

✓ Tests Rust test suite

#[cfg(test)]
mod tests {
    #[test]
    fn test_skip_while_basic() {
        let result: Vec<i32> = [1, 2, 3, 4, 5]
            .iter()
            .copied()
            .skip_while(|&x| x < 3)
            .collect();
        assert_eq!(result, vec![3, 4, 5]);
    }

    #[test]
    fn test_skip_while_includes_later_matches() {
        let result: Vec<i32> = [0i32, 0, 1, 0]
            .iter()
            .copied()
            .skip_while(|&x| x == 0)
            .collect();
        assert_eq!(result, vec![1, 0]);
    }

    #[test]
    fn test_skip_while_all() {
        let result: Vec<i32> = [1, 2, 3].iter().copied().skip_while(|&x| x < 10).collect();
        assert!(result.is_empty());
    }

    #[test]
    fn test_skip_while_none() {
        let result: Vec<i32> = [1, 2, 3].iter().copied().skip_while(|&x| x > 10).collect();
        assert_eq!(result, vec![1, 2, 3]);
    }
}

Exercises

Strip leading whitespace from a character iterator using skip_while(|c| c.is_whitespace()).

Implement a function that extracts the body of a log file by skipping all lines that start with # (comment lines at the top).

Combine skip_while() and take_while() to extract only the elements between two sentinel values in a sequence.

Open Source Repos

functional-rust

View the source for this example on GitHub — OCaml and Rust side by side in the repo.

Rust