My silliest extention made yet 2008...

[Michael Starberg]

... and it is only January. This might get worse. =)

I really like languages like C#, that has a foreach on IEnumerable<T>.

But sometimes you need to go by index and you have to for-loop.
In C-dervived languages it typically looks like this:

for (int i = 0; i < theList.Count -1 ; i++) { [etc.. etc..] }

I have have always liked 0-based offsets, even if we talk in terms of index.
But for being a index, I have always disliked the -1 part of the code on
Count/Length.

I don't think I am alone when confessing that sometimes you miss that little
minus one, with a index out of bounds exception. A lame reason for a bug and
your program to be flawed.

So I tried creating extentions on IList<T>
Simple function that simply returns Count-1

First up was UpperBound()
for (int i = 0; i < theList.UpperBo und() ; i++) { [etc.. etc..] }

That made it look way tooo much like Visual Basic for me, so no thanks.

In Delphi/Pascal you have pred() and succ() on ordinal types, so you could
(and should) do:
for i := 0 to pred(theList.Co unt) do begin [etc.. etc..] end;

I tried that:
for (int i = 0; i < theList.PredCou nt() ; i++) { [etc.. etc..] }

That made no sense at all, so I tried end:
for (int i = 0; i < theList.End() ; i++) { [etc.. etc..] }

I've tried several combinations of stop and end words and the best I can
come with is .ToEnd()

for (int i = 0; i < theList.ToEnd() ; i++) { [etc.. etc..] }

Any thoughts, except that I should ToEnd even thinking of this? =)

- Michael Starberg

[Jeroen Mostert]

Michael Starberg wrote:

.. and it is only January. This might get worse. =)

There's some inspiring quote about a day without stupid questions being like
a day without Usenet.

Actually, I just made that up, but there ought to be.

I really like languages like C#, that has a foreach on IEnumerable<T>.

But sometimes you need to go by index and you have to for-loop.
In C-dervived languages it typically looks like this:

for (int i = 0; i < theList.Count -1 ; i++) { [etc.. etc..] }

I have have always liked 0-based offsets, even if we talk in terms of index.
But for being a index, I have always disliked the -1 part of the code on
Count/Length.

Probably because it's wrong. Your loop will go from 0 through theList.Count
- 2... You're missing the last element, which is theList.Count - 1. That is,
unless the list is empty. Then your loop will immediately barf on an invalid
index, since 0 is certainly not smaller than -1.

for (int i = 0; i != theList.Count; ++i) { ... }

This is a perfectly natural way of writing things. In fact, there's a reason
people prefer zero-based indexing: it gives you much less opportunity for
off-by-one errors.

I don't think I am alone when confessing that sometimes you miss that little
minus one, with a index out of bounds exception. A lame reason for a bug and
your program to be flawed.

See above... don't write that, then.

Any thoughts, except that I should ToEnd even thinking of this? =)

Zero is the number thou shalt start from, and the number of the starting
shall be zero. One thou shalt not start from, unless thou by counting
apples. Two is right out.

--
J.

[Peter Duniho]

On Thu, 17 Jan 2008 09:59:46 -0800, Michael Starberg
<mi************ *************** @gmail.comwrote :

But sometimes you need to go by index and you have to for-loop.
In C-dervived languages it typically looks like this:

for (int i = 0; i < theList.Count -1 ; i++) { [etc.. etc..] }

I have have always liked 0-based offsets, even if we talk in terms of
index.
But for being a index, I have always disliked the -1 part of the code on
Count/Length.

I have no idea what you're talking about. If you want to enumerate every
element in the list, by index, and the condition is "<" instead of "<="
(which is typical), you need "theList.Count" , not "theList.Co unt - 1".

The code you posted is going to miss the last element.

Pete

[Rudy Velthuis]

Michael Starberg wrote:

for (int i = 0; i < theList.Count -1 ; i++) { [etc.. etc..] }

I have have always liked 0-based offsets, even if we talk in terms of
index. But for being a index, I have always disliked the -1 part of
the code on Count/Length.

Huh? In C#, you don't use -1 at all (you must be confusing it with a
Delphi for loop):

for (int i = 0; i < theList.Count; ++i)

Note that the second is a while condition, IOW:

for (A; B; C)
{
D;
}

is equivalent to:

A;
while (B)
{
D;
C;
}

--
Rudy Velthuis http://rvelthuis.de

"A lie gets halfway around the world before the truth has a
chance to get its pants on."
-- Sir Winston Churchill (1874-1965)

[Michael Starberg]

"Jeroen Mostert" <jm******@xs4al l.nlwrote in message
news:47******** *************** @news.xs4all.nl ...

Michael Starberg wrote:

Actually, I just made that up, but there ought to be.

I will do my best =)

Zero is the number thou shalt start from, and the number of the starting
shall be zero. One thou shalt not start from, unless thou by counting
apples. Two is right out.

Does that works on cute mammals with sharp teath, garding a cave?

I like this quote:

Should array indices start at 0 or 1? My compromise of 0.5 was rejected
without, I thought, proper consideration. (Stan Kelly-Bootle)

[Michael Starberg]

"Peter Duniho" <Np*********@nn owslpianmk.comw rote in message
news:op******** *******@petes-computer.local. ..
On Thu, 17 Jan 2008 09:59:46 -0800, Michael Starberg
<mi************ *************** @gmail.comwrote :

>I have no idea what you're talking about. The code you posted is going to
miss the last element.

>Pete

Glad you noticed. The whole thread is like a joke, or just a way to get some
input.
But you get the gold-medal for spotting the problem.

Maybe some future maintainer would see the ToEnd, write the loop with i <
myList.ToEnd(), and then miss two elements.

My post was to show that there is always a problem with for-loops and why
foreach is better. =)

- Michael Starberg

[Michael Starberg]

"Rudy Velthuis" <ne********@rve lthuis.dewrote in message
news:xn******** ********@news.m icrosoft.com...

Michael Starberg wrote:

Thanks dentist! =)

- Michael Starberg

[Peter Duniho]

On Thu, 17 Jan 2008 10:59:22 -0800, Michael Starberg
<mi************ *************** @gmail.comwrote :

[...]
My post was to show that there is always a problem with for-loops and why
foreach is better. =)

So, when will you actually show that? We await with bated breath...

Pete

[Jon Skeet [C# MVP]]

Michael Starberg <mi************ *************** @gmail.comwrote :

.. and it is only January. This might get worse. =)

I really like languages like C#, that has a foreach on IEnumerable<T>.

But sometimes you need to go by index and you have to for-loop.

I realise this thread is a joke, but you could easily write an
extension method of:

public static void ForEach<T>(this IEnumerable<Tso urce,
Action<T,intact ion)
{
int index=0;
foreach (T t in source)
{
action (t, index++);
}
}

Then call it with:

theList.ForEach ((value, index) =>
{
Console.WriteLi ne ("The value at index {0} is {1}",
index, value);
});

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
World class .NET training in the UK: http://iterativetraining.co.uk

[Michael Starberg]

"Peter Duniho" <Np*********@nn owslpianmk.comw rote in message
news:op******** *******@petes-computer.local. ..
On Thu, 17 Jan 2008 10:59:22 -0800, Michael Starberg
<mi************ *************** @gmail.comwrote :

>[...]
My post was to show that there is always a problem with for-loops and why
foreach is better. =)

>So, when will you actually show that? We await with bated breath...

>Pete

Then you have to wait long, Pete.
I don't start silly threads and then explain myself.
I just had fun doing some extentions, no harm done.

- Michael Starberg