arc> (let i 2 (+ i 1))
  3
  arc> (let i 2 (eval '(+ i 1)))
  Error: "reference to undefined identifier: _i"

  > (let ((i 2)) ;Racket
      (eval 'i))
  . . reference to undefined identifier: i

  arc> (time:for i 1 1000 (mywhen '(is i 666) '(prn "Oh no!")))
  Error: "reference to undefined identifier: _i"

One more thing: eval is also much less efficient if you intend to use it repeatedly. By definition, eval performs full syntax analysis every time you use it. In the below example, its argument is a constant, so a smart compiler could theoretically optimize it to run like normal code, but in general its argument would not be constant.

  arc> (= i 0)
  0
  arc> (time:repeat 1000 (++ i))
  time: 2 msec.
  nil
  arc> (time:repeat 1000 (eval '(++ i)))
  time: 145 msec.
  nil

1) actually the "reference to undefined identifier" error can be avoided un-quoting the variables at calling time, as in: (let i 2 (eval­ `(+ ,i 1))) (time:for i 1 1000 (mywh­en `(is ,i 666) '(prn­ "Oh no!")))

2) the last expression is computed in 176 msec, whereas the regular macro 'when' is computed in 2 msec (much faster as you forecasted).

3) these examples don't work in online interpreter Arc Web REPL (http://dabuttonfactory.com:8080/), but they work in TryArc (http://tryarc.org/)

  arc> (let x '(+ 1 2) (repeat 3 (pr x)))
  (+ 1 2)(+ 1 2)(+ 1 2)nil
  arc> (def xrepeat (n . body)
         (eval `(for ,(uniq) 1 ,n ,@body))))
  #<procedure: xrepeat>
  arc> (let x '(+ 1 2) (xrepeat 3 `(pr ,x)))
  333nil

  arc> (let x '(+ 1 2) (xrepeat 3 `(pr ',x)))
  (+ 1 2)(+ 1 2)(+ 1 2)nil

As waterhouse mentioned, two differences between macros and eval are that macros are expanded once when your program is loaded, but eval has to expand and compile its argument every time its called. And like any function eval doesn't have access to the lexical variables of its caller unless you pass in values yourself.

(let x ''(+ 1 2) (xrepeat 3 `(pr ,x)))

but the way you proposed is more "natural" since it respects the "rule" of quoting functions and variables passed at calling time.

It's 'eval that expands its code once every time it's called. If you don't use 'eval at all, then all your arc code will be expanded exactly once, at the time you enter it at the REPL or load it from a file (since those are the points where 'eval is called internally).

When you enter the expression (def foo (x) (obj key x)) is at the REPL, it's evaluated as a two-step process: First it's compiled (which expands the (def ...) and (obj ...) macro forms), and then the compiled code is run. When it's run, the body of the function isn't run yet; instead, it's packed up into a procedure and stored as foo. When you call foo later, no expansion takes place, only running of already compiled code.

A better (but not perfect) way to use 'eval equivalently to 'mac is something like this:

  (def mywhen (test . body)
    `(if ,test (do ,@ body))
  
  (eval `(time:for i 1 1000 ,(mywhen '(is i 666) '(prn "Oh no!"))))

  (def mydo body
    `((fn () ,@body)))
  
  (def mywhen (test . body)
    `(if ,test ,(apply mydo body)))
  
  (eval `(time:for i 1 1000 ,(mywhen '(is i 666) '(prn "Oh no!"))))

  ; The procedure corresponding to an Arc macro can already be obtained
  ; using 'rep.
  (assign mywhen rep.when)
  (assign mytime rep.time)
  (assign myfor rep.for)
  
  (eval:mytime:myfor 'i '1 '1000 (mywhen '(is i 666) '(prn "Oh no!")))