Examples

You might notice the lack of quotation marks on the arguments, which are the parenthesized parts of commands: Hello, world! (the only one in the first program), A, and B. This is because Ė does not make a distinction between names (variables) and literal values in the usual way. We will come back to this.

Otherwise, these two are self-explanatory:

Here, we might want to imagine breaking up write(A) write(B) write(A) into two bigrams: write(A) write(B), and write(B) write(A). They independently describe the permitted courses of action for the program (here, two of them: “B after A“ and “A after B”), but do not otherwise interact, hence the loop:

Use a modifying apostrophe ' to turn the write(A)s into to two distinct commands. This prevents the loop, but the write(A) commands are still identically behaved, by virtue of invoking the same action:

An action can result in success or failure.

Note that the standard library’s read() is unusually literal-minded. It must know in advance what has to be read:

Before tackling the next program, let’s reiterate the bigram-related semantics of Ė.

On each line, commands (each referring to an action) inevitably follow one another. Let’s say that a line contains X Y, two hypothetical commands, juxtaposed. Ė takes it to mean that anytime an X is done, following up with a Y is a permitted course of action.

In fact, the order of commands bears no other meaning than that.

For lines, the order is even less relevant. It serves merely to introduce priorities when two conflicting courses of action are possible.

Concretely, the program knows two ways of proceeding after a write(Well, do you? ). First, it tries read(yes) and fails, and because of that, it tries read(no) next.

To avoid typing write(Well, do you? ) or an even longer string all over again, as we did above, we can splice in another command, like -r.

Any command that starts with a hyphen (the default “dash” character) is perfectly valid, but does nothing on its own, in order to serve this “pivoting” purpose.

Variables and literal values are not distinguished in Ė.

One can, but need not, also construe it this way: all word-like tokens are variables, but they come pre-initialized to themselves, that is, their names.

In the following, this pre-initialization is just passively maintained, which is why all tokens will behave as literal values:

Now, we place an asterisk before read(3), so that it spells *read(3).

This tells the read action not to fail early, but to “try harder”, in case negotiating the token 3 would allow it to succeed.

Negotiating 3 to XXI means that as the program proceeds, 3 ceases to mean 3, and starts meaning XXI instead:

In a way, everything is a variable here, or, rather, a negotiable.

However, new negotiations are never made if there is no asterisk. Also, to be negotiable, a token has to start with a capital letter, or to be numeric.

A token is never negotiated to a non-token, such as a (space-separated) sequence of tokens:

When negotiable tokens have numbers in them (like Chapter1, Chapter2), arranging such tokens in pairs or longer sequences will exhibit some additional specifics of behavior. Specifically, that happens when the tokens are otherwise identical (as in Chapter, plus a number), except for the numbers (as in 1 and 2).

The sequences are automatically shortened or lengthened to make the negotiation possible, and the upper bound number (here: 3) is negotiated as well:

Grouping multiple tokens with balanced parentheses (), square brackets [] or curly brackets {} turns them into a single token, which has sub-tokens:

The highly preliminary standard library can read, write, spell, split, pick, calculate, interpret, (check if the tokens in the argument are) all-equal, (check if a date/time string holds) now, (check if a number is) round. Note that if we add an asterisk, “checking if X” comes to mean “making necessary negotiations so that X”.

The examples below illustrate the behavior of some of the actions. First, spell and all-equal:

If one need not report a number like the 7 in “repeated 7 times”, then the following also accomplishes the above task. It makes use of the fact that *spell(Alphabet -> L L L) cannot negotiate the repeated L tokens to different values.

Also, spell, as well as some other actions, will scan the tokens in their arguments left-to-right, oblivious to anything past the previous token, in the same way that commands are treated in an Ė program. Consequently, -> L L L means the same as, say, -> L L L L L.

For completeness, we bring loops back into the picture, as well as introduce calculate:

Recall that -dash-commands are always valid, and always do nothing. This way, we can split up the program into lines easier:

It might be worth noting that now(2020) is the same as *now(2020), as long as it is still 2020. Past that date, only the “asterized” version will succeed, and will negotiate 2020 to actually mean the present year.

And that is it. Thank you for your interest!