nyuuzyou/wikis huggingface dataset:
Zephyr ASDL

Abstract Syntax Description Language, more commonly known as Zephyr ASDL to disambiguate it from other syntax description languages, is a wikipedia:domain-specific language introduced in 1997 by researchers at Princeton University and the University of Wisconsin at Madison as part of the Zephyr compiler infrastructure project. It is used by several language implementations, notably the reference implementation of Python, to describe abstract syntax trees (ASTs).
== Notable Usage ==
Despite relative obscurity even within the compiler-engineering ecosystem, Zephyr ASDL is routinely chosen to represent ASTs. The following projects use Zephyr ASDL:
* CPython, the reference implementation of Python 
* Typhon, the reference implementation of Monte 
* The Oils shell environment 
Monte and Oils both support compiling `.asdl` files directly as modules.
== Sources ==
* The Zephyr Abstract Syntax Description Language, Appel, Korn, Serra, & Wang 1997. 
* Zephyr ASDL (Abstract Syntax Description Language), math4tots et al 2012. 
Category:1997
Category:Implemented
Category:Declarative paradigm
ZeroBF

ZeroBF is a compression scheme for Brainfuck invented by User:Zzo38, the program is encoded as a single number. Assume the tape is unbounded in both directions and all cells start at zero.
At each step, you do: Divide the number by the number of possible commands, write the command according to the remainder, and then set the number to quotient. Repeat until number is zero.
 At beginning of program: 0=, 1=+ 2=- 3=.
 After a + not in a loop if a > hasn't appeared yet: 0=+ 1=> 2=[ 3=.
 After a + in a loop if a > hasn't appeared yet: 0=+ 1=> 2=[ 3=. 4=]
 After a - not in a loop if a > hasn't appeared yet: 0=- 1=> 2=[ 3=.
 After a - in a loop if a > hasn't appeared yet: 0=- 1=> 2=[ 3=. 4=]
 After a + not in a loop: 0=+ 1=< 2=> 3=[ 4=.
 After a + in a loop: 0=+ 1=< 2=> 3=[ 4=. 5=]
 After a - not in a loop: 0=- 1=< 2=> 3=[ 4=.
 After a - in a loop: 0=- 1=< 2=> 3=[ 4=. 5=]
 After a < not in a loop: 0=< 1=- 2=+ 3=[ 4=. 5=,
 After a < in a loop: 0=< 1=- 2=+ 3=[ 4=. 5=, 6=]
 After a > not in a loop: 0=> 1=- 2=+ 3=[ 4=. 5=,
 After a > in a loop: 0=> 1=- 2=+ 3=[ 4=. 5=, 6=]
 After a [ if a > hasn't appeared yet: 0=, 1=+ 2=- 3=. 4=> 5=[
 After a [: 0=, 1=+ 2=- 3=. 4=< 5=> 6=[
 After a ] not in a loop: 0=, 1=+ 2=- 3=. 4=< 5=>
 After a ] in a loop with nothing before the loop that just ended: 0=, 1=+ 2=- 3=. 4=< 5=>
 After a ] in a loop: 0=, 1=+ 2=- 3=. 4=< 5=> 6=]
 After a , not in a loop: 0=, 1=+ 2=- 3=. 4=< 5=> 6=[
 After a , in a loop: 0=, 1=+ 2=- 3=. 4=< 5=> 6=[ 7=]
 After a . not in a loop: 0=, 1=+ 2=- 3=. 4=< 5=> 6=[
 After a . in a loop: 0=, 1=+ 2=- 3=. 4=< 5=> 6=[ 7=]
Note: This list assumes that the program might use binary I/O. For a program that does not use binary I/O, a . cannot appear directly after a ]
If each cell stores 1 bit, it can be simplified to (* toggles the bit):
 At beginning of program: 0=, 1=* 2=.
 After a * not in a loop if > hasn't appeared yet: 0=. 1=[ 2=>
 After a * in a loop if > hasn't appeared yet: 0=. 1=[ 2=> 3=]
 After a * not in a loop: 0=. 1=[ 2=> 3=<
 After a * in a loop: 0=. 1=[ 2=> 3=] 4=<
 After a < not in a loop: 0=. 1=, 2=* 3=[ 4=<
 After a < in a loop: 0=. 1=, 2=* 3=[ 4=< 5=]
 After a > not in a loop: 0=. 1=, 2=* 3=[ 4=>
 After a > in a loop: 0=. 1=, 2=* 3=[ 4=> 5=]
 After a [ if a > hasn't appeared yet: 0=, 1=* 2=. 3=> 4=[
 After a [: 0=, 1=* 2=. 3=< 4=> 5=[
 After a ] not in a loop: 0=, 1=* 2=. 3=< 4=>
 After a ] in a loop with nothing before the loop that just ended: 0=, 1=* 2=. 3=< 4=>
 After a ] in a loop: 0=, 1=* 2=. 3=< 4=> 5=]
 After a , not in a loop: 0=, 1=* 2=. 3=< 4=> 5=[
 After a , in a loop: 0=, 1=* 2=. 3=< 4=> 5=[ 6=]
 After a . not in a loop: 0=, 1=* 2=. 3=< 4=> 5=[
 After a . in a loop: 0=, 1=* 2=. 3=< 6=> 5=[ 6=]
Category:Languages
Category:Brainfuck equivalents
Category:2007
ZeroDivisionError: Division by 0

ZeroDivisionError: Division by 0 is designed by PSTF and inspired by SyntaxError: invalid syntax which is inspired by foo : The term 'foo' is not recognized as the name of a cmdlet, function, script file, or operable program. Check the spelling of the name, or if a path was included, verify that the path is correct and try again. which is inspired by bash: foo: No such file or directory. It imitates yet another Python error - Zero Division Error.
== Command ==
There are ℵ0 commands, and they prints: 
 File "<stdin>", line 1
 [command]
ZeroDivisionError: Division by 0
== Examples ==
=== ZeroDivisionError ===
x = 114514 / 0
=== Quine ===
 File "<stdin>", line 1
 [command]
ZeroDivisionError: Division by 0
== Interpreters ==
=== Python ===
print('\n'.join([f' File "<stdin>", line 1\n {i}\n\nZeroDivisionError: Division by 0' for i in __import__('sys').stdin.read().split('\n')]))
=== C++ ===
#include<bits/stdc++.h>
char _[1000000];int main(){while(!feof(stdin)){printf(">>> ");gets(_);printf(" File \"<stdin>\", line 1\n %s\n\nZeroDivisionError: Division by 0\n",_);}}
=== Batch ===
@echo off
:bad
set /p x=^>^>^> 
echo File "<stdin>", line 1
echo %x%
echo.
echo ZeroDivisionError: Division by 0
goto bad
== See also ==
* SyntaxError: invalid syntax
* NameError
* IndentationError: unexpected indent
* ZeroDivisionError: Division by 0/NoQuine
== Categories ==
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Total
Category:2024
Category:Implemented
ZeroDivisionError: Division by 0/NoQuine

ZeroDivisionError: Division by 0/NoQuine is designed by PSTF and based on ZeroDivisionError: Division by 0 which is inspired by SyntaxError: invalid syntax which is inspired by foo : The term 'foo' is not recognized as the name of a cmdlet, function, script file, or operable program. Check the spelling of the name, or if a path was included, verify that the path is correct and try again. which is inspired by bash: foo: No such file or directory.
== Syntax ==
Same as ZeroDivisionError: Division by 0, but if your code is:
 File "<stdin>", line 1
 [command]
ZeroDivisionError: Division by 0
then it prints:
 File "<stdin>", line 1
 [command]
UnknownError: 不是，哥们，你搁这干啥呢
== Examples ==
=== ZeroDivisionError ===
不是，哥们？
=== Cheating Quine(I'm going to fool you with invisible characters, lol) ===
 File "<stdin>", line 1
 [command]
​
ZeroDivisionError: Division by 0
== Interpreters ==
Add by yourself, I don't write it anymore!
== Note ==
In fact, it is actually implemented, but the author didn't wanna add the interptreter.
== Categories ==
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Total
Category:2024
Category:Implemented
Zero Instruction Set Computer

Zero Instruction Set Computers are a class of languages similar to OISCs, but even more restricted.
== Explanation ==
A typical program in a "normal" assembly language (and to some extent, even non-assembly languages) consists of code, which operates on data. The code is normally made up of a sequence of commands/instructions, and typically, most of those commands will take arguments.
The OISC (One Instruction Set Computer) concept maintains this construction. However, it only has one sort of instruction/command, which is therefore entirely defined by its arguments (the command itself does not need a name and can be implicit, as there's only one possibility). Most OISC commands are moderately, but not excessively, complex, and typically take many arguments. OISCs also commonly use techniques such as self-modifying code and memory-mapping important registers, in order to gain more functionality from their instruction.
A ZISC takes this concept to its extreme. In addition to having only one command, that command takes no arguments (it represents the language's "ZISC operation", that can operate in the absence of any extra specification). As such, any program necessarily consists of that one command repeated indefinitely; any two programs are thus equivalent, and in fact the program itself is entirely implicit. In order to program in a ZISC, you obviously cannot write the program; instead, you initialize (all, or some subset of) memory.
Pretty much any language which reads commands from memory can be interpreted as a ZISC (with a very complex operation that decodes a command and handles a large number of possibilities). This is easiest to see using OISCs as an example. For example, ByteByteJump, when interpreted as an OISC, has command *b = *a; goto *c;. The ZISC interpretation of the language is more complex, as it has to include the semantics of fetching a memory-mapped instruction from memory: with a 3-word-per-address configuration, its ZISC operation is:
 *(ip[3] * 65536 + ip[4] * 256 + ip[5]) = *(ip[0] * 65536 + ip[1] * 256 + ip[2]); ip = ip[7] * 65536 + ip[8] * 256 + ip[9];
Typically, a language that was designed as a ZISC would have a much simpler operation.
== Advantages of ZISCs ==
OISCs are a common choice for interpreter golf competitions, because only needing to implement one instruction keeps the size of the interpreter low. However, they suffer somewhat from needing to handle the code and data separately (even if they are in the same physical memory array, you nonetheless tend to need separate registers for handling the instruction pointer and for handling any data being manipulated). A ZISC arrangement simplifies the problem still further, because there is no longer any need to keep track of command arguments. (However, it can make programming more complex, as the data itself has to encode rules for operating on that data.)
== Examples ==
* MiniMAX
* StackFlow
* Black
* Last ReSort
* Game of Life
* Spiral Rise
Category:Concepts
Zeryx

Zeryx is a simple language designed by User:Conor O'Brien.
Suppose a program in this language is referred to as S. N starts at 0. Then, the commands of this language can be defined as:
* ( - move the first character in S to the end of S. E.g., 1234 becomes 2341.
* ) - move the last character in S to the beginning of S, and move forward an additional time. E.g., 1234 becomes 4123.
* . - terminate the program, outputting the state of S.
* # - increment N, mod length(S).
The program executes the Nth character in S until it is ..
== Example executions ==
Program: (.)
Step 1: (N = 0) Execute (. Before: (.); after: .)(.
Step 2: (N = 0) Execute .. Before: .)(; after: .)(.
Final result: .)(
Program: ((((((.
Step 1: (N = 0) Execute (. Before: ((((((.; after: (((((.(.
Step 2: (N = 0) Execute (. Before: (((((.(; after: ((((.((.
Step 3: (N = 0) Execute (. Before: ((((.((; after: (((.(((.
Step 4: (N = 0) Execute (. Before: (((.(((; after: ((.((((.
Step 5: (N = 0) Execute (. Before: ((.((((; after: (.(((((.
Step 6: (N = 0) Execute (. Before: (.(((((; after: .((((((.
Step 7: (N = 0) Execute .. Before: .((((((; after: .((((((.
Final result: .((((((
Program: (#(.
Step 1: (N = 0) Execute (. Before: (#(.; after: #(.(.
Step 2: (N = 0) Execute #. Before: #(.(; after: #(.(.
Step 3: (N = 1) Execute (. Before: #(.(; after: (.(#.
Step 4: (N = 1) Execute .. Before: (.(#; after: (.(#.
Final result: (.(#
Category:Languages
Category:String-rewriting paradigm
Category:Self-modifying
Zfuck

Zfuck is a minimal Turing-complete 3-command variation of Smallfuck discovered by User:PythonshellDebugwindow. It was developed independently of Nanofuck.
==Memory==
Like Smallfuck, Zfuck operates on a tape of bits, but unlike Smallfuck, Zfuck uses a left- and right-unbounded tape. The tape is initialized with the program's input as a binary number left- and right-padded with zeros, and the program's output is all previously and currently visited cells in the tape at the end of the program (if it halts) as a binary number.
==The minimization process==
We start out with Smallfuck's 5 commands.
 ><*[]
We can combine *> into } to get 4 commands.
 }<[]
We can also define the empty loop [] to be a nop and merge ]< into ) to get 3 commands.
 }[)
==Simple translation to and from SmallfuckU==
This version of Smallfuck has an unbounded tape. Let's call it SmallfuckU for the sake of brevity.
Zfuck	SmallfuckU
} 	*>
[ 	[
) 	]<
SmallfuckU	Zfuck
> 	}[)}
< 	[)
* 	}[)
[ 	[
] 	)}[)}
==Examples==
===Infinite loop===
 [}[))}[)}}[)[}[)}[))
===Truth-machine===
 [}[)}[))
==Interpreter in JavaScript==
The first argument is the code and the second is the initial tape. Undefined behaviour for a negative cell pointer. Also severely golfed and memory-inefficient as a result.
 var zfuck=(c,m)=>eval("var p=0;"+c.replace(/}/g,"m+=~0];m~p]=!m~p++];").replace(/\)/g,"}p--;").replace(/\[/g,"while(m[p]){").replace(/~/g,"[").replace(/{}/g,"break;"));
==See also==
* Smallfuck
* Nanofuck
Category:Languages Category:2020 Category:Turing complete Category:Turing tarpits Category:Brainfuck derivatives Category:Implemented Category:Cell-based Category:Low-level
Zhouly++

Zhouly++ is an esolang created by Piggy424008. It is based on the article Breaking the ceiling of OIers. Zhouly++ is basically C++, but it enforces strict adherence to the coding guidelines outlined in the aforementioned article. Deviating from these guidelines will result in errors during the compilation process.
== Implementation ==
Official implementation
Category:Joke languages Category:2023 Category:Implemented Category:Languages
Zidryx myno

Zidryx myno is python but every character is caeser-shifted the length of the program mod 26
== hello world ==
 jlchn("byffi qilfx")
== cat ==
 dfwbh(wbdih())
== a+b problem ==
 o=wbdih();p=wbdih();dfdwbh(wbh(a)+wbh(b))
ZiziQue

ZiziQue is a very mysterious esoteric programming language. The only thing known about ZiziQue is that, in it, an implementation of Deadfish might look like this:
 [Start]
 !i^inc"Increment
 !d^dec"Decrement
 !s^sqr"Square
 !o^out"Output
 .
 [out]
 "{number}
 ^Start
 [inc]
 +number
 ^Start
 [dec]
 -number
 ^Start
 [sqr]
 =number,{{number}*{number}}
 ^Start
No visible input method, variable declaration, nor implementation of -1 and -256 resetting is shown. It is speculated that input may be accepted one character at a time, and the number variable could have been predefined, unless ZiziQue is even weirder than it looks.
The instructions are speculated as:
Instruction	Potential Purpose 	Pseudocode
number 	A numeric variable called number. 	int n
+n 	Increments n. 	n++
-n 	Decrements n. 	n--
a*b 	If a and b are numbers, it multiplies them. Unknown behavior otherwise. 	a * b
=n,expr 	Sets n to expr. 	n = ...
{var} 	Replaces var to be interpreted first. If number was 5, "{number} would be "5 instead.	(...)
[abc] 	Declare label abc. Labels may need to be 3 lowercase letters. 	abc:
^abc 	Jumps to label abc. 	GOTO abc
!c 	If character input is not c, it skips to next line. 	if(input == c)
"message 	Prints message. 	print(...)
. 	End program. 	halt
Category:Languages Category:Usability unknown Category:Unknown computational class Category:Unimplemented Category:Unknown year
Zoophilia

This is a full brainfuck equivalent language, because I was too lazy to come up with more than 8 instructions. The compiler for this language is a machine learning algorithm of your choice (the linked github uses google's InceptionV3 model, pretaught several objects) that interprets images of animals as brainfuck instructions. The images must be in the linked folder, and in the correct lexigraphical order (I have also created and linked a handy brainfuck-to-Zoophilia compiler). For convenience's sake, (And the fact that I dont want to upload 50 pictures) I have re-used the same image for every instance of an instruction, but since the compiler is powered by a machine learning algorithm, I encourage you to use a different, hand selected image for each individual instruction!
In Brainfuck	In Zoophilia
+ 	Image of a toucan
- 	Image of a lion
> 	Image of a cat
< 	Image of a dog
[ 	Image of an elephant
] 	Image of a rabbit
. 	Image of a chicken
, 	Image of a turtle
Programs tend to be quite sizable, so I recommend using fairly compressed images.
Here is a Brainfuck Hello World! program:
--<-<<+[+[<+>--->->->-<<<]>]<<--.<++++++.<<-..<<.<+.>>.>>.<<<.+++.>>.>>-.<<<+.
And here it is translated into Zoophilia
= Compiler/Interpreter Package =
You can get the compiler/interpreter and an example program at Github.
Written by Eli and Conner
Category:Brainfuck equivalents
Category:Brainfuck derivatives
Category:Brainfuck
Category:2021
Category:Turing complete
Category:Low-level
Category:Languages
Zucchini

Zucchini is another minimalist language. In it, everything is a node that sends signals to other nodes.
== Concepts ==
Nodes are the atoms of a Zucchini program. Each node has:
* An ID
* A threshold
* A current level
* Targets to send values to
The main interpreter loop goes as follow:
 for each node in the graph:
 if the current level is at least the threshold:
 send signals to targets
Signals are accumulated, which means that values sent are buffered for the next interpreter loop.
=== Special nodes ===
There are three special nodes:
* Stdout
* Stderr
* Exit
The first two special nodes are for output to the real world. Values sent to them aren't directly sent to their respective stream. Instead, the actual output is done between iterations. Note that output happens whenever a value is sent to either stdout or stderr (so you can output NULLs). If nothing is ever sent during an iteration, nothing will happen.
The exit node is there to force the program to quit when its level is greater than zero.
=== Input ===
Input from stdin is a special value that may appear in a node's targets. When encountered, a character is fetched from the stream, with its value converted to an unsigned integer between 0 and 255, inclusive. A -1 is sent on EOF. Multiple requests to stdin in a node's targets will only fetch a single character, duplicated between all targets.
== Notation ==
Programs are stored as a string of nodes delimited by slashes. Each node has two parts: its threshold, and a list of targets. A target is a pair of (node ID, signal to send). The node's string index implicitly encodes its ID, starting from zero.
Thresholds and signals are encoded in a modified base 4 system, where positive integers draw from ' ' (+0), '.' (+1), '`' (+2) and ':' (+3); and negative integers use ' ' (-0), ',' (-1), "'" (-2) and ';' (-3). Zero is marked by '=', input by '-' and a node's current level by '+'.
Special nodes are not explicitely written. Instead, their IDs are:
* Total number of program nodes for stdout
* One more for stderr
* One more again for exit
Example 1: in the cat program below, node 6 is ".9,10.11+". Therefore, its threshold is 1, and it sends -1 to node 9, +1 to node 10 and its level to node 11 when activated.
Example 2: again from the cat program, node 11 is ".13+". 13 is the number of nodes the program has, so when activated this node sends its level to stdout.
== Examples ==
=== Hello, world! ===
 =0,1.2./.0,1./.3.17. ` /.4.17.`../.5.17.`: /.6.17.`: /.7.17.`::/.8.17`: /.9.17` /.10.17.:.:/.11.17.`::/.12.17.: `/.13.17.`: /.14.17.`. /.15.17` ./.16.17``/.19.
=== Cat ===
 =0,1.12./.2.7./.3.6-/.4./.5./.1./.9,10.11+/.6.8./.9./.15./.13,/.13+/.12.0,
This graph shows how nodes are used: clock (blue), output (green) and exit check (red).
== Implementation ==
* 
Category: Languages
Category: Implemented
Category: Low-level
Category: 2013
Zudjn

Zudjn is a small esolang that has 2d cell based memory.
== syntax ==
Symbol	Description 	Implemented
`<` 	go one memory cell left 	yes
`>` 	go one memory cell right 	yes
`^` 	go one memory cell up 	yes
`v` 	go one memory cell down 	yes
`+` 	add one to the current memory cell, put a number (0-9) before it for faster writing 	yes
`-` 	substract one from the current memory cell, put a number (0-9) before it for faster writing 	yes
`x` 	set the width of the memory cell grid, has to be at the start (example: set the width to 4: 4x) 	yes
`y` 	set the height of the memory cell grid, has to be at the start (example: set the height to 4: 4y) 	yes
`@` 	output the current cell value as a number 	yes
`&` 	output the current cell value as an ascii character 	yes
`?` 	if the current memory cell value equals a number, do the code in the brackets, (example: if the current cell value is equal to 5, print it as an ascii character: 5?&; )	yes
`;` 	ends an if statement container 	yes
` 	output the cell grid as a whole (this is mainly used for debugging, but it can be used in other ways) 	yes
`/` 	if you put two, any text in between them will be ignored 	yes
== examples ==
Hello World (not in one line): 
3x3y
9+9+9+9+9+9+9+9+>
9+9+9+5+>
9+9+9+9+9+9+9+9+9+9+9+2+v
9+9+9+9+9+9+9+9+9+9+9+9+9+2+<
9+9+9+9+9+9+9+9+9+9+9+9+3+<
9+9+9+9+9+9+9+9+9+9+9+9+v
9+9+9+9+9+9+9+9+9+9+9+9+6+>
9+9+9+6+>
9+9+9+9+9+9+9+9+9+9+9++
^^<<&>>&v<<&&>&^&v>&<&<v&^&v>>&<&
Hello World (in one line):
3x3y9+9+9+9+9+9+9+9+>9+9+9+5+>9+9+9+9+9+9+9+9+9+9+9+2+v9+9+9+9+9+9+9+9+9+9+9+9+9+2+<9+9+9+9+9+9+9+9+9+9+9+9+3+<9+9+9+9+9+9+9+9+9+9+9+9+v9+9+9+9+9+9+9+9+9+9+9+9+6+>9+9+9+6+>9+9+9+9+9+9+9+9+9+9+9++^^<<&>>&v<<&&>&^&v>&<&<v&^&v>>&<&
== history ==
Zudjn was made in 2025 by DevThatCodes (talk) (me). The name zudjn was chosen when i made a random "word" generator and one of the "words" that it generated was zudjn.
== Links ==
Github page
Category:Languages Category:Works-in-Progress Category:Cell-based Category:Two-dimensional languages Category:2025
Zull

Zull is a joke esolang made by Cortex in which all code is implied from context.
== Commands ==
Name 	What it does 	Syntax
Magic Tilde	Detect what the user wants the program to do, then Does That Thing™.	~
Robert 	Interpret input as Zull code. 	[
Cemisolon 	Start a comment. 	;
Tabloid 	End a comment. 	Press TAB on your keyboard.
== Examples ==
These examples only work if you yourself want the program to Do The Thing™.
=== Hello World ===
 ~
=== Cat program ===
 ~
=== 99 Bottles of Beer ===
 ~
=== Quine ===
 ~
=== Fibonacci ===
 ~
=== Factorial ===
 ~
=== Truth-machine ===
 ~
=== Deadfish interpreter ===
 ; Deadfish interpreter
 Takes input as code	
 ~
=== Self-interpreter ===
 [
or simply
 ~
=== ROT13 ===
 ~
=== FizzBuzz ===
 ~
=== Brainfuck ===
 ~
=== Sashleyfuck ===
 ~
Category:Languages Category:Joke languages Category:Uncomputable
Zyxonia/Common Command List

Here are more analyzation for every command.
= System command control =
do SubroutineName
Indicates the beginning of a subroutine (or function).
end
Indicates the end of a subroutine (or function).
CLS
Clear the screen.
BYE
Exit the programming environment directly.
EXIT
Terminate the program immediately.
= Variable operations =
LET name(type) <- value
Declare a variable and assign a value to it. If the variable type is omitted, it becomes a direct assignment. 
You can change its type with another type as its value, 
assign a blank value to indicate no value, 
and assign a value with DEL to indicate deletion.
= I/O =
LET name <- INPUT(__prompt)
Takes an input from the user and assigns it to a variable. 
The input must match the variable type. 
You can also enter a string with RAW_INPUT instead of INPUT.
PRINT(value, END <- "")
Outputs the specified value, ending with END. 
If there is only one value, feel free to omit the parentheses.
filename |> INPUT
Read data from filename in read-only mode. 
It is possible to change filename to CON to redirect to standard input. 
If filename does not exist, an error occurs.
filename <| PRINT
Write data to filename in append mode. 
If you add another vertical bar(fioename <|| PRINT), 
it means write-only mode 
(in this case, the contents of the filename will be cleared and then written, while the append mode will not clear the contents). 
If filename does not exist, a new file is created for writing instead of an error. 
Redirecting to CON will set the output to standard output.
= Preprocessors =
#INCLUDE<lib_name>
Introduce lib_name. All content is imported by default, and the standard library name and module name need to be added.
#INCLUDE<module>FROM<lib>
Import module from lib. The two modules are separated by a comma.
#IF condition
If the conditions are met, add the code to the processed code file.
#ELSE
If all the conditions of the IF block and ELIF block are not met, the code in the ELSE block is added.
#ELIF condition
Another condition.
#ERROR error
It produces an error. This will make the compilation process incomplete.