Anarki – Community-managed fork of the Arc dialect of Lisp (opens in new tab)

No offense, but I found your example code really confusing.

For the benefit of people familiar with Common Lisp:

  * (= ...) is assignment, not equality testing
  * (map list index-list) is equivalent to (loop for index in index-list collecting (nth index list)), or in a more FP style (mapcar (rcurry #'nth list) index-list)
  * (map function list) is equivalent to (mapcar function list)

I think your example would have been less confusing if it used larger numbers to highlight where addition was happening and where indexing was happening:

  arc> (= l '(4 5 6))
  (4 5 6)
  arc> (= f [+ _ 10])
  #<fn: f>
  arc> (map l '(2 1 0 0))
  (6 5 4 4)
  arc> (map f '(0 1 2))
  (10 11 12)

I don't know Arc, so this confuses me:

  arc> (map l '(0 1 2))
  (1 2 3)

What is the logic here? Is l made into a function that holds state and returns each element in turn (like an iterator function)? Because I would've expected:

  arc> (map l '(0 1 2))
  ((1 2 3) (1 2 3) (1 2 3))

In what way is map being applied here?

This was discussed a lot before (according to Queinnec book at least) but people were worried that too much overloading would yield confusing code and bugs.

Wow next time don't use

  1

and

  l

in the same code listing.

Clojure’s maps, sets, and vectors are all functions.

Kind of like pattern matching in Elixir?

I don't really get why you'd ever want a Lisp-2. Is there an argument/explanation somewhere that I could read up on?

(I've used Clojure and JS, which also seems like a "Lisp"-1 in that you can just put fns into variables and call them like 1st class fns, I just don't get why the distinction is in any way positive rather than confusing, and in Lisp-2s you now need to dereference everything all the time, like in Ruby).