> (define nil '())
  > (eqv? '() 'nil)
  #f

So what you say is to simplify it to a function 'use' that creates a table of symbols? How do you solve the references within modules? I don't see that, but otherwise it's very good. I would even remove the 'as', and make it a simple optional parameter:

  (use 'foo 'f)
  (f!bar 1 2 3)

  (set f (use "foo"))
  (f!bar 1 2 3)

  (= foo (use 'foo))

  (def function-that-assigns-one-to-a-global-symbol-of-your-choice (s)
    (eval `(= ,s 1)))

  import string

Arc should register in some way that the module was loaded, since if two other modules do (use 'x), then they have to reference the same table. This is, afaik, what Python does. So 'locally' (within the current module), you access the symbol table of another package with the name you want (if you don't supply one, then it's the same as in the file), but the system remembers who is who globally.

Each source file is a module, yes.

To be able to load a list of modules, like

  (map use '(string regex parser))

  from long-named-module import foo1, foo2, foo3

  (use* '(foo1 foo2 foo3) 'long-named-module)

  (set spam 1)
  (def myfun (x) (prn x))

  ;; Uses 'a'
  (use 'a)
  (a@myfun "hi!")

  ;; Uses all in 'a'
  (use* 'a)
  (myfun "hy!")

  ;; Use 'a' as 'z'
  (useas 'z 'a)
  (z@myfun "ho!")

  arc> (use 'a)
  t
  arc> a@spam
  1
  arc> (set a@spam 5)
  5
  arc> (use 'a)
  t
  arc> a@spam
  5
  arc> (use 'd)
  ho!
  t
  arc> (use 'b)
  hi!
  t