(parameter foo ...)
  (w/foo ...)

  (= foo ...)
  (w/ foo ...)

  (var foo ...)
  (w/ foo ...)

Another difference is that keyword arguments are no longer supported at all. This is because it's quite difficult to implement them properly, only a single function in Arc/Nu actually used them, and they're not backwards compatible with Arc 3.1, so I decided it wasn't worth it.

"Caveat concerning mutable keys: If a key in an equal?-based hash table is mutated (e.g., a key string is modified with string-set!), then the hash table’s behavior for insertion and lookup operations becomes unpredictable." - http://docs.racket-lang.org/reference/hashtables.html

If you're just interested in what's happening in the current implementation, I have a guess for your table-in-table example: When you initially put h2 in the table, its hash is calculated, and it's filed in a bin of entries that have that hash. Then when you look up h2 again, it calculates a different hash, so it searches the wrong bin and doesn't find the entry. When you look up (table), it finds the right bin, but the only key in that bin is h2. Since h2 is not currently equal? to (table), the search fails again.

I can't reproduce your second example, but what I get is consistent with this explanation:

  arc> h
  #hash(((3 2 . nil) . 3))
  arc> (h '(3 2))
  nil
  arc> (h '(1 2))
  nil

  arc> h
  #hash(((3 2) . 3))
  arc> (h '(3 2))
  nil
  arc> (h '(1 2))
  nil

             (save-table cookie->user* cookfile*)
             (user->cookie* user)

  makeid

  rand-string

https://github.com/rocketnia/rainbow-js

It's not something I'm eager to build off of, for a few reasons:

- Rainbow strives to be consistent with official Arc, in the sense that they can be used to run the same programs. It goes out of its way to implement Arc's warts, making it a more complicated language than it has to be.

- Rainbow.js strives to be consistent with Rainbow, this time in the sense that their code can be maintained side-by-side. I've gone out of my way to make the JavaScript code similar to the original Java code, even if it would have been easier to use more first-class functions or dynamic JavaScript compilation. And if I see a bug, I take note of it but I don't fix it.

- By necessity, I implemented some of the primitive I/O operations in terms of asynchronous JavaScript I/O. This opens up a window for other JavaScript code to run while the side effect is executing. I find it unclear how to make this consistent with either Rainbow or official Arc; both of them support preemptive threading, and yet neither of them spells out exactly which moments in the program are possible preemption points.

  (defop-raw some-fancy-url (str req)
    (w/stdout str
              (anon-login req)
              (prn)
              (some-fancy-url-handler req)))

  (def anon-login (req)
       (if (no (get-user req))
           (withs (user (makeid 14)
                        cookie (cook-user user))
                  (= (logins* user) req!ip)
                  (prcookie cookie)
                  (prn)
                  (save-table cookie->user* cookfile*)
                  (user->cookie* user)
                  )))

  (def some-fancy-url-handler (req)
    (pr "Hello World"))

  ;; And visit /some-fancy-url

(pr req!ip) keeps showing the IP address of the server rather than the IP address of the client.

  (iflet x ((...) :satisfies f)
             'branch1)

  iflet x 2+3 :satisfies even?
            x+1
          3+4 :satisfies even?
            x+2

Need wrapping in parens lest the inner test get wrapped in parens:

  (iflet x 2+3 :satisfies even?
             x+1
           3+4 :satisfies even?
             x+2)

    proxy_set_header X-Real-IP  $remote_addr;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Referer $http_referer;

2. (whenlet var expr ...) could also be written:

  (let var expr
    (when var ...))

3. Another alternative formulation is:

  (let var expr :when (f var)
    ...)

  (let var expr (when (f var)
    ...))

  (whenlet var expr ...)

  (when expr
    (let var expr ...))

  (let var expr
    (when (f var) ...))

  (letwhen (f var) var expr ...)

  (mac letwhen (test var expr . body)
    `(let ,var ,expr
       (when ,test ,@body)))

  (letwhen (even x) x 50
    (prn "I print"))

  (letwhen (even (+ x 1)) x 50
    (prn "I don't print"))

  blah = if (f var) then ... else ...
    where var = expr

  (when (f var) :where var = expr
    ...)

A large part of the problem is that I've been thinking about my proposal as two separate parts: one part deals with backwards compat with Arc, and the other part describes a hyper-static system for Arc.