https://github.com/wting/hackernews
This is a great place to start with understanding Arc, as the jump to Anarki (an Arc fork) will make more sense as it comes bundled with News - a Hacker News style app - which is fun to play with if you have experience with HN and want to try a variation of this site.
arc> (= l '(1 2 3))
(1 2 3)
arc> (= f [+ _ 1])
#<fn: f>
arc> (map l '(0 1 2))
(1 2 3)
arc> (map f '(0 1 2))
(1 2 3)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)
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) arc> (map l '(0 1 2))
(1 2 3)
arc> (map l '(0 1 2))
((1 2 3) (1 2 3) (1 2 3))
1
l
Wouldn't it be better to separate CSS and JS into separate, static files and only have the forum deal with, at best, IDs and classes in HTML?
I'm asking because I'm tempted to actually try to fork it and make a PR for it but it seems like such a simple and obvious bit of housekeeping that I have to assume there's a reason no one else has bothered yet.
[0]https://github.com/arclanguage/anarki/blob/master/lib/news.a...
Interesting to see what this will lead to.
(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).
And looks like an easy trap for misreading code ...
> In Arc, data structures can be used wherever functions are, and they behave as functions from indices to whatever's stored there.
(quoted from the Arc tutorial)
So
arc> (l 0)
1
But I like this particular feature. If you think about it, an array is a mathematical function, or map, from indices to values. So it makes sense to be able to apply it to indices to get the respective values.
Clojure is definitely better thought out as a language, and while Arc has some interesting ideas around web development, it also doesn't have a module system, so everything is just loaded into the same global namespace, which is pretty insane.
I don't know that any programming language can be everything it needs to be from the outset, but it certainly needs inherent featured supporting longevity, a framework that supports change and evolution, while still having a pleasing and useful function that can be taken advantage of immediately.
To say they are functions would be incorrect. By the same logic, a keyword is would be a function.
Oh and (#{1 2} 3) is equivalent to (get #{1 2} 3) not (contains? #{1 2} 3)
So point taken.
(your-macro
(let ((x (foo y))
(bar x))))
Where your comments falls down is that all the Lisp-2s I know allow the "function definition" of a symbol to be overriden in a similar way, e.g., in Common Lisp the macro might expand to (flet ((bar (arg) (* 5 arg))) (let ((x (foo y))) (bar x))) where FLET is a macro similar to LET but for function definitions.
Also, of course, you must use gensyms for any locally bound identifier, whether it is a let or flet. Nobody said that Lisp-2 allows for labels and flets without having to use gensyms; nobody in their right mind is going to lexically bind identifiers in macro-generated code that don't use gensymed names (other than in cases when there is no possible capture).
Lisp-2 addresses (in a good-enough-beats-perfect way) the following problem: the programmer's code wrongly capturing references that the macro would like to use.
The macro wants to generate some (foo ...) call to a function in the global environment. But, oops, in a Lisp-1, a user's local variable foo takes this. In a Lisp-1, the user would have to have a local function by that name.
If global functions have reasonably descriptive names, and local functions are used sparingly, the potential for a clash is low.
We can have a warning when a local function shadows a global one; it won't be too much of a nuisance since global functiions tend to use descriptive names, and local functions are relatively rare compared to local variables.
(def str “foo”)
Additionally, I think we’re pretty used to “separate namespaces” for nouns and verbs in normal languages: it’s fairly rare, for example, for the word “run” to be ambiguous between its noun use and it’s verb use, in the context of a sentence.
It is not true syntactically, because special operators are recognized only in the leftmost position, as are function-style macros.
But it is not even true when all symbols in the form are variable bindings. Because at some point, the function is called, and that is not uniform. The leftmost thing is treated as a function being invoked, and the others as arguments being passed. These are different categories. We take the leftmost object and activate its ability to behave as a process; and we don't do that for the other objects. That's effectively a different semantic space.
Objects potentially have two "semantic bindings": a binding to the ability to behave as a function (denoting a process which takes arguments and produces values, and possibly side effects) and the trivial binding to the value that they denote; e.g. the integer object 3 to the abstract integer three. These bindings are two spaces, effectively. Therefore, Lisp-1 doesn't get away from two spaces. It resolves the leftmost object of a call form in the "function behavior space" and the remaining objects in the "value denotational space", in order to bring about a function call.
Lisp-2 has a cleaner story/explanation of operators. It simply embraces the idea that the left position and argument positions are different, through the entire evaluation stack, rather than trying to pretend they are the same.
In a Lisp-2, you cannot write an expression which refers to an operator as if it were a variable. Whereas in Lisp-1, meaningless nonsense like (progn progn) is possible, in a Lisp-2 this can exist with a meaning. The potential that we can give any form meaning is a core theme in Lisp. The fact that we can bind a progn variable so that (progn progn) works is more "Lispy" than having to give up and conclude that it's an absurdity.
At this point I'm so used to lisp-2 that I make all sorts of silly mistakes when I program in a lisp-1. In English, a word could be a noun or a verb depending on its position in a sentence, so there is a parallel there. Whether or not it's a good thing is a matter of taste.
The only clearly objective difference is that lisp-1 is simpler, which is probably why most lisps created in the past 30 or so years are lisp-1s.
The advantage of a Lisp-2 is that it makes macro writing easier; you can include calls to known functions in the expansion without having to deal with the possibility that those names have been shadowed.
A variable foo, referenced as $foo, has nothing do with a function foo called as "foo args ...".
Imagine how stupid it would be if assigning a variable called ls prevented the ls command from working.
In addition to the simplified hygiene, one consideration is that Lisp dialects typically have mutable variables. But the ANSI-Lisp-style labels and flet forms bind functions immutably. Thus a compiler never has to suspect that a local function will change.
In TXR Lisp, developed a way to combine Lisp-2 and Lisp-1 into a single dialect, to get the best of both with almost no downsides. In a nutshell, the square bracket syntax performs Lisp-1 style evaluation: [a b c] means expand/evaluate a, b, c in the same mannner, and then treat the value of a as a callable object which receives the values of b c.
Furthermore, any arguments of [...] which are symbolic (after macro-expansion) are treated in a combined namespace which contains both function and variable bindings. When the symbol is global, if it has both kinds of bindings, preference is given to the variable.
This [a b c] is a sugar for (dwim a b c), which is a special operator that is recognized properly by the macro expander, interpreter and compiler, including the various shadowing corner cases between macro and ordinary bindings.
Thus, there is no reason to have to choose between Lisp-1 and Lisp-2.
However, the implementation is a bit more complicated than just Lisp-2 alone, never mind Lisp-1.
Someone with insight mentioned that there was a belief that it would be easier to optimize separate namespaces, but that reality proved them wrong, but I haven't verified that claim.