Re: question about linker

On Sat, 30 Nov 2024 09:54:30 -0800
Tim Rentsch <tr.17687@z991.linuxsc.com> wrote:

Michael S <already5chosen@yahoo.com> writes:
 

IMHO, any way to mix more than one 'modifier' (not in C standard
meaning of the word, but in more general meaning) is potentially
confusing.  It does not matter whether modifier is 'const' or '*'
or [] or (). 

 
It surprises me that you would say this.  Certainly there are type
forms that might be difficult to absorb (e.g., 'float *********')
but that doesn't mean they are necessarily confusing.  There are two
obvious ways to write type forms that are easy to decode.  One way
is to write any derivings right-to-left:
 
   [] * (double,double) * float
 
which can be read directly as "array of pointer to function that
returns a pointer to float", and the other way is simply the reversal
of that:
 
   float * (double,double) * []
 
which can be read right-to-left the same way.  The constructors for
derived types (pointer, array, function) act like nouns.  Qualifiers
such as const or volatile act like adjectives and always go to the
left of the noun they modify, so for example
 
   [] volatile* float
 
is an array of volatile pointer to float, or in the other ordering
 
   float volatile* []
 
which is simply a reversal of noun phrases, with any modifying
adjectives staying on the left side of the noun they modify.
 

That's nice. It's a pity it will never be adapted in C.

The syntax used in C is harder to read for two reasons:  one, the
ordering of derivations is both left-to-right and right-to-left,
depending on what derivation is being applied;  and two, any
identifier being declared goes in the middle of the type rather
than at one of the ends.  Both of those confusions can be removed
simply by using a consistent ordering, either left-to-right or
right-to-left (with qualifying adjectives always on the left of
the noun they modify).
 
Note that both of the consistent orderings correspond directly to a
natural English wording, which accounts for them being easier to
comprehend than C-style type forms.  (I conjecture that some foreign
languages might not have that property, but since I am for the most
part ignorant of essentially all natural languages other than
English I have no more to say about that.)

As you can see, in a reply to my post Bart already suggested that the
problematic part is not a chain itself, but mixture of terms that has
to be read left-to-right with those has to be read right-to-left.
You can also see that I already mostly agreed with him.
Mostly rather than completely, because I think that when a single
declaration has more than half a dozen terms it is difficult to
understand even when it does not change direction in the middle.

But my main disagreement with Bart was orthogonal to this discussion.
It was about 'const' not being any harder to understand than other
"right-to-left' type modifiers.