(mac mac (name args . body)
    `(set ,name
       (annotate 'mac
         (fn ,(cons 'expansion-context args)
           ,@body))))

That way macros that need it can get it, while macros which don't need it can ignore it.

We can potentially define 'expansion-context as a table or function, and potentially we could allow an implementation to have expansion-context!line, say provide line number etc. information so that the macro can give decent error messages. Of course if we have a dorky backend (like mzscheme) then we can just have it return expansion-context!line as nil, because it can't somehow extract line numbers, but for implementations that can, then good.

Say we make a convention that we can make a new post on arclanguage.com with the post title "<library>my-library" in order to define a new library called "my-library". Library code must be indented by two spaces as normal to differentiate commentary on the library from the library code itself.

Then when 'require can't find my-library on the local copy, it uses http-get, trawls through http://www.google.com/search?q=site:arclanguage.com+%22<... , and searches for the newest post on arclanguage.com, downloads it, then parses out the library code.

LOL.

That would be cool, but probably stupid.

  (= pusher cons)
  ; push is defined in arc.arc
  (mac my-push (e l)
    `(symeval!pusher ,e ,l))
  (let pusher (fn (x ls) (+ ls (list x)))
    (prn (my-push 'a '(b c d)))
    (prn (pusher 'd '(a b c))))

example:

  (let list '(foo bar) (do (prn list)))
    |    |   unbound    |    |    |
   mac   |             mac   | function 
      function            function

  =>(let (global list) '(foo bar) (do ((global prn) (global list))))

Well, maybe, but we'd probably need 1) destructurable functions (so we can serialize functions), 2) some way of iterating over global variables, 3) a decent sense of 'eq?, one which returns false for distinct mutable strings, preferably in an easy eq?-key-compare association table (so we can properly/easily serialize recursive structures).

Arc-on-mzscheme actually maintains a table of globals that have been ever assigned, together with the last known arc-side assignment (IIRC it actually keeps two copies of the global, one in the table and one in the actual mzscheme global variable space).

edit:

@lboard: I also somehow doubt you want to save the whole interpreter environment; probably you just want something like this:

  (mac restartable body
    `(*restartable-f (fn (restart) ,@body)))
  (def *restartable-f (bf)
    (bf (point ret (afn () (ret self)))))

  (restartable
    (initialize-me)
    (while foo
      (if
        (some-event)
          (do-something)
        (some-error-occured)
          (restart))))

  (def my-do-something (restart)
    (if
      (some-event)
        (do-something)
      (some-error-occured)
        (restart)))

  (restartable
    (initialize-me)
    (while foo
      (my-do-something restart)))

   #hash((a . 1) (b . 2))

?

  arc> #hash((a . 1) (b . 2))
  Error: "Type: unknown type #f"

  arc> (= h (read "#hash((a . 1) (b . 2))"))
  #hash((b . 2) (a . 1))
  arc> h!b
  2
  arc> (= h!b 3)
  Error: "hash-table-put!: expects type <mutable hash-table> as 1st argument,
  given: #hash((b . 2) (a . 1)); other arguments were: b 3"

> Something that should be researched is if having an array type is not a premature optimization.

  (def >> (parm . args)
    ((afn (parm args)
       (if (no args)
           parm
           (self ((car args) parm) (cdr args))))
     parm args))

  (def >> args
     (rreduce (fn (a b) a.b) rev.args))

  (def >> args
    ; throw an error here so that user won't get
    ; mysterious errors in the 'reduce part
    (if (no args)
      (err "'>> requires at least one argument"))
    (reduce (fn (a b) b.a) args))