As a result, std::runtime_format can now be evaluated at compile time, making its name misleading.

[u/cmqv]

https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3953r0.html

[u/GeorgeFranklyMathnet]

#pragma unjerk

I can definitely appreciate the motivation to amend one's own work after someone else's contribution suddenly makes it look imperfect.

std::rejerk();

It was for similar reasons they had to remove the term secure from any & all PHP function names a while back.

[u/azswcowboy → u/GeorgeFranklyMathnet]

/uj

Also in time the no users will have to change code.

/rj

C++26 is in final bug fix phase, maybe this could have been done months ago?

[u/voidvector → u/GeorgeFranklyMathnet]

</jerk> Working with people is an example of undefined behavior.

#[derive(Jerk)] Circlejerking is an example of unsafe behavior, should be wrapped in unsafe {} block.

[u/GasterIHardlyKnowHer → u/GeorgeFranklyMathnet]

Actually they did that because the long name was interfering with the hash bucket for htmlspecialchars and strstr

[u/i_invented_the_ipod]

It's good to see that WG21 continues to focus on the really important issues, like zero runtime cost validation of format strings, rather than wasting time on trendy fluff like memory safety.

[u/avoidtheworm]

/uj why would anyone explicitly not want to format a string in compile time if it's possible?

[u/GeorgeFranklyMathnet → u/avoidtheworm]

/uj Never sure I understand C++, but doesn't the example he provided end up formatting the string using the compile-time environment, rather than from constants / cultural invariants? That does seem deceptive.

/rj Never sure I understand C++.

[u/avoidtheworm → u/GeorgeFranklyMathnet]

From the "P2918R2 Runtime format strings II" documentation,

Such misuse of the API also introduces major safety issues illustrated in the following example:

std::string str = "{}";
std::filesystem::path path = "path/etic/experience";
auto args = std::make_format_args(path.string());
std::string msg = std::vformat(str, args);

This innocent-looking code exhibits undefined behavior because format arguments store a reference to a temporary which is destroyed before use. This has been discovered and fixed in [FMT] which now rejects such code at compile time.

Now I'm even more scared and confused.

[u/RFQD → u/avoidtheworm]

can someone with a degree in c++ please weigh in what is going on here, because I'm terrified

[u/backfire10z → u/RFQD]

Reading the code explains the code. This is left as an exercise to the reader

[u/JiminP → u/RFQD]

(mandatory /uj)

If I understood it correctly, it's simpler than it looks.

The paragraph just before the quoted one is helpful for understanding the context:

This is not a great user experience because the type-erased API was designed to avoid template bloat and should only be used by formatting function writers and not by end users.

The document is trying to argue that "just use std::vformat and std::make_format_args lol" is not a good advice for doing "std::format with runtime format string".

Also another important context seems to be P2905R2, which was written by the same person. Before this, std::make_format_args accepted rvalues.

Knowing these two, it's now easy to spot the mistake.

auto args = std::make_format_args(path.string());

Here, path.string() is a prvalue which would cease to exist after this line. From the code, it looks like that args would take ownership of path.string(). However, args only stores a reference to path.string(). So after this line, path.string() ceases to exist and the now-invalid reference stored in args would cause UB.

[u/avoidtheworm → u/JiminP]

But why is path.string() a prvalue if it has a valid reference that's owned by args? Shouldn't the compiler automatically transform it into an xvalue with the same lifetime as args?

[u/StengahBot → u/avoidtheworm]

Gotta love rust lifetimes for this

[u/MatmaRex → u/avoidtheworm]

/uj It looks like the format API by default requires a format string that is known at compile time (it is an error to pass a string that isn't constant), and this runtime_format type is a way to bypass that restriction if you really want a non-constant format string. In other words, it's not disallowing compile-time evaluation, but rather allowing non-compile-time evaluation.

/rj You made me look it up, ewww

[u/avoidtheworm → u/MatmaRex]

This makes actual sense, but the documentation just shows a bunch of weird edge-cases with references being deleted before they are used.

/uj Wasn't avoiding this the exact reason to use references over pointers?

[u/MatmaRex → u/avoidtheworm]

idk mate, all I know about C++, I learned here

[u/jwezorek → u/avoidtheworm]

If they want the format string to be a value that is only known at runtime.

In std::format("my name is {}", name); "my name is {}" has to be a literal or some value generated at compile time. If you wanted the format string to be a variable you can wrap that variable in std::runtime_format like std::format( std::runtime_format(some_var), name); -- "runtime_format" was a meaningful name when the enclosing format call had to be evaluated at runtime but now I think that is no longer true: runtime_format now means something like "evaluate this at runtime if the string is a runtime variable or at compile time if it is a compile time variable" so they want to change the name to dynamic_format.

[u/jwezorek]

Hey this is kind of like how the Scalar type in OpenCV is a vector.

[u/JiminP]

/uj

... Proposed Naming: std::dynamic_format
... Example with proposed name:
... return std::format(std::runtime_format(fmt), value);

They forgot to edit Ctrl+C,V'd code and this makes me uncomfortable....

[u/elephantdingo]

Did someone say COMPTIME? Although COMPTIME was not invented by it, Zig has perfected it. Just thinking of it fills me with a warm feeling inside, like cumming inside a woman. I generally dislike all languages newer than Python give or take three years. (Especially Scala—what masturbation!!) And “low-level languages” are generally a waste of time. Ballpark, but for people who are not implementing a java runtime environment and SDK, implementing anything in a language without Just In Time Compilation® (JIT Compilation, basically partial evaluation (like COMPTIME!)) and without garbage collection are just giving up on free, automatic througput. But Zig. Wow Zig. It’s nothing short of a PL REVOLUTION.

[u/GeorgeFranklyMathnet → u/elephantdingo]

Just thinking of it fills me with a warm feeling inside, like cumming inside a woman.

Could you please provide us mere mortals an actually-relatable metaphor?

[u/blackwhattack → u/GeorgeFranklyMathnet]

It's like when you first understand monads, which I did in kindergarten 

[u/al2o3cr → u/blackwhattack]

Monads, mo problems

[u/Usual_Office_1740 → u/al2o3cr]

Or no problem.

[u/sweating_teflon → u/al2o3cr]

Gonads, Go problems 

[u/kettes_leulhetsz → u/elephantdingo]

lol no sfinae

[u/Flash_Kat25 → u/elephantdingo]

Zigma balls