Slate has a concatenative syntax

[Brian Rice]

NOTE: this has been cross-posted to 3 mailing lists. Keep that in mind if 
you reply.

Some of you fellows are from the Tunes list, so you have heard a little of 
this language.  The language is pretty basic... objects are namespaces that 
sit in a graph, with the (unidrectional) connections representing either 
slots in the objects or names within namespaces, depending on your perspective.

Slate expressions are just concatenations of lookup directives (i.e. name 
the next object in the chain and you're there). So there's a namespace 
stack to follow evaluation of expressions. There's exactly one special 
syntax operator, and it pops the namespaces off of the stack and causes 
evaluation. For our first round at creating an environment, the system will 
be much like a hierarchy, with "<" slots forming the basis for obtaining 
other objects. Note that this doesn't pop namespaces off the stack, it just 
causes the expression's path to double-back. Executable code is possible 
because the object model supports inheritance of behavior and a data-flow 
model between slots. The initial system is sticking with ":" slots for 
assignment and "^" (read "result"). There is also a very powerful 
meta-object system being worked out, but this will also take time.

There's an old (and broken) tutorial at 
http://www.tunes.org/~water/slate-tutorial.html, but at least the syntax of 
the example expressions has been properly updated. (Slate was applicative 
in syntax for quite a while.) I'm rebuilding the tutorial at 
http://diktuon.arrow.cx/list.php?ns=tutorial.

Too much is changing too quickly for me to keep all my documentation 
properly consistent, so please bear with me. This is also why I have been 
so secretive about the development process, since it would wind up 
confusing the vast majority of people without good reason.

Absolutely everything is at the level where the user can work with. Even 
the "." operator will be available for modification once the compiler is 
ported to Slate in terms of meta-objects and such.

Side Note:
I promised language definition at least a week ago, and it was ready to go 
at that point, but I have had my hands full with my job and with getting 
the documentation system ready.

The Slate language old documentation is at 
http://www.tunes.org/~water/slate-home.html but this will soon be replaced 
by the contents at http://diktuon.arrow.cx. There's a lot of new content 
there, and some re-written and revised Tunes work. The linking system is 
not online just yet, though, so it's not simple to navigate. The system 
will be re-usable for many projects.

Anyway, I'm in the process of opening up this project, since we are 
reaching some very definite and practical specifications, instead of the 
general guidelines we had before.

Thanks,
~