It's my understanding that expression templates as a technique were discovered significantly prior to the original C++ Standard in 1998. Why weren't they used to improve the performance of several standard classes like
std::string and streams?
Expression templates were first published by Todd Veldhuizen in June 1995, in an article in the C++ Report magazine. By that time, the standard committee was already heavily involved with adding the STL to the C++ standard, a task which all by itself delayed the standard by one or two years. (The STL was presented to the committee in 1993, and officially proposed in 1994. It took another four years to finish the standard.)
Given that the C++ standardization committee is a bunch of volunteers, some of them not even backed by companies paying their expenses, I don't think anyone had any resources to use on adding yet another idea to the C++ standard.
Also, 1995 is just the year Veldhuizen's article was published. For the technique to become known and recognized, it would have taken another few years. (The idea of the STL dates back to the 70s, an Ada implementation was done in the late 80s, work at a C++ implementation must have started around 1990, and it took another three years for the idea to find its way to the C++ standardization committee.)
There were, however, just three years from Todd's article until the final vote on the standard. That was way too little time to incorporate an idea that was still brand-new and basically untested.
Add to that the fact that Expression Templates, being a kind of template meta-programming, stress compilers way more than the comparatively "simple" STL does. And from what I remember, even in 1998, when the standard was published, we didn't have a compiler that could even compile all of the STL.
Given that one of the standardization committee's main goals was to standardize established practice (not that they stuck to this rigorously), Expression Templates should never have been on the agenda back then.
The simple answer is: you obviously didn't lobby for it. Nor did I because I had (and have) my own agenda which doesn't include expression templates. Also, the interface in particular for strings is already trying to serve way too many masters, resulting in a class which is used for everything and good for mothing.
The standard library has already
std::valarray and family which is intended to support an expression template style of implementation. As far as I can tell it doesn't quite cut it, though. One problem which caused this is that the people who lobbied to get its half-baked version included into the standard stopped working in it the moment it included. There were attempts to rescue it (e.g. David Vandevoorde, Matt Austern, and I worked on it for a day or so at the Stockholm meeting) but in the end nobody was interested enough.
The technique now known as "expression templates" was discovered (independently) at least as far back as 1994 by both Todd Veldhuizen and myself (Todd's article is from 1995, but it takes a bit of time for stuff to get published; my own work was first shown in comp.lang.c++).
I actually started attending C++ committee meetings exactly because of this issue. I presented the technique and a complete redesign of std::valarray to the committee at the first Santa Cruz meeting in March 1996. It was deemed too large of a change, but as Dietmar alludes to, we got some words in at the subsequent meetin in Stockholm that enable the use of expression templates for the implementation of std::valarrray. To my surprise, those words are still there: See paragraph 3-6 of subsection [valarray.syn] 29.7.1 in http://wg21.link/N4727 .