in my case what happens in languages is i hit a ceiling. in some languages i hit it right away, in others it takes a week or two. the worst ceiling imo is lack of first-class functions. beside that, code-as-data is another major lisp benefit. just consider lisp a language with ceilings substantially higher than most other languages

  (repeat (abs pow) ... )

  (def power (nbr pow)
     (withs (acc 1.0
             power+ (fn (times)
                        (repeat times
                            (zap * acc nbr))
                        acc))
            (if
              (> pow 0)
                    (power+ pow)
              (< pow 0)
                    (/ 1 (power+ (- pow)))
              1)))

  arc> (with (x 0 y 0.0)
          (is (+ x 0.0) (+ y 0.0)))
  t

  (def eq args
      (apply is (map [+ _ 0.0] args)))

  (if (is x 0)
      1
      2)

  (prn (if (is x 0)
      1
      2))

  print if x==0
      then 1
      else 2

also, check out the tutorial. despite it being being in .txt (probably for formatting purposes,) it's actually good:

http://ycombinator.com/arc/tut.txt

ken's reference site is also darn handy:

  printf ("%d\n", x == 0 ? 1 : 2);

  (prn (if (is x 0) 1 2)

  cd "c:\documents and settings\account\desktop\arc2"
  mzscheme -m -f "as.scm"

  mzscheme --no-init-file --mute-banner --load-cd C:\path\to\arc\as.scm

thanks for pointing it out

i don't think these are distinct concepts. to me they are the exact same thing except in one case we're attaching a name to what we're making, and in the other we aren't. i can see how people familiar with lisp might see essentially 'lambda' and 'set' in the forms, but on the surface 'fn' and 'def' are very similar

i see the need for say, 'and' and the anaphoric 'aand', but to me def is so redundant with fn i actually do use that (= name (fn (x) ...)) form someone mentioned here

> > Again, overloading should be used sparingly, and only when the concepts are related in a certain way that I won't bother trying to articulate right now.

i agree, but again i don't think this is an inappropriate case. what i would like to see in Arc is something that Lua does in various places. the best example is its tables, which are simultaneously arrays, hash tables, and with its metatable system, any other structure you can think of from multiple-inheritance objects to arbitrarily-linked lists. and they act respectively depending on how they're used. eg if you use a table as an array it will iterate fast. the result is that the programmer is relieved of the details of choosing and using structures, and can instead focus on actually using them

is Lua's implementation of tables more sophisticated than arrays, hash tables, etc would have been individually? definitely. but it relieves the programmer of a lot of thought that is able to focus on something else. tables are definitely simpler than if their functionality was spread out, yet no functionality is lost compared to such a model. in fact, functionality is gained through the flexibility

by upping the sophistication underneath, a language can become simpler. if you only rely on the sort of simplicity brought about by a pure axiomatic approach, you get a sort of "assembly" simplicity. is MOV DX,8 simple? yes, but for naught

(not to blitzkrieg with text, but i thought i would explain the philosophy in one place)

> > for certain things like varargs

full varargs would be the only alteration

> > Doesn't that hurt your eyes?

Please see (and refute if you like) my comment at http://arclanguage.org/item?id=5213 .

There is some significant complexity in setting a variable. Note the current existence of four (or more) different forms of 'fn: 'fn (anonymous), 'afn (capturing 'self as a local name), 'rfn (using a user defined local name), and 'def (using a user defined global name). All these forms exist for the purpose of creating functions, but they each has a different way of setting varaibles.

that's if we're looking at it from the perspective of the operator. but if we look at it from the perspective of an expression, i think it is simpler. to illustrate: one of the nice examples on the front page of ruby-lang.org is the following (keeping their comments):

  # Ruby knows what you
  # mean, even if you
  # want to do math on
  # an entire Array
  cities  = %w[ London
                Oslo
                Paris
                Amsterdam
                Berlin ]
  visited = %w[Berlin Oslo]
 
  puts "I still need " +
       "to visit the " +
       "following cities:",
       cities - visited

and the optional args parameter. (def fun (a (o b)) ...) isn't called like this: (fun (1 (o 2)))

  (= a 0)
  
  ((afn ()
     (pr ++.a)
     (if (isnt a 8) (self))))

  (= a 0)
  
  (drain (do (pr ++.a)
             (isnt a 8)))

  (drain:do
    (pr ++.a)
    (isnt a 8))