Examine individual changes

'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 = Coincidentally, as of 8:12 PM on March 15, 2026, there are 7 members in the development team of this language (except [[User:i am islptng|islptng]] which is in space-time travel ([https://antimatter-dimensions.fandom.com/wiki/Eternity_Challenges eternity challenge 12])). Leader: [[User:PrySigneToFry]](PSTF) Developers: <span style='font-family:Fraktur;background:green;color:white'>[[User:I am islptng]](In time-space travel, unable to participate in development)</span>, [[User:Yoyolin0409]] 1st-batch members: [[User:Hammy]], [[User:cleverxia]], [[User:Yayimhere]] 2nd-batch members: [[User:MihaiEso]], [[User:Qazwsxplm]] = 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 [[User_talk:/w/wiki/index.php/Talk:index.php/Main_page|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: <span style="font-family: Serif;"><tt>death</tt> - Delete all files on the device that is running this command.</span> = 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 <code>library_name.module_name</code>, 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 <code>module_name</code>. @define x y Define x as y so you can define boolean literal by yourself. This is not simply "let", because it works like <code>#define</code> 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 [[Septem Lingua#operator|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. * <code>[} {]</code> 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 '''''<span style='color:red'>NO</span>''''' 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: <code>do end</code> is a code block. = Extended Command Table = == By PSTF himself == type(x) Return x after converting it to the corresponding data type. (also see [[Septem_Lingua#type|this]] to know how it this work) typeof x Return x's type. (also see [[Septem_Lingua#typeof|this]] to know how it this work) lambda <arg_list> do <function_body> end Function definition. Can be assigned to variable. (also see [[Septem_Lingua#lambda|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=== <pre>[expr|j1 in k1|j2 in k2|...]</pre> these are list comprehensions, evaluates expr for all j1 in k1, j2 in k2,... and put them in a list <pre>[expr1 where expr2|j1 in k1|j2 in k2|...]</pre> this is just like above, but it only keeps expr1 when expr2 is truthy. <pre>[expr1 without expr2|j1 in k1|j2 in k2|...]</pre> only keeps expr1 when expr2 is falsey. <pre>[expr1 ordered_by expr3|j1 in k1|j2 in k2|...]</pre> same as above but sorts the resulting list based on exp3. <pre>[expr1 drops expr2|j1 in k1|j2 in k2|...]</pre> shortcut for {{cd|[expr1 without expr1&#61;&#61;expr2&#x7c;j1 in k1...]}} <pre>[expr1 if expr2 else expr3|j1 in k1|j2 in k2|...]</pre> should be self-explanatory <pre>[expr1 with var2=expr2|j1 in k1|j2 in k2|...]</pre> 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) {{cd|j* in k*}} blocks. the "where x", "without x", "drops x", "if y else x" can be chained, so {{cd|[i where i<8 drops 3 without i<2 if x<7 else 3 drops 4&#x7c;i in[1,2,3,1,9,7,8,5,4,5,0,6]]}} is vaid and returns {{cd|[2,3,5,5,6]}} map(x,f) shortcut for {{cd|[f(y)&#x7c;y in x]}} filter(x,f) shortcut for {{cd|[y where f(y)&#x7c;y in x]}} reverse(x) reverses x. '''This will not change x.''' sort(x) sort(x,keyf) sorts x in inctrasing order. if {{cd|keyf}} given, sorts x by keyf(x) increasing. '''This will not change x.''' reduce(x,f) returns {{cd|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) <pre> 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 </pre> This defines a class. Constructor must be a function or there's a TypeError when {{cd|new}}ing it. In-class function may use {{cd|this}} to mean the object itself, eg. you can use {{cd|1=this.X=1}} to set the object's X property to 1. if a property has the keyword {{cd|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 {{cd|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 {{cd|operator$}} with $ replaced with the operator. <pre> new class_name(...args) </pre> self-explanatory <pre> class X extends Y1,Y2,... do <snip> end </pre> These are class inheritance. inherited classes may access the ancestor classes' protected properties freely (but not private properties). classes are also types; {{cd|X(Y)}} where X is a class name tries to invoke the {{cd|X.conversion(typeof Y)}} to Y. if it fails, it tries to invoke {{cd|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, {{cd|typeof}} can detect custom classes. ===misc=== "...@[x]@..." This is string interpolation. the stringified x will be inserted to the string. there can me multiple <code>@[x]@</code>s in a ztring. and(y,z) or(y,z) xor(y,z) Bit-operations (deprecated; use {{cd|&&#x7c;`}} instead lambda* <arg_list> do <body> end Generator functions; the {{cd|return x}}s works like {{cd|yield x}} in other languages for i from <start> to <end> [step <step>] do <body> end A for loop. equal to {{cd|1=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 {{cd|for(i of <iter>){<body>} }} in node.js or {{cd|for i in <iter>: body}} in Python == By Qazwsxplm == X⅋Y X NAND Y X׳Y X NOR Y X‘Y X XNOR Y = 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 <!--my edits ended--> 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 {{cd|!}} 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(π))<big><big><big>ʃ</big></big></big>_₀^{^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 "''N''ot ''a'' ''N''umber". 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'''. <!-- we already have floor.ceil--> 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). {{cd|string.match}} treats y as a normal string but {{cd|string.match_re}}treats y as a regular expression. Coincidentally, there are exactly 7 functions in the string lib. == time == <!--lets make the number of libs 7! --> 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 {{cd|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 {{cd|format}} as follows: {| class="wikitable sortable" |+ 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 {{cd|%}} |} time.strptime(format,str) Basicly the inverse of {{cd|time.strftime}}, but this function always return a time list time.asctime(x) Shorthand for {{cd|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, {{cd|...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. {{cd|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 {{cd|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 [[Septem_Lingua#process.eval|this]] to know how it this work) process.exec(x) edecutes x as a septem lingua code in current scope. (also see [[Septem_Lingua#process.exec|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 complete]]ness 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]]== <pre> @no_tab_on let i <- int(stdin) while i!=0 do print i end print i halt </pre> ==OOP examples== <pre> [} 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 </pre> ==[[CT]] interpreter== <pre> 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 </pre> = 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. = Categories = [[Category:2026]] [[Category:Languages]] [[Category:User Edited]] [[Category:Turing complete]]'