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.
1> (mapdo (op put-line `@1: @2`) '#"how now brown cow" 0)
how: 0
now: 1
brown: 2
cow: 3
nil
mapdo: map for side effects of calling the function, not calculating a result, like map.
op: produce a lambda function out of an expression in which @1, @2, ... explicitly indicate the insertion of positional arguments, which are then implicitly bestowed onto the generated lambda.
`...`: quasistring syntax: supports @ notations for interpolating. @1, @2 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.
#"...": 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.
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, ...
These are some of the ingredients in my one-member research programme into nicer Lisp coding.
> 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.
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.
> 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
No, the increment is necessary to keep the counter going. The choice of pre-increment versus post-increment handles the "start at 1" issue you mentioned, but it isn't auto incrementing.
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.
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.
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
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.
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.
This is at least a bit more pythonic:
op: produce a lambda function out of an expression in which @1, @2, ... explicitly indicate the insertion of positional arguments, which are then implicitly bestowed onto the generated lambda.
`...`: quasistring syntax: supports @ notations for interpolating. @1, @2 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.
#"...": 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.
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, ...
These are some of the ingredients in my one-member research programme into nicer Lisp coding.
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);
This can’t be further from truth. C++ is essentially Frankenstein’s monster.
If anything it is more of a Chimera
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
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/p06...
> 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.
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 Search for "do not use" and you'll find plenty of hits.
here you go: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines
Reminds me of Good Parts, Bad Parts meme of JS.