Operators over mutation forms :=

[kiranandcode]

Hi! Is it possible to write macros of the following form:

macro
 | '$obj += $vl': '$obj := $obj + $vl'

class Ball(mutable x,mutable y)

def ball: Ball(10,10)

ball.x += 2.0

The above fails with the error:

 // fails with left-hand argument is not a mutable identifier

[mflatt]

That's an interesting example that is currently not possible.

The problem is that the left-hand side of an infix expression operator must be parsed as an expression, because parsing it that way is necessary to find the infix operator afterward (by the enforest algorithm). But := only works with an identifier to its left, or it works as handled by something like .. That is, in ball.x := ball.x + 2.0, it's really the . in the left ball.x that handles :=.

More generally, the issue is that the left-hand side of := is not an expression position. I can imagine something like l-value positions, analogous to repetition repetitions, where ball.x would expand as an l-value. But repetition positions work because there's something on the outside, such as [] or (), to recognize the ... and treat the group before as a repetition instead of an expression. There's nothing on the outside of := to trigger parsing to the left as an l-value, unless we make := special for all expression positions — which doesn't seem immediately worthwhile, but I'm not certain.

[kiranandcode]

Yes, after playing around with it, I started to realise that the problem was with how the ball.x was being processed.

For now, I'm making do with something like:

macro
| 'set ($x) += $y': '$x := $x + $y'
| 'set ($x) -= $y': '$x := $x - $y'

but it feels a little unsatisfying that I can't use the exact syntax that I want.

To clarify w.r.t your answer, I understand that Rhombus' macro and expr.macro etc. default templates won't work, but is it possible to implement the operation using lower level mechanisms?

Looking through the Rhombus source, I found the implementation of := which I thought might be relevant:

(define-syntax :=
  (expression-infix-operator
   (expr-quote :=)
   '((default . weaker))
   'automatic
   (lambda (form1 form2 self-stx)
     (define mv (and (identifier? form1)
                     (syntax-local-value* form1 mutable-variable-ref)))
     (unless mv
       (raise-syntax-error #f
                           "left-hand argument is not a mutable identifier"
                           self-stx))
     #`(let ([#,form1 #,form2])
         (set! #,(mutable-variable-id mv) #,form1)))
   'left))

Using expression-infix-operator, would it be possible to implement something like +=? Ideally without having to modify rhombus sources?

I tried copying the definition of := and modifying it to implement +=, such that when expanded, it would expand to an expression using :=, but I couldn't get it to work.

[mflatt]

I don't think that working at a lower level can help here, at least not in a general way. The fact that the left-hand side of := isn't an expression is a more fundamental mismatch with the enforest function, so there would have to be a change to enforest or the way that it is used for expressions.

Copying := doesn't help because the handling of := in ball.x := ... is in the implementation of .. Using the very latest Rhombus, you could change the way . works with specifically x and y for a Ball using the dot class clause, but this doesn't feel like a very good solution:

#lang rhombus/and_meta

class Ball(private mutable _x, private mutable _y):
  opaque
  internal _Ball

  constructor (x, y):
    super(x, y)

  dot '$left . x':
    ~tail: tail
    convert(left, '_x', tail)

  dot '$left . y':
    ~tail: tail
    convert(left, '_y', tail)

meta:
  fun convert(left, fld, tail):    
    match tail
    | '+= $rhs':
        values('block:
                  def b :~ _Ball = $left
                  b . $fld := b . $fld + $rhs',
               '')
    | ':= $rhs':
        values('($left :~ _Ball) . $fld := $rhs',
               '')
    | ~else:
        '($left :~ _Ball) . $fld'

def ball: Ball(10,10)

ball.x += 2.0

[kiranandcode]

Okay, thanks for the code snippet and the explanation, it makes sense: infix operators require the preceding token stream to be parsed as an expression, which prevents . from running it's code to handle :=.

Maybe as some feedback from a user's perspective of using rhombus, while I understand entirely why things end up failing, it felt somewhat frustrating and unsatisfying to find that I couldn't write macros to generalise over code with :=.

A possible solution (apologies if I repeat something you've already mentioned before --- I'm not as familiar with the internals of Rhombus, so I'll admit some of your points went over my head):

• Allow "unparsing" an expression? I guess once the LHS $obj gets parsed as an expression in the infix pattern $obj := $vl, when my template contains $obj := ..., $obj is not reparsed, and inserted into the template as an expression --- it would be nice if I could somehow tell rhombus to "unparse" $obj back into its token stream when processing the template

Of course, I don't really have a good understanding of how the internals of the enforesting mechanism works, so maybe what I've suggested above is not possible at all.

[mflatt]

Another idea: instead of trying to have l-value positions, have a notion of assignment operators. Then, forms like . and [] that currently recognize := could instead recognize assignment operators generally, and a syntax class would provide the same capability to user-defined macros.

The protocol for assignment-operator expansion would be a little different from expression-operator expansion, although implementing one as a pattern-based macro would probably look about the same. The "fails with left-hand argument is not a mutable identifier" error message (at the start of this thread) could include the potential solution of defining an assignment operator.

[mflatt]

Added in 4ec3621 — although not with a suggestion in the error message, so far.