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

Bart <bc@freeuk.com> writes:

On 29/08/2024 21:30, Keith Thompson wrote:

Bart <bc@freeuk.com> writes:
[...]

So what exactly is different about the LHS and RHS here:
>
    A = A;

The RHS is evaluated to determine the current value stored in the
object
named A.  The LHS is evaluated to determine the object that's designated
by the name A; its current value is irrelevant.

>
Sure, but the same thing happens on both sides: one ends up performing
a Read via that Lvalue, and the other does a Write via that Lvalue.

The read is done by converting the lvalue to its value, which is not an
lvalue.  Please read the discussion of "lvalue conversion" in the C
standard.

In C terms, the RHS undergoes *lvalue conversion*, where an expression
that's an lvalue is converted to the value stored in the designated
object.  The LHS does not undergo lvalue conversion.
 

(In BLISS, doing the same thing requires 'A = .A' AIUI; while 'A = A'
is also valid, there is a hidden mismatch in indirection levels
between left and right. It is asymmetric while in C it is symmetric,
although seem to disagree on that latter point.)

Because BLISS, unlike C, does not have implicit lvalue conversion;
the
prefix "." operator performs explicit lvalue conversion.  I presume the
"." operator isn't specific to assignments.

>
But it must have that conversion on the LHS, otherwise it's A's
address that is written to rather than its value, which doesn't make
sense. That's why I said it was asymmetric; the RHS needs an explicit
operator, the LHS doesn't.

No, the address isn't written.  The object is written.

The RHS evaluation determines the value currently stored in the object.
The LHS evaluation does not.  That's the asymmetry.

In BLISS, the evaluation of the expression A determines the object that
the name A designates.  In C, it can either do that *or* it can extract
the value currently stored in that object.

I'd initially thought that both sides needed it.
>

In C, the LHS and RHS are evaluated differently.  In BLISS, they're
evaluated in the same way, requiring an explicit operator to do what
done implicitly by context in C.  I'd call the former asymmetric and the
latter symmetric.

>
It sounds like you've got it backwards.
>
How can A = B be asymmetric, but A = .B be symmetric?

We're talking about the "=" operator, not about a particular instance of
it.

The "=" operation in C is asymmetric because it treats the two operands
differently based on their context.  The "=" operation is BLISS is
symmetric because it treats them the same (requiring an explicit lvalue
conversion on the RHS if you want the value of A).

[...]

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