9

9 is an esolang designed by User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff with the goal of compiling to 90. As such, it cannot perform infinite loops(90 could), but has bounded loops built-in.
== Declarations ==
There are 4 types of declarations. They may only appear outside of code blocks
1. Variable bits: a variable bit is one bit of information that can be turned on, but not off.
 declare name;
2. Constants: can be either a bit, number, or string. 
 const name = value;
3. Subroutines: can be called within the program and act as blocks. Subroutines may not return anything
 name { code }
4. Lambdas: equivalent to expressions, must be given names
 name(arguments) => expression;
== Simple statements ==
1. Increment a variable bit. This statement has three equivalent syntaxes.
 name++;
 ++name;
 punch name;
2. In-place Boolean addition. Equivalent to the C code variable |= value
 name += value;
3. Running a subroutine. This statement has two equivalent syntaxes.
 run subroutine;
 subroutine();
4. Print statements. They take one argument (number, string, or boolean) and they print it.
 print value;
A statement may contain just an expression, however this is ignored, unless it is undefined, in which case undefined behavior happens.
== Compound statements ==
1. If statements. They may not have an else block, nor an else if block.
 if condition { code }
2. Repeat statements. They repeat the code a specified number of times. These statements may have numbers, while if-statements may not.
 repeat amount { code }
3. While statements. They repeat the code while a condition is true, with a specified limit on the amount of times.
 repeat limit while condition { code }
4. Repeat with index statements. Same as repeat statements, but they keep track of the index in a variable. The variable may not be modified or declared anywhere in the program.
 repeat amount with variable { code }
5. Conditional operator statements. They are composed of a simple statement followed by a question mark, and then a condition. If the condition is true, the statement is run.
 statement ? condition;
6. With statements. They may only appear in loops and take an argument as a constant. On the nth iteration, the with clause activates.
 with constant { code }
== Operators ==
There are 4 boolean operators: !, ~, |, &. Note that ! and ~ have the same effect.
There is also 1 math operator: +. It works as you'd expect, but it is only useful for loops.
Finally, there is the built-in prescan function, which takes an argument as a string and gets input from the user as that type. Note that the input is taken in before the code is executed, to make it possible to compile to 90.
== Example Program ==
const amount = prescan();
// This program is a looping counter.
// Input the amount of iterations you want and the program will output a "staircase" of that height. 
main {
 repeat amount with index {
 repeat index {
 print "1";
 }
 print "\n";
 }
}
=== Truth-machine (loops for 10,000 iterations) ===
declare a;
const inf = 10000;
main {
 a += prescan();
 print a;
 if a {
 repeat inf {
 print 1;
 }
 }
}
== Converting 9 programs to 90 ==
Converting 9 programs to 90 is quite hard, and it is broken up into multiple steps.
=== Converting the program to just print, ++ and ? ===
Firstly, we take input from the prescan function replace the function with that.
Next, we replace all lambdas and subroutines with their occurrences. So:
 nand(x, y) => !(x&y)
 hello { print "Hello, World!"; }
 main { print nand(1, 0); }
would become:
 main { print !(1& 0); run hello; }
==== Expressions ====
Next, we need to create and expression simplifier.
There will be 2 types, simple and complex.
Simple takes the form:
 AND: args
 OR: args
Where AND [and if the last one is 0 or if it's 1.] OR is the result.
Complex takes the form:
 ADD: numbers
 AND: args
 OR: args
 WEIGHT: Number
 (Multiple AND OR WEIGHT triplets)
To convert an expression to a simple expression, do this:
1. Take all the values before & and put them in AND
2. Take
==== All other statements ====
repeat and repeat with blocks can be made like this.
# Replace all repeat blocks with the ADD component of the complex expression.
# Add the WEIGHT component with an if statement.
while loops are just repeat loops but each iteration has an if block.
It is trivial to transform an if block into a ? statement.
+= statements can be ++ ?
=== Transforming this into 90 ===
 var++ -> var $
 ? -> tobytes( state 90 ment )
*print is ommitted.
*tobytes converts it to a series of octets
Simple Expressions can be made by nested ifs.
Category:Total
Category:Unknown computational class
Category:Output only
Category:Languages
Category:2024