I think this is a great idea, and should be a standard feature for anything that calls itself a 'reprogrammable programming language'. After all, the ultimate in reprogramability is being able to recode the interpreter itself.
I have a different suggestion for implementing it: instead of redefining the interpreter, have a macro that is called on every expression before it's interpreted. The macro would compile the expression down to canonical Arc, which could then be executed by the standard interpreter. Not sure what the pros/cons are of doing it that way, but it sounds to me like an easier hack than redefining the Scheme function.
All macros in an expression are expanded before any part of the expression is executed. So (assign k (h k)) will be expanded before each is executed, and at that point k has no value, so (eval k) will fail.
So you need to move eval into the result of the macro expansion, and avoid calling it in the macro expansion itself:
Really? I thought easy list concatenation was the better idea. Arc is a list-based language, and concatenation is a very basic list operation, so I thought it would be a good thing to optimise it as much as possible.
You could use Arc templates, which are an easy way of saving and loading Arc objects to/from text files. That's what this forum uses. I believe kens' site has some documentation for this, or you could look at the news.y source code.
If you want to use a SQL database instead, someone wrote an interface for it and posted it to the forum (maybe also on Anarki?) but I can't find it with Google.
It looks like some Ruby program has dropped a cookie. defop-raw will bring back all cookies created by localhost, so perhaps you've been running some Ruby web service from your machine?
Just to add: if you want your function to take any number (including zero) arguments, then just use a symbol instead of an argument list, and all the arguments will be bound to that symbol.
So if you have
(def foo (a b . c) ...stuff...)
and you call (foo 1 2 3 4 5), a is bound to 1, b is bound to 2, and c is bound to the list (3 4 5).
And
(def foo a ...stuff...)
is just shorthand for
(def foo ( . a) ...stuff...).
So calling (foo 1 2 3) in this case means a is bound to the list (1 2 3).