I agree with you and am working on it. The only reason I've hesitated with that feature is that certain errors reveal information about the sandboxing mechanism I'm not sure I want people to have.

  arc> (system "ls")
  subprocess: `execute' access denied for /bin/sh

Other than that, it's really rather cool. Great job!

Now that I have better command over the language, these things don't bother me so much. They have their own sense, and I increasingly appreciate how "externally exposed names [are] approximately hamming encoded." [1]

  (mac loop (start test update . body)
    (w/uniq (gfn gparm)
      `(do ,start
           ((rfn ,gfn (,gparm) 
              (if ,gparm
                  (do ,@body ,update (,gfn ,test))))
            ,test))))

  (mac aloop (start test update . body)
    (w/uniq (gfn gparm)
      (mac continue ()
        `(do ,update (,gfn ,test)))
      `(do ,start
           ((rfn ,gfn (,gparm) 
              (if ,gparm
                  (do ,@body (continue))))
            ,test))))

   ; s/loop/aloop/ was the only change from for's definition
  (mac afor (v init max . body)
    (w/uniq (gi gm)
      `(with (,v nil ,gi ,init ,gm (+ ,max 1))
         (aloop (assign ,v ,gi) (< ,v ,gm) (assign ,v (+ ,v 1))
           ,@body))))

  ; prints i from zero to ten, skipping odd values of i
  arc> (afor i 0 10
         (if (odd i)
              (continue)
             (pr i)))
  *** redefining continue
  0246810nil

  (afor i 0 10
    (afor j 0 10
      ...
      (continue)
      ...
      )
    ...
    (continue)
    ...
    )

I recommend sticking to an anaphoric variable that has no macro wrapping it, sort of like this:

  (mac aloop (start test update . body)
    (w/uniq (gfn gparm)
      `(do ,start
           ((rfn ,gfn (,gparm) 
              (if ,gparm
                  (let continue (fn () ,update (,gfn ,test))
                    ,@body
                    (do.continue))))
            ,test))))

Very good point, I hadn't tried to nest them before.

(afor i 0 3 (when (odd i) (continue)) (prn i)) goes to:

0

2

4

5

Why make another web-based repl for arc when there is already palsecam's evsrv [1], nostrademons' ArcLite [2], thaddeus' wterm project [3] and pg's prompt.arc? (Are there others?)

These projects don't serve identical purposes. Try Arc is meant to be a tool for introducing people to Arc in a hands-on way. Sandboxed eval makes this safe and Chris Done's jquery-console makes it convenient (that is, once I've worked some of the kinks out). It is probably suboptimal for real development though (beyond as some sort of scratchpad) since it doesn't offer persistence: accidentally refresh the page and you lose your work.

prompt.arc, on the other hand, is nice for real development. Not only can you try things out at the repl, but you can plug them in as real applications at the prompt. However, it wouldn't be as good in the Try Arc context since it calls raw eval, granting access to the underlying system (it's a double-edged sword).

evsrv is great. Sandboxed eval plus persistence for multiple users, and you can even start an anonymous session, all at an ajaxified terminal? palsecam mentioned in [4] that he used mzscheme for sandboxing as well; there may be some useful ideas in what he's done for this project.

I haven't actually tried what thaddeus did, has anybody else? I also have less to say about ArcLite, except that it's awesome he got a working implementation of Arc in JavaScript.

[1] http://dabuttonfactory.com:8080/

[2] http://jonathan.tang.name/files/arclite/index.html

[3] http://arclanguage.org/item?id=10604

The REPL points out that it's "lacking certain refinements". These correspond roughly to the TODO list at http://evanrmurphy.posterous.com/try-arc-todo. Bug reports and other feedback are very welcome.

By the way, an end-user can emulate stdout by doing something like this:

  (def eval-w/stdout (expr)
    (tostring:let result nil
      (let output (tostring (= result (eval expr)))
        (unless (empty output)
          (prn "output: " output))
        (write result))))

  arc> (eval-w/stdout '(time (reduce + (n-of 1000 rand.100))))
  output: time: 339 msec.
  
  49840

1. stdout now displays properly.

  arc> (pr "hello")
  hello"hello"

   (def eval-w/stdout (expr)
  -  (tostring:let result nil
  -    (let output (tostring (= result (eval expr)))
  +  (tostring:withs (result nil
  +                   output (tostring (= result (eval expr))))
         (unless (empty output)
           (prn "output: " output))
  -      (write result))))
  +      (write result)))

  arc> (plural 2 "dog")
  "2 dogs"

  ; not indenting properly
  arc> (ppr:macex1 '(accum a (each  x '(1 2 3) (a x))))
  (withs (gs954 nil
  a
  (fn (_) (push _ gs954)))
  (each x (quote (1 2 3)) (a x))
  (rev gs954))t

  arc> (tag strong (link  "Arc Forum" "http://arclanguage.org"))
  <strong><a href="http://arclanguage.org">Arc Forum</a></strong>"</strong>"

  arc> (def average (x y)
  >      (prn "my arguments were:  " (list x y))
  >      (/ (+ x y) 2))
  #<procedure: average>
  arc> (average 100 200)
  my arguments were: (100 200)
  150

That is an awesome bug/feature.

To be sure, what you get at that repl isn't pure arc3.1 (at least for now it's not). It's arc3.1 plus anarki's $ minus libs.arc. So since it has $, you can drop to scheme without even exploiting rocketnia's discovery. You just can't do much harm there (at least, you're not supposed to be able to do much harm there, and you just helped me gain a bit of confidence about that).

It does concern me that you're able to see the current directory and version, but I guess as long as you're not able to change anything on the system it might be ok.

(Someone has to try these things out, and it may as well be me, who intends to do no harm, before it's someone else, who might feel mischievous.)

http://www.paulgraham.com/arcll1.html has a nice high-level discussion of syntax in Arc.

do you go directly to the source file to view how the dot is implemented?

  (mac afn (parms . body)
    `(rfn self ,parms ,@body))