Box::new macro like vec! in Rust

Question

I've seen a lot of usage of Box::new in Rust language.

https://doc.rust-lang.org/book/ch15-01-box.html

fn main() {
    let b = Box::new(5);
    println!("b = {}", b);
}

However, I think this is a bit redundant, especially, in the code like this:

enum List {
    Cons(i32, Box<List>),
    Nil,
}

use crate::List::{Cons, Nil};

fn main() {
    let list = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil))))));
}

Now, I want to write in a concise way using Macro as we've seen as vec!

https://doc.rust-lang.org/book/ch19-06-macros.html?highlight=vec#declarative-macros-with-macro_rules-for-general-metaprogramming

let v: Vec<u32> = vec![1, 2, 3];

so that with box! macro, we could write:

fn main() {
    let b = box!(5);
    println!("b = {}", b);
}

or

fn main() {
    let list = Cons(1, box!(Cons(2, box!(Cons(3, box!(Nil))))));
}

My question is

1. Is there any reason that box! macro is not popular even it's used frequently in Rust?

2. What is the proper way to define the macro? Is there any points of attention?

Answer 1

This is a bit subjective, but vectors are used far more often, I believe. And the vec! macro saves you a lot more code compared to the box! macro you are referring to.

As for the macro implementation, you can write something like this:

macro_rules! bx {
    ($e:expr) => {
        Box::new($e)
    };
}

Here is an example usage:

let b = Box::new(3);
let m = bx!(7);

Note that I named it bx! and not box!, as the latter is a reserved word in Rust.

Answer 2

however, for some unknown reason Rust guys prefer to use macro for vec! or println!

I suggest asking this the other way around: why couldn't vec! and println! be functions? And the answer is, both are variadic (can take variable number of arguments) and there are no variadic functions in Rust. It's much worse for println!, whose arguments can have different types too; and constraints on those types depend on the first argument! Try writing down a type for println as a function, and you'll find it would be much less usable and less efficient.

The problem vec! solves is smaller. But as Chayim Friedman's comment says, until quite recently you couldn't even have had

Vec::from([1,2,3])

if there were no vec! macro. I think the best you could have done was

Vec::from(&[1,2,3])

As Chayim points out, this is strictly worse than vec!.

Of course, Box::new doesn't have this problem at all. So it's a function just because it didn't have to be a macro.

but as I post the Cons list expample, it's obvious the latter syntax is redundant and does have an issue for readability

In that case box! is no less redundant; instead a way to get rid of redundancy is

fn cons(head: i32, tail: List) -> List {
    List::Cons(head, Box::new(tail))
}

and then

let list = cons(1, cons(2, cons(3, Nil)));

Or even a list! macro and

let list = list![1,2,3];

Answer 3

Thanks to @at54321, I googled and found

https://doc.rust-lang.org/beta/unstable-book/language-features/box-syntax.html

#![feature(box_syntax)]

fn main() {
    let b = box 5;
}

So, already there.