10 ms·

C++20 Improved the For-Loop Syntax

46 points by jpmitchell 2mo ago

HarHarVeryFunny 2mo ago
C++20 also has an enumerate() generator, so if you like the python syntax you can just do: for (auto [i,v] : std::views::enumerate(vec)) std::cout << i << ": " << v << std::endl; FWIW C++23 also has a python-like print and println: std::println("{}: {}", i, v);
- BigTTYGothGF 2mo ago
  The enumerate is a better solution than the one in the blog post.
- arikrahman 2mo ago
  This is the way I've been doing it and with less hiccups.
- Maxatar 2mo ago
  std::views::enumerate is a C++23 feature, not C++20.
- WalterBright 2mo ago
  > std::cout << i << ": " << v << std::endl; C++ needs to abandon iostreams. Didn't the C++ community acknowledge that it was a bad idea? In the early days of D, people did want to do a version of it for D, but I objected and currently nobody wants it.
  - Matheus28 2mo ago
    https://en.cppreference.com/cpp/io/print https://en.cppreference.com/cpp/io/print
    - WalterBright 2mo ago
      Thanks. Looks like it finally made C++23!
      - extraduder_ire 2mo ago
        fmt:print from fmtlib has been around for at least a decade, though having it be in the spec by default now is nice. Even in c++20, you could use format() to do most of what you'd want from it.
  - pjmlp 2mo ago
    Some folks don't like iostreams, I keep using them, since Turbo C++ 1.0 for MS-DOS. Although I would probably use std::print in more modern compilers. D needs to work into its marketing, all key features that made it relevant back in 2011 with Andrei's book have now been copied even if badly, across all mainstream languages.
    - WalterBright 2mo ago
      > Some folks don't like iostreams I thought it was ugly in 1987, and it hasn't improved with age. Then < > for templates made it worse. Then there's formatted I/O: void IOS_precision() { cout << "\n--------------------------\n"; cout << "Implementing ios::precision\n\n"; cout << "Implementing ios::width"; cout.setf(ios::fixed, ios::floatfield); cout.precision(2); cout<<3.1422; cout << "\n--------------------------\n"; } and I don't know if the problem with multithreading was resolved or not. > copied even if badly Any program can be written in any language. But why suffer?
      - pjmlp 2mo ago
        That is always given as an example of how bad it is, yet I seldom have used any kind of such formatting since 1993. iostreams hardly played a role in all C++ GUI frameworks and for object serialisation, precision flags were seldom used.
WCSTombs 2mo ago
The C++20 version is still clearly inferior to the Python and Lua examples because you still have to manually increment the counter in the loop body. IMO the sibling comment by HarHarVeryFunny has a much better C++ equivalent for this idiom, even if it's slightly more verbose.
- Gualdrapo 2mo ago
  > you still have to manually increment the counter in the loop body It doesn't look like that to me, the ++i thing seems to be just to start printing the array from 1 (I don't know how things are in Python nowadays but I know in Lua arrays start at 1, so there's no need for something like this in there), the value of i is still increasing without telling it explicitly to do so
  - sheept 2mo ago
    Python is 0-indexed. In OP's example, the start parameter makes i start at 1. Their C++17 example prints starting from 0. Probably a mistake. If you look at the linked page for C++20[0], other types can be put in the initializer statement, so it's unlikely the loop auto-increments. [0]: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0614r0.html https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p06...
    - kbenson 2mo ago
      So, it's just a while loop in a for loop's clothing? That's not going to be confusing for people at all...
      - comex 2mo ago
        No, it's a for loop that happens to include an unrelated variable declaration.
        kbenson 2mo ago
        Ah, I see. The increment is so they can manually handle the included feature of the other cases, which number of the iteration you're on. Nice that it will automatically loop across a collection, annoying that they couldn't go the whole way and you need to deal with it manually.
on_the_train 2mo ago
What a strange example, as c++ did get Pythons enumerate, but in c++23
fourseventy 2mo ago
Just what C++ needs, more bloat lol.
- petilon 2mo ago
  C++ is probably the only language that needs a strong style guide, to define a subset you are allowed to use in the project. Linus Torwalds famously said that subset is zero. You're not allowed to use C++ in Linux, a wise move. Here's Google's: https://google.github.io/styleguide/cppguide.html https://google.github.io/styleguide/cppguide.html Search for "do not use" and you'll find plenty of hits.
  - tcfhgj 2mo ago
    > C++ is probably the only language that needs a strong style guide, here you go: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines
    - zeroq 2mo ago
      Good Lord. Reminds me of Good Parts, Bad Parts meme of JS.
  - bigcityslider 2mo ago
    And it's not because he's cranky or something, he was holding out for something worthy to possibly use instead of C. Turned out to be Rust.
    - leecommamichael 2mo ago
      > And it's not because he's cranky or something, he was holding out for something worthy to possibly use instead of C. Good point. > Turned out to be Rust. He was evaluating C++ in the 90's, you make it sound like he recently decided to write Rust instead of C. The reality is that Rust is allowed in limited ways into _some parts_ of the kernel codebase. Rust got so much further than C++ ever did, that is true.
Gualdrapo 2mo ago
The way this website shows the programming languages is odd. They're blue and slanted and if you hover your mouse cursor over them they have a color transition, so you'd think they are links - and yet you click on them and nothing happens
adityamwagh 2mo ago
> It seems to me that the C++ Standards Committee is doing a decent job maintaining the language, and introducing useful features when it makes sense to do so. This can’t be further from truth. C++ is essentially Frankenstein’s monster.
- gregdaniels421 2mo ago
  An articulate creature that hounds its creator for abandoning it? If anything it is more of a Chimera
- saghm 2mo ago
  And the real monster was the one who created it all along!
- hnisnotbenign 2mo ago
  I believe one of the main goals of whatever shadowy organizations are behind the "standards committee" is to sabotage the language to help clear the way for Rust. If these people really have a great idea for what the future C++ should be like, then they should introduce that language all at once. Let us see their grand vision in one big package that can be embraced or rejected. This steady drip-drip-drip of half-baked features every few years is creating one hellish language. I spend a lot of time in the Chromium source code and have seen plenty of boneheaded code, especially in places like Autofill where they seem to turn the newbies loose, but also in surprising places like V8, due to newbs using newfangled C++ "features" to do what worked perfectly well before in older idioms and was easier to read also. Take for instance the function TryReduceFromMSB in v8/src/compiler/turboshaft/wasm-shuffle-reducer.cc -- do you see any reason that std::optional<uint8_t> max; couldn't just be a regular uint8_t? Let's name it 'max_used' also so the name is more descriptive and doesn't clobber the namespace.
  - foldr 2mo ago
    >do you see any reason that std::optional<uint8_t> max; couldn't just be a regular uint8_t? It's so that if (max) is truthy iff max has been assigned (including the case where it's been assigned zero). I don't know if it's possible for max to be assigned zero in this specific context, or what the correct behavior is if max==0. However, the good thing about this code is that it clearly communicates that the intended check is 'has been assigned to' rather than 'is nonzero'. The function, for reference: void WasmShuffleAnalyzer::TryReduceFromMSB(OpIndex input, const Simd128ShuffleOp& shuffle, uint8_t lower_limit, uint8_t upper_limit) { DemandedBytes demanded = GetDemandedBytes(&shuffle); std::optional<uint8_t> max = {}; for (unsigned i = 0; i < demanded.bytes(); ++i) { uint8_t index = shuffle.shuffle[i]; if (index >= lower_limit && index <= upper_limit) { max = std::max(static_cast<uint8_t>(index % kSimd128Size), max.value_or(uint8_t{0})); } } if (max) { // input can be reduced. TRACE("Can reduce Op %d based upon max used index: %d\n", input.id(), max.value()); demanded_byte_analysis_.Add( input, DemandedBytes::LowFromMaxShuffleIndex(max.value())); } }
galkk 2mo ago
Only people who saw nothing bad in passing pairs .begin(), .end() in tons of places in c++ for like 30 years can say that thing like ‘auto&&’ improves anything.
- Tadpole9181 2mo ago
  What exactly is your complaint with it? `auto&&` has been standard syntax in C++ for going on 15 years now and has a very clear, irreplaceable meaning - a type-deduced forward reference - to any remotely competent developer.
  - HackerThemAll 2mo ago
    I think C++ needs more of `:`, `::` and maybe new operators `&&&` and `&&&&`.
    - xigoi 2mo ago
      C++32 will look like for<template> [auto&&&&]:::static (std::for_enumeration_initializer &&⁢ @auto: {{const signed&&&&& i const}}) { }
- lentil_soup 2mo ago
  and completely unnecessary in that example, it's a string, type string, makes it way easier to understand
dvt 2mo ago
I am so happy I haven't written a line of C++ in like 15 years. Absolutely disgusting language. Every time I look up one of their new standards, I'm like how does anyone keep all of this in their head (usually on top of stuff like boost, etc.)? No wonder LLMs are a thing.
- lioeters 2mo ago
  C++ is a decades-long mistake that spawned other misguided directions in the entire software industry. We're still trying to undo many of the bad ideas, but I'm afraid even Rust has too much of C++ in it, not only in terms of syntax but mentality and culture. LLMs are making things worse by automatically generating code in such bloated languages, where people have less need to even look at the horrific spaghetti inside. The whole thing needs to be reconsidered from the ground up, from first principles, by actual creative thinking human beings with lessons of hindsight. > Gall's Law: A complex system that works is invariably found to have evolved from a simple system that worked. A complex system designed from scratch never works and cannot be patched up to make it work. You have to start over with a working simple system.
WalterBright 2mo ago
C++ should copy D's elegance: import std.stdio; string[9] vec = [ "the", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog" ]; void main() { foreach (i, s; vec) writeln(i, ": ", s); }
- WalterBright 2mo ago
  Although D is a strongly typed language, it is very good at type inference. The `s` is inferred as `string`, and `i` as `size_t`.
- deleted 2mo ago
  [deleted]
- entrope 2mo ago
  Go is similar: package main import "fmt" var vec = []string{"the", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog"} func main() { for i, s := range vec { fmt.Printf("%d: %s\n", i, s) } } Using `fmt.Println(i, ":", s)` inserts spaces on both sides of the colon, so the output is not quite right. I find Go's `range` syntax easier to read than D's `(i, s; vec)` -- although generator functions that work with `range` have unaesthetic return types.
  - WalterBright 2mo ago
    D has several usages for `foreach` depending on the number and type of its arguments. In this case, it sees that `vec` is an array, and so constructs a loop over the array. If `vec` was a range, the loop will be constructed as a loop over the array. It's nice because it makes the syntax for arrays and ranges interchangeable, making for easy refactoring.
    - entrope 2mo ago
      Go is similar: `for/range` has always worked on arrays, slices, maps, strings and channels, and they extended it to integers in version 1.22 and to user-defined generators in version 1.23. It generates one or two outputs depending on the type of the RHS, but one can assign the index value to _ to ignore it. Among standard types, only channels and integers generate one output; containers (including strings) give an index or key and a value.
HeavyStorm 2mo ago
Given both Lua and python use a enumerator, the C++ example isn't really the correct equivalent. for (auto [i, v] : std::views::enumerate(vec)) { std::cout << i << ": " << v << '\n'; } This is how you'd do it.
- ziotom78 2mo ago
  True, but this is C++23, while the post is about C++20.
UncleOxidant 2mo ago
Reading this, I really can't make much sense of it: for (int i=0; auto&& it: vec) cout << (++i) << ": " << it << endl; It's certainly not obvious what's going on there at a glance. This is at least a bit more pythonic: for (auto [i, it] : std::views::enumerate(vec)) { std::cout << i << ": " << it << "\n"; }
- grg0 2mo ago
  It's probably easier to understand if you read about the "if statement with initializer" linked from the post: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0305r0.html https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p03...
  - dataflow 2mo ago
    Not really, I was well aware of if-with-init and I still found this quite confusing. That one actually shows what the variable is initialized to. This one doesn't.
    - hdjrudni 2mo ago
      > That one actually shows what the variable is initialized to. This one doesn't. reply Which variable? `i` is clearly initialized to `0` and `it` doesn't have an initializer per se... it starts at the first value of the container. It almost seems like an abuse to put 2 unrelated things in the `for(...)` but that's what they did.
      - grg0 2mo ago
        [dead]
- senkora 2mo ago
  The part that confuses me is that they use “it” to name a variable that is not actually an iterator. That’s very bad style. I would name it “s”.
kazinator 2mo ago
1> (mapdo (op put-line `@1: @2`) '#"how now brown cow" 0) how: 0 now: 1 brown: 2 cow: 3 nil mapdo: a mapping function for side effects of calling the function, not calculating a result, like map does. op: produce a lambda expression out of an expression in which @1, @2, ... explicitly indicate the insertion of positional arguments, which are implicitly collected and become the parameter list of the lambda. `...`: quasistring syntax: supports @ notations for interpolating. The @1, @2 elements of op do not require a double @@ inside a quasistring. put-line: ordinary function to put a string to a stream (standard output by default) followed by newline. The lambda generated by op contains a (put-line ...) expression as its body, with @1 and @2 transformed into references to to generated, unique parameter names. #"...": string list literal: contents are broken on whitespace and denote a list of strings #"foo bar" -> ("foo" "bar"). Requires ' quote in front to be quoted literally, and not evaluated as a compound expression applying the argument "bar" to the operator "foo". Yes, there is a #`...` quasi string list for templating over this. nil: the value returned by mapdo after the side effects, printed by the REPL, not part of the output. 0: ordinary integer zero. But endowed with the power of being iterable. Where an iterable thing is required, 0 denotes the whole numbers 0, 1, 2, ... Similarly, 42 denotes 42, 43, ... These are some of the ingredients produced by my one-member research programme into nicer Lisp coding. 2> (map (ret `@1: @2`) '#"how now brown cow" 0) ("how: 0" "now: 1" "brown: 2" "cow: 3") map: take tuples by iterating over argument iterables in parallel, pass them to a function to project each tuple to a value, then return a list of values. ret: cousin of op built on the same framework as op. Used for turning an expression into a lambda, when the expression isn't a compound form with an obvious operator. To turn (foo bar) into a lamdbda with op we use (op foo bar). But what if we have a simple variable x and want (lambda () x)? (op x) is not right, it means (lambda () (x)). (ret x) provides the sugar. Here, it lets us spin up a two-argument function that evaluates a quasistring.
drnick1 2mo ago
Give me the explicit C syntax any day over this monstrosity. I refuse to write anything other than C++98, the last version of C++ that built on C without trying to turn it into a completely different language.
- pjmlp 2mo ago
  So K&R C it is, nothing of that C23 crazy stuff.
hackthemack 2mo ago
I guess I am officially old and no longer know what the cool "it" is any more. The C++17 example seems much more clear to me. It is more typing, but so what? It is not that much more typing, and it looks like code that people have written for 40 years.
jandrewrogers 2mo ago
As someone who likes and uses modern C++ this seems like a very marginal improvement. I see the use case but it seems rather unimportant.
vianchen 2mo ago
This is not an improvement. In fact it makes the code harder to understand. The way it's written makes people less familiar with this syntax think `int i = 0` and `auto &&it : vec` are two separate statements.
anon291 2mo ago
You can do this right now with an iterator adaptor and some range trickery. The c++ range based for loop already enables the same behavior as python. The only thing missing is a standard enumerate function. This is a Fine addition to c++ due to how c++ uses lifetimes for resource management but the syntax is convoluted and the claim that this is intended to enable enumeration is... Just silly.
v9v 2mo ago
In C with https://github.com/aartaka/pretty.c https://github.com/aartaka/pretty.c, foreach (i, int, 10, vector(10, int, 1, 2, 3, 3, 4, 5)) println(*i);
pjmlp 2mo ago
Even more modern, we are getting C++26 nowadays. CTADs for vector (no need for explicit string), ranges enumeration, and range-based for-loop with structured types int main() { vector vec = { "the", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog" }; for (auto&& [i, it] : vec | std::views::enumerate) println ("{}:{}", ++i, it); } Compiler explorer example, https://cpp.godbolt.org/z/3r8rPdjbG https://cpp.godbolt.org/z/3r8rPdjbG
- Bimos 2mo ago
  I'm super confused. In your example, ++i is equivalent to (i+1) and the loop updates i itself. But with the syntax in the blogpost, i is only initialized, and it is the ++i that updates the value?
  - spider-mario 2mo ago
    Yes. You don’t sound that confused?
  - pjmlp 2mo ago
    Copy paste error, too late to update the comment, it should be a plain i.
bjoli 2mo ago
the looping facilities in most languages suck. We are at a position where iteration is either "increment or decrement numbers", or "go through this collection". Everything else means degrading performance. In some languages (Python, ruby) the choice is between the comfortable way to iterate through a collection (for a in xyz:), or the fast way (while). It is just stupid.

46 points by jpmitchell 2mo ago

C++20 also has an enumerate() generator, so if you like the python syntax you can just do: for (auto [i,v] : std::views::enumerate(vec)) std::cout << i << ": " << v << std::endl; FWIW C++23 also has a python-like print and println: std::println("{}: {}", i, v);

BigTTYGothGF 2mo ago
The enumerate is a better solution than the one in the blog post.
arikrahman 2mo ago
This is the way I've been doing it and with less hiccups.
Maxatar 2mo ago
std::views::enumerate is a C++23 feature, not C++20.
WalterBright 2mo ago
> std::cout << i << ": " << v << std::endl; C++ needs to abandon iostreams. Didn't the C++ community acknowledge that it was a bad idea? In the early days of D, people did want to do a version of it for D, but I objected and currently nobody wants it.
- Matheus28 2mo ago
  https://en.cppreference.com/cpp/io/print https://en.cppreference.com/cpp/io/print
  - WalterBright 2mo ago
    Thanks. Looks like it finally made C++23!
    - extraduder_ire 2mo ago
      fmt:print from fmtlib has been around for at least a decade, though having it be in the spec by default now is nice. Even in c++20, you could use format() to do most of what you'd want from it.
- pjmlp 2mo ago
  Some folks don't like iostreams, I keep using them, since Turbo C++ 1.0 for MS-DOS. Although I would probably use std::print in more modern compilers. D needs to work into its marketing, all key features that made it relevant back in 2011 with Andrei's book have now been copied even if badly, across all mainstream languages.
  - WalterBright 2mo ago
    > Some folks don't like iostreams I thought it was ugly in 1987, and it hasn't improved with age. Then < > for templates made it worse. Then there's formatted I/O: void IOS_precision() { cout << "\n--------------------------\n"; cout << "Implementing ios::precision\n\n"; cout << "Implementing ios::width"; cout.setf(ios::fixed, ios::floatfield); cout.precision(2); cout<<3.1422; cout << "\n--------------------------\n"; } and I don't know if the problem with multithreading was resolved or not. > copied even if badly Any program can be written in any language. But why suffer?
    - pjmlp 2mo ago
      That is always given as an example of how bad it is, yet I seldom have used any kind of such formatting since 1993. iostreams hardly played a role in all C++ GUI frameworks and for object serialisation, precision flags were seldom used.

WCSTombs 2mo ago

The C++20 version is still clearly inferior to the Python and Lua examples because you still have to manually increment the counter in the loop body. IMO the sibling comment by HarHarVeryFunny has a much better C++ equivalent for this idiom, even if it's slightly more verbose.

Gualdrapo 2mo ago
> you still have to manually increment the counter in the loop body It doesn't look like that to me, the ++i thing seems to be just to start printing the array from 1 (I don't know how things are in Python nowadays but I know in Lua arrays start at 1, so there's no need for something like this in there), the value of i is still increasing without telling it explicitly to do so
- sheept 2mo ago
  Python is 0-indexed. In OP's example, the start parameter makes i start at 1. Their C++17 example prints starting from 0. Probably a mistake. If you look at the linked page for C++20[0], other types can be put in the initializer statement, so it's unlikely the loop auto-increments. [0]: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0614r0.html https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p06...
  - kbenson 2mo ago
    So, it's just a while loop in a for loop's clothing? That's not going to be confusing for people at all...
    - comex 2mo ago
      No, it's a for loop that happens to include an unrelated variable declaration.
      - kbenson 2mo ago
        Ah, I see. The increment is so they can manually handle the included feature of the other cases, which number of the iteration you're on. Nice that it will automatically loop across a collection, annoying that they couldn't go the whole way and you need to deal with it manually.

on_the_train 2mo ago

What a strange example, as c++ did get Pythons enumerate, but in c++23

fourseventy 2mo ago

Just what C++ needs, more bloat lol.

petilon 2mo ago
C++ is probably the only language that needs a strong style guide, to define a subset you are allowed to use in the project. Linus Torwalds famously said that subset is zero. You're not allowed to use C++ in Linux, a wise move. Here's Google's: https://google.github.io/styleguide/cppguide.html https://google.github.io/styleguide/cppguide.html Search for "do not use" and you'll find plenty of hits.
- tcfhgj 2mo ago
  > C++ is probably the only language that needs a strong style guide, here you go: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines
  - zeroq 2mo ago
    Good Lord. Reminds me of Good Parts, Bad Parts meme of JS.
- bigcityslider 2mo ago
  And it's not because he's cranky or something, he was holding out for something worthy to possibly use instead of C. Turned out to be Rust.
  - leecommamichael 2mo ago
    > And it's not because he's cranky or something, he was holding out for something worthy to possibly use instead of C. Good point. > Turned out to be Rust. He was evaluating C++ in the 90's, you make it sound like he recently decided to write Rust instead of C. The reality is that Rust is allowed in limited ways into _some parts_ of the kernel codebase. Rust got so much further than C++ ever did, that is true.

Gualdrapo 2mo ago

The way this website shows the programming languages is odd. They're blue and slanted and if you hover your mouse cursor over them they have a color transition, so you'd think they are links - and yet you click on them and nothing happens

adityamwagh 2mo ago

> It seems to me that the C++ Standards Committee is doing a decent job maintaining the language, and introducing useful features when it makes sense to do so. This can’t be further from truth. C++ is essentially Frankenstein’s monster.

gregdaniels421 2mo ago
An articulate creature that hounds its creator for abandoning it? If anything it is more of a Chimera
saghm 2mo ago
And the real monster was the one who created it all along!
hnisnotbenign 2mo ago
I believe one of the main goals of whatever shadowy organizations are behind the "standards committee" is to sabotage the language to help clear the way for Rust. If these people really have a great idea for what the future C++ should be like, then they should introduce that language all at once. Let us see their grand vision in one big package that can be embraced or rejected. This steady drip-drip-drip of half-baked features every few years is creating one hellish language. I spend a lot of time in the Chromium source code and have seen plenty of boneheaded code, especially in places like Autofill where they seem to turn the newbies loose, but also in surprising places like V8, due to newbs using newfangled C++ "features" to do what worked perfectly well before in older idioms and was easier to read also. Take for instance the function TryReduceFromMSB in v8/src/compiler/turboshaft/wasm-shuffle-reducer.cc -- do you see any reason that std::optional<uint8_t> max; couldn't just be a regular uint8_t? Let's name it 'max_used' also so the name is more descriptive and doesn't clobber the namespace.
- foldr 2mo ago
  >do you see any reason that std::optional<uint8_t> max; couldn't just be a regular uint8_t? It's so that if (max) is truthy iff max has been assigned (including the case where it's been assigned zero). I don't know if it's possible for max to be assigned zero in this specific context, or what the correct behavior is if max==0. However, the good thing about this code is that it clearly communicates that the intended check is 'has been assigned to' rather than 'is nonzero'. The function, for reference: void WasmShuffleAnalyzer::TryReduceFromMSB(OpIndex input, const Simd128ShuffleOp& shuffle, uint8_t lower_limit, uint8_t upper_limit) { DemandedBytes demanded = GetDemandedBytes(&shuffle); std::optional<uint8_t> max = {}; for (unsigned i = 0; i < demanded.bytes(); ++i) { uint8_t index = shuffle.shuffle[i]; if (index >= lower_limit && index <= upper_limit) { max = std::max(static_cast<uint8_t>(index % kSimd128Size), max.value_or(uint8_t{0})); } } if (max) { // input can be reduced. TRACE("Can reduce Op %d based upon max used index: %d\n", input.id(), max.value()); demanded_byte_analysis_.Add( input, DemandedBytes::LowFromMaxShuffleIndex(max.value())); } }

galkk 2mo ago

Only people who saw nothing bad in passing pairs .begin(), .end() in tons of places in c++ for like 30 years can say that thing like ‘auto&&’ improves anything.

Tadpole9181 2mo ago
What exactly is your complaint with it? `auto&&` has been standard syntax in C++ for going on 15 years now and has a very clear, irreplaceable meaning - a type-deduced forward reference - to any remotely competent developer.
- HackerThemAll 2mo ago
  I think C++ needs more of `:`, `::` and maybe new operators `&&&` and `&&&&`.
  - xigoi 2mo ago
    C++32 will look like for<template> [auto&&&&]:::static (std::for_enumeration_initializer &&⁢ @auto: {{const signed&&&&& i const}}) { }
lentil_soup 2mo ago
and completely unnecessary in that example, it's a string, type string, makes it way easier to understand

dvt 2mo ago

I am so happy I haven't written a line of C++ in like 15 years. Absolutely disgusting language. Every time I look up one of their new standards, I'm like how does anyone keep all of this in their head (usually on top of stuff like boost, etc.)? No wonder LLMs are a thing.

lioeters 2mo ago
C++ is a decades-long mistake that spawned other misguided directions in the entire software industry. We're still trying to undo many of the bad ideas, but I'm afraid even Rust has too much of C++ in it, not only in terms of syntax but mentality and culture. LLMs are making things worse by automatically generating code in such bloated languages, where people have less need to even look at the horrific spaghetti inside. The whole thing needs to be reconsidered from the ground up, from first principles, by actual creative thinking human beings with lessons of hindsight. > Gall's Law: A complex system that works is invariably found to have evolved from a simple system that worked. A complex system designed from scratch never works and cannot be patched up to make it work. You have to start over with a working simple system.

WalterBright 2mo ago

C++ should copy D's elegance: import std.stdio; string[9] vec = [ "the", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog" ]; void main() { foreach (i, s; vec) writeln(i, ": ", s); }

WalterBright 2mo ago
Although D is a strongly typed language, it is very good at type inference. The `s` is inferred as `string`, and `i` as `size_t`.
deleted 2mo ago
[deleted]
entrope 2mo ago
Go is similar: package main import "fmt" var vec = []string{"the", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog"} func main() { for i, s := range vec { fmt.Printf("%d: %s\n", i, s) } } Using `fmt.Println(i, ":", s)` inserts spaces on both sides of the colon, so the output is not quite right. I find Go's `range` syntax easier to read than D's `(i, s; vec)` -- although generator functions that work with `range` have unaesthetic return types.
- WalterBright 2mo ago
  D has several usages for `foreach` depending on the number and type of its arguments. In this case, it sees that `vec` is an array, and so constructs a loop over the array. If `vec` was a range, the loop will be constructed as a loop over the array. It's nice because it makes the syntax for arrays and ranges interchangeable, making for easy refactoring.
  - entrope 2mo ago
    Go is similar: `for/range` has always worked on arrays, slices, maps, strings and channels, and they extended it to integers in version 1.22 and to user-defined generators in version 1.23. It generates one or two outputs depending on the type of the RHS, but one can assign the index value to _ to ignore it. Among standard types, only channels and integers generate one output; containers (including strings) give an index or key and a value.

HeavyStorm 2mo ago

Given both Lua and python use a enumerator, the C++ example isn't really the correct equivalent. for (auto [i, v] : std::views::enumerate(vec)) { std::cout << i << ": " << v << '\n'; } This is how you'd do it.

ziotom78 2mo ago
True, but this is C++23, while the post is about C++20.

UncleOxidant 2mo ago

Reading this, I really can't make much sense of it: for (int i=0; auto&& it: vec) cout << (++i) << ": " << it << endl; It's certainly not obvious what's going on there at a glance. This is at least a bit more pythonic: for (auto [i, it] : std::views::enumerate(vec)) { std::cout << i << ": " << it << "\n"; }

grg0 2mo ago
It's probably easier to understand if you read about the "if statement with initializer" linked from the post: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0305r0.html https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p03...
- dataflow 2mo ago
  Not really, I was well aware of if-with-init and I still found this quite confusing. That one actually shows what the variable is initialized to. This one doesn't.
  - hdjrudni 2mo ago
    > That one actually shows what the variable is initialized to. This one doesn't. reply Which variable? `i` is clearly initialized to `0` and `it` doesn't have an initializer per se... it starts at the first value of the container. It almost seems like an abuse to put 2 unrelated things in the `for(...)` but that's what they did.
    - grg0 2mo ago
      [dead]
senkora 2mo ago
The part that confuses me is that they use “it” to name a variable that is not actually an iterator. That’s very bad style. I would name it “s”.

kazinator 2mo ago

1> (mapdo (op put-line `@1: @2`) '#"how now brown cow" 0) how: 0 now: 1 brown: 2 cow: 3 nil mapdo: a mapping function for side effects of calling the function, not calculating a result, like map does. op: produce a lambda expression out of an expression in which @1, @2, ... explicitly indicate the insertion of positional arguments, which are implicitly collected and become the parameter list of the lambda. `...`: quasistring syntax: supports @ notations for interpolating. The @1, @2 elements of op do not require a double @@ inside a quasistring. put-line: ordinary function to put a string to a stream (standard output by default) followed by newline. The lambda generated by op contains a (put-line ...) expression as its body, with @1 and @2 transformed into references to to generated, unique parameter names. #"...": string list literal: contents are broken on whitespace and denote a list of strings #"foo bar" -> ("foo" "bar"). Requires ' quote in front to be quoted literally, and not evaluated as a compound expression applying the argument "bar" to the operator "foo". Yes, there is a #`...` quasi string list for templating over this. nil: the value returned by mapdo after the side effects, printed by the REPL, not part of the output. 0: ordinary integer zero. But endowed with the power of being iterable. Where an iterable thing is required, 0 denotes the whole numbers 0, 1, 2, ... Similarly, 42 denotes 42, 43, ... These are some of the ingredients produced by my one-member research programme into nicer Lisp coding. 2> (map (ret `@1: @2`) '#"how now brown cow" 0) ("how: 0" "now: 1" "brown: 2" "cow: 3") map: take tuples by iterating over argument iterables in parallel, pass them to a function to project each tuple to a value, then return a list of values. ret: cousin of op built on the same framework as op. Used for turning an expression into a lambda, when the expression isn't a compound form with an obvious operator. To turn (foo bar) into a lamdbda with op we use (op foo bar). But what if we have a simple variable x and want (lambda () x)? (op x) is not right, it means (lambda () (x)). (ret x) provides the sugar. Here, it lets us spin up a two-argument function that evaluates a quasistring.

drnick1 2mo ago

Give me the explicit C syntax any day over this monstrosity. I refuse to write anything other than C++98, the last version of C++ that built on C without trying to turn it into a completely different language.

pjmlp 2mo ago
So K&R C it is, nothing of that C23 crazy stuff.

hackthemack 2mo ago

I guess I am officially old and no longer know what the cool "it" is any more. The C++17 example seems much more clear to me. It is more typing, but so what? It is not that much more typing, and it looks like code that people have written for 40 years.

jandrewrogers 2mo ago

As someone who likes and uses modern C++ this seems like a very marginal improvement. I see the use case but it seems rather unimportant.

vianchen 2mo ago

This is not an improvement. In fact it makes the code harder to understand. The way it's written makes people less familiar with this syntax think `int i = 0` and `auto &&it : vec` are two separate statements.

anon291 2mo ago

You can do this right now with an iterator adaptor and some range trickery. The c++ range based for loop already enables the same behavior as python. The only thing missing is a standard enumerate function. This is a Fine addition to c++ due to how c++ uses lifetimes for resource management but the syntax is convoluted and the claim that this is intended to enable enumeration is... Just silly.

v9v 2mo ago

In C with https://github.com/aartaka/pretty.c https://github.com/aartaka/pretty.c, foreach (i, int, 10, vector(10, int, 1, 2, 3, 3, 4, 5)) println(*i);

pjmlp 2mo ago

Even more modern, we are getting C++26 nowadays. CTADs for vector (no need for explicit string), ranges enumeration, and range-based for-loop with structured types int main() { vector vec = { "the", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog" }; for (auto&& [i, it] : vec | std::views::enumerate) println ("{}:{}", ++i, it); } Compiler explorer example, https://cpp.godbolt.org/z/3r8rPdjbG https://cpp.godbolt.org/z/3r8rPdjbG

Bimos 2mo ago
I'm super confused. In your example, ++i is equivalent to (i+1) and the loop updates i itself. But with the syntax in the blogpost, i is only initialized, and it is the ++i that updates the value?
- spider-mario 2mo ago
  Yes. You don’t sound that confused?
- pjmlp 2mo ago
  Copy paste error, too late to update the comment, it should be a plain i.

bjoli 2mo ago

the looping facilities in most languages suck. We are at a position where iteration is either "increment or decrement numbers", or "go through this collection". Everything else means degrading performance. In some languages (Python, ruby) the choice is between the comfortable way to iterate through a collection (for a in xyz:), or the fast way (while). It is just stupid.