; solution to the "problem" of improper lists: allow any atom as a list
  ;  terminator, not just nil.  means list recursion should terminate on
  ;  atom rather than nil, (def empty (x) (or (atom x) (is x "")))

  arc> (str "arc")
  6

Even if call position and assignment weren't handled separately, it would still be possible to work off of the length of the argument and the index, without needing a range.

  (+ (str "world") (len "world"))

  (let (a b c) (fn-returning-list-of-3-things)
    ...)

  (if a b
      c d
        e)

  (if a
      b
      c
      d
      e)

arc code or scheme code?

However, in this case I agree with Adlai: pg had even planned on getting ppr to "properly indent long ifs". I presume that means to implement the wavy feature. It's also the convention for Anarki, according to the CONVENTIONS file.

So, here's what I'm thinking should be done for ifs:

1) If you only have three expressions, if-then-else, use:

  (if a
      b
      c)

  (if a b
      c d
      ...
        e)

  (if (a       )
        (b       )
      (c       )
        (d       )
      (e       ))

Another question:

How do people indent do, and, or, etc.:

a)

  (do abc
      bcd
      cde)

  (do
    abc
    bcd
    cde)

Should case be indented like 'if:

  (case
    a
      (b     )
    c
      (d     )
    (e      ))

  (case
     a (b    )
     c (d    )
     (e     ))

  (case
    a-short     (b ...)
    c-very-long (d ...)
                (e ...))

  (case
    a-short
      (b ...)
    c-very-long
      (d ...)
    ; else
      (e ...))

  (each type-frag types
    ; Assemble the ('type name) pairs into two lists, so that we can iterate
    ; through them.
    (case (type type-frag)
      ; If it's a symbol, then we're defining a new name; add a new set of
      ; values, and go.
      sym
        (do
          (zap [cons type-frag _] names)
          (zap [cons nil       _] values))
      ; Otherwise, we're adding a value to an existing variant.
      cons
        ; I changed my mind about the order (now it's (name pred?) instead of
        ; (pred? name)), so I'm reversing it here.
        (zap [cons (rev type-frag) _] (car values))
      ; else
        (err "Invalid member of tagged union declaration.")))

  (def macexn (n expr)
    " Macroexpand `expr' `n' times.  NB: `expr' *is* evaluated!
      See also [[macex1]] [[macex]] "
    (if (and (number n) (> n 0))
      (macexn (- n 1) (macex1 expr))
      expr))

  (cond ((condition1)
         (result-code1))
        ((condition2)
         (result-code2))
        (default-code))

On a possibly related note, when compiling (assign ...) forms, ac.scm calls macex on the 1st arg:

  (assign (foo bar) 12)

This example is from Common Lisp's object system, called CLOS. When you want to do some code while accessing specific slots of an object, you can use a 'with-slots form, which lets you name symbols that you'll use to reference specific slots of the object. The 'with-slots form then generates local symbol-macros for each symbol you mentioned, which expand into code to access those slots. An example, taken from PCL [1]:

  (with-slots ((bal balance)) account  ; Here 'balance is the name of the slot, and 'account is the specific object
    (when (< bal *minimum-balance*)    ; *symbol* is a CL convention for global variables
      (decf bal (* bal .01)))))        ; decf is like --

You can do this to a certain extent already, using package!symbol notation, but this still doesn't allow using symbols without prefixes.

  (def trivial-example (obj with) (foo obj with))

arc-read seems to be designed for easy extensibility although I haven't tried it at all. (If I had looked carefully before embarking upon parser.arc, I might have saved myself a lot of trouble).

parser.arc doesn't support the full range of scheme numbers, nor does it support |foo| symbol syntax yet, apart from ||. I'm working on a new version that will hopefully be faster - welder depends on the tokeniser for syntax highlighting.

parsecomb.arc, if I understand correctly, isn't an arc parser but a library for building parsers.

As the author, you get to name your babies. I didn't agonise over java-new, java-implement, or (ugh) java-static-invoke - they're mostly buried under arc macros in any case.

In the worst case, if there's a conflict with mz (or ac-tunnel), I would recommend an excellent symbol renaming hack available on github at http://catdancer.github.com/load-rename.html