Septem Lingua is designed by PSTF. It has 7 basic commands, and every development can add more commands into this language.

Disclaimer

The name of this language literally means 'seven languages,' but it has no direct connection to seven languages. Septem stands for 7, which means this has 7 command.

Development Team

Leader: User:PrySigneToFry(PSTF)

Developers: User:I am islptng, User:Yoyolin0409

1st-batch members: User:Hammy, User:cleverxia, User:Yayimhere

2nd-batch members: User:MihaiEso

Rules

What a coincidence—the rules of this language are seven, and the basic commands are also seven.

Do not add non-computable commands to this language.
Adding joke commands is prohibited. Septem Lingua is a serious language.
Unless otherwise specified, all commands will be treated as functions.
Adding built-in data storage is prohibited. We stipulate that all data in this language must be stored in variables. However, commands are allowed to access registers or memory to implement more complex programs, and it is permissible to add data types or simulate stacks, queues, deques, binary trees, hash tables, etc., through functions.
No memes are allowed to add in the command, nor appear in the description. The purpose of creating this language was not to become worse or more chaotic.
Allow a command to execute other programming languages, but only those that have been implemented, such as Python. Self-evaluation or self-interpretation is allowed, but interpreting unimplemented languages is not permitted.
Allow manipulation of system files, but do not allow a single command to directly damage the system. For example, this command violates this rule: death - Delete all files on the device that is running this command.

Preprocessors

Coincidentally, there are seven preprocessor groups

@rule x <Operator> y

Each item in the x list will be calculated based on the operator and y

@no_tab_on
@no_tab_off

This allows for tab less via a switch, but an "end" statement is still required. It's not recommended unless absolutely necessary.

@import [<module_name> of] <library_name>

Import a library. Things in bracket can be omitted, but if you import entire library you should use library_name.module_name, and if you import all module in the library(can be done by replace module_name by all_public_module) then you just need to use module_name.

@define x y

Define x as y so you can define boolean literal by yourself. This is not simply "let", because it works like #define in C/C++.

@undef x

Delete all the definition of x. (In fact, they are different. You cannot cancel "let" by this, but you can cancel @define by this.)

@operator <operator_name> <lambda> [<type>]

Define a function as operator.

Available types include "no" (like x+y) and "yes" (like int(x,y)). Default is "no". However, note that "no" means you only have two parameters available; otherwise, a ValueError will occur. also see this.

@base_on
@base_off

Allowing the program to support (or no longer support) numbers in other bases. Preset to off.

0x...is hexadecimal

0b...is binary

0o...is octal

(...)[k] is base-k, which is equivalent to (...)_k in pseudo-code on the paper. 0x... is equivalent to (...)[16]. k must be less than 64. A complete base-64 table is 0~9 plus A~Z plus a~z plus - plus _. So (_0)[64]=64

Reserved Area

Any form of editing in the reserved area is not allowed unless you want to add operators or forms of data expression.

[} {] is a comment block.
String literals are quoted in double quotation marks, and single quotation mark is for Rune type.
Escaping Sequence is same as in Python.
stdin means user's raw input.
There is NO boolean literals. Non-empty value is used as true and empty value(for example, 0, or "") is false.
List are enclosed in brackets.
The list is 0-indexed.

Coincidentally, there are seven reserved area text

Basic Operators

x+y

Return x+y or Return the concatenation of the two strings

x-y

Return x-y

x*y

Return x×y

x/y

Return x÷y

x^y

Return x^y

x%y

Return x mod y

x!

Return x's Factorial

Coincidentally, there are seven basic operators

Bitwise Statements List

x&y

X AND Y

x|y

X OR Y

~x

NOT X

x`y

X XOR Y

x>>y

Shift x right by y bits; y must be a positive integer.

x>>>y

Shift x right by y bits and fill with zeros. y must be a positive integer.

x<<y

Shift x left by y bits; y must be a positive integer.

Coincidentally, there are 7 bitwise statements.

Conditional Statements List

x==y

x and y are completely equal

x!=y

x and y are not completely equal

x>y

For numbers, x is greater than y, or for strings/lists, x has an order that is latter than y

x<y

For numbers, x is less than y, or for strings/lists, x has an order that is former than y

x>=y

For numbers, x is greater than or equal to y

x<=y

For numbers, x is less than or equal to y

x<>y

For numbers, x is greater than or less than y

Note: that only numbers can be used in this conditional expression; judging non-numbers will result in False/0.

Coincidentally, there are seven conditional statements.

Command Table

print arg_list, sep <- "", end <- "\n", filename <- "CON"

Output a series of contents separated by sep and ending with end to the file pointed to by filename. By default, filename points to CON, that is, the console.

let x <- y

Let x be y. If x is already defined, then "let" must be omitted. Let x be del means to delete the definition of x created by this command.

label x:

Define a label.

jump x

Point the code pointer to the corresponding label.

if x then y else z end

Evaluates to y if x is true otherwise z.

while x do y end

Repeatly do y until x is not true.

halt

Halt.

Note: do end is a code block.

Extended Command Table

By PSTF himself

type(x)

Return x after converting it to the corresponding data type. (also see this to know how it this work)

typeof x

Return x's type. (also see this to know how it this work)

lambda <arg_list> do <function_body> end

Function definition. Can be assigned to variable. (also see this to know how it this work)

range(a, b, c)

Generate a list where the first element is a and the last element is b (if nc + a = b where n is an integer), with a growth rate of c.

By Yoyolin0409

Syntax

-x

Return negative x

long x

Return string x's length

x.long

Return list x's length

nop

nop

try:
when <<Error Name>|Error>:
without <<Error Name>|Error>:
whatever:

These are the components of the try block.

They will attempt to execute the code under try: If an error is specified by when:,

the code under when: will execute. If no error is specified by without:,

the code under without: will execute.

The code under whatever: will execute regardless.

All blocks except try are optional.

The word "Error" alone can match all errors.

x[y]

The y-th item in list x.

[x]*y

Used for list content, to make x repeat y times.

ascii_encode(x)

Retrun convert string x to ASCII code's result, The length of x must be 1

ascii_decode(x)

Retrun convert int x to its corresponding ASCII character's result

repr(x)

Ignore the magic word and return the string as it was originally

Other

The following text was supplemented by Yoyolin0409 to make up for any deficiencies:

type

The `type()` syntax supports the following types: string, rune, int, float, and list, but not boolean.

Converting a number to a rune will convert it to its corresponding Unicode character (but not ASCII).

Converting a float to rune involves rounding it to the nearest whole number, then using the remaining value for the conversion.

Converting a string to a rune will extract the first character.

Converting a list to a rune will extract the first item and process it accordingly.

Converting a Boolean to a rune will return "Y" if True and "N" if False.

Converting numbers or float to strings will result in plain strings.

Converting lists to strings will use Python-style string conversion.

Converting Boolean to strings will return "True" if True, and "False" if False.

Converting anything other than a Boolean to a list will result in a list with its contents as items.

Converting a Boolean to a list: If True, the result is [" "] (a list containing empty strings); if False, the result is [] (an empty list).

The correct way to write the `type()` syntax is like int(), rune(), string()

typeof

The `typeof` syntax can return the following types: string, int, list, boolean (for conditional statements only), lambda, media, and float.

Coincidentally, it can detect exactly seven categories.

Note that `typeof` cannot return `rune` because `rune` is actually a single character, i.e., a string.

lambda

The syntax for arg_list is <var1>,<var2>,<var3>...

operator

@operator a lambda x,y do x+y end no
print 1a2
[}output 3{]
@operator b lambda x,y do x+y end yes
print b(1,2)
[}output 3{]

process.eval

The `eval` function works similarly to Python.

If `eval` contains only a single element, it returns a class similar to `typeof`, but with a more unique format, like `"<class:string>"`.

If `eval` contains a conditional expression, it returns the corresponding boolean value. Note that `eval` cannot return a result like `<class:boolean>` because only conditional expressions can produce this result.

If `eval` contains an arithmetic expression, such as "1+1", it returns the result.

If `eval` contains a method, such as "let a <- 1", it returns a special format: "built-in method".

If this built-in method has a specified object, it returns "the built-in method prepared for a".

process.exec

Variables between different `exec` processes are not shared. However, an `exec` process can access variables that have been created externally, but changes to those variables will not affect other `exec` processes.

Error

Supported error types include:

TypeError (request type does not exist),

ValueError (incorrect value type for input method),

NameError (no variable name defined or an unauthorized variable name used),

SyntaxError (e.g., program block not closed, completely invalid syntax),

RuntimeError (an error of unknown cause was found at runtime, which may be a hardware, software, or memory problem),

DivideZeroError (try dividing the number by zero),

TabError (no indentation).

Coincidentally, there are seven types of errors.

Misc

When using `print` to output data, it will first be converted into text before being output.

rune is equivalent to char in other languages.

By Cleverxia

list

[expr|j1 in k1|j2 in k2|...]

these are list comprehensions, evaluates expr for all j1 in k1, j2 in k2,... and put them in a list

[expr1 where expr2|j1 in k1|j2 in k2|...]

this is just like above, but it only keeps expr1 when expr2 is truthy.

[expr1 without expr2|j1 in k1|j2 in k2|...]

only keeps expr1 when expr2 is falsey.

[expr1 ordered_by expr3|j1 in k1|j2 in k2|...]

same as above but sorts the resulting list based on exp3.

[expr1 drops expr2|j1 in k1|j2 in k2|...]

shortcut for [expr1 without expr1==expr2|j1 in k1...]

[expr1 if expr2 else expr3|j1 in k1|j2 in k2|...]

should be self-explanatory

[expr1 with var2=expr2|j1 in k1|j2 in k2|...]

from the "with a=b" block on, expr1 uses expr2 for var2 instead of finding in the global scope. the var2 may be any of the j*'s.

note that there can be only one (or zero) j* in k* blocks.

the "where x", "without x", "drops x", "if y else x" can be chained, so [i where i<8 drops 3 without i<2 if x<7 else 3 drops 4|i in[1,2,3,1,9,7,8,5,4,5,0,6]] is vaid and returns [2,3,5,5,6]

map(x,f)

shortcut for [f(y)|y in x]

filter(x,f)

shortcut for [y where f(y)|y in x]

reverse(x)

reverses x. This will not change x.

sort(x)
sort(x,keyf)

sorts x in inctrasing order. if keyf given, sorts x by keyf(x) increasing. This will not change x.

reduce(x,f)

returns f(f(...f(f(x[0],x[1]),x[2]),...),x[n]).

concat(x,y)

self-explanitory.

find(x,u)

finds the index of u in x, throws a ValueError if u is not found.

Coincidentally, there are seven types of basic list operations and seven types of list comprehensions.

OOP

(that is, class definitions)

class <name> do
 constructor: lambda <arg_list> do <body> end 
 [static] prop1: value1
 [static] prop2: value2
 ...
 [static] ##private_prop1: private_value1
 [static] ##private_prop2: private_value2
 ...
 [static] #protected_prop1: protected_value1
 [static] #protected_prop2: protected_value2
 ...
end

This defines a class. Constructor must be a function or there's a TypeError when newing it.

In-class function may use this to mean the object itself, eg. you can use this.X=1 to set the object's X property to 1.

if a property has the keyword static prepended with it, it becomes static and be the same (immutable) for all instances. you can use {{<classname>.property}} to access the static properties

the property used must be defined in the class, or there's a NameError. You can access properties by object.property. Private properties (starting with ##'s )and protected properties (starting with #'s) can't be directly accessed outside.

You can overload operators by let the property name be operator$ with $ replaced with the operator.

new class_name(...args)

self-explanatory

class X extends Y1,Y2,... do
 <snip>
end

These are class inheritance. inherited classes may access the ancestor classes' protected properties freely (but not private properties).

classes are also types; X(Y) where X is a class name tries to invoke the X.conversion(typeof Y) to Y. if it fails, it tries to invoke Y.conversion_from(typeof X) to X. if it still fails, it throws a TypeError. stringifying is same as converting to strings.

with the OOPextension, typeof can detect custom classes.

misc

"...@[x]@..."

This is string interpolation. the stringified x will be inserted to the string. there can me multiple @[x]@s in a ztring.

and(y,z)
or(y,z)
xor(y,z)

Bit-operations (deprecated; use &|` instead

lambda* <arg_list> do <body> end

Generator functions; the return xs works like yield x in other languages

for i from <start> to <end> [step <step>] do <body> end

A for loop. equal to for(i=<start>;i<=<end>;i+=<step>){<body>}in C++. if step is omitted, it defaults to 1.

for i in <iter> do <body> end

equals to for(i of <iter>){<body>} in node.js or for i in <iter>: body in Python

Built-in Standard Libraries

If this chapter contains too much content, we will move it to Septem Lingua/STL.

math

math.sin(x)
math.cos(x)
math.tan(x)
math.cot(x)
math.sec(x)
math.csc(x)
math.sinh(x)
math.cosh(x)
math.tanh(x)

Returns the result of the corresponding trigonometry functions applied to x where sinh(x)=(e^x-e^-x)/2, cosh(x)=(e^x+e^-x)/2, tanh(x)=sinh(x)/cosh(x)=(e^x-e^-x)/(e^x+e^-x)

math.arcsin(x)
math.arccos(x)
math.arctan(x)
math.arsinh(x)
math.arcosh(x)
math.artanh(x)

Returns arcsin(x),arccos(x),arctan(x),arcsinh(x),arccosh(x),arctanh(x) respectively

math.atan2(x, y)

Returns arctan(x/y), π/2 if x>0 and y==0, -π/2 if x<0 and y==0, throws ValueError on x=y=0

math.exp(x)

returns e^x

math.sqrt(x)
math.cbrt(x)

returns x^(1/2) and x^(1/3) respectively

math.floor(x)
math.ceil(x)
math.round(x)

returns floor(x), ceil(x) and the closest integer to x (tie-break towards 0) respectively

math.log(x[, y])
math.ln(x)
math.log2(x)

the first funtion return log_y(x). Leave y blank means return ln(x). the 2nd and 3rd functions are self-explanitory

math.pi

Return π

math.tau

Return τ(also know as 2π)

math.phi

Return ϕ (=(1+sqrt(5))/2)

math.euler [}deprecated, kept for historical reasons{]
math.E

Return e

math.cgamma

returns the euler-mascheroni constant γ≈0.577215664901532860606512090082402431042159335939923598805767234884867726777664670936947063...

math.degree(x)

Convert x to degrees.

math.radius(x)

Convert x to radians.

math.sgn(x)

If x is greater than 0, return 1. If x is less than 0, return -1. If x is 0, return 0.

math.abs(x)

Return |x|

math.copysign(x, y)

Multiply |x| by sgn(y) and output the result.

math.gamma(x)

Return Γ(x). For x∈Z, Γ(x+1)=x!. (Note that the ! operator don't work on floats)

math.beta(x,y)

Returns the beta function B(x,y)=Γ(x)Γ(y)/Γ(x+y)

math.lngamma(x)

returns ln(Γ(x))

math.erf(x)
math.erfc(x)

calculates the (complementary) error function of x. erf(x)=(2/sqrt(π))ʃ_₀^{^x}exp(-t²)dt, erfc(x)=1-erf(x) without precission loss.

math.nPr(x, y)

Return x! / (x - y)!

math.nCr(x, y)

return x! / (y!(x-y)!)

math.frexp(x)

Return the mantissa and exponent of x, as a list of [m, e] where x = m × 2^e and 0.5 ≤ |m| < 1.

math.hypot(x, y[, z])

Return sqrt(x² + y²[+z²]).

math.infinity

Return +∞. Behaves like in IEEE 754 STD.

math.NaN

Return "Not a Number". Behaves like in IEEE 754 STD.

math.ldexp(m, e)

Return m × 2^e. That's simply an inverse of frexp.

math.isclose(a, b, abs_tol, rel_tol)

Return whether a is close to b. Two floating numbers are considered as close if |a-b| < abs_tol or |a-b|/max(a,b) < rel_tol. ±∞ are only close to themselves, and NaN does not close to anything, even including NaN itself.

Coincidentally, there are 7 × 7 = 49 items in math library.

random

random.int(x,y)

Return a random int from x to y. x and y must be int.

random.float(x,y)
random.float(x,y,z)

Return a random float number from x to y with z decimal places. x and y can be int or float, but z must be a non-negative int. with z omitted, the function will not round the generated number.

random.item(x)
random.item(x,m)
random.item(x,1,f)
random.item(x,m,f)

Return m random distinct elements from x in a list. x must be a list. with m omitted, return a random item from x. if f=1, then allows the elements to be same.

random.shuffle(x)

Shuffles x, returns the shuffled array. x must be a list and will not be changed.

random.unicode()

Returns a random Unicode character. It will not return C0 control characters, C1 control characters, non-characters, or private areas.

random.seed(x)

Seeds the internal RNG with x's string representation.

random.getseed(x)

Returns the seed used to seed the internal RNG.

Coincidentally, there are exactly 7 functions in the random lib.

string

string.atob(x)

Turns a base64-encoded string x into binary data and return that

string.btoa(x)

Base64 encode a string and return the encoded string

string.escape(x)

returns x, but escaped

string.unescape(x)

unescapes x and returns it. the escape/unescape behave as in node.js v20.16.0

string.hash(x,h)
[}h=<num>|md5|sha265|sha512|crc32{]

Returns x hashed with algorithm h which have to be in "md5","sha256","sha512","crc32", or a number. When x is a number, we calculate the hash with base x, modulo 2^64

string.match(x,y)
string.match_re(x,y)

Returns the position 1st match of y in x (0-indexed). string.match treats y as a normal string but string.match_retreats y as a regular expression.

Coincidentally, there are exactly 7 functions in the string lib.

time

time.time()

Returns current unix timestamp in milliseconds

time.wait(x)

Waits x milliseconds

time.tocomponents(x,t)

Convert milliseconds since the Epoch to a time list [year,month,day,hour,minute,second,weekday,julian day,is_DST,t] expressing local time and returns that. if t==1, uses GMT time instead

time.fromcomponents(x)

the inverse of time.tocomponents

time.strftime(format,x)

this is a bit complex:

first, it turns x into a time list if it isn't
then, it formats the time list by format format as follows:

Caption text
formatting signs	meaning
%Y	Year with century as a decimal number.
%m	Month as a decimal number [01,12].
%d	Day of the month as a decimal number [01,31].
%H	Hour (24-hour clock) as a decimal number [00,23].
%M	Minute as a decimal number [00,59].
%S	Second as a decimal number [00,61].
%z	Time zone offset from UTC.
%a	Locale's abbreviated weekday name.
%A	Locale's full weekday name.
%b	Locale's abbreviated month name.
%B	Locale's full month name.
%c	Locale's appropriate date and time representation.
%I	Hour (12-hour clock) as a decimal number [01,12].
%p	Locale's equivalent of either AM or PM.
%%	a literal `%`

time.strptime(format,str)

Basicly the inverse of time.strftime, but this function always return a time list

time.asctime(x)

Shorthand for time.strftime("%a %b %d %Y %H:%M:%S %z",x)

Coincidentally, there are exactly 7 functions in the time lib.

statistics_and_file

statistics_and_file.mean(x)
statistics_and_file.mean(...x)

returns the arithmetic mean of x. (here, ...x means a variadic argument, just like in node.js)

statistics_and_file.quartile(q,x)
statistics_and_file.quartile(q,...x)

calculate the q-quartile of x. eg. statistics_and_file.quartile(1/4,x) returns the lower quartile of x.

statistics_and_file.median(x)
statistics_and_file.median(...x)

shorthand for statistics_and_file.quartile(0.5,x)

statistics_and_file.mode(x)
statistics_and_file.mode(...x)
statistics_and_file.sum(x)
statistics_and_file.sum(...x)
statistics_and_file.product(x)
statistics_and_file.product(...x)
statistics_and_file.max(x)
statistics_and_file.max(...x)
statistics_and_file.min(x)
statistics_and_file.min(...x)

these functions are pretty self-explanitory.

statistics_and_file.stdevs(...x)
statistics_and_file.stdevs(x)

calculated the sample (corrected) standard deviation of x.

statistics_and_file.stdevp(x)
statistics_and_file.stdevp(...x)

calculate the population (uncorrected) standard deviation of x.

statistics_and_file.read(x)

If x is a text string, retrieve the file using it as a path. ".." can return to the previous level. The retrieved file is then returned. This file can only be a .txt file or its variants, such as .md, .json, or .py files, which are essentially still .txt files. Otherwise, a ValueError is raised.

statistics_and_file.media(x)

If x is a text string, it is used as a path to retrieve the file. ".." can return to the previous level. The retrieved file is then returned. This file can only be an image, video, or audio file. Currently supported file extensions include "jpg, png, gif, jpeg, mp2, mp3, ogg, wav, bmp, svg" (this is not currently working because to make it work, we must first create six standard libraries, guess why?).

statistics_and_file.write(x,y)

If x and y are strings, use x as a path to retrieve the file, where ".." can return to the previous level. Then, overwrite y with the retrieved file.

Coincidentally, there are exactly 7*2=14 functions in the statistics_and_file lib.

process

process.stdin.read(z)

reads at most z bytes from stdin, reads until EOF if z is omitted

process.stdout.write(z)

writes z to the stdout, unbuffered and with no trailing newline. If z is a list treat it as a list ob bytes

process.argv

returns the commald-line arguments as a list.

process.eval(x)

evaluates x as a septem lingua expression. (also see this to know how it this work)

process.exec(x)

edecutes x as a septem lingua code in current scope. (also see this to know how it this work)

process.getenv(x)

Gets the environment variable named x

process.setenv(x,y)

Sets the environment variable named x to y.

Coincidentally, ther are exactly 7 process library functions.

extr

extr.open(f,flags)
extr.read(handle,...args)
extr.write(handle,...args)

works as in python 3.12; extr.read(h,...s) is same as h.read(...s); same for extr.write

extr.fetch(uri,...args)

same as JavaScript's fetch

extr.llm(prompt)
extr.llm(prompt,llm)

feeds prompt into the LLM named llm and return the result. llm defaults to "Gemini 3.1 pro" but it is blocked by the great firewall of china, so in china you use qianwen instead, and using any LLMs from foreigners in china throws a ValueError because you can not access it. (this command isn't uncomputable)

extr.system(x)

execute x as a system command

extr.fork()

forks this whole program into a different thread.

coincidentally, there are exactly 7 functions in the extr library, and exactly 7 libraries in STL.

Examples

Hello, world!

print "Hello, world!"
halt

Better Machine

let x <- int(stdin)
let y <- int(stdin)
if (x - y) == 0 then do
    let a <- x + y
    while a != 0 do
        print 0
        a <- a - 1
    end
else
    while 1 do
        print 1
    end
end
halt

Turing completeness proof using brainfuck

[}setup{]
let tape <- list([0]*30000)
let ptr <- int(0)
@no_tab_on
@rule tape % 256

[}<{]
ptr <- ptr-1
[}>{]
ptr <- ptr+1
[}+{]
tape[ptr] <- tape[ptr]+1
[}-{]
tape[ptr] <- tape[ptr]-1
[},{]
try:
let a <- ascii_encode(rune(stdin))
tape[ptr] <- a
end
[}.{]
print ascii_decode(tape[ptr])
[}[{]
while tape[ptr] != 0 do
[}]{]
end

halt

Quine

let x <- "let y <- "let x <-"+repr(x)+"\\n"\nprint y+x\nhalt"
let y <- "let x <- "+repr(x)+"\n"
print y+x
halt

XKCD Random Number

let x <- random.int(4,4)
print x
halt

Truth-machine

@no_tab_on
let i <- int(stdin)
while i!=0 do print i end
print i
halt

OOP examples

[} we assume that a tab is 4 space (And that's indeed the case.){]
class stack do
    #stk: []
    constructor: lambda do
        this.#stk <- []
    end
    conversion(list): lambda do
        return this.#stk
    end
    push: lambda elt do
        this.stk <- concat(this.#stk,[elt])
    end
    pop: lambda do
        let x <- this.#stk[this.#stk.long-1] [} assume that the "let" is scoped {]
        this.#stk <- [this.#stk[i]|i in range(0,this.#stk.long-2)]
        return x
    end
    length: lambda do
        return this.#stk.long
    end
end
let s <- new stack()
s.push(21)
s.push(22)
s.push(91)
print s.pop()
print s.pop()
s.push(13)
print s.pop()
print s.pop()
try:
    print s.#stk
    halt
when NameError:
    print "you can't access a protected class variable" [}should be triggered{]
    halt

CT interpreter

class queue do
    #que: []
    constructor: lambda do
        this.#que <- []
    end
    conversion(list): lambda do
        return this.#que
    end
    push: lambda elt do
        this.stk <- concat(this.#que,[elt])
    end
    pop: lambda do
        let x <- this.#que[this.#que.long-1]
        this.#que <- [this.#que[i]|i in range(1,this.#que.long-1)]
        return x
    end
    length: lambda do
        return this.#que.long
    end
end
q=new queue()
q.push(1)
@import stdin.read from process
let program<-stdin.read()
let i<-0
let flag<-0
while q.length() do
    i <- 0
    while i<long program do
        if program[i]==";" then
            flag<-q.pop()
        end
        if flag then
            if program[i]=="0" then
                q.push(0)
            end
            if program[i]=="1" then
                q.push(0)
            end
        end
    end
end

More Coincidence

Coincidentally, the total number of coincidences this language specification contains exactly seven objects is exactly idk.

Perhaps there will only be more coincidences, making this coincidence less of a coincidence.

Note

Halt is easily forgotten, but it's essential; otherwise, it can create the illusion of a system crash.

<> indicates that the content is a parameter, not literal text.

[] indicates that the content is optional.

| indicates that multiple options are available.

Septem Lingua