'do, as in the following[1]:

  (if (< (rand) 0.5)
      (do (prn "No, Mr. Bond, I expect you to die...")
          (-- mi6 007)))

>2.find with a :key in Arc

An example in Common Lisp, just to make sure we're talking about the same thing:

  [1]> (find 'vader
             '((indiana-jones whip snakes)
               (vader lightsabre light-side)
               (dijkstra EWDs goto)))
  NIL
  
  [2]> (find 'vader
             '((indiana-jones whip snakes)
               (vader lightsabre light-side)
               (dijkstra EWDs goto))
             :key #'car)
  (VADER LIGHTSABRE LIGHT-SIDE)

  arc> (find [is (car _) 'vader]
             '((indiana-jones whip snakes)
               (vader lightsabre light-side)
               (dijkstra EWDs goto)))
  (vader lightsabre light-side)

[1]Yes, this is just 'when. Shush, it's an example.

  ; Common Lisp:
  (flet ((f (x y)
           (blah blah x y)))
    (remove-if-not f xs))

  ; Arc:
  (let f (fn (x y)
           (blah blah x y))
    (keep f xs))

  arc> ''nil
  (quote nil)
  arc> ''arst
  (quote arst)
  arc> (coerce ''nil 'string)
  "quote"
  arc> (coerce ''arst 'string)
  "quotearst"

  arc> (with (indiana (obj hat 'fedora weapon 'whip)
         vader (obj hat 'helmet weapon 'lightsaber)
         bond (obj weapon 'walther-ppk))
        (coerce (map [_ 'hat]
                     (list indiana vader bond))
                'string))
  "fedorahelmet"

  arc> (with (indiana (obj hat 'fedora weapon 'whip)
         vader (obj hat 'helmet weapon 'lightsaber)
         bond (obj weapon 'walther-ppk))
        (trues idfn
               (map [_ 'hat]
                    (list indiana vader bond))))
  (fedora helmet)

I agree 100% about different group requiring different landing pages. Both of the ones you mentioned are good targets, I think. I'll do more keyword research to help dissect the audiences.

The beginning programmers' page is easiest, because pg's tutorial already targets them:

"This is a brief tutorial on Arc. It's intended for readers with little programming experience and no Lisp experience. It is thus also an introduction to Lisp."

All we have to do is put the tutorial in an iFrame next to the REPL, as thaddeus suggested. [1] I can take care of this one. (Eventually it would be cool to have an interactive tutorial though, as you suggested.)

Can I get your input on a page that targets a Lisper who's new to Arc? They can be coming from the Lisp dialect of your choice.

And what other audiences would you consider? Maybe people new to Lisp but coming from other programming experience, such as Ruby or JavaScript?

--

  screen-x: "Narrowest" 700 
            "Narrower" 800 
            "Narrow" 900 *default*
            "Wide" 1200  
            "Wider" 1400 
            "Widest" 1600
 
  screen-y: "Shortest" 400 
            "Shorter" 500 
            "Short" 600 *default*
            "Tall" 750 
            "Taller" 900 
            "Tallest" 1200 

If you would like you can create an account on PetroEnergyNews then go to the user preferences to select the various combinations to get a feel for these sizes.

The "Widest" by "Tallest" setting is perfect for my 27 inch iMac screen :)

Anyways hopefully this info is helpful/useful.

[edit:

1. oops, that's only the map inset window, so it doesn't include the top and bottom bars, but still they should be easy to guesstimate at about 24px each.

    (def amicable (n)
         (let step (sum-divisors n)
          (and (isnt n step)
               (is n
                   (sum-divisors (sum-divisors n))))))

    (def amicable (n)
         (let step n.sum-divisors()
              (and n.isnt(step)
                   n.is(n.sum-divisors().sum-divisors()))))

When nesting tables in Arc, you write something like this:

    ((nested-table user-id) name)

    name.user-id.nested-table()()

    name.(user-id.nested-table())()

    (user-id.nested-table() name)

    nested-table.user-id.name

  foo.bar(qux);

  (foo<-bar qux)

  (car foo)

  (foo<-car)

I think, ideally, Arc should allow you to change the syntax, on a file-by-file (expression-by-expression?) basis. Then the default could be what it is right now, but still allow people to write with whatever syntax they want. Arc isn't there yet, but I think that's a nice ideal to strive for.

---

P.S. Somewhat related, is the concept of "sweet expressions": http://www.dwheeler.com/readable/

With sweet expressions, you can write "foo(bar)" rather than "(foo bar)", but it still allows you to use "(foo bar)" when you want to. In other words, it lets you mix-and-match Lisp syntax and more traditional syntax, even within the same file. So you can use whichever one happens to be most readable at the time.

---

  (let-values ([(from-server to-server) (tcp-connect "google.com" 80)])
              (write-string "GET / HTTP/1.1\nHost: google.com\n\n" to-server)
              (close-output-port to-server)
              (do ((response (read-line from-server) (read-line from-server)))
                  ((eof-object? response))
                  (write response)
                  (newline)))

  (xdef tcp-connect (lambda (host port)
                      (let-values ([(from-server to-server)
                                    (tcp-connect host port)])
                        (list from-server to-server))))

To read the response body, web.arc just says (tostring (whilet line (readline in) (prn line))). Apparently it there's EOF detection somewhere in this process....

Still, that spurious "?&" would probably break other pages, so I committed a fix: https://github.com/nex3/arc/commit/ea05adec8235fe3713b05dd9f...

Here's how to use web.arc:

  (load "lib/web.arc")
  (google "foo")              ; It comes with its own Google demo. :-p
  (get-url "www.google.com")