879-iterator-trait — Iterator Trait

struct Range { current: i32, end_: i32 }

impl Iterator for Range {
    type Item = i32;
    fn next(&mut self) -> Option<i32> {
        if self.current >= self.end_ { None }
        else { let v = self.current; self.current += 1; Some(v) }
    }
}

let range start stop =
  let rec aux n () =
    if n >= stop then Seq.Nil
    else Seq.Cons (n, aux (n + 1))
  in
  aux start

//! Example 879: Iterator Trait
//!
//! OCaml's `Seq` and hand-rolled `{ next : unit -> 'a option }` records map
//! directly onto Rust's [`Iterator`] trait. Implementing the trait for a
//! custom struct yields all of the standard adaptors (`map`, `filter`,
//! `take`, `sum`, ...) for free, so the OCaml helpers `iter_map`,
//! `iter_filter`, and `take` collapse into method calls.

/// A bounded half-open integer range `[start, stop)`.
///
/// Mirrors the OCaml `range` / `range_iter` functions.
pub struct Range {
    current: i64,
    stop: i64,
}

impl Range {
    /// Creates a range yielding values from `start` (inclusive) to `stop`
    /// (exclusive).
    pub fn new(start: i64, stop: i64) -> Self {
        Self {
            current: start,
            stop,
        }
    }
}

impl Iterator for Range {
    type Item = i64;

    fn next(&mut self) -> Option<Self::Item> {
        if self.current >= self.stop {
            None
        } else {
            let v = self.current;
            self.current += 1;
            Some(v)
        }
    }
}

/// An unbounded counter starting at `n`, incrementing by one each call.
///
/// Mirrors OCaml's `counter_from`. Pair with [`Iterator::take`] to bound it.
pub struct Counter {
    current: i64,
}

impl Counter {
    /// Creates a counter whose first emitted value is `n`.
    pub fn from(n: i64) -> Self {
        Self { current: n }
    }
}

impl Iterator for Counter {
    type Item = i64;

    fn next(&mut self) -> Option<Self::Item> {
        let v = self.current;
        self.current += 1;
        Some(v)
    }
}

/// Collects any iterator into a `Vec`.
///
/// Alias for [`Iterator::collect`] that matches the shape of OCaml's
/// `seq_to_list` / `iter_to_list`.
pub fn to_vec<I: Iterator>(it: I) -> Vec<I::Item> {
    it.collect()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn range_yields_half_open_interval() {
        let v: Vec<i64> = Range::new(1, 6).collect();
        assert_eq!(v, vec![1, 2, 3, 4, 5]);
    }

    #[test]
    fn range_empty_when_start_ge_stop() {
        assert_eq!(Range::new(5, 5).count(), 0);
        assert_eq!(Range::new(6, 5).count(), 0);
    }

    #[test]
    fn map_and_filter_compose_like_ocaml_helpers() {
        let result: Vec<i64> = Range::new(1, 11)
            .map(|x| x * 2)
            .filter(|x| *x <= 10)
            .collect();
        assert_eq!(result, vec![2, 4, 6, 8, 10]);
    }

    #[test]
    fn counter_with_take_is_bounded() {
        let v: Vec<i64> = Counter::from(0).take(5).collect();
        assert_eq!(v, vec![0, 1, 2, 3, 4]);
    }

    #[test]
    fn counter_starts_at_given_offset() {
        let v: Vec<i64> = Counter::from(100).take(3).collect();
        assert_eq!(v, vec![100, 101, 102]);
    }

    #[test]
    fn to_vec_matches_collect() {
        assert_eq!(to_vec(Range::new(0, 4)), vec![0, 1, 2, 3]);
    }

    #[test]
    fn fold_builds_list_in_forward_order() {
        // OCaml's `seq_to_list` folds left to build a reversed list and then
        // reverses it. Rust's `fold` can push directly for forward order.
        let v = Range::new(1, 4).fold(Vec::new(), |mut acc, x| {
            acc.push(x);
            acc
        });
        assert_eq!(v, vec![1, 2, 3]);
    }

    #[test]
    fn sum_and_product_via_iterator_trait() {
        let sum: i64 = Range::new(1, 5).sum();
        let product: i64 = Range::new(1, 5).product();
        assert_eq!(sum, 10);
        assert_eq!(product, 24);
    }
}

(* Example 085: Iterator Trait *)
(* OCaml Seq → Rust Iterator *)

(* Approach 1: Using Seq (lazy sequences) *)
let range start stop =
  let rec aux n () =
    if n >= stop then Seq.Nil
    else Seq.Cons (n, aux (n + 1))
  in
  aux start

let seq_to_list seq =
  Seq.fold_left (fun acc x -> x :: acc) [] seq |> List.rev

(* Approach 2: Custom iterator via closure *)
type 'a iterator = {
  next : unit -> 'a option;
}

let range_iter start stop =
  let current = ref start in
  { next = fun () ->
    if !current >= stop then None
    else begin
      let v = !current in
      incr current;
      Some v
    end
  }

let iter_to_list it =
  let rec aux acc =
    match it.next () with
    | None -> List.rev acc
    | Some v -> aux (v :: acc)
  in
  aux []

let iter_map f it =
  { next = fun () ->
    match it.next () with
    | None -> None
    | Some v -> Some (f v)
  }

let iter_filter pred it =
  let rec find () =
    match it.next () with
    | None -> None
    | Some v -> if pred v then Some v else find ()
  in
  { next = find }

(* Approach 3: Using List as iterator source *)
let counter_from n =
  let c = ref n in
  { next = fun () ->
    let v = !c in
    c := v + 1;
    Some v
  }

let take n it =
  let count = ref 0 in
  { next = fun () ->
    if !count >= n then None
    else begin
      incr count;
      it.next ()
    end
  }

(* Tests *)
let () =
  let s = range 1 6 in
  assert (seq_to_list s = [1; 2; 3; 4; 5]);

  let it = range_iter 1 6 in
  assert (iter_to_list it = [1; 2; 3; 4; 5]);

  let it2 = range_iter 1 11 in
  let doubled = iter_map (fun x -> x * 2) it2 in
  let evens = iter_filter (fun x -> x <= 10) doubled in
  assert (iter_to_list evens = [2; 4; 6; 8; 10]);

  let inf = counter_from 0 in
  let first5 = take 5 inf in
  assert (iter_to_list first5 = [0; 1; 2; 3; 4]);

  Printf.printf "✓ All tests passed\n"