Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:

> Tim Rentsch <tr.17687@z991.linuxsc.com> writes:
>
>> Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
>>
>>> Tim Rentsch <tr.17687@z991.linuxsc.com> writes:
>>>
>>>> Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
>>>>
>>>>> [...] I would argue that using `->` rather than `.` when the
>>>>> prefix is a pointer makes for more explicit code, which is a
>>>>> good thing; [...]
>>>>
>>>> More explicit is not always better.
>>>
>>> No, it isn't.
>>>
>>> If you had anything to say about this particular case (`->` being
>>> more explicit than `.`, and whether it's better), this would have
>>> been a good opportunity to say it.
>>
>> In the particular case of using '.' instead of '->', more
>> explicit is not always better.
>
> That's a useless statement.

No more useless than the statement from you that prompted
the discussion.

In article <86wmxx7t7l.fsf@linuxsc.com>,
Tim Rentsch <tr.17687@z991.linuxsc.com> wrote:
....
>> That's a useless statement.
>
>No more useless than the statement from you that prompted
>the discussion.

I love it when CLC regs fight!

--
The randomly chosen signature file that would have appeared here is more than 4
lines long. As such, it violates one or more Usenet RFCs. In order to remain
in compliance with said RFCs, the actual sig can be found at the following URL:
http://user.xmission.com/~gazelle/Sigs/Infallibility

Tim Rentsch <tr.17687@z991.linuxsc.com> writes:
> Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
>> Tim Rentsch <tr.17687@z991.linuxsc.com> writes:
>>> Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
>>>> Tim Rentsch <tr.17687@z991.linuxsc.com> writes:
>>>>> Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
>>>>>> [...] I would argue that using `->` rather than `.` when the
>>>>>> prefix is a pointer makes for more explicit code, which is a
>>>>>> good thing; [...]
>>>>>
>>>>> More explicit is not always better.
>>>>
>>>> No, it isn't.
>>>>
>>>> If you had anything to say about this particular case (`->` being
>>>> more explicit than `.`, and whether it's better), this would have
>>>> been a good opportunity to say it.
>>>
>>> In the particular case of using '.' instead of '->', more
>>> explicit is not always better.
>>
>> That's a useless statement.
>
> No more useless than the statement from you that prompted
> the discussion.

My original statement, quoted above, was that using `->` rather than
`.` is more explicit and that that's a good thing. That was and
is my opinion, applicable only to that particular case. I've used
languages that use `.` for both (where the prefix can be either
a structure or a pointer), and haven't had any particular problem
with that. I have a preference, but not a strong preference.

If I see `foo->bar` in C code, I know that `foo` is a pointer
expression pointing to a struct or union. If I see `foo.bar`, I
know that `foo` is an expression of struct or union type. I know
that without looking for the declaration. I sometimes find it
useful to be able to understand something about a code fragment
without having to understand 100% of the context.

You apparently think that was a useless statement. You apparently
thought it was important enough to comment on it.

You refuted a claim that explicit is *always* better. Of course
I never said that, nor do I believe it.

I tried to invite you to expand on your statement. Perhaps you think
that dropping `->` and using `.` for both structs and pointers (and
unions and union pointers) would have been better. Perhaps you have
good reasons for your preference, assuming it is your preference.
Perhaps an explanation of those preferences would have been useful
and interesting. Heck, I might even agree with you.

Instead, you chose to respond several times, adding exactly nothing
useful to the discussion. Perhaps you expected us to understand
what you were thinking without you saying it. If so, that was an
unrealistic expectation.

Let's stop this.

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Will write code for food.
void Void(void) { Void(); } /* The recursive call of the void */

Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
> Tim Rentsch <tr.17687@z991.linuxsc.com> writes:
>> Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
>>> Tim Rentsch <tr.17687@z991.linuxsc.com> writes:
>>>> Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
>>>>> Tim Rentsch <tr.17687@z991.linuxsc.com> writes:
>>>>>> Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
>>>>>>> [...] I would argue that using `->` rather than `.` when the
>>>>>>> prefix is a pointer makes for more explicit code, which is a
>>>>>>> good thing; [...]
>>>>>>
>>>>>> More explicit is not always better.
>>>>>
>>>>> No, it isn't.
>>>>>
>>>>> If you had anything to say about this particular case (`->` being
>>>>> more explicit than `.`, and whether it's better), this would have
>>>>> been a good opportunity to say it.
>>>>
>>>> In the particular case of using '.' instead of '->', more
>>>> explicit is not always better.
>>>
>>> That's a useless statement.
>>
>> No more useless than the statement from you that prompted
>> the discussion.
>
> My original statement, quoted above, was that using `->` rather than
> `.` is more explicit and that that's a good thing. That was and
> is my opinion, applicable only to that particular case. I've used
> languages that use `.` for both (where the prefix can be either
> a structure or a pointer), and haven't had any particular problem
> with that. I have a preference, but not a strong preference.
>
> If I see `foo->bar` in C code, I know that `foo` is a pointer
> expression pointing to a struct or union. If I see `foo.bar`, I
> know that `foo` is an expression of struct or union type. I know
> that without looking for the declaration. I sometimes find it
> useful to be able to understand something about a code fragment
> without having to understand 100% of the context.
>
> You apparently think that was a useless statement. You apparently
> thought it was important enough to comment on it.
>
> You refuted a claim that explicit is *always* better. Of course
> I never said that, nor do I believe it.
>
> I tried to invite you to expand on your statement. Perhaps you think
> that dropping `->` and using `.` for both structs and pointers (and
> unions and union pointers) would have been better. Perhaps you have
> good reasons for your preference, assuming it is your preference.
> Perhaps an explanation of those preferences would have been useful
> and interesting. Heck, I might even agree with you.

If I see:
foo->x *= 2;
frob(foo);
I don't even twitch. However, if I see:
foo.x *= 2;
frob(foo);
I begin to worry - how much of a structure am I filling the stack with,
or is frob just a harmless macro, or what. I immediately need to know
more.

So I'm definitely in team keep-em-different.

Phil
--
We are no longer hunters and nomads. No longer awed and frightened, as we have
gained some understanding of the world in which we live. As such, we can cast
aside childish remnants from the dawn of our civilization.
-- NotSanguine on SoylentNews, after Eugen Weber in /The Western Tradition/

Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:

> Tim Rentsch <tr.17687@z991.linuxsc.com> writes:
>
>> Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
>>
>>> Tim Rentsch <tr.17687@z991.linuxsc.com> writes:
>>>
>>>> Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
>>>>
>>>>> Tim Rentsch <tr.17687@z991.linuxsc.com> writes:
>>>>>
>>>>>> Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
>>>>>>
>>>>>>> [...] I would argue that using `->` rather than `.` when the
>>>>>>> prefix is a pointer makes for more explicit code, which is a
>>>>>>> good thing; [...]
>>>>>>
>>>>>> More explicit is not always better.
>>>>>
>>>>> No, it isn't.
>>>>>
>>>>> If you had anything to say about this particular case (`->` being
>>>>> more explicit than `.`, and whether it's better), this would have
>>>>> been a good opportunity to say it.
>>>>
>>>> In the particular case of using '.' instead of '->', more
>>>> explicit is not always better.
>>>
>>> That's a useless statement.
>>
>> No more useless than the statement from you that prompted
>> the discussion.
>
> My original statement, quoted above, was that using `->` rather
> than `.` is more explicit and that that's a good thing. That was
> and is my opinion, applicable only to that particular case. I've
> used languages that use `.` for both (where the prefix can be
> either a structure or a pointer), and haven't had any particular
> problem with that. I have a preference, but not a strong
> preference.
>
> If I see `foo->bar` in C code, I know that `foo` is a pointer
> expression pointing to a struct or union. If I see `foo.bar`, I
> know that `foo` is an expression of struct or union type. I know
> that without looking for the declaration. I sometimes find it
> useful to be able to understand something about a code fragment
> without having to understand 100% of the context.
>
> You apparently think that was a useless statement. You apparently
> thought it was important enough to comment on it.

I didn't say your statement was useless. I said only that
my statement is no more useless than yours.

> You refuted a claim that explicit is *always* better. Of course I
> never said that, nor do I believe it.

I was not refuting, nor was I trying to refute, any such claim.
I was merely responding to a statement of your opinion, giving
a statement of my own opinion.

> I tried to invite you to expand on your statement. Perhaps you
> think that dropping `->` and using `.` for both structs and
> pointers (and unions and union pointers) would have been better.
> Perhaps you have good reasons for your preference, assuming it is
> your preference. Perhaps an explanation of those preferences
> would have been useful and interesting. Heck, I might even agree
> with you.

You asked if I had anything to say about this particular case.
I did that.

> Instead, you chose to respond several times,

This statement mischaracterizes my postings. I responded once to
your implicit question about a more specific statement. I
responded later to your one-line posting saying that my response
was a useless statement. In both cases I was responding to what
was said in the immediately previous posting.

> adding exactly
> nothing useful to the discussion. Perhaps you expected us to
> understand what you were thinking without you saying it. If so,
> that was an unrealistic expectation.

It would be good for you to learn that just because you want
something doesn't mean that other people want it.

> Let's stop this.

Feel free to stop at any time. If there are no responses to my
comments here I'm not inclined to continue.