|Computational class||Turing complete|
- Note that ix is typically lowercased except, often, at the start of a sentence.
Ix is a programming language created by Orisphera. The name is the name of the Latin letter X but also can be understood as the Roman 9.
Ix operates on strings. It has a memory of the type
map<string, nonempty_string>. (The
map type is similar to Python
The ix program consists of expressions.
Expressions can be of 3 types: literal expressions, modified expressions, and compound expressions.
A literal expression is either a result of applying the
q modifier (see below) to a string (in this case it evaluates to the string to which the
q modifier is applied) or the letter
i (in this case it reads an undefined amount of input and evaluates to it; it reads when it is evaluated, e. g.
rrrEnter something: rorYou entered rico gets the input after outputting "Enter something: ").
A modified expression is a literal or compound expression followed by some modifiers. Here are possible modifiers:
hmodifier returns the first character of its argument.
tmodifier returns its argument without the first character, like Python
qmodifier does the following:
- Doubles all the "y" characters, except possibly for some of them not followed by one of the characters "nry" or newline. (You can leave it without doubling before a newline if you are not going to replace it.)
- Puts a "y" character before each "r" character
- Replaces newlines with the string "yn". You don't have to replace all of them when applying it to get a literal expression, but it's recommended to do so.
- Views the result as a Python string and applies its
joinmethod to the constant string "rr".
gmodifier by default always returns an empty string by default, but its behavior can be changed.
- Identity modifiers always return their arguments but have side effects:
<expression>ooutputs the result of evaluating the expression.
<expression><expression>pevaluates both expressions and modifies the
gto return the result of evaluating the second expression for the result of evaluating the first expression.
- Any character other than
cghiopqrtxis an identity modifier with no side effects.
The modifiers are applied left to right.
A compound expression is a literal or modified expression followed by a balanced parentheses sequence where the opening parentheses are literal and modified expressions and the closing parentheses are the letters
c. When it is evaluated, the literal and modified expressions within it are evaluated and the results are concatenated.
The program is pre-processed as follows:
- It may be cut by the letter
x. The part after it is considered comment in this case.
- If it isn't,
arcan be added to the end of the program. If this happens, an error is thrown after the program halts.
- An even number of the letters
rris added to the beginning. For example,
rEnter something: rorYou entered ricobecomes
rrrEnter something: rorYou entered rico.
It is pre-processed in such a way that it can be parsed into expressions. If that is impossible, the behavior is undefined but it is recommended that the program is published here.
The execution goes in cycles. Each time all the expressions in the program are evaluated. Then, if the program was not terminated with the letter
x (including the case when it throws an error), it halts. Otherwise, a new program is constructed as follows: the
q modifier is applied for the values of all except the last expressions, and then the results are concatenated together with the result of the last expression.
The interpreter doesn't have to pre-process, then parse, and then execute the program. It can or can not do these things simultaneously depending on the implementation.
In the very first edit, it is said that ix is case-insensitive. That was a mistake. It can be case-sensitive, case-insensitive or partially case-sensitive (probably like URL) depending on the implementation.
The following program was in this section. I think I made a mistake when designing it because it doesn't seem to work.
Here is a fixed version: