Can I assign to a field nested N levels into an object? about urlang HOT 8 CLOSED

(import renderer.view.style.position make-new-renderer)
(define renderer (make-new-renderer))
(:= renderer.view.style.position "option-for-outer-renderer")
(let ([renderer (make-new-renderer)])
  ;; oops; this will write to the outer renderer
  (:= renderer.view.style.position "option-for-inner-renderer"))

;; (:dot (a b c d) val) becomes a.b.c.d = val
(define-urlang-macro (:=dot stx)
  (syntax-parse stx
    ;; a.b.c.d = val where a b c can be expressions, but d has to be an id
    ([_ (dot-e:expr ...+ key-last:id) e:expr]
     (with-syntax ([key-last-str (datum->syntax #'key-last (~a (syntax->datum #'key-last)))])
       #'(let ([obj (dot dot-e ...)])
           (:= obj key-last-str e))))
    ;; todo : (:= (a b c d) val) allow d to be an expression or just a name like above
    ;; ex: (let ([d "position"]) (:=dot (renderer view style d) val))
    ;; I think I would need something like (identifier-bound? #'d)
    ;; to determine how an id should be treated. I'm not sure.
    ))

(:=dot (renderer view style position) "option-value")

   (:= (dot a b c d) ...)   

  (:= a.b.c.d ...)

#lang racket
(require urlang syntax/parse)

(define (join-identifiers ids)
  ; note: since we use ~a we can handle both identifiers and literal strings
  (define stx    (first (syntax-e ids)))
  (define joined (string->symbol (apply ~a (add-between (syntax->datum ids) "."))))
  (datum->syntax stx joined stx))

(define (id-or-string? x)
  (and (syntax? x)
       (or (symbol? (syntax-e x))
           (string? (syntax-e x)))))

; This version of := is correct, but the version below generates
; better code in the case that e0 ... consists of identifiers.
; In (:=dot (a b c d) val) only a needs to imported
#;(define-urlang-macro (:=dot stx)
    (syntax-parse stx
      [(_ (e0 ...+ en) e)
       (syntax/loc stx
         (array! (ref e0 ...) en e))]))

;; (:=dot (a b c d) val) becomes a.b.c.d = val
;; generates better code, but one must import the dotted identifer
(define-urlang-macro (:=dot stx)
  (syntax-parse stx
    ; the simple case consists of all identifiers or literal strings
    [(_ (x ...+) e)
     #:when (andmap id-or-string? (syntax->list #'(x ...)))
     (with-syntax ([x-dotted (join-identifiers #'(x ...))])
       (syntax/loc stx
         (:= x-dotted e)))]
    ; the general case
    [(_ (e0 ...+ en) e)
     (syntax/loc stx
       (array! (ref e0 ...) en e))]))

(urlang
 (urmodule bug
   (import a.b.c.d)
   (var a b c d)
   (:=dot (a b c d)   42)
   (:=dot (a b c "d") "val")
   (:=dot (a b c 43)  "val")
   (let ([d "x"])
     (:=dot (a b c d)   42))
   (:=dot ("a" b "c" d) 45)))

(define-urlang-macro (:=dot0 stx)
  (syntax-parse stx
    ;; a.b.c.d = val where a b c can be expressions, but d has to be an id, string, or number
    ([_ (dot-e:expr ...+ key-last) e:expr]
     #:when (or (string? (syntax->datum #'key-last))
                (identifier? #'key-last)
                (number? (syntax->datum #'key-last)))
     (define datum (syntax->datum #'key-last) )
     (define val (if (number? datum) datum (~a datum)))
     (with-syntax ([key-last-str (datum->syntax #'key-last val)])
       #'(let ([obj (dot dot-e ...)])
           (:= obj key-last-str e))))
    ;; to determine how an id should be treated. I'm not sure.
    ([_ (dot-e:expr ...+ key-last) e:expr]
     ;; else error
     (raise-syntax-error #f "last input has to be an identifier, string, or number" #'key-last))))

:=dot0 fails because it uses "x" as the last key (not "c")
(let ([x "c"]) (:=dot0 (a b x) "val")) => fails : ((function(x){return ((function(obj){return (obj["x"]="val");})(a.b));})("c"));

:=dot1 works if b is an expression
(let ([x "c"]) (:=dot0 (a "b" x) "val")) => works : ((function(x){return a["b"][x]="val";})("c"));

:=dot2 fails because it should be a.b[x]="val"
(import a.b.x)
(let ([x "c"]) (:=dot2 (a "b" x) "val")) => fails : ((function(x){return (a.b.x="val");})("c"));

(:=dot0 (a b 0) "val")   => works : ((function(obj){return (obj[0]="val");})(a.b));
(:=dot1 (a "b" 0) "val") => works : a["b"][0]="val";
(:=dot1 (a "b" 0) "val") => works : a["b"][0]="val";

(:=dot0 (a (ref b 0) c) "val") => won't compile
(:=dot1 (a (ref b 0) c) "val") => not quite right : a[b[0]]["c"]="val";
(:=dot2 (a (ref b 0) c) "val") => not quite right : a[b[0]]["c"]="val";

(:= (ref (ref a "b") 0) "c" "val") => not an id in the assignment position
(:=dot0 ((ref (ref a "b") 0) c) "val") => works but hard to reason about : ((function(obj){return (obj["c"]="val");})(a["b"][0]));
(:=dot1 ((ref (ref a "b") 0) "c") "val") => not enough terms for the macro but works for more terms
(:=dot2 ((ref (ref a "b") 0) "c") "val") => not enough terms for the macro but works for more terms

;;;
;; Chained assignment macro
;; Example:
;; (:=dot (a "b" (Ref 0) "c") "val") => a.b[0].c = "val"
(define-urlang-macro (:=dot stx)
  (syntax-parse stx
    [(_ [e0 en] e)
     (syntax/loc stx
       (array! e0 en e))]
    [(_ [e0:expr e1:expr ...+ ((~datum Ref) r:expr)] body:expr)
     (syntax/loc stx
       (:=dot [(ref e0 e1 ...) r] body))]
    [(_ [e0:expr e1:expr ...+ ((~datum Ref) r:expr) en:expr ...+] body:expr)
     (syntax/loc stx
       (:=dot [(ref (ref e0 e1 ...) r) en ...] body))]
    [(_ [e0:expr ((~datum Ref) r:expr) en:expr ...] body:expr)
     (syntax/loc stx
       (:=dot [(ref e0 r) en ...] body))]
    [(_ (e0 e1 ...+ en) e)
     (syntax/loc stx
       (array! (ref e0 e1 ...) en e))]))

  (import new-object)
  (var [a (new-object)]
       x)
  (:=dot [a "b" "c" "d" (Ref 0)] "val")
  (:=dot [a "b" "c" (Ref x) "d"] "val")
  (:=dot [a "b" (Ref 0) "c" "d"] "val")
  (:=dot [a (Ref 0) "b" "c" "d"] "val")
  (let ([a (new-object)]
        [x 1])
    (:=dot [a "b" "c" (Ref x) "d"] "val"))

var a=(new_object()),x;
a["b"]["b"]["b"][0]="val";
a["b"]["b"][x]["d"]="val";
a["b"][0]["c"]["d"]="val";
a[0]["b"]["b"]["d"]="val";
((function(a_1,x_2){return a_1["b"]["b"][x_2]["d"]="val";})((new_object()),1));

  (var [a (new-object)]
       x)
  (:=dot [a "b" "c" "d" (Ref 0)] "val")
  (:=dot [a "b" "c" (Ref x) "d"] "val")
  (:=dot [a "b" (Ref 0) "c" "d"] "val")
  (:=dot [a (Ref 0) "b" "c" "d"] "val")
  (let ([a (new-object)]
        [x 1])
    (:=dot [a "b" "c" (Ref x) "d"] "val"))

var a=(new_object()),x;
a["b"]["c"]["d"][0]="val";
a["b"]["c"][x]["d"]="val";
a["b"][0]["c"]["d"]="val";
a[0]["b"]["c"]["d"]="val";
((function(a_1,x_2){return a_1["b"]["c"][x_2]["d"]="val";})((new_object()),1));