I think you're misusing defvar. You can read about defvar at https://awwx.ws/defvar2. In short, to invoke your prompt function everytime you refer to x, say this:
arc> (defvar x (fn() (prompt "> ")))
For example:
arc> (len x)
> abc
3
BTW, I tend to avoid using the interactive repl when I'm performing raw I/O because of the need for the (readc) hack you mentioned. I'd rather just write my code in a script and run it in batch mode.
I was using defvar where I should have been using =. But the idea in my post was just to store the result of (prompt) in the variable x, which is meant to be a string.
And yes, now that I am moving past the experimental phase of my script, I will be running things in batch mode.
Yes, my impression is that "stack-based lisp" describes http://factorcode.org to a 't'. In Factor you can throw code on the stack by a process called.. quoting. And then invoke it inside some other higher-order function.
I'm not sure how many people here follow the github account, so if you have questions just post them here. Don't worry about creating too many posts or comments, it's not like there's a lot of contention here :) Just do what works best for your learning, and we'll let you know if we want you to scale back.
If you see something broken or have suggestions to improve the documentation, post them on Github.
I think you can go pretty far treating Arc as a dialect of Scheme. Arc is basically like Scheme + Lisp-style macros. So until you start dealing with macros things should correspond pretty closely. The names change, as you already noticed, so () is nil and not is no[1]. A second point of difference is that Arc tends to have fewer parens, so for example this Scheme code:
(let ((x 3) (y 4))
...)
turns into this in Arc:
(with (x 3 y 4)
...)
Kinnard is right that the atom primitive is pretty much what you want. The exact transliteration of your definition would be:
(def atom? (x)
(and (no x) (no (alist x))))
Or, with more syntactic sugar:
(def atom? (x)
(and no.x (~alist x)))
[1] Hmm, somebody should write a "Arc for Scheme programmers" primer, just with a quick cheatsheet of common names and their equivalents. Any takers?
That version of `atom?` always returns nil, so I'll offer a correction.
Here's a very direct transliteration:
(= atom?
(fn (x)
(and (no (acons x)) (no (no x)))))
The equivalents for `not` and `null?` in Arc are both `no`, because the empty list is the only falsy value. Scheme uses dedicated values for true and false, `t` and `#f`, but Arc uses the symbols `t` and `nil`, and `nil` doubles as the empty list.
Here's a version that uses the utilities Arc provides out of the box:
Also, from an outside perspective, I think your idea for a "Arc for Scheme" primer would be a great idea. The Little Schemer is widely recommended, so it could potentially result in more people finding their way into Arc.
This is great! The description of quoting using signifier and signified, the description of trees be evoking the nested nature of natural language, .. (still reading)
