Cannot be formatted with the default formatted - rust

Question

mystring.rs
pub fn return_string() {
return "Some String"
}
then in main, I want to print this string
mod mystring;
const test = config::return_string();
println!("{}", test);
the error I get is
println!("{}", test);
| ^^^^ `()` cannot be formatted with the default formatted

Answer 1

I assume that your minimal reproducible example is:
pub fn return_string() {
return "Some String"
}
fn main() {
const test = return_string();
println!("{}", test);
}
error: missing type for `const` item
--> src/main.rs:6:11
|
6 | const test = return_string();
| ^^^^ help: provide a type for the constant: `test: ()`
error[E0308]: mismatched types
--> src/main.rs:2:12
|
1 | pub fn return_string() {
| - help: try adding a return type: `-> &'static str`
2 | return "Some String"
| ^^^^^^^^^^^^^ expected `()`, found `&str`
error[E0277]: `()` doesn't implement `std::fmt::Display`
--> src/main.rs:7:20
|
7 | println!("{}", test);
| ^^^^ `()` cannot be formatted with the default formatter
|
= help: the trait `std::fmt::Display` is not implemented for `()`
= note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
= note: this error originates in the macro `$crate::format_args_nl` (in Nightly builds, run with -Z macro-backtrace for more info)
Solution
There are two errors in your code:
don't use const inside of functions. Use let. let is an immutable value. let mut would be mutable. const is only used for immutable globals.
you are missing the return type for your return_string() function
I'll assume here that the return type is &str, but it might as well have to be String. For more info search for &str vs String.
Third, as a minor annotation, avoid return as much as possible, if not required. The last line of a function is automatically the return type if you don't finish it with ;.
pub fn return_string() -> &'static str {
"Some String"
}
fn main() {
let test = return_string();
println!("{}", test);
}
Some String
Explanation of the error message
The error message says that () is not printable.
() is the empty type, analogous to void in C++. As you don't annotate the return type of return_string(), Rust assumes it's (). And () cannot be printed directly, at least not with the Display formatter.
You could print it with the Debug formatter, though:
pub fn return_void() {}
fn main() {
let test = return_void();
println!("{:?}", test);
}
()
Note that contrary to C++, () is actually a storable type, even if it is of size 0 with no data in it. That makes things a lot easier for generics. C++ templates that need to be able to deal with void return values were a major pain factor for me in the past, as they always required a special case.