What is the difference between Box and impl Trait? When would you choose one over the other?

The ‘Box‘ and ‘impl Trait‘ are two different language constructs in Rust that are commonly used in different scenarios.

‘Box‘ is a smart pointer in Rust that is used to store data on the heap rather than the stack. Using ‘Box‘ allows you to allocate memory on the heap, which can be useful in situations when you don’t know the size of the data at compile time or when you want to be able to share ownership of the data across multiple parts of your program.

Here’s an example of using ‘Box‘ to store a vector on the heap:

    fn main() {
        let v = vec![1, 2, 3];
        let boxed_v = Box::new(v);
        
        println!("boxed_v = {:?}", boxed_v);
    }

On the other hand, ‘impl Trait‘ is a feature in Rust that allows you to return a value whose concrete type is unknown at compile time. It is similar to returning a trait object, but it is more efficient because it doesn’t require dynamic dispatch.

Here’s an example of using ‘impl Trait‘ to return an iterator:

    fn get_numbers() -> impl Iterator<Item = i32> {
        (0..10).into_iter()
    }
    
    fn main() {
        let numbers = get_numbers();
        
        for n in numbers {
            println!("{}", n);
        }
    }

So, when would you choose ‘Box‘ over ‘impl Trait‘? Use ‘Box‘ when you need to store data on the heap, especially when the size of that data is not known at compile time, and use ‘impl Trait‘ when you need to return a value whose concrete type is unknown, but still want the efficiency of static dispatch.