Zyxonia

Zyxonia(pronounced /zæiksœniə/) is an Esolang designed by PSTF.
= Language Overview =
Zyxonia is a quasi-assembly, high-level, and powerful programming language. It uses an easy-to-understand but cumbersome syntax, and is capable of writing extremely powerful programs, even embedded in web pages, and even directly manipulated devices.
= Basic Syntax Overview =
== Module ==
In Zyxonia, every program must set programming environment to System, otherwise it can not be runned in any machine.
ENV <- System
do Main
// Anything you want to do
end
== Comment ==
// Signe line comment
/*Comment block*/
== Identifier ==
Any identifier that legal in Python also legal in Zyxonia.
== Variable ==
Zyxonia uses math-like syntax to assign anything to variable.
LET var_name(var_type) <- var_value
You can also leave var_value blank to set a variable to NULL, or set var_value to DELETE to delete the variable name.
When you assign another value to variable, then you can omit colon and omit variable type.
== Statement ==
ALL STATEMENT MUST WRITTEN IN UPPERCASE, EXCEPT THE START AND THE END OF SUBROUTINE. I USE UPPERCASE HERE, JUST WANT TO LET YOU HOW TO WRITE A STATEMENT IN ZYXONIA.
== Input and Output ==
In Zyonia, the output is oriented to the standard output by default, and the input is oriented to the standard input by default.
You can use the following statements to specify the input and output files. Note that STDIN is used for standard input, while STDOUT is for standard output.
filename |> INPUT
filename <| PRINT
== Conditional Control Flow ==
Zyxonia uses following structure to represent a conditional control flow.
=== Normal conditional ===
IF(expression){code}
=== If-else statement ===
IF(expression){code1}ELSE{code2}
=== If-elif-else statement ===
ELSE can be omitted.
IF(expression1){code1}ELIF(expression2){code2}...ELSE{codeM}
=== Goto-statement ===
IF(expression){GOTO label}
== Loop ==
Zyxonia uses following structure to represent a loop control flow.
=== Iterative loop ===
The iteration loop executes the same statement for each iteration object in the iteration container.
FOR(iter_obj IN iter_cont){code}
=== Conditional loop ===
The same code is executed as long as the condition is true (or not).
WHILE(expression){code}
DO{code}WHILE(expression)
WHILENOT(expression){code}
DO{code}UNTIL(expression)
=== Break and continue ===
Break will directly break the loop, and continue will jump to next round of loop.
=== Goto-statement ===
:LABEL label_name
IF(expression)
{
 // Do anything
 GOTO label_name
}
:LABEL end
:LABEL label_name
IF(!(expression))
{
 // Do anything
 GOTO label_name
}
:LABEL end
:LABEL label_name
// Do anything
IF(expression)
{
 GOTO label_name
}
:LABEL end
:LABEL label_name
// Do anything
IF(!(expression))
{
 GOTO label_name
}
:LABEL end
== Label ==
The labels are defined by this:
:LABEL label_name
NOP // This is do nothing, you can replace it by your code
:LABEL end
== Subroutine and functions ==
=== Subroutine ===
A subroutine is just a procedure and doesn't return any value. As a result, the subroutine can be thought of as a function that returns nothing and has no arguments.
do subroutine_name
NOP
end
=== Function ===
do function_name function_type arg_list <- [*args, **kwargs]
NOP
RET return_value
end
Here are some example:
do add INT arg_list <- [a(INT), b(INT)]
NOP
RET a + b
end
do divide INT arg_list <- [a(INT), b(INT)]
IF(b=0)
{
 THROW(ZeroDivisionError) "You can't divide by zero!"
}
ELSE
{
 LET c(INT) <- a / b
}
RET c
end
== Error handling ==
Zyxonia also can handle error.
=== Throw error ===
THROW(error_level) error_message
=== Handle error ===
TRY{error_statement}CATCH(error_level){handle_code}ELSE{success}FINALLY{final}
= Advanced Syntax Overview =
== Preprocessing code ==
Preprocessing code is the statement that didn't included in any code-block.
All variable defined in preprocessing code or in Main subroutine are global.
== Import library ==
Zyxonia supports a lot of library, it is too many to show here.
Use these code to import a library:
#INCLUDE<library_name>
Or, if you want to include only some methods:
#INCLUDE<method_name>FROM<library_name>
Here shows some useful libraries. Zyxonia/Libraries
== Object-oriented ==
=== Definition of class ===
ENV <- System
// Define a class and create an object
CLASS Person:
 LET name(STRING) <-
 LET age(INT) <-
 __INIT__ arg_list <- [STRING name, INT age]
 LET this.name <- name
 LET this.age <- age
 end
 do greet STRING arg_list <- 
 NOP
 RET f"Hello, my name is {this.name} and I am {this.age} years old."
 end
LET person <- Person("Alice", 30) // "Spawn" a person
PRINT person.greet() // Output: Hello, my name is Alice and I am 30 years old.
=== Inheritance and polymorphism ===
Let's say we've defined the person class.
CLASS Employee(Person):
 LET employeeID(STRING) <-
 __INIT__ arg_list <- [STRING name, INT age]
 SUPER(name, age)
 LET this.employeeID <- employeeID
 end
 OVERRIDE do greet STRING arg_list <- 
 NOP
 RET SUPER.greet() + f"My employee ID is {this.employeeID}."
 end
LET employee <- Employee("Bob", 40, "E12345")
PRINT employee.greet() // Output: Hello, my name is Bob and I am 40 years old. My employee ID is E12345.
= Compilation =
See here: Zyxonia/Compile
= More analyze =
See here: Zyxonia/Common Command List
= Categories and References =
Category:Languages
Category:2025
Category:Turing complete
Category:High-level