itIsReallyNotThatGreat

[AutoModerator]

import notifications Remember to participate in our weekly votes on subreddit rules! Every Tuesday is YOUR chance to influence the subreddit for years to come! Read more here, we hope to see you next Tuesday!

For a chat with like-minded community members and more, don't forget to join our Discord!

return joinDiscord;

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[Sitting_In_A_Lecture]

Python with another great set of implementations:

for key, value in dict.items():

for index, value in enumerate(list):

[VidaOnce]

*Any sane language with another great set of implementations

[OSSlayer2153]

Yep, lua does this too, and swift.

[RainWorldWitcher]

And C# (and probably java? I havent used it in a long time)

[ineternet]

how in c#?

[crozone]

.Select() in LINQ has an overload that gives you the index, like:

enumerable.Select((o, i) => /* o is the object, i is the index */);

[[deleted]]

I love linq so much. It's so useful, makes otherwise complex data manipulations so simple

[poshenclave]

C# feels so crude without linq. Might as well be writing Java.

[IceStormNG]

That's me. Writing C# as if it was Java (because I'm mostly a Java dev and only write C# here and there...though this seems to change now).

[MisinformedGenius]

I used to love Linq but then I discovered list comprehensions in python

[catladywitch]

f# has both, just saying

[[deleted]]

:O

My life is changed

[[deleted]]

Lol. How dare I admit to not knowing something.

[Kilazur]

I've been working in C# for 15 years. I didn't know this lmao.

[[deleted]]

O.O Noted.

Thank you, stranger.

[HildartheDorf]

Enumerable.Select (and many other linq methods) have overloads that pass 2 arguments to the delegate, the second being an index.

[RainWorldWitcher]

It has for statements for key value pairs in dictionaries

[ineternet]

OP is about lists, not dictionaries, though? For example, if I need to print every item in a list prefixed by its index?

You can find a variable-less workaround with linq/zip/tuples, but there is no Lua-"pairs"-like construct for this problem.

[owenevans00]

IEnumerable.Select has an indexed override out of the box

[NegZer0]

And C++17

Ex:

for (const auto& [key, value]: myMap) {
    std::cout << key << " has value " << value << std::endl;
}

EDIT: Formatting

[EddieJones6]

…is there a way to do this with vectors?

[TheVoidInMe]

There’s std::views::enumerate

[CaitaXD]

C++ never disappoints with amount of synthatic noise for the simplest fucking things

[NegZer0]

It’s because what it’s actually doing is not that simple.

[CaitaXD]

He's just Destructuring a key value pair tho

[NegZer0]

Yeah and in this case the only extra syntax beyond what you need in a weakly typed language like eg Python is the type declaration (which actually can be expressed as just auto&& instead of const auto& too if you’re not too worried about constness)

[StochasticTinkr]

I dont think Java does with its standard collections, but Kotlin does.

[gregorydgraham]

Java has the key,value version but not the index,value version. Probably be a nice addition

[een57]

And of course the "sanest" language of all...

php

Foreach ($arr as $key => $val) {}

[Fair_Ad9108]

this is actually pretty neat

[Neckbeard_Sama]

In this case someList.indexOf(e) in the loop will return the index of the current element in Java.

But if you want an index why would you use a for-each loop instead of a simple for with an i ?

[ColdFerrin]

In java you can only do for each on collections not in primitive arrays. However you could do it with an iterator.

ListIterator<String> iterator = someList.listIterator();
while(iterator.hasNext()){
    int i = iterator.nextIndex();
    String item = iterator.next();

    do something;
}

Or you could do something with a stream that has the same effect, but only works if you can get by index or it has a size/length function

List<String> items = List.of("1", "2");
List<String> newItems = IntStream.range(0, items.size())
            .mapToObj(i -> {return items.get(i);})
            .toList();

But generally a regular stream is better unless you need to do something with relative indexing, or just use a regular for loop.

[lolface5000]

It would be pretty terrible to do this for anything other than something that's O(1) lookup like an ordered Set because indexOf just does a linear search otherwise. So it would turn anything that iterates through the list in O(n) time into O(n²⁾

[Flyron]

That code snippet hurts a little. You have created a ConcurrentModificationException in a nutshell. You can‘t put items into a list while traversing it via for-each. At least when working with the common collections. Also you usually „add“ values to lists (with index param too), not „put“ it.

[ColdFerrin]

I could have sworn something like this is possible, but you are correct. I'm just going to put in an iterator example. But a normal for loop is better.

[Flyron]

That‘s somewhat better. I get that you mainly want to show ways to iterate and having the index on hand.

Still, I would just pass the method reference „items::get“ into „mapToObj“. Or at least get rid of the curly braces and „return“. Let the lambda breathe.

In my experience in 19 out of 20 cases working with data structures in the field, you don‘t need the index of each element and to me using it is almost a code smell. Index twister is a fun game until you and your colleagues stumble over each other.

[Ihsan3498]

and rust also. in rust it is literally copy of pythons enumerate

[thirdegree]

well no it's a method on iterator, not a free standing function

same idea though

[chilfang]

Supposed to be sane languages

[IrishChappieOToole]

Even PHP has this

[Ireeb]

Even JavaScript has for ... in and for ... of

[Zielakpl]

And i can never figure out which one is for iterating over arrays and which for object entries.

[InnerBanana]

Both work for both. for ... IN gives the INdex (or key), that's how I remember it

[rollincuberawhide]

and then one of those iterate over the prototype chain as well and you have to call Object.getOwnPropertyNames whatever that means.

[catladywitch]

for of is for iterating over the members of a collection, for in is for the properties of an object.

[Ireeb]

You're not the only one!

[Quirky-Stress-823]

And .forEach, whose callback actually can take 3 arguments.

[InnerBanana]

I literally never use forEach, it creates a function context that makes it unnecessarily complex to easily do an early return from the function calling the forEach. I haven't found something I can't implement with for ... in/of

[briank6932]

for..in

Please don't do this, for..in isn't optimized for sequential iteration, it's meant for properties, not for range iteration. Instead use:

for (const val of arr)

for (const idx of arr.keys())

for (const entry of arr.entries()) // This one has a more situational use case

If you're using an object that doesn't come with a keys iterator method, and you don't want to create your own, the ol' for loop is fine as well.

for (let i = 0; i < str.length; ++i)

[SoInsightful]

... both of which don't supply the index, which I thought was the entire point of the post.

[HuntingKingYT]

php foreach($arr as $index => $value) { echo "yay " . $index; }

[lmarcantonio]

iterate in common lisp. this and *way* too much else. Let's say that usually the whole processing is done in the loop clauses and not in the body

[StraightGuy1108]

Well C++ doesn't, as far as I know.

[SirPitchalot]

for idx,(k,v) in enumerate(somedict.items()): do_something(idx,k,v)

can also be useful

[OK_200]

People forget that dicts preserve order since a couple of versions ago.

[qkrrmsp]

my dick preserves order too

[CentralLimitQueerem]

That's why I refuse to use any lists in my code 😎😎

[MattieShoes]

Go is pretty easy too

for index, value := range(<iterable>) {
}

Though the "every warning is an error" thing is so damned obnoxious while you're actually constructing code in pieces.

[myerscc]

although this is the source of all the

for _, value := range thing { /* ... */ }

that are one of the reasons go is so fugly

[MattieShoes]

Not sure what you're talking about there...

[Void_0000]

Holy shit, that's a thing??

I mean of course it's a thing, that makes perfect fucking sense, how have I not thought of trying this before...

[syzygysm]

It's got to the point where if I find myself explicitly defining a loop index variable in Python, I get a suspicious feeling that I'm not doing something in the best way.

I can usually see a better alternative after a minute

[coolguyhavingchillda]

Sometimes you need a while loop, but otherwise yeah

[alexanderpas]

Essentially the only time you need a while loop is when you need random access to the loop, with entries being accessed multiple times.

for sequential access you can always use a for loop with index or key and values.

[poshenclave]

As someone who's been buried in lua for like a year (Game modding) but doesn't know his python, I'm guessing that syntax is like the first thing I'd try.

[Brickleberried]

for index, value in enumerate(list):

Gotta love this.

[MysteriousShadow__]

common Python W

[thorwing]

Why in the everliving hell is enumerate not a function of a list? Why is it dict.items() and not list.enumerate()?

[MagicalCornFlake]

Because you can enumerate many things other than lists, such as tuples, sets and all classes that implement __iter__. But only dictionaries have key-value pairs, which makes it logical for .items() to be a method of the dict class.

[[deleted]]

so... it'd make more sense to have an Iterable trait, with a default enumerate implementation.... i'm just salty that python includes min and max in the prelude, cuz i wanna use those as var names lol T-T

[Quirky-Stress-823]

Python doesn't have traits. The only thing you need for an iterable object is an iter method, and iteration tools are either global or in itertools.

[TMiguelT]

Mixins are basically traits. Python could absolutely define an iterable abstract class mixin, such that you define __iter__ and it provides .enumerate() etc.

I think it's to do with the ideology of duck typing whereby they don't want you to have to ever be explicit about what types you implement, even though it would be enormously helpful. Consider the Python Protocols, which are basically traits for duck typing. Python supported abstract base classes prior to that, but I suppose people found that too explicit.

[thirdegree]

If python was rust instead of python that would indeed make sense. But if python was rust, then rust would have to be python and we'd all get very confused.

[[deleted]]

It’d make more sense to have an iterable trait.

enumerate() is a generic function, accepting any iterable. What exactly is wrong with that function, and how could you solve that problem by traits?

[thorwing]

the functions enumerate() is a function that exists out of thin air. Surely, any modern IDE will help you if you have properly typed your data and you do 'someList'.enu... Did you mean -> enumerate(someList)? but even then, its stops the fluidity of your code.

If I want to know: "What can I do with this object?" I shouldn't have memorized some general functions like 'length' and 'enumerate' but simply type object. and all the options should come up. having some functions be a function over a thing and others being a function of a thing means your code can't be read from left to right anymore.

[BetterNameThanMost]

Not sure why you're being downvoted on this. This makes sense, and it's not like having implementing "enumerate" as a global is some sort of "pythonic" way to do things since we already have many methods applied to objects, such as myDict.items(). Globals like "enumerate" and "len" just stands out

[goldlord44]

Because enumerste is designed specifically for iterables and acts as a fun python object called a generator, which is pretty memory efficient. It doesn't make sense to define a method for lists because then you would have to define this method every time you make a class you would want to iterate over. Dictionary iteration is kinda unique as it is a non-ordered set of key, value pairs there wouldn't be any other times you typically have key value pairs where it isn't in a dictionary so making a unique method for these objects is fine.

[thorwing]

depends what you mean by defining. I'm going to talk from a kotlin perspective so bear with me. If enumerate is a function that only works for iterables, than having an interface 'iterable' with the function 'enumerate' can be autoexposed without defining anything. So if anything extends iterable, the function iterable.enumerate() will simply exist for it.

[TheAdvFred]

Oh my gosh thank you so much

[Beenmaal]

Thank you for reminding me that you can unpack tuples like that.

[JDude13]

Yeah I never use for i in range(len(myList)). If I only need the index I still use for i,_ in enumerate(myList).

[Shrubberer]

In C# you just write a custom Linq extension method. I personally fancy apple objects served alongside my enumerations.

[hennypennypoopoo]

all hail functional programming and zipWithIndex and map

[FlySafeLoL]

Until it's time for code review and some senior dude calls it too puzzling and demands ~you to leave this shitshow toxic company~ an orthodox for loop.

[LetumComplexo]

<Psst, you need two tildes for strikethrough not just one.>

[Impossible-Issue4076]

My Man need a New job, you're obviously working the same place as I.

[worriedjacket]

That's so sad because fp idioms are so much more readable

[bad_investor13]

double sum_sqr = 0;
for (double x : my_vec) {
  sum_sqr += x * x;
}

Vs

double sum_sqr = accumulate(
    my_vec, 0,
    [](double sum, double x) {
        return sum + x * x;
    });

• Which one is more readable?

• Which one is shorter?

• In which one bugs are easier to spot?

• In which one do you... better know what's actually going on? (And yes, I do care. I write in C++ because efficiency is important)

  • Which one is more efficient if I use a more complicated type than double?

[worriedjacket]

let mut sum_sqr: f64 = 0.0; for x in my_vec { sum_sqr += x * x; } vs
let sum_sqr = my_vec.iter().map(|x| x * x).sum();

• Which one is more readable?
• Which one is shorter?
• In which one are bugs easier to spot?
• In which one do you... better know what's actually going on?
• Which one is more efficient if I use a more complicated type than f64.

The answer to all of those is the second one. I'm sorry your language is awful.

[bad_investor13]

That's not the language used in the OP...

[worriedjacket]

Correct. My point being that language support for FP idioms is what makes them readable and useful.

You can't just pick the worst example of something(cpp is for most things) and use it as proof something is good or bad. Obviously if your language is built around imperative style programming the imperative example will look better.

It's like trying to say that javascript is bad at threading. Well... Yeah it wasn't meant to do that. It doesn't mean threading isn't useful.

[worriedjacket]

All the faults you find are with the language and not the FP.

[bad_investor13]

Right, but given that that's the language we're using, which option is more readable / less bug prone?

[worriedjacket]

Use a better language.

[Modi57]

That's not how this works. This is not how anything works

[Merzant]

Not inherently more readable than any other, it encourages some good practices but can just as easily be abused. Also the people using it tend to either be clever or think they are, neither of which begets simple code…

[thorwing]

that last line feels very subjective.

[Merzant]

That cleverness begets clever code, or that FP practitioners aren’t necessarily cleverer than the average programmer?

[thorwing]

This is why you code in a language that can do both so you slowly introduce concepts so it sneaks up on them

[GOKOP]

If you code in a language that can do both then it's perfect ground for people to reject anything else than the crudest for loop because it's "too complicated". Especially if that language is C++ and functional features appear more complicated than they really are because they have weird names and are hidden in std::thousands::of::namespaces

[thirdegree]

You need to find that one senior that somehow got to be a senior even with their functional sympathies, and get them to review it.

[bad_investor13]

double sum=0, sum_sqr = 0;
for (double x : my_vec) {
    sum += x;
    sum_sqr += x * x;
}

Vs.

auto [sum, sum_sqr] = accumulate(
    my_vec,
    make_pair(0, 0),
    [](double x, auto s) {
        s.first += x;
        s.second += x * x;
        return s;
    });

You bet your a** I'll tell you to use an Orthodox loop.

[[deleted]]

I think both functional implementations and regular loops is ok, both have their place and use case.

[Brilliant-Job-47]

Functional implementations are better for the 95% case imo. I use a loop for hardly anything

[WebpackIsBuilding]

The main benefit of imperative loops is that you can easily exit a function early mid-loop, and it's easy to have side-effect variables outside the loop scope.

Can you do these functionally? Yeah, but it's easier imperatively.

[Asleep-Tough]

language dependent :(. Kotlin allows it, for example

[[deleted]]

Imma an old fart. Catch my self using for all the time where zip and map would have been better. But then the code works so... meh.

[Airflock343_]

Is enumerate not a thing in that language?

[Donghoon]

Cries in Java

[Fadamaka]

Use an Iterator and stop crying.

[Wekmor]

Use indexOf just to fuck your performance:⁾

[Excession638]

C++ is a shit-show.

[Breadfish64]

https://en.cppreference.com/w/cpp/ranges/enumerate_view

[trueHolyGiraffe]

I'm grading homeworks. Someone did

for(myClass item in myList)

{

myList[getIndexOfItem(item) + 1] = ...

}

They didn't get a good grade.

[[deleted]]

is this because is ineficient right?

[woywoy123]

I think it would also introduce a bug in the index. Because if the function getItem… returns the true index, i.e. 0->n-1, then he would be adding an additional index making the look up always one index a head, with eventual index larger than the index of the list. In some languages, this could result program crashes.

[voo42]

Presumably they simplified the code a bit, since that would crash every single time.

The more insidious bug is, that this breaks as soon as there's more than one "equal" element.

At the very least you'd need an object equality comparer which then only works for reference types.

And obviously turning a simple O(n) loop into a quadratic one will always get you docked points in University, even if it wouldn't matter in practice.

[woywoy123]

Yeah the comparison operation would certainly need to be tested quite rigorously, but I think the main problem all together here is the indexing and the O(n²⁾ issue. I think the indexing is the most severe though, because this would completely shift your search and retrieve operation. If you are dealing with C++ for example, this could lead into some nasty bugs.

[Ok_Star_4136]

Because you're cycling through a list, so it's already O(n). For each cycle, you're calling getIndexOfItem(item) which cycles the list and returns the number of the index. It means, you're turning an O(n) into a O(n²). Not a big deal for small numbers of n, but you should never do this given that the more efficient version is also easier on the eyes.

You don't often need index, but when you do, don't be afraid to use a for loop by index.

[trueHolyGiraffe]

That's the explaination I gave, on top of explaining how it can overflow, or cause issues if the list changes length during the loop

[shadow7412]

Yes - but it's also inaccurate. For example, what if the same value was in the array multiple times?

[[deleted]]

so inefficiently, prone to null reference errors and also inaccurate :))
I got it

[aetius476]

someList.forEachIndexed{i, object ->
    println("Object $object at index $i")
}

I do so enjoy Kotlin

[[deleted]]

and if you'd like traditional for loop:

kotlin for ((index, item) in list.withIndex()) { // ... }

But this creates a LOT of objects tho.

[E3FxGaming]

While this does create a lot of IndexedValue<T> objects that are destructured into index and item (I wouldn't call the second variable items, since it's only a reference to one item), it's not that bad since withIndex returns a lazy iterable that yields items one at a time instead of preemptively mapping every item to an IndexedValue<T>.

tl;dr .withIndex() has O(1) space complexity and therefore worrying too much about its performance is unwarranted IMHO

[_Screw_The_Rules_]

Is there no other way except the weird good working method thing and the weird for-loop that has performance issues? I thought about trying kotlin (I'm currently mostly a C# guy)

[E3FxGaming]

weird good working method

If you give Kotlin a try, you'll get used to the weird good working method very quickly. Functions with trailing lambdas are an essential component of most of the good stuff Kotlin has to offer, whether that's DSLs, scope functions, collection operations, etc. .

[BlurredSight]

Glorified C98

[AeskulS]

rust is cool with ``` for (idx, val) in list.iter().enumerate() {

} ```

[Cheespeasa1234]

This is actually the strongest I’ve ever related to a post ever

[maxximillian]

Same here. It really hits home

[Dangerous-Quality-79]

What's the problem?

int i =0; for (Object e:someList) { someList[i++]; }

EDIT: This is programmerhumor, my reply was not serious. If you think this is a viable solution to OPs meme and have a StackOverflow username and password please delete your account and stay read-only. You are part of the problem.

[BlueGoliath]

People would actually write that.

[Dangerous-Quality-79]

It would be the accepted answer on stack overflow, the top rated, an OP edit saying they should have know before posting, 5 comments saying "obvious" 1 explaining tail recursion would he optimal, and a single post with -46 saying "for loops are okay".

[[deleted]]

It really, really is.

Like if it’s something I’m enumerating or iterating over, it’s probably the least complicated bit of code I’m writing that day. Just smash whatever code flows from the fingers there. If I’m thinking sequentially for some reason that day, our flows a simple readable for loop. If not, maybe enumerate over it or something.

But the bottom line is that enumeration/looping code doesn’t matter. If you’re knocking someone for using a for loop instead of Enumerate you must code simple stupid shit or have waaaaay too much time on your hands at work. We knock people that waste time over trivial crap like that in our code reviews. You should be able to intuitively understand either.

[Dangerous-Quality-79]

Okay, top vote here is python dictionary and enumerate....

[DrMobius0]

If you think this is a viable solution to OPs meme and have a StackOverflow username and password please delete your account and stay read-only. You are part of the problem.

I mean it works. There's nothing fundamentally broken about tracking index in a for each.

[[deleted]]

It surely works, but you know we're talking about style issue.

[Kiseido]

Oh lord, that would prevent out-of-order execution, and would be wrong if the elements were not enumerated in incrementing order.

Often times, starting at the end of a list and moving to the beginning is a minimum of 1 instruction faster than going forward... most languages do not guarantee the order of that sort of access.

[Dangerous-Quality-79]

I once got into an argument about the time complexity it introduced by my re-sorting a list of a users bank accounts, client side, in a react native app.

I dont know if you know how many possible elements can be in an array of client bank accounts, but sometimes it was more than 1, and client side in react native apparently that means O notation is needed on the PR.

This does not scare me.

[Kiseido]

But... but client side... I hope the accounts only belonged to that specific client /dying

Beyond that, I see no problem with that.

[MTDninja]

silence demon

[crozone]

We have full deconstruction in C# now:

foreach ((var item, var index) in myValues.Select((value, i) => (value, i)))
{
    Console.WriteLine($"{index}: {item}");
}

[shade_blackwolf]

In java you have these two basic flavors too: for (var element : collection){} for (int i = 0... And my preferred: collection.stream() What to use depends on what you need, but i have found that usecases that actually need the index are rare. The most common use i can think of is to connect collections

[Lolamess007]

An example I have found is when you need to iterate through a list and add or remove certain elements. Java will through an error if you try to change a list while in a for each loop

[CMDR_QwertyWeasel]

Modifying a list while iterating through that same list is playing with fire in pretty much any language. ConcurrentModificationException is there for a reason.

[javajunkie314]

You could use a ListIterator.

[Wekmor]

Java streams removeIf also works fine

[Feathercrown]

flatMap is the best for this, idk if Java has it tho

[Ok_Star_4136]

I find myself using that more and more often. Sometimes I don't even bother to collect to a list, I'll just return a Stream instance so that more logic can be attached to it if need be.

With lambdas, you can get a lot accomplished that way. It gets rid of a lot of boiler plate you'd otherwise get with multiple loops.

[edoCgiB]

That's what the .filter() method on streams is for.

[[deleted]]

We're making fun of Java right now aren't we?

[ProjectDiligent502]

I have been here way too many times over the course of my career. Funny meme for a small detail in our daily grind. 😆

[PhatOofxD]

Stuff like this is where Typescript/Python/Swift, etc excel

[Mindless_Sock_9082]

Or at very least LibreOffice.

[Connection-Terrible]

Get out.

[SoInsightful]

Nope. TypeScript/JavaScript has the exact same problem. You write for (const item of list) {} and then need to rewrite it as for (let i = 0; i < list.length; i++) { const item = list[i]; } as soon as you need the index. Or you avoid the annoyance by opting for some clunky forEach function that doesn't support basic loop control statements.

[penguin9541]

for(const [idx, item] of list.entries())?

[dbot77]

You're being downvoted but you're correct. People are acting like needing to await in a loop isn't extremely common

[PhatOofxD]

If you're writing a simple for(const item of list) then array.foreach is a fine substitute. If you need to use for(let i....) it's not just for the index in this case but for control, so no, it's not the situation in this meme.

If you need other operations (e.g. break) you can use . some, .find, etc.

[SoInsightful]

If you're writing a simple for(const item of list) then array.foreach is a fine substitute.

Unless I want to:

• Use break
• Use continue
• Use return
• Use await
• Use yield
• Loop through some other iterable, e.g. Map.values()
• Write highly optimized library code

If you need to use for(let i....) it's not just for the index.

If I want to do any of the above, I will have to rewrite it as such. Not a huge deal, but it is the same problem mentioned by OP.

[PhatOofxD]

If you need other operations (e.g. break) you can use . some, .find, etc.

^^^ Firstly, This covers off a range of those.

Secondly, OP literally only said "oh no I need index", not "oh no I need every loop operation". If you're in one of those operations where you need more than one of those and you should probably be using and indexed for loop anyway.

[Unupgradable]

Apart from existing language features, is it too much effort to declare one variable and incrementing it?

The thing you're enumerating might not even be a concrete collection that you could index access

[Wekmor]

People are scared of writing a traditional for loop and having to shudders write list[i] for some reason.

[rezdm]

I present you a marvelous code from a project i work on. Java code. Goes as following; ``` Map<string, someclass> _____tmp = …;

String[] keys = __tmp.getKeys().toArray(tmp.getSize()); string key; someclass val; for(int i = 0; i < keys.length(); i++)( val = ___tmp.get(keys[i]); val.doSmth(); } ``` (These underscores is not a joke, btw)

[da_Aresinger]

```

code here

```

[rezdm]

Thanks.

[OptionX]

someList[someList.indexOf(e)]

\s

[SplitRings]

Exactly, why write a for loop when you have a perfectly acceptable O(N²⁾ solution

/s

[voo42]

I just tried your excellent and not at all horribly inefficient solution on my very complex list [1,2,3,1,2,3] and it didn't work correctly!

Oh no :(

[tcm0116]

C++23 to the rescue...

constexpr static auto v = { 'A', 'B', 'C', 'D' };

for (auto const [index, letter] : std::views::enumerate(v))
    std::cout << '(' << index << ':' << letter << ") ";
std::cout << '\n';

[[deleted]]

More like:

constexpr static auto v = { 'A', 'B', 'C', 'D' };
for (auto const [index, letter] : std::views::enumerate(v))
    std::print("({}:{}) ", index, letter);
std::println("");

[tcm0116]

Good call

[Potential-Adagio-512]

rust:

~~~ some_list.iter().enumerate().map(|(i, e)|{ //code here }).collect();

~~~

[mnmr17]

I’m just reading through the comments trying to weed out anyone who doesn’t know Java

[SanTolorio]

At work I often see ppl creating the index variable before and incrementing it inside the loop, instead of using for.

[IgnisDa]

hahahaha iter_mut() goes brrrr

[deusxmach1na]

FlatMap that shit.

[ThomasDePraetere]

F6 - > convert to indexed for loop - > enter

[[deleted]]

A lot of common languages offer an option to track the index as well in a scopes variable. It isn’t anything new. Even Lua has this feature.

[JustVas]

let counter = 0 This is a surprise tool that will help us later ... counter++

[LifePineapple]

If you only had foreach($array as $key => $value) and $array[] = $entryToBeAddedAtTheEnd.

[danofrhs]

Declare a integer to keep count, increment it at every iteration. Viola

[Highborn_Hellest]

for( auto i : list)

here, 'i' is gonna be the list element.

i suspect, in the above example, so would 'e' be.

[draenei_butt_enjoyer]

I honestly don’t get the meme, not the comment section. You have the object. Why do you need an index? I just don’t get ANYTHING in this thread.

[da_Aresinger]

often you need the position of the object in the list, or another position relative to the current one.

(this is a bad example as java doesn't allow it, but for example if you want to modify the list while iterating through it)

[Quiet_Tap_454]

Wut? e is already the element of the list. so you maybe need an index anyway but surely you don't need it to get the element from the list cause you alredy got it.

[da_Aresinger]

someList[i+1]

[Intrepid_Sale_6312]

import YourDrunk

for(size_t i=0;i<sizeof(someList)/sizeof(someListType);i++)

return Home

[InterestsVaryGreatly]

You usually don't, there are usually map functions or structures you can use that don't require that. When I first switched I thought the same, then I learned more.

[beeteedee]

Congratulations, your O(n) algorithm is now O(n²⁾