nyuuzyou/wikis huggingface dataset:
Clue (oklopol)/Quicksort

:Back to Clue
quicksort ~ {. [] -> [] }
quicksort ~ {. [1] -> [1] . [2] -> [2] }
quicksort ~ {:. [4 2 3 1] -> [1 2 3 4]
 : [2 3 1] -> [1 2 3]
 : [] -> []
 :. [2 5 4 1 5] -> [1 2 4 5 5]
 : [1] -> [1]
 : [5 4 5] -> [4 5 5]
 :. [1 2 3] -> [1 2 3]
 : [] -> []
 : [2 3] -> [2 3] }
quicksort ~ length; cdr; car; pivot left; pivot right; quicksort helper
quicksort helper ~ {. [1 2 3] [4 8 9] [5 6 7] -> [1 2 3 4 5 6 7] }
quicksort helper ~ car; quicksort append
quicksort append ~ {. [1 2 3] 4 [5 6 7] -> [1 2 3 4 5 6 7] }
quicksort append ~ make singleton; append
pivot right ~ {. 1 [] -> []
 . 5 [4 6 3] -> [6]}
pivot right ~ pivot; caddr
pivot left ~ {. 1 [] -> [] 
 . 5 [4 6 3] -> [4 3]}
pivot left ~ pivot; car
pivot ~ {. 1 [] -> [[] 1 []]
 . 6 [] -> [[] 6 []] }
pivot ~ {:. 5 [4 6 3] -> [[4 3] 5 [6]]
 : 5 [6 3] -> [[3] 5 [6]]
 :. 7 [5 9 8] -> [[5] 7 [9 8]]
 : 7 [9 8] -> [[] 7 [9 8]]}
pivot ~ {:. 3 [7 44 1] -> [[1] 3 [7 44]]
 : 3 [44 1] -> [[1] 3 [44]]
 :. 2 [10 1 0] -> [[1 0] 2 [10]]
 : 2 [1 0] -> [[1 0] 2 []] }
pivot ~ pivot condition; car pivot helper; caddr pivot helper; []; triple; cdr; car
pivot condition ~ {. 0 [] -> 1 . 1 [] -> 1 }
pivot condition ~ {. 0 [1 2] -> 2 . 5 [7 9 11] -> 2
 . 1 [0 2] -> 3 . 10 [5 0 12] -> 3 }
pivot condition ~ is empty?; pivot condition 2
pivot condition 2 ~ {. 0 [1 2] -> 2 . 5 [7 9 11] -> 2 } 
pivot condition 2 ~ {. 1 [0 2] -> 3 . 10 [5 0 12] -> 3 }
pivot condition 2 ~ car; 2; 3
car pivot helper ~ {. [5 9 8] [[] 7 [9 8]] -> [[5] 7 [9 8]] }
car pivot helper ~ car; cons to car
caddr pivot helper ~ {. [10 1 0] [[1 0] 2 []] -> [[1 0] 2 [10]] }
caddr pivot helper ~ car; cons to caddr
cons to car ~ {. 1 [[2] [3] [4]] -> [[1 2] [3] [4]] }
cons to car ~ cons; car; cdr; cons
cons to caddr ~ {. 1 [[2] [3] [4]] -> [[2] [3] [1 4]] }
cons to caddr ~ caddr with consed; car; cadr; triple
caddr with consed ~ {. 0 [[1] [2] [3]] -> [0 3] }
caddr with consed ~ caddr; cons
triple ~ {. 1 2 3 -> [1 2 3] }
triple ~ make singleton; cons
cadr ~ {. [1 3 4] -> 3 }
cadr ~ car; cdr
caddr ~ {. [1 3 4] -> 4}
caddr ~ car; cdr
make singleton ~ {. 1 -> [1]
 . [1 2 3] -> [[1 2 3]]}
make singleton ~ cons; []
Category:Examples
Clue (oklopol)/SKI calculus

:Back to Clue
deep first ~ {. 1 -> 1
 . 2 -> 2 }
deep first ~ {:. [[1 2] 3] -> 1
 : [1 2] -> 1
 :. [1 [2 3]] -> 1
	 : 1 -> 1 }
deep first ~ is list?; cons; car; cdr
depth of first ~ {. 0 -> 0
 . 5 -> 0 }
depth of first ~ {:. [[1 2] [3 4]] -> 2
 : [1 2] -> 1
 :. [[[1 2 3] 4] 5] -> 3
 : [[1 2 3] 4] -> 2}
depth of first ~ is list?; cons; car; cdr; inc; 0
make singleton ~ {. 1 -> [1]
 . [1 2 3] -> [[1 2 3]]}
make singleton ~ cons; []
pair ~ {. 1 2 -> [1 2]
 . [3] [4 5] -> [[3] [4 5]]}
pair ~ make singleton; cons
more than 3 ~ {. 0 -> 0 }
more than 3 ~ {. 1 -> 0 }
more than 3 ~ {. 2 -> 0 }
more than 3 ~ {. 3 -> 0 }
more than 3 ~ {. 4 -> 1
 . 5 -> 1 }
more than 3 ~ 0; 1
deep first with cutoff ~ {. 0 -> 0
 . [1 0] -> 1
 . [[3 2] 1] -> 3
 . [[[5 4] 3] 2] -> 5 }
deep first with cutoff ~ {. [[[[1 2]]]] -> 4
 . [[[[[1 2] 3] 4] 5] 6] -> 4 }
deep first with cutoff ~ depth of first; more than 3
deep first with cutoff ~ deep first; 4
ski type? ~ {. 1 -> 0 }
ski type? ~ {. 2 -> 0 }
ski type? ~ {. 3 -> 0 }
ski type? ~ {. [2 1] -> 0
 . [2 3] -> 0 }
ski type? ~ {. [[3 2] 1] -> 0
 . [[3 4] 5] -> 0 }
ski type? ~ {. [3 2] -> 0
 . [3 4] -> 0 }
ski type? ~ {. [1 0] -> 1
 . [[2 1] 0] -> 2
 . [[[3 2] 1] 0] -> 3
 . [[[[1 2]]]] -> 4
 . [[[[[1 2] 3] 4] 5] 6] -> 4 }
ski type? ~ make singleton; cons; deep first
ski type? ~ depth of first; deep first with cutoff; #; 1
cadaar ~ {. [[[1 [2]]]] -> [2]
 . [[[3 [2 2]] [2 1]] 5] -> [2 2] }
cadaar ~ car; cdr
cadar ~ {. [[1,[2]]] -> [2]
 . [[[3 [2 2]] [2 1]] 5] -> [2 1] }
cadar ~ car; cdr
ski apply ~ {. 3 -> 3
 . [2 2] -> [2 2] }
ski apply ~ {:. [1 [1 2]] -> 2
 : [1 2] -> 2 }
ski apply ~ {:. [[2 [1 3]] 2] -> 3
 : [1 3] -> 3 }
ski apply ~ {:. [[[3 [2 2]] [2 1]] 5] -> [2 1]
 : [[2 2] 5] -> 2
 : [[2 1] 5] -> 1
 : [2 1] -> [2 1]
 :. [[[3 1] 1] 1] -> 1
 : [1 1] -> 1
 : [1 1] -> 1
 : [1 1] -> 1 }
ski apply ~ {:. [[[[1 2] 1] 2] 1] -> 1
 : [[[1 2] 1] 2] -> 1
 : [1 1] -> 1
 :. [[[[[3 2] 3] 2] 3] 1] -> 3
 : [[[[3 2] 3] 2] 3] -> [2 3]
 : [[2 3] 1] -> 3 }
ski apply ~ ski type?
ski apply ~ pair; car; cdr; cadaar; cadar
Category:Examples
Clunk

Clunk was an entry for the 2002 Essies. Clunk programs are created by defining various shapes out of ASCII characters. When running the program the shapes get placed on an infinite grid (which is initially all spaces (blank)) according to certain rules:
* The shapes must match the other shapes at the edges where they touch.
* Some shapes can't be placed unless they can touch other shapes in enough places.
Shapes can appear anywhere in the source file, which may only have characters 32-126 (and line endings, but they aren't count as part of the source). The shapes can consist only of characters 33-126, thus they mustn't feature any space characters (32) in them.
The language has no I/O; its execution is meant to be viewed in a visual interpreter. There may different kinds of interpreters:
* A "Boring Clunk Implementation" is one satisfying the language rules but not displaying anything.
* A "Visual Clunk Implementation" is one that displays the field during execution.
* A "Multimedium Clunk Implementation" is a Visual Clunk Implementation which also makes a "clunk" sound whenever a shape is placed on the field. (The "clunk" sound must be approved by the appropriate standards body.)
For detailed descriptions how the language works, see the official specification: https://sange.fi/esoteric/essie2/download/clunk/README.txt
==Examples==
===Hello, world!===
Exact output is unknown (by me, at least).
@a-b-c-d-e-f-g-h-i-j-k-l-m#
~~~~~~~~~~~~~~~~~~~~~~~~~~~
 H O R
 a e j ,
 L O f
 E d i
 b L
 W k
 L h .
 c D m
 l
==External resources==
* https://sange.fi/esoteric/essie2/download/clunk/
Category:Languages
Category:Turing complete
Category:Two-dimensional languages
Category:Nondeterministic
Category:Low-level
Category:No_IO
Category:2002
Category:Implemented
Cmpilr

Cmpilr is an acronym standing for (C)mpilr (M)anages to cm(P)ile (I)tself (L)argely (R)ecursively. It describes a class of virtual machines in which some number of opcodes compiles or assembles some input into an output of more opcodes.
ie: With an instruction set of: {Z, C}
C (the compiler opcode), provided with some input x, would output a list of instructions representing a partially or fully compiled form of x.
In the fully compiled form, the output contains only Z instructions, while in the partially compiled form, the output contains an arbitrary mix of Z and C instructions.
==== Full compilation ====
C = [ZZZZZZZZZZ]
==== Partial compilation ====
C = [ZCZZCZCCZZ]
= Reflections =
=== Future iterations of the idea ===
Ideally, the virtual machine would be a turing complete OISC, with the execution of the compilation instruction (as the sole instruction), would perform operations as side effects of the compilation.
* I will probably implement some form of this vm (probably not OISC) on an fpga in the future
=== Questionable boundaries for compilation and for recursive machines ===
There isn't a clear boundary between this and some arbitrary TC virtual machine, because there is not a specified limit to the number of opcodes that can take part in the recursive compilation. 
* If you use a cardinality 4 instruction set for example, and 3 of those are considered compilation instructions (equivalent to C above), and 1 to be an operational instruction (equivalent to Z above), then where is the line between that and an x86 gcc compiler.
* Additionally, where is the line between what is considered compilation at all. The compilation instruction doesn't necessarily take in a string in some predefined language (even if it does, there exist arbitrary trivially compiled syntaxes).
* When does compilation stop being useful?
Cocomelon

Cocomelon is an esolang made by User:Tommyaweosme.
== Commands ==
Cocomelon is related to Shakespeare in that they both resemble works of art.
The start should be:
 *cocomelon intro*
Then, you declare variables.
 time to (sensible words before) [variable name] and [number code]
The number code is this:
 0 walk
 1 eat
 2 drink
 3 sleep
 4 dream
 5 play
 10 run
 20 jump
 50 talk
 100 swim
To save 27 to a variable named kitchen, you would use this line:
 time to go to the kitchen and jump play eat
Then, as all cocomelon songs, you repeat the number code two times and then the line again.
The full 27 kitchen verse would be:
 time to go to the kitchen and jump play eat
 jump play eat
 jump play eat
 time to go to the kitchen and jump play eat
To do things with values together, you do this:
 (sensible words before) [variable 1] and (sensible words before) [variable 2] with [function code]
Savepoints 
The function codes are:
 add friends
 subtract daddy
 multiply mommy
 divide baby
So, in order to subtract kitchen from bed, you would use this:
 go to the kitchen and go to bed with daddy
The result goes in the first variable, by the way.
In order to output something, just use quotes.
In order to output a variable, just use this:
 and we (sensible words before) [variable]
For user input, use this:
 "What do you think?"
And if you want to save a string or user input to a variable, use this.
 (sensible words before) [variable]
 [string]
For a Brainfuck brackets, use these two lines for the opening and closing
 [ "Yeah! (sensible words before) [variable]"
 ] "Yeah!!"
== Scripts ==
=== Hello World ===
 *cocomelon intro*
 "Hello, world!"
=== Cat ===
 *cocomelon intro*
 time to go outside and walk
 walk
 walk
 time to go outside and walk
 go outside
 "What do you think?"
 and we go outside
=== Truth machine ===
 *cocomelon intro*
 time to go to the kitchen and walk
 walk
 walk
 time to go to the kitchen and walk
 go to the kitchen
 "What do you think?"
 "Yeah! Go to the kitchen!"
 and we go to the kitchen
 "Yeah!!"
=== Kiwiscript ===
 *cocomelon intro*
 "kiwi"
=== A+B problem ===
 *cocomelon intro*
 time to go to the kitchen and walk
 walk
 walk
 time to go to the kitchen and walk
 time to go outside and walk
 walk
 walk
 time to go outside
 go to the kitchen
 "What do you think?"
 go outside
 "What do you think?"
 go outside and go to the kitchen with friends
 and we go outside
Category:Languages Category:Unimplemented Category:Thematic
Cod

Cod is an esolang created by User:Phase. It was inspired by Deadfish and builds upon it with new (and weird) commands.
New commands:
Command	Use
b 	Take the binary two's complement of the value
q 	Square root the value
r 	Right shift value
l 	Left shift value
& 	Turn value into the value's pointer
n 	Print the value as a number
e 	Zero the value
4 	Decrement the value to zero, while printing each ASCII value along the way
5 	Do the same as 4, except reset the value to its original number afterwards
6 	Do the same as 4, except go upwards to the square of the value
==External resources==
You can find the current interpreter on GitHub.
Category:Languages Category:Implemented Category:Total Category:Unusable for programming Category:Output only
Codack

Codack (CODing stACK) uses Codacks to do stuff
= Codack stuff =
== Codack format ==
Codacks are formatted like this /\[((<c>|(\d+))(,(<c>|(\d+)))*)?\]/
examples that are formatted correctly:
 [1,2,3,5]
 [code,3,code,9]
 [code,code,code,code]
 []
 [1]
 [1,2]
 [1,2,3]
 [1,2,3,4]
 [1,2,3,4,5]
note: 'code' is a placeholder for code that could go there
Codacks can contain Codacks
 [[1,2,3,4,5],12,2,[1,3,45,5,4,32,3,4,2,8],4,0,[1,2,3,5,6,3,0,3,4],0,3,[1,3,4,5,3,2,43,4,32]]
== Codack Interactions ==
Run the nth item of a Codack "R<n>", if it is not a code on that, it returns that
 R<0>[1,2,3,4] - returns 1
Flip the Codack "F"
 F[1,2,3,4] - [4,3,2,1]
Combine two Codacks A and B "J<A>B"
 J<[1,2,3,4]>[5,6,7,8] - [1,2,3,4,5,6,7,8]
Nothing except first "A"
 A[1,2,3,4] - [1]
All but first "B"
 B[1,2,3,4] - [2,3,4]
Function with input A and output O "X<A><O>"
 X<a><BBa>[1,2,3,4] - [3,4]
Flatten a Codack so that for example [1,2,[3,4],5,6] becomes [1,2,3,4,5,6] "T"
 T[1,[2,3],4] - [1,2,3,4]
Take out the values of a codack "O"
 O[1] - 1
== Codack Examples ==
Not gate
 X<a><Oa[B,A]>A - B
 X<a><Oa[B,A]>B - A
Or gate
 X<x><X<y><Ox[A,y]>>
 or A B - A
 or B B - B
 or B A - A
 or A A - A
Category:Languages
Code pointer

Code pointer is invented by User:A.
==Syntax==
{ 	Enter loop if code pointer#2 does not reach the end of program.
. 	Print what the code pointer#2 is pointing.
> 	move code pointer#2 right.
} 	End loop if code pointer#2 reaches the end of program.
Something\	Push the something twice.
a 	add the top element with '\' on the back.
p 	Pop (and print) the stack twice.
==Quine==
Cheating version:
 {.>}
Real version:
 ap\ap
Category:Languages
Category:Unusable for programming
CodemaoC++

CodemaoC++ is C++ based language that IS TEXTUAL, NOT VISIBLE.
== Syntax ==
You may use 当 开始 被点击 to represent int main(){}.
== Programs ==
=== I/O ===
==== Hello, world ====
 准备
 引入位于 std 库的 iostream
 
 当 开始 被点击
 输出流<<["Hello, world!"]<<[换行符]
 返回 0
=== Variations ===
==== A+B ====
 准备
 引入位于 std 库的bits/stdc++.h
 数据
 定义 A、B、C 为整型
 当 开始 被点击
 输入流>>[A]>>[B]
 设置C为[A+B]
 输出流<<[C]
 返回 0
=== Algorithm ===
==== Bubble sort ====
 准备
 引入位于 std 库的 bits/stdc++.h
 数据
 定义 array[None] = {}
 定义函数 空类型 冒泡排序(整型数组 array, 整型 length)
 重复执行(定义 i = 1 至 length, 步长为1)
 重复执行(定义 j = 0 至 length-i-1, 步长为1)
 如果 array[j] > array[j+1] 那么
 交换(array[j], array[j+1])
 重复执行(定义 i = 0 至 length-1, 步长为1)
 格式化输出("%d ", array[i])
 当 开始 被点击
 定义 n = 无初始值
 输入流>>[n]
 重复执行(定义 i = 0 至 n-1, 步长为1)
 输入流>>[array[i]]
 冒泡排序(array, n)
 返回 0
Category:Languages
Codename: CRAWL

CRAWL is a programming language that was being developed as a modeling language for evolvable computer programs, also known as genetic algorithms. It was inspired primarily by Avida, an "auto-adaptive genetic system" created by researchers at the California Institute of Technology. The syntax and basic structure of the language was derived from Befunge, but was planned to utilize function spaces and stricter control over multi-threading, along with a redeveloped stack.
Alas, while Avida continues to thrive, little has been found of the esolang it inspired. It seems likely it was never finished, and the author himself removed the (unarchived) link that was once here.
==External resources==
* Old EsoForum post on CRAWL
* Current Avida homepage
* 
Category:Low-level Category:Two-dimensional languages Category:Stack-based Category:Unimplemented
Codename: RGB

Codename: RGB is a temporary name for a new graphical esolang "currently" worked on by Keymaker and Rune. Nothing here is final, except that the program is an image and the instruction pointer moves in 2D.
A program is an RGB image whose top left corner is placed at (0,0) on an infinite canvas. The interpreter should display the changes in the image in realtime during execution.
The Instruction Pointer moves in two dimensions and points at a pixel on the canvas.
Each pixel has an R, G and a B value (8 bits). The R is the instruction to be executed, G specifies the direction to read arguments from, and B is the argument count. The arguments are read from pixels next to the IP. Alternatively the instructions could have a fixed argument count, and the B value could be used for something else.
==Suggestion for G values==
> is the IP
 
 678 812 
 5>1 7^3
 432 654
This means odd values of G will read arguments diagonally
Or we could just use right angles:
 4
 3>1
 2
If G is 0, then only B will be used as argument
==Instructions==
 NOP
 Put (value, x, y)
 Get (x, y)
 Copy_Area (x1, y1, w, h, x2, y2)
Math
 Add (arg1, arg2 ... argN)
 Subtract 
 Multiply 
 Divide 
File IO
 Read (x, y, w, h) reads w*h*3 bytes from input and fills them into the specified area
 Write (x, y, w, h) writes the byte values of the specified area to output.
Category:Languages
Category:Unimplemented
Category:2005
Codesine

Made by user:MDude because Fourier has nothing to do with Fourier transforms. But it uses discrete cosign transforms instead to "keep things real".
The primary idea of codesine is to have functions represented as discrete codesine transforms, of a dimensionality equal to their quantity of inputs. A function definition thus follows one of two forms:
<function name>{
(<x frequency>[,<y frequency>]|<amplitude>)
[<x frequency>[,<y frequency>],<amplitude>]
}
<function name>{<frequency>*<amplitude>[+<frequency>*<amplitude>][,<frequency>*<amplitude>[+<frequency>*<amplitude>]]}
In interactive mode
Functions can be one or many dimensional, but always return the value of the point on the resulting waveform at the coordinates passed to it. The number of parameters is implicit when defining a function, and should equal the wave set with the largest number of frequency parameters.
All conditionals are based on numerical comparators: There is no built-in storage for booleans, though if statements can use & and |.
Category:Languages Category:Thematic
Codesine/implementation

:
So far I have this running along with html that's just an input box with the ID read and a button to call EVAL().
I'm wondering if I should bother trying to implement named variables, or just go with making people use numbers as variable references.
 function program()
 {
 	this.wavesets = [];
 	
 	this.add = function(name,f,a) {
 		//here I should be able to take a string and convert it to an array index
 		//or if not found, create a new index. Thus allowing named wavesets.	
 	}
 
 function waveset()
 {
 	this.waves = [];
 
 	this.add = function(f,a) {
 		f = Math.min(Math.abs(f));
 		while (f >= this.waves.length) {
 			this.waves.push(0);
 		}
 		this.waves[f] = a;
 	};
 
 	this.weval = function(input) {
 		//No idea if this is how cosine wave transform works.
 		var total = this.waves[0];
 		for (var loop = 1; loop < this.waves.length ; loop++) {
 			total += (1/loop)/Math.cos(input)*this.waves[loop];
 		}
 		return total;
 	};
 
 	this.waverage = function(total) {
 		return total/this.waves.length;
 	};
 }
 
 
 function LineEval(commands) {
 	
 	switch(commands[0]) {
 		case "addwave":
 			if (commands.length == 3) { Waveset.add(commands[1],commands[2]); } else {
 					window.alert("Wrong number of arguments for " + commands[0]);
 				}
 			break;
 		case "print":
 			if (commands.length == 2) { window.alert(Waveset.weval(commands[1])); } else {
 					window.alert("Wrong number of arguments for " + commands[0]);
 				}
 			break;
 		case "alert":
 			for (var loop = 1; loop < commands.length ; loop++) {
 				window.alert(commands[loop]);
 			}
 			break;
 		case "nop":
 			break;
 		default:
 			window.alert('Command "'+commands[0]+'" not understood, skipped.');
 	}
 }
 
 function EVAL() {
 	//read
 	var command = document.getElementById("read").value;
 	LineEval(command.split(" "));
 }
 
 var Waveset = new waveset();
Category:Implementations
Coercionfulity

Coercionfulity, meaning "something with (much) coercion", is an esolang created by CreeperBomb in 2023. For short, it can also be referred to as "Coer". In it, numbers must be coerced into variables to do almost anything meaningful. Anything number that goes between a quote and an apostrophe (in that order) is replaced with the variable associated with that number. Other than that, Coer is very simple: every line has an ID, a pipe, what gets set, an equals sign, and then what to set it to. "input" & "output" are keywords representing input (decimal, per line) & output (5-adic). The operations are + for addition, - for subtraction, * or x for multiplication, / or ÷ for division, % or m for moding, ^ or ** for exponentiation, [ ] for flooring, and the previously mentioned coercion. All but the outermost operation used, flooring, & coercion require parenthesis. Note that the "what gets set" doesn't require coercion to specify its a variable, as you won't be setting 1 to 2 while you may set var. 1 to 2. When executing code, the first line of code that's run is line 0 (skipping it if there is no line 0), and from then goes to the line with the smallest ID with a real part greater than the current line's ID (not considering possible change to the ID created by running the line). If there is no such line, the program halts. If there's a tie, one will get picked randomly. Coer uses complex numbers. Variables that haven't been set yet are equal to their name.
==Examples==
Truth machine: 
0 | output = -0.25 x input
Category:Languages
Coeus

Coeus is an esolang inspired (loosely) by 3-cell brainf*ck. It uses 4 registers (A-D). A is initially 1 and all others are 0.
=== Commands ===
X and Y represent any register.
Command 	Meaning
aX 	Print value stored in X.
bX 	Multiply A and X, store result in A.
cX 	Set X to 1/X.
dX 	Increment X.
eX 	Decrement X.
fX 	Swap A and X.
gX 	Set X to n, where A = kXn and X doesn't divide k.
hX 	Set X to input.
[XY][m][n]	Program m is ran independently of the main program. After m halts, set V = register Y. While register X from the main program doesn't equal V, run n.
=== Example Programs ===
Truth Machine:
 hA[AB][][aA]aA
Factorial:
 hB[BB][][bBeB]aA
Infinite counter starting from 0:
 [BB][eB][aBdB]
CAT program which terminates upon a user input of 0:
 [AB][][hAaA]
== Interpreters ==
GitHub contains a Coeus interpreter implementation in Common Lisp.
Category:Languages Category:Implemented Category:2020
Coffee is the answer

coffee is the answer is an esolang created for this with 3 commands.
== commands ==
 create() - creates a string
 x.attach(y) - adds y prefixed with a space to x, unless it is the first then there is no prefixed space
 console() - outputs a string
== example ==
create(string)
string.attach("what")
string.attach("is")
string.attach("the")
string.attach("best")
string.attach("liquid")
console(string)
Cogc

Cogc (close/open/gotvat/comvar) is a asembeld langege where you need to open every stack and goto every var.
Evrything which suronded by : are eval as python code. 
Example:add :1+ord(' '): >> add 33
=Cogc types=
* var : vat is a 8 bit int
* stack : stack is both a namespace and an 8 bit stack
=Cogc commands=
* create {var} : create {var}
* delete {var} : delete {var} (note that at end of program all vars will be deleted)
* gotvar {var} : goto {var}
* comvar {var} : come from {var}
* add {int} : increments the curent var by {int}
* sub {int} : decrements the curent var by {int}
* input : read one character into current var
* print : print current var as ascii
* while : while current var is not 0
* end : end of while statment
* open {stack} : goto {stack} and set namespace to {stack}
* close {stacl} : come from {stack} and set namespace to global
* push : push 'var' to current open stack and create new 'var' (NOTE: namespace should be cleard)
* pop : pop current open stack create old 'var' (NOTE: namespace should be cleard)
When a stack is open the special variable 'var' is reserved to be the top of stack.
'#' is comment.
Stacks are created automatecly, no need to create them manualy.
Example truth machene code:
 create inp
 create _cp
 create _check
 gotvar _check
 add 1
 comvar _check
 gotvar inp
 input
 print
 sub :ord('0'):
 while
 comvar inp
 gotvar _check
 sub 1
 comvar _check
 gotvar inp
 while
 comvar inp
 gotvar _cp
 add 1
 comvar _cp
 gotvar inp
 end
 end
 comvar inp
 gotvar _check
 while
 comvar _check
 gotvar _cp
 print
 comvar _cp
 gotvar _check
 end
Example stack:
 create a # creates global a
 gotvar a
 add :ord('a'):
 print # prints a
 comvar a
 open stack
 create a # creates local a
 govar a
 add :ord('b'):
 print # prints b
 comvar a
 gotvar var
 add :ord('c'):
 comvar var
 delete a # only 'var' can remain
 push
 gotvar var
 add :ord('d'):
 print # prints d
 comvar var
 pop
 gotvar var
 print # prints c
 comvar var
 close stack
 open other
 gotvar var
 add :ord('e'):
 print # prints e
 comvar var
 close other
 open stack
 gotvar var
 print # prints c
 comvar var
 close stack
Category:Languages Category:Implemented Category:Stack-based