Holy morphing specifications...

...Batman. TinyLang morphs into something I had not expected. A language where being specific is possible as well as being fuzzy / soupy.

Am a bit confused over the syntax but I think keeping it simple is important as is keeping the code clean and maintainable.

Will be heading out soon for a long walk. Resume later...

Was hard to do any work as the mindspace is rife with conflict. Haven't taken my meds. Have to be decisive over the Liew witchy 6, now being grown by their own powers / followers.

There need to be clear rules on the square parentheses.

1. operator [ expression ]
2. operator [ expression ] operator
3. [ expression [ expression ] ]
4. [ expression [ expression ] operator ]

1. an expression is sorted by operator

2. a sorted expression is operated on

3. an expression indexes another one

4. an expression indexing another one is operated on

This should clear up any confusion!

Then there are the TELL and ASK syntaxes to consider.

I think that,

! expression operator expression (is the most basic form)

? operator expression_1 expression_2 (is also basic functionality)

But,

? expression operator expression ! operator

This needs explanation. ASK of the relationship e-o-e TOLD to operate again

! expression operator ? operator

This one TELLS an e, operated on, ASKING the operator

The reason we TELL and ASK the previous statement is that we say want 'Apples RELATE Oranges' to favor '<' as the RELATE, then GET the result of that change.

Lots of things use loops, so we have to accommodate that,

! [ expression [ expression ] ] ? operator

This is equivalent to a loop. Conditions are checked something like this,

expression ? operator expression ! operator expression

This makes expression check the result of o-e and tell o-e if true

To declare a function, just say 'expression' provided it is a valid one. Every expression is a function potentially.

Finally there is JumbleLiar, what this means is simply, some information needs to be LIES and the rest are a JUMBLE of truths. Lies and truth are both important as truth is dependent on the set of inequalities. JumbleLiar is a function that takes care of these RELATIONSHIPS.

All operators end up defining a complex of truth or a pool of lies, not any one value / result. What a great language -Haha!