Re: Top 10 most common hard skills listed on resumes...

Bart <bc@freeuk.com> wrote:

On 10/09/2024 15:24, Ben Bacarisse wrote:

Bart <bc@freeuk.com> writes:
I don't know if you were deliberately twisting the term because you are
now 100% committed to some false symmetry in assignments, or whether you
are just very loose in your use of terms, but rvalue expressions (C does
not really use the term, but it's better than non-lvalue expressions)
can't have "references" to them.  That was all that Waldek Hebisch was
saying.  Did you think for a second that he did not know that if you put
an int value into an object you can take the pointer to that object?

 
He took the symmetry I was claiming for assignment, and created an
asymmetric counter-example where the dereferencing part of the LHS was
moved into a function, necessitating the creation of a discrete
reference for the LHS.
 
I created a counter-counter-example where dereferences on both sides
were moved into the function, so restoring the symmetry.

Really not.  My point was about conceptual model and important
part is to keep such model simple.  You used complex language
construct which defeats the purose of conceptual model.
 

And yes I'm still committed to that symmetry. I'ved used it for
countless language implementations. C is little different other than it
has a 700-page standard that suggests a recommended model of how it's
supposed to work.
 
You can't really use that to bash me about the head with and maintain
that all my ideas about language implementation are wrong because C
views assignment in its own idiosyncratic manner.

Well, gcc implements assignment in similar way to you (or at least
did that in the past, I have not checked if recent version do the
same).  To be more precise, gcc parser when seeing a variable
creates read reference to this variable.  When parser realizes that
already recognized part of expression is the left hand side of an
assignment it converts it to write access.  So your approach is
no worse than gcc.  But it creates troubles, process of changing
subexpression with read references into write access is more
complicated than replacing read instruction by write instruction.
One, they need to recognize things which are invalid.  Second,
from the very beginning gcc transforms its intermediate representation.
But some transforms valid on right hand side are invalid on the
left hand side, so gcc needs to postpone them and do later.
Third, intermdiate form contains extra information and that
needs to be handled later.

So your (and gcc) approach is: "let us pretend that assigment
operator is symmetric and fix asymetry (that is left hand side)
later".  That works, and I can imagine good reasons to proceed
that way.  Or intead of "fixing" one can first generate intemediate
for and then pass right hand side to "right hand side code
generator" and left hand side to "left hand side code generator".
One way or another, in this approach left hand side of assigment
must be handled differently than right hand side.  But saying that
assignment operator is really symmetric is wrong.  Different
treatement treatment of sizes shows this.  And once you accept
that assignment operator is asymetric, then in Bliss you can handle
both sides in exactly the same way.  In C, there is implict
lvalue convertion and at tops of arguments to assigment there
is slight asymetry, you do not apply lvalue convertion to the
left hand argument, but apply it to the right argument.  This
is simpler model then yours when you want precise destription.

--
                              Waldek Hebisch