box x as an expression has the type Box<T> where T is the type of x. It places x in a new heap allocation and returns a unique, owning pointer to that allocation. I think the only difference from Box::new(x) is that x is not placed on the stack first (see some of the comments on that issue).
That can be answered by looking at that 3-line function alone. Its type must be Box<T> because it is returned by the function immediately. For the same reason, it must have the same semantics of Box::new() – there's nothing else in that function.
I just checked the latest stable version of Rust standard library, Box::new() still uses box x. Seems that the box keyword is still in use? Or, maybe, normal users cannot use box any longer in their own code?
I think what the box keyword does here is almost identical to what malloc() function does.
The final type return by Box::new() is exactly Box<T>, this is doubtless. However, I am not sure if implicit type conversion happened here. By an example of C language:
char *new_str() {
return malloc(8);
}
malloc() return void * but it is then converted to char * implicitly.
Rust has very very few type conversions that happen implicitly. The only that come to mind are stuff like *mut T to *const T and &'long T to &'short T and &T to &dyn SomeTrait.
TL;DR: Box was originally a part of language and had special syntax — and today it's a bit special, still, but that only happened because there was no time to properly rip it out before Rust 1.0 release.
IOW: you should be able to create your own Box-like type now, but couldn't do that via copy-paste of the original Box implementation.
You can read about that story here.
Right, I said it's never been in the stable language. The standard library is allowed to use unstable features, like box_syntax. You can use box in your own code if you use a nightly compiler and put #![feature(box_syntax)] in your crate root.
It's similar, but note that box and Box::new take care of both allocation and initialization, while malloc only does allocation. They also always return a valid pointer, while malloc can return NULL to indicate that allocation failed (in which situation Box::new would panic/abort/call some OOM handler). The closest thing to malloc in Rust's std is std::alloc::alloc.