Although it might be better to make a thread pool, where each Arc-side thread is a "task" (which will reschedule itself until it ends), much like how Erlang does it and how SNAP will eventually do it. This will allow you to easily launch and destroy thousands of Arc-side threads on a machine with far fewer cores.

  > (= foo '(1 2 3))
  > (= (cadr foo) 7)
  > foo
  (1 7 3)

  (zap join x '(a b c))

  (= x (join x '(a b c)))

(d::join ...)

  (add-ssyntax-bottom ; Or perhaps -top
    #\! (sym:string 'L #\!))

  (join! foo bar)

  ((sym:string 'join #\!) foo bar)

As an aside, you might want to try this on Anarki:

  (require "ssyntaxes.arc")
  (def foo! (x)
    (= (cdr x) 42)
    x)
  (= bar '(1 2))
  (foo! bar)

I think this convention is good; I'm just somewhat concerned with the fact that foo!bar is plenty overloaded.

Next, when the body of a progn is expanded as part of the arc compilation process, the 'curly token is checked for and replaced with a let.

This means you can also write the following:

  (do (curly (+ 1 2))
      (cons ^ ^))

This function should return '(foo) but returns nil instead:

  (do {}
      (push 'foo ^)
      ^)

  (define (ac-body body env)
    (if (null? body)
      '()
      (if (and (list? (car body)) (eq? 'curly (car (car body))))
          `((let ((^ (begin ,@(ac-body (cdr (car body)) env))))
             ,@(ac-body (cdr body) (cons '^ env))))
          (cons (ac (car body) env) (ac-body (cdr body) env)))))

Here's the main issues I have with it:

1. Breaks the symmetry of declaration vs. use of parameters- If you're using a variable you should see it declared somewhere. It is true that anaphoric macros like 'aif break this rule, but the payoff with these macros is really high because they allow you avoid an entire 'let form. This makes them worth having, anyway.

2. The token count in the body of the macro doesn't change appreciably- Yes, you do have one less 'unquote-splice reference, but that is a pretty small gain.

3. The rule for macros used to be "if you see a comma, data is being spliced in". The comma used to divide the syntactic from the metasyntactic content- This now breaks that rule.

4. The Ampersand is a potentially extremely valuable symbol character that could now no longer be used for other purposes as the language evolves.