Factor/VocabularyFileout

Currently, vocabularies flow in one direction: from disk to
image. Hopefully someday, they'll flow in the other direction, from
image back to disk.

Let's suppose I'm working on some new project and I'm experimenting at
the listener. I switch to a new vocabulary for the project:

    IN: my-project

And I come up with a few words:

    : a 10 ;
    : b 20 ;

The current state of affairs is such that I can save the image,
restart Factor, and the 'my-project' vocabulary will be
available. However, there will be no sign of it in any of the
vocabulary roots.

So what should the semantics of vocabulary file out be? Let's suppose
there's a 'sync' word. It would "synchronize" the vocabularies in
image with those on disk.

        If a vocabulary exists in image but not in any roots, create a
        new vocabulary on disk.

        If the vocabulary exists in image and on disk, reconcile any
        differences based on the timestamps of the changes.

If I've added words to a vocabulary at the listener, but these don't
exist on disk, then the vocab on disk would be updated.

Programatically filing out vocabularies is an interesting task. We're
used to seeing a vocabulary file structured as follows:

     USING: ... ;

     IN: ... ;

     : a ... ;

     : b ... ;

     ...

A naive fileout mechanism would actually produce a file where each
word is accompanied by it's own 'USING:' statement instead of one
monolithic one at the top of the file. Perhaps there could be some
post-processing to consolidate all the individual USINGs into the
traditional style.

Finally, how to deal with expressions involving parsing words is still
an open problem. I.e. if you do this at the listener:

   TUPLE: abc x y z ;

quite a bit of work is done as a result of parsing the
statement. A fileout mechanism would have to notice the
existence of the 'abc' class and fileout the proper TUPLE statement.

Achiving the fileout capability is important. I think it will
encourage more experimentation with in image vocabulary editing
tools. Another interesting point is that vocabularies can be
viewed as a basic form of persistence. The nice thing is that
vocabularies are much more fine grained than whole images.

Let's say that Factor had a Mac Paint kind of application. I start it
up, draw a picture, and exit the tool. It leave the picture object on
the stack. I go into a new project vocabulary:

    IN: a-new-picture

I then "assign" the object to a word name:

	:> the-picture

At this point I can "synchronize" the system. I've created an object,
given it a name in a new "workspace" and done all of this without
dealing with any files.