There was a long time ago a proposal for format string, I can't remember the number. In any case, the old one should be rebased to be in line with fmt and if there's a new one it should also be based on fmt formatting.

Also, if you truly propose the compiler replace f"aaa {expr} bbb" with "aaa " << expr << " bbb" it means that the following code would not work:

void g(std::string);

g(f"aaa{expr}bbb");

This is because the bit shift operator will be called, but don't make sense in this context.

If we based the string expressions on fmt, then the following should work.

You might also have dangerous combinations if you use stream operators blindly:

int a = 1;

int b = 4;

f"{a}{b}" // equivalent to "16"??

There is also a couple of important questions to be answered:

- What is the type of f""? Depending on the answer, using those can be as fast as format, slower or faster.

- When is the expression inside the {} evaluated? Depending on the answer, you might there might have performance implications or a footgun with temporaries and scopes.

- How are the format options sent to a f string?

- Does using this language feature will require the inclusion of a specific header? The answer will probably depend on what you answered on the other questions.

Em qua., 28 de dez. de 2022 03:59, Yuri via Std-Proposals <std-proposals@lists.isocpp.org> escreveu:

**********************************
** Problem that f-strings solve **
**********************************

String formatting in C++ requires more characters than minimally necessary.

There are two major ways to format complex strings in C++:
1. using operator<<, for example:
std::cout << "threshold is " << threshold << ", time is now " <<
time() << std::endl; (1)
2. using std::format, for example:
std::cout << std::format("threshold is {}, time is now {}",
threshold, time()) << std::endl; (2)

Both ways have problems: they require more characters than minimally
necessary to perform the task of formatting. The second way also separates
variables and their print locations, which makes it more error prone.

It's common to need to do a lot of complex message printing for programs,
when various values or expressions need to be incorporated into the message.
C++ code in these cases is less expressive than it can be.

**********************
** Proposed feature **
**********************

Introduce a special kind of string in C++: f-string.

f-string begins with the 'f' character (f"string" or Lf"string"). When an
f-string is encountered it is interpreted in the same way as regular strings
with this exception:

> The '{' character is assumed to begin an rvalue expression. Compiler
would
> change context after '{' and would begin to parse the rvalue, expecting
> to find the closing '}' after the rvalue ends. The closing '}' would
restore
> the string context. In order for '{' and '}' characters to appear in
> an f-string they should be escaped, \{ and \}.

Compiler would replace all "...{<rvalue>}..." tokens in f-strings with
"..." << <rvalue> << "...", allowing them to be further processed in the
same
way as an operator<<-based print construct.

This way forming complex strings in C++ would become simpler. The above
example
would look like:
std::cout << "threshold is {threshold}, time is now {time()}" <<
std::endl; (3)
This is more readable and intuitive than both (1) and (2).

*****************
** Limitations **
*****************

(1) rvalues should be printable with operator<<.
(2) for simplicity macros wouldn't be allowed in rvalues embedded in
f-strings.

*************************************
** Affected elements of toolchains **
*************************************

* C++ compiler
* Syntax highlighters in editors and other software

**************
** Benefits **
**************

f-strings would simplify string formatting and allow to make string
formatting
code as simple as possible. This would make printing code less error
prone, and
would make it much easier to read.

*****************************
** What inspired this idea **
*****************************

(1) While writing a lot of C++ code with many complex messages incorporating
a lot of various values I was thinking that it got to be a shorter and
easier way of doing this.
(2) While seeing f-strings in Python recently I realized that C++ can also
greatly benefit from this feature.

*************
** Example **
*************

This code would be legal C++ code with f-strings:

#include <chrono>
#include <ctime>
#include <iostream>
#include <pwd.h>
#include <unistd.h>

using namespace std;

int main() {
auto now =
chrono::system_clock::to_time_t(chrono::system_clock::now());
cout << "Hello {getpwuid(geteuid())->pw_name}"
", the time now is {ctime(&now)}." << endl;
}



Thank you,
Yuri Victorovich

--
Std-Proposals mailing list
Std-Proposals@lists.isocpp.org
https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals