[Joker_vD]

My apologies, it should've been (if you insist on indentation)

        let a, b, c = 0, 1, 0
    fb_start:
        writen(a)
        b +:= a
        a :=
          b - a
        c +:= 1
        if c < 100 do
          goto fb-start

Would you care to elaborate about brackets helping with tracking the order of execution? I'm really curious about that part.

[kazinator]

TXR Lisp, with infix via ifx macro:

  (ifx
    (let ((a 0) (b 1) (c 0))
      (tagbody
       fb-start
        (prinl a)
        (b += a)
        (a := b - a)
        (c += 1)
        (if (c < 100)
          (go fb-start)))))

[tmtvl]

Well, the P in PEMDAS stands for 'brackets'. The clearest example, even though it's rather uncommon:

  a := x ** y ** z

(and that's hoping the language does the OOE for exponentiation arithmetically correctly) versus

  (setf a (expt x (expt y z)))

It's a bit like how Reverse Polish Notation is superior to the infix notation we torture ourselves with (x + y * z or (x + y) * z versus x y z * + or x y + z *).

[Joker_vD]

But that's just associativity, not the order of evaluation? E.g. in C# expressions are evaluated strictly left to right, so if it had operator **, the order of evaluation would've been:

    tmp1 := x, tmp2 := y, tmp3 := z, tmp4 := tmp2 ** tmp3, yield tmp1 ** tmp4

And, eh, I am not really that convinced that

    a b * c d * x y * z t * p q * + + sqrt + +

is much less torturous than

    a * b + c * d + sqrt(x * y + z * t + p * q)