Discussion about ambuigity in postifx unary and binary operators

[MiroPalmu]

Hi.

I'm a student on a compilers course and out of interest of cpp2 I wanted to write a compiler for a language which is inspired by cpp2 syntax. While designing how expressions should be parsed I have been testing the rule:

postfix unary operators have to be written without intervening whitespace

I wrote a small test program to test how different cases are parsed. The full test is at end of this post but in summary it uses type foo to test how binary multiplication interacts with postifx dereference operator, parentheses and "function call operator":

foo: type = {
    value_: int;

    operator=: (out this, value: int) = {
        value_ = value;
    }
    
    operator(): (this, _: foo) = {
        std::cout << "Function call!\n";
    }

    operator*: (this, rhs: foo) -> foo = {
        std::cout << "Multiplication!\n";
        return foo(value_ * rhs.value_); 
    }

    operator*: (this) -> foo = {
        std::cout << "Dereferenced!\n";
        return foo(value_); 
    }
}

Now for a object A of type foo, following list shows how cppfront (2a17de7) handles different expressions. Plain does not compile means that cppfront gave error: posfitx unary * (dereference) cannot be immediatly followed by a ....

A*A
Does not compile

A* A
Does not compile

A * A
Multiplication!

A**A
Does not compile

A** A
Does not compile

A* * A
Dereferenced!
Multiplication!

A * * A
Does not compile (error: prefix '*ptr' not valid)

A(A)
Function call!

A (A)
Function call!

A*(A)
Does not compile

A* (A)
Does not compile

A * (A)
Multiplication!

A**(A)
Does not compile

A** (A)
Does not compile

A* * (A)
Dereferenced!
Multiplication!

A * * (A)
Does not compile (error: prefix '*ptr' not valid)

(A*)(A)
Dereferenced!
Function call!

(A*) (A)
Dereferenced!
Function call!

(A *) (A)
Does not compile (error: unexpected text - expression list not terminated by )

(A*)*(A)
Does not compile

(A*)* (A)
Does not compile

(A*) * (A)
Dereferenced!
Multiplication!

(A *) * (A)
Does not compile (error: unexpected text - expression list not terminated by )

I have two remarks about this:

Maybe I don't understand something but with this quote from design note: Postfix operators:

cases like x**y mean the same as x* * y since they can't mean anything else, which is convenient so we can still write things like ab and a2 conveniently with the obvious meaning.

I find it interesting that A*A and A**A does not compile. Bug?

What if, in the spirit of maximal munch, the rule would be changed to:

If operator can be interpreted as a binary operator based on neighboring tokens/expressions it is a binary operator.

Like maximal much this would be applied from left to right.

Going trough the list again we see that now all cases have unambiguous meaning without changing meaning of the ones that compiled:

A*A
Now compiles!
[A, *, A] can be binary operation -> * is binary operator

A* A
Now compiles!
[A, *, A] can be binary operator -> * is binary operator

A * A
Unchanged
[A, *, A] can be binary operator -> * is binary operation

A**A
Now compiles!
[A, *, *] can not be part of binary operator -> first * is unary operator
Now A* is expression, so
[A*, *, A] can be binary operator -> second * is binary operation


A** A
Now compiles!
Same as above.

A* * A
Unchanged
Same as above.

A * * A
Now compiles!
Same as above.

A(A)
Unchanged

A (A)
Unchanged

A*(A)
Now compiles!
Interpret opening parenthesis '(' as a start of subexpression
[A, *, (] -> * is binary operator
So this would be equal to A * A.
If the intent was to do dereference followed with function call,
then this would result unintended behavior,
however if there would be no arguments or more than one argument,
there should be compilation error from empty parentheses or
using comma operator.

A* (A)
Now compiles!
Same as above.

A * (A)
Unchanged.
Same as above.

A**(A)
Now compiles!
[A, *, *] can not be binary operator -> first * is unary operator
[A*, *, (]  -> second * is binary operator with same reasons as above.
So this would be dereference followed by multiplication.

A** (A)
Now compiles!
Same as above

A* * (A)
Dereferenced!
Multiplication!
Stays the same based on above.

A * * (A)
Now compiles!
Same as above.

(A*)(A)
Unchanged
[A, *, )] can not be anything else than dereference of A -> * is unary operator

(A*) (A)
Unchanged.
Same as above.

(A *) (A)
Now compiles!
Same as above.

(A*)*(A)
Now compiles!
(A*) is dereference similarly to above,
so second * is interpreted as binary operator.

(A*)* (A)
Now compiles!
Same as above.

(A*) * (A)
Unchanged.
Same as above.

(A *) * (A)
Now compiles!
Same as above.

These are just some simple examples but I would be interested to hear counterarguments to this rule.

Here is the full source code for the test program:

main: () = {
    A: foo = 1;

    std::cout << "A*A\n";
    // _ = A*A;
    std::cout << "Does not compile\n";
    std::cout << std::endl;

    std::cout << "A* A\n";
    // _ = A* A;
    std::cout << "Does not compile\n";
    std::cout << std::endl;

    std::cout << "A * A\n";
    _ = A * A;
    std::cout << std::endl;

    std::cout << "A**A\n";
    // _ = A**A;
    std::cout << "Does not compile\n";
    std::cout << std::endl;

    std::cout << "A** A\n";
    // _ = A** A;
    std::cout << "Does not compile\n";
    std::cout << std::endl;

    std::cout << "A* * A\n";
    _ = A* * A;
    std::cout << std::endl;

    std::cout << "A * * A\n";
    // _ = A * * A;
    std::cout << "Does not compile (error: prefix '*ptr' not valid)\n";
    std::cout << std::endl;

    std::cout << "A(A)\n";
    _ = A(A);
    std::cout << std::endl;

    std::cout << "A (A)\n";
    _ = A (A);
    std::cout << std::endl;

    std::cout << "A*(A)\n";
    // _ = A*(A);
    std::cout << "Does not compile\n";
    std::cout << std::endl;

    std::cout << "A* (A)\n";
    // _ = A* (A);
    std::cout << "Does not compile\n";
    std::cout << std::endl;

    std::cout << "A * (A)\n";
    _ = A * (A);
    std::cout << std::endl;

    std::cout << "A**(A)\n";
    // _ = A**(A);
    std::cout << "Does not compile\n";
    std::cout << std::endl;

    std::cout << "A** (A)\n";
    // _ = A** (A);
    std::cout << "Does not compile\n";
    std::cout << std::endl;

    std::cout << "A* * (A)\n";
    _ = A* * (A);
    std::cout << std::endl;

    std::cout << "A * * (A)\n";
    // _ = A * * (A);
    std::cout << "Does not compile (error: prefix '*ptr' not valid)\n";
    std::cout << std::endl;

    std::cout << "(A*)(A)\n";
    _ = (A*)(A);
    std::cout << std::endl;

    std::cout << "(A*) (A)\n";
    _ = (A*) (A);
    std::cout << std::endl;

    std::cout << "(A *) (A)\n";
    // _ = (A *) (A);
    std::cout << "Does not compile (error: unexpected text - expression list not terminated by )\n";
    std::cout << std::endl;

    std::cout << "(A*)*(A)\n";
    // _ = (A*)*(A);
    std::cout << "Does not compile\n";
    std::cout << std::endl;

    std::cout << "(A*)* (A)\n";
    // _ = (A*)* (A);
    std::cout << "Does not compile\n";
    std::cout << std::endl;

    std::cout << "(A*) * (A)\n";
    _ = (A*) * (A);
    std::cout << std::endl;

    std::cout << "(A *) * (A)\n";
    // _ = (A *) * (A);
    std::cout << "Does not compile (error: unexpected text - expression list not terminated by )\n";
    std::cout << std::endl;

}

foo: type = {
    value_: int;

    operator=: (out this, value: int) = {
        value_ = value;
    }
    
    operator(): (this, _: foo) = {
        std::cout << "Function call!\n";
    }

    operator*: (this, rhs: foo) -> foo = {
        std::cout << "Multiplication!\n";
        return foo(value_ * rhs.value_); 
    }

    operator*: (this) -> foo = {
        std::cout << "Dereferenced!\n";
        return foo(value_); 
    }
}

[DyXel]

Could you also test when the type is a a pointer-pointer or more? That is, A is a **int, I don't see how A***5 would work (as (A**) * 5) unless you know what the type of A is.

[MiroPalmu]

I don't see how A***5 would work (as (A**) * 5) unless you know what type of A is.

I don't know how cppfront is implemented, but in general at parsing it does not matter what type A is.
It could be a tokens representing a [un]qualified identifier or some tokens which have already been parsed to be a some expression.

First parser would look at [A, *, *] and determine the first * as unary because if it would be binary
the second * would always make the expression erroneous. So A* becomes a expression on its own.

Then it would look at [A*, *, *] and with same logic as before would determine that the second * would be unary.
So A** becomes a expression on its own.

Lastly it would look at [A**, *, 5] and determine that the third * could be a binary, so it interperts it as one.

It does not matter if A, A* or A** actually are of type for which unary * is defined,
because this would be a semantic/type error not parsing one, so it would be analyzed at later stage and given error then.
This is why I called it to be in spirit of maximal munch, because it too does some decisions which could make later compilation staged give errors.

Here is similar list to the list in the original post with different cases.

A***A
error: postfix unary * can not be followed by a (, identifier or literal

A** *A
Dereferenced!
Dereferenced!
Multiplication!

A* * *A
Does not compile (error: prefix '*ptr' is not valid Cpp2)

A * * *A
Does not compile (error: prefix '*ptr' is not valid Cpp2)

(A*)**A
error: postfix unary * can not be followed by a (, identifier or literal

(A*)* *A
Dereferenced!
Dereferenced!
Multiplication!

(A*) * *A
Does not compile (error: prefix '*ptr' is not valid Cpp2)

(A *) * *A
Does not compile( error: unexpected text - expression-list is not terminated by ')')

((A*)*)*A
error: postfix unary * can not be followed by a (, identifier or literal

((A*)*) *A
Dereferenced!
Dereferenced!
Multiplication!

((A*) *) *A
Does not compile( error: unexpected text - expression-list is not terminated by ')')

((A *) *) *A
Does not compile( error: unexpected text - expression-list is not terminated by ')')

A***(A)
error: postfix unary * can not be followed by a (, identifier or literal

A** *(A)
Dereferenced!
Dereferenced!
Multiplication!

A* * *(A)
Does not compile (error: prefix '*ptr' is not valid Cpp2)

A * * *(A)
Does not compile (error: prefix '*ptr' is not valid Cpp2)

(A*)**(A)
error: postfix unary * can not be followed by a (, identifier or literal

(A*)* *(A)
Dereferenced!
Dereferenced!
Multiplication!

(A*) * *(A)
Does not compile (error: prefix '*ptr' is not valid Cpp2)

(A *) * *(A)
Does not compile( error: unexpected text - expression-list is not terminated by ')')

((A*)*)*(A)
error: postfix unary * can not be followed by a (, identifier or literal

((A*)*) *(A)
Dereferenced!
Dereferenced!
Multiplication!

((A*) *) *(A)
Does not compile( error: unexpected text - expression-list is not terminated by ')')

((A *) *) *(A)
Does not compile( error: unexpected text - expression-list is not terminated by ')')

And here it is how they would be parsed under my parsing rule:

A***A
From: error: postfix unary * can not be followed by a (, identifier or literal
To: Now compiles!
Explained at beginning of this post.

A** *A
Unchanged.
Same as above.

A* * *A
From: Does not compile (error: prefix '*ptr' is not valid Cpp2)
To: Now compiles!
Same as above.

A * * *A
From: Does not compile (error: prefix '*ptr' is not valid Cpp2)
To: Now compiles!
Same as above.

(A*)**A
From: error: postfix unary * can not be followed by a (, identifier or literal
To: Now compiles!
[A, *, )] -> unary
[(A*), *, *] -> unary
[(A*)*, *, A] -> binary

(A*)* *A
Unchanged.
Same as above.

(A*) * *A
From: Does not compile (error: prefix '*ptr' is not valid Cpp2)
To: Now compiles.
Same as above.

(A *) * *A
From: Does not compile (error: prefix '*ptr' is not valid Cpp2)
To: Now compiles.
Same as above.

((A*)*)*A
From: error: postfix unary * can not be followed by a (, identifier or literal
To: Now compiles.
[A, *, )] -> unary
[(A*), *, )] -> unary
[((A*)*), *, A] -> binary

((A*)*) *A
Unchanged.
Same as above.

((A*) *) *A
From: Does not compile( error: unexpected text - expression-list is not terminated by ')')
To: Now compiles.
Same as above.

((A *) *) *A
From: Does not compile( error: unexpected text - expression-list is not terminated by ')')
To: Now compiles.
Same as above.

A***(A)
From: error: postfix unary * can not be followed by a (, identifier or literal
To: Now compiles
[A, *, *] -> unary
[A*, *, *] -> unary
[A**, *, (] -> binary

A** *(A)
Unchanged.
Same as above.

A* * *(A)
From: Does not compile (error: prefix '*ptr' is not valid Cpp2)
To: Now compiles
Same as above.

A * * *(A)
From: Does not compile (error: prefix '*ptr' is not valid Cpp2)
To: Now compiles
Same as above.

(A*)**(A)
From: error: postfix unary * can not be followed by a (, identifier or literal
To: Now compiles
[A, *, )] -> unary
[(A*), *, *] -> unary
[(A*)*, *, (] -> binary

(A*)* *(A)
Unchanged.
Same as above.

(A*) * *(A)
From: Does not compile (error: prefix '*ptr' is not valid Cpp2)
To: Now compiles
Same as above.

(A *) * *(A)
From: Does not compile( error: unexpected text - expression-list is not terminated by ')')
To: Now compiles
Same as above.

((A*)*)*(A)
From: error: postfix unary * can not be followed by a (, identifier or literal
To: Now compiles
[A, *, )] -> unary
[(A*), *, )] -> unary
[((A*)*), *, (] -> binary

((A*)*) *(A)
Unchanged.
Same as above.

((A*) *) *(A)
From: Does not compile( error: unexpected text - expression-list is not terminated by ')')
To: Now compiles
Same as above.
 
((A *) *) *(A)
From: Does not compile( error: unexpected text - expression-list is not terminated by ')')
To: Now compiles
Same as above.

And for completion here is the test program:

main: () = {
    A: foo = 1;

    std::cout << "A***A\n";
    // _ = A***A;
    std::cout << "error: postfix unary * can not be followed by a (, identifier or literal\n";
    std::cout << std::endl;

    std::cout << "A** *A\n";
    _ = A** *A;
    std::cout << std::endl;

    std::cout << "A* * *A\n";
    // _ = A* * *A;
    std::cout << "Does not compile (error: prefix '*ptr' is not valid Cpp2)\n";
    std::cout << std::endl;

    std::cout << "A * * *A\n";
    // _ = A * * *A;
    std::cout << "Does not compile (error: prefix '*ptr' is not valid Cpp2)\n";
    std::cout << std::endl;

    std::cout << "(A*)**A\n";
    // _ = (A*)**A;
    std::cout << "error: postfix unary * can not be followed by a (, identifier or literal\n";
    std::cout << std::endl;

    std::cout << "(A*)* *A\n";
    _ = (A*)* *A;
    std::cout << std::endl;

    std::cout << "(A*) * *A\n";
    // _ = (A*) * *A;
    std::cout << "Does not compile (error: prefix '*ptr' is not valid Cpp2)\n";
    std::cout << std::endl;

    std::cout << "(A *) * *A\n";
    // _ = (A *) * *A;
    std::cout << "Does not compile( error: unexpected text - expression-list is not terminated by ')')\n";
    std::cout << std::endl;
    
    std::cout << "((A*)*)*A\n";
    // _ = ((A*)*)*A;
    std::cout << "error: postfix unary * can not be followed by a (, identifier or literal\n";
    std::cout << std::endl;

    std::cout << "((A*)*) *A\n";
    _ = ((A*)*) *A;
    std::cout << std::endl;

    std::cout << "((A*) *) *A\n";
    // _ = ((A*) *) *A;
    std::cout << "Does not compile( error: unexpected text - expression-list is not terminated by ')')\n";
    std::cout << std::endl;

    std::cout << "((A *) *) *A\n";
    // _ = ((A *) *) *A;
    std::cout << "Does not compile( error: unexpected text - expression-list is not terminated by ')')\n";
    std::cout << std::endl;
    
    std::cout << "A***(A)\n";
    // _ = A***(A);
    std::cout << "error: postfix unary * can not be followed by a (, identifier or literal\n";
    std::cout << std::endl;

    std::cout << "A** *(A)\n";
    _ = A** *(A);
    std::cout << std::endl;

    std::cout << "A* * *(A)\n";
    // _ = A* * *(A);
    std::cout << "Does not compile (error: prefix '*ptr' is not valid Cpp2)\n";
    std::cout << std::endl;

    std::cout << "A * * *(A)\n";
    // _ = A * * *(A);
    std::cout << "Does not compile (error: prefix '*ptr' is not valid Cpp2)\n";
    std::cout << std::endl;

    std::cout << "(A*)**(A)\n";
    // _ = (A*)**(A);
    std::cout << "error: postfix unary * can not be followed by a (, identifier or literal\n";
    std::cout << std::endl;

    std::cout << "(A*)* *(A)\n";
    _ = (A*)* *(A);
    std::cout << std::endl;

    std::cout << "(A*) * *(A)\n";
    // _ = (A*) * *(A);
    std::cout << "Does not compile (error: prefix '*ptr' is not valid Cpp2)\n";
    std::cout << std::endl;

    std::cout << "(A *) * *(A)\n";
    // _ = (A *) * *(A);
    std::cout << "Does not compile( error: unexpected text - expression-list is not terminated by ')')\n";
    std::cout << std::endl;
    
    std::cout << "((A*)*)*(A)\n";
    // _ = ((A*)*)*(A);
    std::cout << "error: postfix unary * can not be followed by a (, identifier or literal\n";
    std::cout << std::endl;

    std::cout << "((A*)*) *(A)\n";
    _ = ((A*)*) *(A);
    std::cout << std::endl;

    std::cout << "((A*) *) *(A)\n";
    // _ = ((A*) *) *(A);
    std::cout << "Does not compile( error: unexpected text - expression-list is not terminated by ')')\n";
    std::cout << std::endl;

    std::cout << "((A *) *) *(A)\n";
    // _ = ((A *) *) *(A);
    std::cout << "Does not compile( error: unexpected text - expression-list is not terminated by ')')\n";
    std::cout << std::endl;

}

foo: type = {
    value_: int;

    operator=: (out this, value: int) = {
        value_ = value;
    }
    
    operator(): (this, _: foo) = {
        std::cout << "Function call!\n";
    }

    operator*: (this, rhs: foo) -> foo = {
        std::cout << "Multiplication!\n";
        return foo(value_ * rhs.value_); 
    }

    operator*: (this) -> foo = {
        std::cout << "Dereferenced!\n";
        return foo(value_); 
    }
}

[DyXel]

Thanks for doing extensive tests for this!

[gregmarr]

Maybe I don't understand something but with this quote from design note: Postfix operators:

cases like x**y mean the same as x* * y since they can't mean anything else, which is convenient so we can still write things like a*b and a*2 conveniently with the obvious meaning.

I find it interesting that A*A and A**A does not compile. Bug?

@hsutter I think that this points out that https://github.com/hsutter/cppfront/wiki/Design-note:-Postfix-operators

as a convenience, cases like x**y mean the same as x* * y since they can't mean anything else,

was not updated after https://github.com/hsutter/cppfront/wiki/Design-note:-Postfix-unary-operators-vs-binary-operators was created. Here is further discussion on that topic: #152 (comment)

Disambiguate unary and binary * and &. This is what I'm currently trying... the current rule is that ... * and & that appear as a suffix are the unary operators, and if they are followed by ( or an identifier or a literal and a binary operator was intended you add whitespace before it). This is an experiment but so far it's working well for my uses, but I continue to be open to feedback.

[MiroPalmu]

Thanks for linking the discussion that happened, nice to read longer explanation for reasoning for current behavior. I think #152 had the same idea as what I tried to describe :)

These are just my two cents, but it just does not feel right to have whitespace with semantic meaning, also it is weird to allow a+b but not a*b. I guess it is just tradeoff between allowing visually ambiguous cases versus not allowing them and giving nice error messages, however I think that if visual ambiguity would lead to different semantic from what was the intent, I think in many cases the type system or other warnings would at least come to close to the "nice errors".

Lastly in both cases I like that the ambiguity would be solved with simple rule, like with maximal munch. I just would prefer giving users more freedom how they want to format their code using whitespace over wrinkles like a+b vs a*b, but maybe freedom is not good argument for language which is trying to evolve cpp to more "safe" direction.

[gregmarr]

These are just my two cents, but it just does not feel right to have whitespace with semantic meaning,

It already has semantic meaning, although generally in the opposite direction.
x+ + vs x++, x > > y vs x >> y.

it is weird to allow a+b but not a*b. I guess it is just tradeoff between allowing visually ambiguous cases versus not allowing them and giving nice error messages

Yeah, it's unfortunate that one of the two is both a unary postfix and a binary operator, while the other is a unary prefix operator and a binary operator. I think there would be less confusion, but also greater... I'm not sure what, maybe objection, if + and - were made unary postfix operators, so you had to do x- instead of -x. I believe that Herb considered that, but rejected it.

[AbhinavK00]

x+ + vs x++, x > > y vs x >> y.

Please explain both of those cases, I thought cppfront doesn't have postfix unary addition operator?

Edit: Sorry, I just realised those cases are ill-formed.

[hsutter]

Thanks! This commit's change has been bugging me ever since I did it, especially not being able to write a*b, especially in interpolations, and I now no longer remember why I did it in the first place (what problem I thought it was solving at the time).

So I just reverted that change, and everything seems to be fine, plus simple things like a*b work again without whitespace. I've also updated the Design note: Postfix unary operators vs binary operators last bullet, which is now simply this:

Disambiguate unary and binary * and &. This is what I'm currently trying... the current rule is that if can be a postfix operator, it is. For example, a*b and a&b must be binary operators because they are followed by an identifier, it would be grammatically invalid for them to be postfix operators in those examples.

Since you wrote a great lengthy test case, I've massaged it slightly. All the cases now print "Dereferenced! Dereferenced! Multiply!" :) Here's the output:

A***A           Dereferenced! Dereferenced! Multiplication!
A** *A          Dereferenced! Dereferenced! Multiplication!
A* * *A         Dereferenced! Dereferenced! Multiplication!
A * * *A        Dereferenced! Dereferenced! Multiplication!
(A*)**A         Dereferenced! Dereferenced! Multiplication!
(A*)* *A        Dereferenced! Dereferenced! Multiplication!
(A*) * *A       Dereferenced! Dereferenced! Multiplication!
(A *) * *A      Dereferenced! Dereferenced! Multiplication!
((A*)*)*A       Dereferenced! Dereferenced! Multiplication!
((A*)*) *A      Dereferenced! Dereferenced! Multiplication!
((A*) *) *A     Dereferenced! Dereferenced! Multiplication!
((A *) *) *A    Dereferenced! Dereferenced! Multiplication!
A***(A)         Dereferenced! Dereferenced! Multiplication!
A** *(A)        Dereferenced! Dereferenced! Multiplication!
A* * *(A)       Dereferenced! Dereferenced! Multiplication!
A * * *(A)      Dereferenced! Dereferenced! Multiplication!
(A*)**(A)       Dereferenced! Dereferenced! Multiplication!
(A*)* *(A)      Dereferenced! Dereferenced! Multiplication!
(A*) * *(A)     Dereferenced! Dereferenced! Multiplication!
(A *) * *(A)    Dereferenced! Dereferenced! Multiplication!
((A*)*)*(A)     Dereferenced! Dereferenced! Multiplication!
((A*)*) *(A)    Dereferenced! Dereferenced! Multiplication!
((A*) *) *(A)   Dereferenced! Dereferenced! Multiplication!
((A *) *) *(A)  Dereferenced! Dereferenced! Multiplication!

Here's the code:

main: () = {
    A: foo = 1;

    std::cout << "A***A    \t";
    _ = A***A;

    std::cout << "\nA** *A   \t";
    _ = A** *A;

    std::cout << "\nA* * *A  \t";
    _ = A* * *A;

    std::cout << "\nA * * *A  \t";
    _ = A * * *A;

    std::cout << "\n(A*)**A  \t";
    _ = (A*)**A;

    std::cout << "\n(A*)* *A\t";
    _ = (A*)* *A;

    std::cout << "\n(A*) * *A\t";
    _ = (A*) * *A;

    std::cout << "\n(A *) * *A\t";
    _ = (A *) * *A;

    std::cout << "\n((A*)*)*A\t";
    _ = ((A*)*)*A;

    std::cout << "\n((A*)*) *A\t";
    _ = ((A*)*) *A;

    std::cout << "\n((A*) *) *A\t";
    _ = ((A*) *) *A;

    std::cout << "\n((A *) *) *A\t";
    _ = ((A *) *) *A;

    std::cout << "\nA***(A)  \t";
    _ = A***(A);

    std::cout << "\nA** *(A)\t";
    _ = A** *(A);

    std::cout << "\nA* * *(A)\t";
    _ = A* * *(A);

    std::cout << "\nA * * *(A)\t";
    _ = A * * *(A);

    std::cout << "\n(A*)**(A)\t";
    _ = (A*)**(A);

    std::cout << "\n(A*)* *(A)\t";
    _ = (A*)* *(A);

    std::cout << "\n(A*) * *(A)\t";
    _ = (A*) * *(A);

    std::cout << "\n(A *) * *(A)\t";
    _ = (A *) * *(A);

    std::cout << "\n((A*)*)*(A)\t";
    _ = ((A*)*)*(A);

    std::cout << "\n((A*)*) *(A)\t";
    _ = ((A*)*) *(A);

    std::cout << "\n((A*) *) *(A)\t";
    _ = ((A*) *) *(A);

    std::cout << "\n((A *) *) *(A)\t";
    _ = ((A *) *) *(A);

    std::cout << "\n\n";

}

foo: type = {
    value_: int;

    operator=: (out this, value: int) = {
        value_ = value;
    }

    operator(): (this, _: foo) = {
        std::cout << "Function call! ";
    }

    operator*: (this, rhs: foo) -> foo = {
        std::cout << "Multiplication! ";
        return foo(value_ * rhs.value_);
    }

    operator*: (this) -> foo = {
        std::cout << "Dereferenced! ";
        return foo(value_);
    }
}

[MiroPalmu]

Thanks for the update!