Conditionally iterate over one of several possible iterators

by

The most straightforward solution is to use a trait object:

use std::iter;

fn main() {
    let mut a;
    let mut b;

    let x: Option<i64> = None;

    // Repeat x 5 times if present, otherwise count from 1 to 5
    let iter: &mut dyn Iterator<Item = i64> = match x {
        None => {
            a = 1..5;
            &mut a
        }
        Some(x) => {
            b = iter::repeat(x).take(5);
            &mut b
        }
    };

    for i in iter {
        println!("{}", i);
    }
}

The main downside for this solution is that you have to allocate stack space for each concrete type you have. This also means variables for each type. A good thing is that only the used type needs to be initialized.

The same idea but requiring heap allocation is to use boxed trait objects:

use std::iter;

fn main() {
    let x: Option<i64> = None;

    // Repeat x 5 times if present, otherwise count from 1 to 5
    let iter: Box<dyn Iterator<Item = i64>> = match x {
        None => Box::new(1..5),
        Some(x) => Box::new(iter::repeat(x).take(5)),
    };

    for i in iter {
        println!("{}", i);
    }
}

This is mostly useful when you want to return the iterator from a function. The stack space taken is a single pointer, and only the needed heap space will be allocated.

You can also use an enum for each possible concrete iterator.

More Related Contents:

  1. What are non-lexical lifetimes?
  2. What are Rust’s exact auto-dereferencing rules?
  3. Why is a trait not implemented for a type that clearly has it implemented?
  4. Why can impl trait not be used to return multiple / conditional types?
  5. Passing mutable self reference to method of owned object
  6. Rust proper error handling (auto convert from one error type to another with question mark)
  7. Why is a borrow still held in the else block of an if let?
  8. How to create a static string at compile time
  9. How to call a method when a trait and struct use the same method name?
  10. How to convert ‘struct’ to ‘&[u8]’?
  11. How does the mechanism behind the creation of boxed traits work?
  12. Why does passing a closure to function which accepts a function pointer not work?
  13. How do you set, clear and toggle a single bit in Rust?
  14. Is it possible to declare the type of the variable in Rust for loops?
  15. Lifetime of variables passed to a new thread
  16. How can I co-sort two Vecs based on the values in one of the Vecs?
  17. How can I distinguish between a deserialized field that is missing and one that is null?
  18. Cannot create a generic function that uses a literal zero
  19. How can I store a pattern in a variable in Rust?
  20. How to avoid temporary allocations when using a complex key for a HashMap?
  21. Why does compilation not fail when a member of a moved value is assigned to?
  22. Why does a mutable borrow of a closure through DerefMut not work?
  23. How to switch between Rust toolchains?
  24. What does “missing lifetime specifier” mean when storing a &str in a structure?
  25. Why can Serde not derive Deserialize for a struct containing only a &Path?
  26. Is there a list of all cfg features?
  27. Comparing every element in a vector with the next one
  28. How to concatenate static strings in Rust
  29. How can I conditionally provide a default reference without performing unnecessary computation when it isn’t used?
  30. How can I build multiple binaries with Cargo?

Leave a Comment