Hacker News Reader

Hacker News

Comment by pabs3 | Hacker News Reader

Parent Full thread

pabs3

How would one print a literal "Hello {x}!" without the formatting?

View on HN

> Also to escape these curly braces, just put two of them in front of eachother

So that would be "Hello {{x}}!".

Is this feature was introduced in 1.58, does that mean strings in 1.57 didn't need the extra curly braces?

I imagine this is going to break a lot of existing code. There doesn't even seem to be a way to have {x} mean the same thing in 1.57 and 1.58

Rust has a pretty strict backwards compatibility policy. Generally speaking breaking changes are not allowed, unless they fix a specific vulnerability or other critical issue. Language-level breaking changes can be done with the Edition mechanism. Three editions have been released so far, with three years between each of them.

Additionally, new releases are frequently tested with a tool called Crater, which basically builds and runs the tests for all publicly available Rust code. This helps massively in upholding backwards compatibility guarantees and in evaluating if a compatibility break is worth it.

No. That was invalid syntax previously.

At this point I should research it myself, but I'm on mobile currently.

But how would you print {x} in 1.57? I doubt you would escape it with {{ in that release. Maybe \{ then? Does that still work in 1.58?

This still smells fishy to me, but I need to dig deeper.

In previous Rust versions, you can't print {0} by printing `{x}`. Adding braces around variables turns them into named variables. For example:

    pub fn main() {
        let y = 4;
        println!("{x}", x=y);
    }

To print '{x}', you need to write:

    pub fn main() {
        let x = 4; // unused
        println!("{{x}}");
    }

The last bit of information that GP might be missing is that

    pub fn main() {
        let x = 4; // unused
        println!("{x}");
    }

would previously be a compile time error (because the format! family of macros perform string interpolation at compile time):

    error: there is no argument named `x`
     --> <source>:3:15
      |
    3 |     println!("{x}");
      |               ^^^

So no new existing code will stop compiling, some things that were previously compile errors will now work.

> I doubt you would escape it with {{ in that release

You would. Brackets were still escaping in that release because you would of course still do `println!("{}", x);`

You might be missing the fact that this applies only to format strings, not strings in general. The interpolation into curly brackets is done by the format! (or println!) macros, not a language feature of strings in general.

`{}` has always been special in format strings, so no real change there. If you've got a string that happens to contain "Hello {x}!" and you want to print it, you must template it in, as the format string needs to be a literal:

    print!("{}", hello_string)

Or as others have pointed out, you can double-up the braces:

    print!("Hello {{x}}!")

Then if you want to be cute, you could do something like this:

    print!("Hello {x}!", x="{x}")

Note that the named parameter syntax isn't new -- what's new is capturing named parameters from a scope that's larger than the format macro:

    let x = "{x}"
    print!("Hello {x}!")

And also note that it's a compile-time error to have an unused format parameter in a string, so that last code example wouldn't have compiled at all in older versions of rust.

Reply on news.ycombinator.com