# Slate has a concatenative syntax

## Brian Rice — 2000-06-10 20:08:19

    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,

    ~