Bruce Long
unread,Jun 18, 2011, 2:03:51 AM6/18/11Sign in to reply to author
Sign in to forward
You do not have permission to delete messages in this group
Either email addresses are anonymous for this group or you need the view member email addresses permission to view the original message
to Slipstream Proteus Developers
Greetings all,
I hope everything is going well. The good news is that the software is
getting closer to being grokable without 10 hours of study. But there
are a number of things in the program that have become "hack-like"
over time. The features of the language that I am working on intersect
with those things such that the hacks will become more entrenched if I
don't do something now.
The upshot is that I'm adding a number of inter-related features and
syntax improvements at the same time that I am refactoring the
existing code. I'd like to express what I am doing in this email, both
to communicate and document as well as to request comments. (Hopefully
this will be a REAL request for comments and not a specification of an
already-vetted standard.)
The biggest change is in the way searching and functions work. The new
change will allow a closer mapping to English, provide a pretty way to
express chains of composed functions or nested searches and most
importantly, it facilitates a better syntax for "searching to write"
vs. read only searches. The new syntax will also facilitate some new
semantics which will reduce the need for the \\\^[...] syntax that is
so hard to grok.
Here are the new rules:
A list given in square brackets evaluates to it's last member unless
the operation performed is the inverse function. In that case it
evaluates to it's first member. (Also, recall the result of a list
like [itm1, itm2, <itm3>, itm4] which evaluates to the item marked
with "<...>". This is rarely needed.)
In function mode we set the first item of a '[...]' list to the
arguments like this:
[args, var1, var2, ..., var n, return] <: {argument 1, argument 2}
With function tags this looks like so:
sqrt <: 9
We can compose functions like so:
f <: g <: h <: 9
In a C-like language this would be:
f(g(h(9)))
But we can also do this backwards if we want it to look like a list of
things to be done:
9:>h:>g:>f
We can invert a function like so:
3!>f!>g!>h OR 3 <! f <! g <! h
Semantically, "LIST <: item" and "item :> LIST" assert that item is
the first element of list.
Similarly, "LIST <! item" and "item !> LIST" assert that item is the
last element of list. (And BTW, return the first item of LIST instead
of the last one).
Similar changes are underway for searching or "indexing" as I have
called it before. Though the details of that are not final and I want
to get this post off.t
OTHER HIGHLIGHTS:
* The normalize function will be broken up and smaller.
* infon.flags will be reorganized
* I have found a way to retain language agnosticality while still
allowing keywords. The keywords will substitute for symbols. So you
could create a French version, a Japanese version, etc. The connection
with natural language has been hard for non-technical folks to see
until now.
I'm off to code.
Bruce