I took a quick look at Arc. If nothing else, I want to see how it compares to Scheme. Here are a few remarks (in no particular order).
- = is used for assignment rather than for equality testing. This may be confusing to people using other variants of Lisp. Possibly less so to users of languages that use the same operator. Still, inside parentheses it looks a bit odd: (= x 4)
- Many abbrevations! Quite a few of them seem gratuitous; I’m used to def, but what about mac, rem, pr, prn, fn, o, and so on, some of which only shave off a character or two. It makes the resulting code a bit shorter, but whether it’s clearer is a different issue.
- The [ ... _ ... ] syntax seems useful. This is basically a shortcut for simple lambdas, e.g. [+ _ 1] is equivalent to (fn (x) (+ x 1)).
- Odd assignment rules for lists and hash tables. E.g. if airports is a hash table, then (airports “Boston”) looks up the key “Boston” in there. This also works in assignments: (= (airports “Orlando”) ‘mco). Lists work the same way, if I understand correctly. Personally, I think it’s a bit confusing, and I’m not sure it’s a good idea to overload this kind of syntax. (foo bar) can now mean: function application, hash table lookup, list lookup…
- On the other hand, you get to do table lookups with map:
(map airports ‘(“San Francisco” “Orlando” “Paris”))
=> (sfo mco cdg)
- On a side note, the use of hash tables for dictionaries, and the keys and vals functions to get keys and values, look suspiciously Pythonic. :-)
- Compose functions with “:”:
odd:car is equivalent to (fn (x) (odd (car (x)))
- “Negation” operator ~:
~odd? is equivalent to (fn (x) (not (odd? x)))
N.B. It’s not hard to do the same thing in Chicken… I already talked about defining custom literals in a separate post, and an implementation of ~ would use the same mechanism. More about this later.
- if with more than 3 arguments is a nested if… e.g.
(if a b c d e) => (if a b (if c d e))
- Some forms were reinvented without parentheses, which is much clearer, IMHO. E.g.
(let x 1 …body…)
(with (a 1 b 2) …body…)
Compare this to the parentheses-fest that is let in Scheme and Common Lisp. :-}
No “conclusion” at this point; I have only skimmed the tutorial and tinkered a bit with the REPL. Plus, it’s likely to change anyway.
On forums, the biggest gripe people seem to have is the lack of Unicode support, and PG’s apparent unwillingless to add it.