crate | CrateDB is a distributed SQL database for storing and analyzing massive amounts of data in real-time

#[main] is an old, unstable attribute that was mostly removed from the language in 1.53.0. However, the removal missed one line, with the result you see: the attribute had no effect, but it could be used on stable Rust without an error, and conflicted with imported attributes named main. This was a bug, not intended behaviour. It has been fixed as of nightly-2022-02-10 and 1.59.0-beta.8. Your example with use tokio::main; and #[main] can now run without error.

Before it was removed, the unstable #[main] was used to specify the entry point of a program. Alex Crichton described the behaviour of it and related attributes in a 2016 comment on GitHub:

Ah yes, we've got three entry points. I.. think this is how they work:

• First, #[start], the receiver of int argc and char **argv. This is literally the symbol main (or what is called by that symbol generated in the compiler).
• Next, there's #[lang = "start"]. If no #[start] exists in the crate graph then the compiler generates a main function that calls this. This functions receives argc/argv along with a third argument that is a function pointer to the #[main] function (defined below). Importantly, #[lang = "start"] can be located in a library. For example it's located in the standard library (libstd).
• Finally, #[main], the main function for an executable. This is passed no arguments and is called by #[lang = "start"] (if it decides to). The standard library uses this to initialize itself and then call the Rust program. This, if not specified, defaults to fn main at the top.

So to answer your question, this isn't the same as #[start]. To answer your other (possibly not yet asked) question, yes we have too many entry points.

No, you can't.

By definition of the orphan rules:

Given impl Trait for T0, an impl is valid only if at least one of the following is true:

• Trait is a local trait
• All of
  • At least one of the types T0..=Tn must be a local type. Let Ti be the first such type.
  • No uncovered type parameters P1..=Pn may appear in T0..Ti (excluding Ti)

Only the appearance of uncovered type parameters is restricted. Note that for the purposes of coherence, fundamental types are special. The T in Box is not considered covered, and Box is considered local.

Local trait

A trait which was defined in the current crate. A trait definition is local or not independent of applied type arguments. Given trait Foo, Foo is always local, regardless of the types substituted for T and U.

Local type

A struct, enum, or union which was defined in the current crate. This is not affected by applied type arguments. struct Foo is considered local, but Vec is not. LocalType is local. Type aliases do not affect locality.

As neither Index nor Range nor Vec are local, and Range is not a fundamental type, you cannot impl Index<...>> for Vec, no matter what you put in the place of the ....

The reason for these rules is that nothing prevents Range or Vec from implementing impl Index> for Vec. Such impl does not exist, and probably never will, but the rules are the same among all types, and in the general case this definitely can happen.

You cannot overload the range operator either - it always creates a Range (or RangeInclusive, RangeFull, etc.).

The only solution I can think about is to create a newtype wrapper for Vec, as suggested in the comments.

If you want your vector to return a wrapped slice, you can use a bit of unsafe code:

There is no main module, even though you have a main.rs file. The stuff you put in the main.rs file are considered to be at the root of the crate.

So you have two ways to call the function:

You are using rocket 0.5.0-rc.1 and rocket_contrib 0.4.10. While Json from rocket_contrib does implement Responder, it implements the Responder trait of Rocket v4, not that of Rocket v5.

In Rocket v5, Json is not part of rocket_contib anymore, but included in the rocket crate (note that you need to enable the json feature on the rocket crate):

Try adding:

WebAssembly got the ability to return multiple values just recently. The compiler used doesn't seem to support this yet or doesn't use it for compatibility reasons, i.e. for runtimes that don't know this feature yet.

Therefore, the compiler rewrites the code as follows:

This crate does not seem to account for field reordering. It appears the compiler reordered the struct to have upper first:

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

1. [$($x),+] expands to an array of input elements: [1, 2, 3]
2. 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)
3. <[_]>::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:

Is it beneficial to build multiple values from the same builder?

• If yes, use &mut self
• If no, use self

Consider std::thread::Builder which is a builder for std::thread::Thread. It uses Option fields internally to configure how to build the thread: