What is "<[_]>" in Rust?

Question

In the vec! macro implementation there is this rule:

($($x:expr),+ $(,)?) => (
    $crate::__rust_force_expr!(<[_]>::into_vec(box [$($x),+]))
);

What exactly is that <[_]> in it?

Whew, Rust is generally pretty readable and intuitive, but `<[_]>::` looks like something straight out of an esolang. — Silvio Mayolo, Dec 19 '21 at 18:45

kmdreko · Accepted Answer · 2021-12-24T07:35:14.477

30

Breaking down the specific parts of the syntax:

<T>::f is the syntax to explicitly call f associated with a type T. Usually just T::f is enough, but pedantically, :: requires a path, which is why it is used here since [_] is not. The <...> allows any type to be used as a path. See Why do I need angle brackets in <$a> when implementing macro based on type?
[T] is the type denoting a slice of type T.
_ used as a type is a placeholder or "wildcard". It is not a type itself, but serves to indicate that the type should be inferred. See What does it mean to instantiate a Rust generic with an underscore?

edited Dec 24 '21 at 07:35

answered Dec 18 '21 at 21:34

kmdreko

42,554
6
57
106

1

For reference: [Qualified paths](https://doc.rust-lang.org/reference/paths.html#qualified-paths). – IInspectable Dec 21 '21 at 18:55
This answer is a perfect explanation for `<[()]>` in the Rust Macro book. https://danielkeep.github.io/tlborm/book/blk-counting.html#slice-length – Peter Mar 17 '22 at 04:26

score 15 · Answer 2 · answered Dec 18 '21 at 21:03

Let's go step by step to see how <[_]>::into_vec(box [$($x),+]) produces a Vec:

[$($x),+] expands to an array of input elements: [1, 2, 3]
box ... puts that into a Box. box expressions are nightly-only syntax sugar for Box::new: box 5 is syntax sugar for Box::new(5) (actually it's the other way around: internally Box::new uses box, which is implemented in the compiler)
<[_]>::into_vec(...) calls the to_vec method on a slice containing elements that have an inferred type ([_]). Wrapping the [_] in angled brackets is needed for syntactic reasons to call an method on a slice type. And into_vec is a function that takes a boxed slice and produces a Vec:
```
pub fn into_vec<A: Allocator>(self: Box<Self, A>) -> Vec<T, A> {
    // ...
}
```

This could be done in many simpler ways, but this code was fine-tuned to improve the performance of vec!. For instance, since the size of the Vec can be known in an advance, into_vec doesn't cause the Vec to be reallocated during its construction.

What is "<[_]>" in Rust?

2 Answers2