NEVER USE POINTERS, ALWAYS USE _NAMES_.
Then it's much easier to change what they refer to, for example.

???

Eeek, this is kind of the opposite of my graphical language idea, isn't it?

(maybe synthesis now??)



I think everything of significance within a certain context does need a name,
that name may be more than one word!

A quoted sentence may be a name of something dealing with that subject....??:
  `Why People Don't Heal and How They Can'




a lexical scope is implemented as a hash (table), just like (lua"s) global scope, and packages

virtual tables that merge several actual tables, or else inherit from parent tables?
A class can just be a table, just like an object.

Have a `cd'-like command for changing the `current' table.
Normally it will be the current lexical scope, merged with parent lexical scopes,
and eventually the global scope.

Need to be able to implement table values that are computed when read, and perform actions when written to.  Do this using reference types?

We have different types of values - how about different types of references? ???



simplify lua"s syntax.  Don"t require () for function call, or , for separator.

print 1 2 ; print 2 3

is better than:

print(1, 2) print(2, 3)

I guess it"s a matter of taste...  I think I like pliant"s syntax a lot.



table init syntax is:
    a = {x=0, y=0}
should be:
a = table
	x: 0
	y: 0

or
a = table(x: 0  y: 0)

maybe...


distinguish _objects_ and _values_ ?

immutable strings?





Don"t distinguish plurals from singular,
so tables can have multiple entries with the same key. ????

ops + - * / ^ can all work on plurals just as well as singulars....
well in fact not; only if they have the same number,
and are ordered.

Maybe should be different syntax for `get 1 by key' and `get all having key',
the first should have `0' and `multiple' exceptions...  Sounds good...

But how to change the table?  We can delete all by key, delete 1 by reference, ...

Have table as a list of name maps.  But we"re back to name maps again, which are the lua `table'!  We can regard a `name map' as a `name (referent)' table.

What is a good name for that which is named?  Do we have such a word in english?  What about in Latin?  nomen, nomand ?

sum summand ?

I should learn Latin again, I think it's a good language.



sum - to be,

so a `sum' in math, is an equality or being equivalent??





allowing names with spaces in them is important, e.g for a book
`Why People Don't Heal and How They Can'
`The Rite of Spring'
`Beethoven"s 5th Symphony'

Names are presented in italics in math (var names) and for book names, is this
a good convention?  In English we use capital letters for most names (proper nouns: place names, people names; book titles)




I like the term dict or glossary better than hash or lua's `table' (which latter is highly confusing with `RDB table' to me.




I think lua's table idea where each table is both an array and a hash is not good,
it should be each table is an array, and it may be an array of binding
(alt: namings?), and it may be indexed either by ordinal position or by name.  In
addition, the array may store non-binding elements.

Thus it fits the common `ordered dictionary', or `ordered structure' model, such as debian package list entries, personal profiles, ...




Hey, I've been very dark on putting things in a specific order; but the natural numbers do have an order after all!  cardinal (size - think cardinality), ordinal (order or position, 1st, 2nd 3rd,...)   a = []  a.length() is a cardinal, a[x], x is an ordinal

That's interesting, cardinals are commonly outputs, ordinals inputs... ?



-----------------------------------------------------------

name space
relation
action
event


time
  before, after * then

clock


number
  0 nothing
  1 something

Interesting, that people use decimal, computers use binary, so a nice simple human number like 1,000,000,000 is very complex for the machine!


distance / locality of components (i.e. on separate machines, etc.)


box ??  (variable)





space
object
node
link
channel