Unexpected result using Operator Assignment with methods causing side effects 🤔

[Kai Ejler Rasmussen]

I encountered an unexpected result related to Operator assignments and methods which has side effects on the mutable variable on the same instance.

I have tried to make a short example of what I have encountered and some variations thereof:

💭 Simplified example
🏁 🍇
    🆕🖥️🆕 ❗ ➡️ computer 
    🔄 computer ❗
🍉

🐇 🖥️ 🍇

    🖍️🆕 pointer 🔢 ⬅️ 0

    🆕 🍇🍉

    ❗ 🔄 🍇
        💭 Scenario A, unexpected result
        💭 Set the instances pointer to 123 (side effect) and increment with 4, expecting 127
        pointer ⬅➕ 📍 🐕 123 ❗

        💭 Pointer: 4
        😀 🍪 🔤Pointer: 🔤 🔡 pointer 10 ❗ 🍪 ❗

        💭 Reset pointer
        📍 🐕 0 ❗

        💭 Scenario B, works as expected
        💭 Split operations
        📍 🐕 123 ❗ ➡️ ret 
        pointer ⬅➕ ret

        💭 Pointer: 127
        😀 🍪 🔤Pointer: 🔤 🔡 pointer 10 ❗ 🍪 ❗

        💭 Reset pointer
        📍 🐕 0 ❗

        💭 Scenario C, works as expected
        💭 Similar approach but more elaborate
        📍 🐕 123 ❗ ➕ pointer ➡️ 📍 🐕 ❗ 

        💭 Pointer: 127
        😀 🍪 🔤Pointer: 🔤 🔡 pointer 10 ❗ 🍪 ❗
    🍉

    ❗ 📍 value 🔢 ➡️ 🔢 🍇
        value ➡️ 🖍️ pointer 
        ↩️ 4
    🍉

    ➡ 📍 value 🔢 ➡️ 🔢 🍇
        value ➡️ 🖍️ pointer 
        ↩️ 4
    🍉
🍉

The unexpected result relates to pointer ⬅➕ 📍 🐕 123 ❗. My assumption is that the 📍❗ mutates the pointer variable and the Operator Assignment then increments it by 4 resulting in a pointer of 127.

However, it seems that the Operator Assignment has already copied the value of pointer before the 📍❗ has been evaluated.

I'm not sure if this is a bug or if I'm misunderstanding the scopes 🤔

[thbwd]

Thanks for bringing this up. I see how this is confusing, but this is the way it is intended to work.

pointer ⬅➕ 📍 🐕 123 ❗ is equivalent to pointer ➕ 📍 🐕 123 ❗ ➡️ pointer (which is not equivalent to C). Emojicode always evaluates expressions in statements strictly from left to right. The result 123 is correct therefore.

I realize the documentation is pretty vague here when saying "an operator is applied to the value of a variable and another operand and the result of the operation is then stored into the variable" but the last example actually implies this: "finally divided by 3" i ⬅️➗ 3. This should probably be clarified in the documentation.

We could consider introducing a right operator assignment tough: 📍 🐕 123 ❗➕➡️ pointer, which would do what you want.

[Kai Ejler Rasmussen]

Just to clarify, the expression pointer ⬅➕ 📍 🐕 123 ❗ evaluates to 4 not 123. (Pointer (0) + return (4))

Reordering the equivalence to 📍 🐕 123 ❗ ➕ pointer ➡️ pointer would give the desired side effect result of 127 correctly applying changes to pointer before accessing it for addition.

It might be worth considering changing the right operator assignment to 📍 🐕 123 ❗➕➡️ 🖍 pointer including 🖍 to keep consistency for mutable variables

[thbwd]

Sorry, for the confusion. It appears I accidentally wrote 123 above.

Including 🖍 would indeed be very reasonable as far as consistency is concerned. I don’t really see the need for a right operator assignment though, as code as in your example is confusing anyway.