nyuuzyou/wikis huggingface dataset:
Fuckhard

Fuckhard is yet another brainfuck derivative, made by User:Umnikos. It aims to just be brainfuck but harder to use. 
==Language overview==
Command	Description
> 	Move the tape head to the right by one
< 	Move the tape head to its initial position
+ 	Set the current cell's value to 1
. 	Output the current cell's bit
, 	Input a bit. If it's 1, set the current cell's value to 1.
( 	Jump forward to the matching ) if the cell at the pointer is 1, halting if there's no matching ).
] 	Jump back to the matching [ if the cell at the pointer is 1, halting if there's no matching [.
Each cell can only hold a single bit, and once set to a 1 can never be reset back to 0. Therefore working with data requires its constant copying to new blank cells over and over. Furthermore, the < instruction goes all the way to the beginning of the array, so moving left involves going to the start and then going right again to where you want to be. The square brackets and the parentheses only need to match up among themselves and not with each other, allowing for very non-standard control flow if the programmer chooses to make use of that.
==Examples==
===Truth machine===
 ,[.]
===Cat program===
 [>,.+]
===Cat 1s and halt on 0===
 +([.)>,]
===Add two numbers===
Numbers are represented as N 1s terminated by a 0
 +([.)>,]+([.)>,].
===Multiply two numbers===
 +[>,]>+([<([.)>]>[>]+)>,].
==Computational class==
Fuckhard is Truing Complete because it can emulate a Bitwise Cyclic Tag system, which is Turing Complete. This is a Bitwise Cyclic Tag implementation by User:Olus2000:
 Memory layout:
 - program queue data flag
 - program queue consumed flag
 - program queue data
 - data queue data flag
 - data queue consumed flag
 - data queue data
 
 Input encoding:
 - program encoded as pairs of bits 10 for 0 and 11 for 1
 - a single 0 bit
 - data encoded as pairs of bits 10 for 0 and 11 for 1
 - a single 0 bit
 
 Read program and data; expects at least 1 bit of program and data:
 +>+>>>>>,[>>,>>>>,] <>>>+>+>>>>> ,[>>,>>>>,] <
 Banch on the frst bit of program and consume it:
 [[[[[<>[>>>>>>]+>
 ( If false delet first bit of data
 <[>>>>>>]+
 <>>>>[>>>>>>]+>.
 If not all data has been consumed then repeat
 >>>>]<>
 Otherwise spill over to the true branch
 ) >>>>> ( This will be false if coming into a true branch
 If true then it's complicated
 <[>>>>>>]+>>+
 Branch on the first bit of data
 <>>>>[>>>>>>]>
 ( If false just consume one bit of program and repeat
 <>[>>>>>>]+>
 ( Copy bit 0 at the end of program
 <[>>>>>>]+<]
 ) Copy bit 1 at the end of program
 <[>>>>>>]+>>+<]
 ) If true branch on first bit of program
 <>[>>>>>>]+>
 ( Copy bit 0 at the end of program *and* data
 <[>>>>>>]+ <>>>[>>>>>>]+<]
 ) Copy bit 1 at the end of program *and* data
 <[>>>>>>]+>>+ <>>>[>>>>>>]+>>+<]
 )
Category:Languages Category:Brainfuck derivatives Category:Cell-based Category:Low-level Category:Turing complete Category:Implemented
Fucklang

Fucklang is an assembly-like but human-readable lanugage that is compiled to brainfuck.
It's main purpose is to make programming in brainfuck faster, better and more efficient.
== Syntax ==
=== Variables ===
Fucklang uses normal named variables, that are declared using var command:
 var a 2;
If you want to change value of already exisitng variable, you can use command val:
 val a 2;
 val a 3;
 val a "Hi!";
As you can see, Fucklang is dynamically typed, although all value types it supports is int and string. Arrays are not supported in Fucklang.
=== If, for, while and loop===
If statement is based partly on assembler and partly on c:
 ifeq a 2;
 //code;
 else;
 //another code;
 ifend;
Possible variations of if statement are: ifeq (if equal), ifneq (if not equal), ifgr (if greater than), ifls (if less than), ifgrq (if greater or equal), iflsq (if less or equal), ifst (if same value type).
For statement is limited to incrementation by one starting on zero:
 for a 6;
 //code;
 forend;
As explanation, this is similar code written in c:
 for (int i = 0; i < 6; i++) {
 //code
 }
While loop is simply based on if statement, so that you won't have to remember bunch of different commands:
 while ifgr a 3;
 //code;
 whileend;
And finally, loop command is used in infinite loops:
 loop;
 //this code will be
 executed forever;
 loopend;
=== Math operations ===
Math operations are performed using commands add, sub, mult, div as follows:
 var a 3; //a = 3;
 add a 6; //a = 3+6 = 9;
 sub a 1; //a = 9-1 = 8;
 div a 2; //a = 8/2 = 4;
=== Input/Output ===
Input and output operations are performed by commands in and out:
 //Multiplication program
 in a;
 in b;
 mult a b;
 out a;
The in operation always saves input as an integer, so if you want to save it as string use instr [variable name] [length of the string]
=== Comments ===
Comments starts normaly with //, but they must be ended with semicolon like a command.
== Examples ==
===Hello World===
 out "Hello, World!";
===Cat===
 loop;
 in a;
 out a;
 loopend;
===Calculator===
 out "Enter two numbers: ";
 in a;
 in b;
 var sum a;
 add sum b;
 out "Sum is: ";
 out sum;
 var dif a;
 sub dif b;
 out "Difference is: ";
 out dif;
 var prod a;
 mult prod b;
 out "Product is: ";
 out prod;
 var port a;
 div port b;
 out "Portion is: ";
 out port;
== Compiler ==
Not yet done.
Fuckscript

Fuckscript is a joke esoteric programming language created by Josh Schiavone. Fuckscript is based heavily off of Brainfuck although it is argued that it's more intuitive, with more descriptive keywords, and it shares the same tape size of 30 000 bytes. Programmers have a lot of memory to work with, so they can design all sorts of applications. Fuckscript is also said to be Turing complete so it's perfect for developing a self-driving car. The challenging part of programming in Fuckscript is that programmers are not allowed to write comments, the interpreter forbids comments as it makes programming easier. 
=== Development ===
Fuckscript was developed in modern C++. The source code can be found on its official GitHub Repository. 
 Fuckscript Instruction Set
Fuckscript Instruction	Description
FUCK 	increments the current value of the memory pointer (cell)
FUCKK 	decrements the current value of the memory pointer (cell)
FFUCK 	moves the memory pointer to the next cell
FUCKKK 	moves the memory pointer backwards to the previous cell
FUCKER 	user input, reads a character to stdin
FUCKITY 	outputs current value in the cell to stdout
WHATTHEFUCK 	enters a while loop
IAMFUCKED 	marks the end of the loop
THISISFUCKED 	sets the memory pointer to 0
==Hello, world! Program in Fuckscript==
FFUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK WHATTHEFUCK FUCKKK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FFUCK FUCKK IAMFUCKED FUCKKK FUCKITY
FFUCK FUCK FUCK FUCK FUCK WHATTHEFUCK FUCKKK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FFUCK FUCKK IAMFUCKED FUCKKK FUCK FUCKITY
FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCKITY FUCKITY
FUCK FUCK FUCK FUCKITY
FFUCK FFUCK FUCK FUCK FUCK FUCK FUCK FUCK WHATTHEFUCK FUCKKK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FFUCK FUCKK IAMFUCKED FUCKKK FUCK FUCK FUCKITY
FUCKK FUCKK FUCKK FUCKK FUCKK FUCKK FUCKK FUCKK FUCKK FUCKK FUCKK FUCKK FUCKITY
FFUCK FUCK FUCK FUCK FUCK FUCK FUCK WHATTHEFUCK FUCKKK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FFUCK FUCKK IAMFUCKED FUCKKK FUCK FUCKITY
FUCKKK FUCKITY
FUCK FUCK FUCK FUCKITY
FUCKK FUCKK FUCKK FUCKK FUCKK FUCKK FUCKITY
FUCKK FUCKK FUCKK FUCKK FUCKK FUCKK FUCKK FUCKK FUCKITY
FFUCK FFUCK FFUCK FUCK FUCK FUCK FUCK WHATTHEFUCK FUCKKK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FFUCK FUCKK IAMFUCKED FUCKKK FUCK FUCKITY
==Add Two Numbers in Fuckscript==
 FUCKER
 FFUCK
 FUCKER
 FUCKKK
 FFUCK
 WHATTHEFUCK
 FUCKK
 FUCKKK
 FUCK
 FFUCK
 IAMFUCKED
 FUCKKK
 FUCKITY
==Implementation==
In the style of a trivial brainfuck substitution.
 #!/usr/bin/ruby
 eval 'm=Hash.new(p=0);'+ARGF.read.gsub(/[!-~]+|./,
 'THISISFUCKED' => 'p=0;',
 'FUCKKK' => 'p-=1;',
 'FFUCK' => 'p+=1;',
 'FUCKK' => 'm[p]-=1;',
 'FUCK' => 'm[p]+=1;',
 'WHATTHEFUCK' => '(',
 'IAMFUCKED' => ')while((m[p]&=255)!=0);',
 'FUCKITY' => 'putc m[p];',
 'FUCKER' => 'm[p]=STDIN.getbyte if !STDIN.eof;')
Category:Languages Category:Implemented Category:Turing complete Category:Low-level Category:Turing tarpits Category:Cell-based Category:Brainfuck derivatives Category:Joke languages Category:Pseudonatural
Fuckshitfuck

Its goal is to create an iterating quine and a quine.
==Commands==
F prints fuck.
f prints Fuck.
s prints shit.
==Example programs==
===Iterating quine===
 fuck
and:
 Fuck
===Quine===
 shit
==Implementations==
===Python===
 k={'f':'Fuck','F':'fuck','s':'shit'}
 for i in input():
 if i in k:
 print(k[i])
Category:Languages
Category:Joke languages
Category:2024
Category:Output only
Category:Total
Category:Implemented
Fucktion

Fucktion is an esolang created by islptng.
== Intro ==
We have only parenthesis. Other characters are considered as comments.
Each program are computed by calling function f(). Arguments are passed without punctuation or spaces.
Example:
 (()(())(()()))
Calls:
 f(f(),f(f()),f(f(),f()))
Depending on the number of arguments, f() performs differently.
We have a dictionary to store variables. Like some of my other esolangs, numbers are fractions.
Writting to variable infinity causes a character to be printed to stdout, and reading from it returnes a character from stdin.
== f() ==
No. of args	Meaning
0 	Evaluates to 1.
1 	Evaluates to variable[arg1].
2 	Sets variable[arg1] to arg2. Evaluates to arg2.
3 	Evaluates to arg1/arg2-arg3.
4+ 	
j = lambda a,b,c: (a<=b + b<=c + a<=c) % 2
cnt = 0
while not j(arg1,arg2,arg3):
 for i in args[3:]: evaluate(i)
 cnt += 1
return cnt
== Turing Completeness ==
Brainfuck conversion:
 (start) = ((()()())())
 > = ((()()())(((()()()))()((()()())()())))
 < = ((()()())(((()()()))()())
 + = (((()()()))((((()()())))()((()()())()())))
 - = (((()()()))((((()()())))()()))
 , = (((()()()))(()(()()())()))
 . = ((()(()()())())((()()())))
 [ = ((()()())(((()()())))(()()())
 ] = )
Fugue

Fugue is an esoteric programming language created by Nikita Ayzikovsky in 2005. It shares semantics with its sister language, Prelude, but uses music as source code. Each "voice" in Prelude is indeed a separate voice in Fugue. Simultaneous instructions in Prelude correspond to notes in different voices sounding simultaneously; other than that, note durations don't matter.
The first note played by each voice doesn't matter. The intervals between a note and the next one (in the same voice) correspond to Prelude instructions, in the following fashion:
* # - Unison
* ^ - ascending second
* v - descending second
* + - ascending fourth or tritone
* - - descending fourth or tritone
* ( - ascending fifth
* ) - descending fifth
* ! - ascending sixth
* ? - descending sixth
Third, ascending or descending, is a "push number" instruction: the next interval is interpreted as a number to be pushed. 5 semitones up pushes 5, and 10 semitones down pushes -10. This allows for a greater range of numbers to be pushed than in Prelude, which only allows 0..9.
Intervals greater than a sixth are ignored and may be used freely.
==Compiler==
There is a compiler for Fugue that generates 80x86 code from a MIDI file. It can also "disassemble" the MIDI file to human-readable format. The compiler's source can be found on The Esoteric File Archive.
Note that due to a bug in the compiler, a voice with more instructions than the following voice (counting pushing a number as a single instruction) can have its excess instructions cut off in certain circumstances. Therefore, the voices should always increase in instruction count, either by rearranging them or by appending no-ops as necessary.
==Examples==
For another example, see the hello world program.
==See also==
* Prelude
Category:Pattern-based
Category:Turing complete
Category:Stack-based
Category:Implemented
Category:Languages
Category:Non-textual
Category: 2005
FukYorBrane

FukYorBrane is a cross between Brainfuck and Core War (see Redcode). Two FYB programs
run simultaneously. The data buffer for each of them is the opponent's program buffer. The
objective is to cause the opponent's program to quit with a "bomb."
==Scoreboard==
Here's the current FYB scoreboard:
 | 1 2 3 4 5 6 7 8 9 | pts | program
 1 | + - - + - + - - - | -3 | disableLoopsAndBomb-1.fyb
 2 | + + - + - + - - - | -1 | findAndDestroy-1.fyb
 3 | + + + + + + + + + | 9 | logicex-2.fyb
 4 | - - - + - - - - - | -7 | mangler-1.fyb
 5 | + + - + + + - - - | 1 | nodefect.fyb
 6 | - - - + - 0 - - - | -6 | nothing-1.fyb
 7 | + + - + + + + - + | 5 | runbomber.fyb
 8 | + + - + + + + + + | 7 | rungluebomber.fyb
 9 | + + - + + + - - + | 3 | simplething.fyb
(+: win -:loss 0: draw)
==External resources==
* FukYorBrane spec
* Some examples, including the programs above
* FukYorBrane in the Esoteric File Archive
* The current freenode #esoteric FYB hill
Category:Brainfuck derivatives
Category:Programming games
Category:Languages
Fumber

Brainflakes but with more, and numbers. Yay! (not to be confused with the normal brainflakes w/ numbers Esolang: Numberflakes)
Pronounced like Tums and Bur 
=Commands=
 
Fumber	Brainf
1 	>
2 	<
3 	+
4 	-
5 	.
6 	,
7 	[
8 	]
9 	N/A
0 	no op
9 adds the next letter's ascii value to the selected cell
=Examples=
Hello World:
 9H.9e.9l.9l.9o.9",".9" ".9W.9o.9r.9l.9d.9!.0
Category:Languages Category:Brainfuck derivatives Category:Turing complete Category:Unimplemented Category:Cell-based Category:Low-level
Fun 2 code

Fun 2 code is a modification of Python where its like Fun 2 rhyme, a trendy song by Howard Moody.
== How it works ==
First, you think up a swear word the first letter of the python command. Then, you write down 3 words that rhyme with it, seperated by new lines, and then the command.
== Hello World ==
 sis
 diss
 this
 print("hello world")
== Truth machine ==
 truck
 duck
 pluck
 f = int(input())
 this
 list
 quiz
 print(f)
 tank
 bank
 rank
 while f==1:
 trick
 flick
 kick
 print(f)
Category:Languages Category:Joke languages Category:Pseudonatural Category:High-level Category:Turing complete Category:Implemented
== Python interpreter ==
Assuming the program is stored in program.txt,
program = open("program.txt", "r")
program = program.read()
things = program.split('''
)
code=""
i = int(len(things)/4)
count = 0
while i!=0:
 j=4
 while j!=0:
 count+=1
 j-=1
 if (count+1)%4==0:
 code+='''
+things[count]
 i-=1
exec(code)
Replace the exec at the end with print and you have a transpiler.
Note that this does not enforce rhyme schemes, so you could make a program like this:
 1
 2
 3
 4
 print(yaya)
 1
 2
 3
 4
 y = 3
And the interpreter would not get mad at you. These are not accepted as official programs.
Func()

Func[] is a esolang inspired by lambda calculus. Idk. Oh also User:Yayimhere made it
== syntax ==
Func[] has a single thing it can do:
 F[x y]
This creates a function f that takes input as x and will output y. So if we pass f the letter r:
 F.r /yes this is passing a input
It would result in y. Yea. Func[] allows for recursive functions. It also can do this:
 F[x >]
This copies the latest letter put in code to that position. So this returns the input. This can be used to do whats called combining:
 F[x >< y >]
This will combine x and y and move the result to the output. Combining will take the left char thats being combined and duplicate it and then add y to the start of that string, so the result here is xxy. To make a function output the result:
 F[x x]$
Yea you just add the money sign to the end. There is one conditional:
 F[x ? y >]
This combines x and y and checks if results from the combination is 3 instances of x or the left input. If it is it will make the output be the function passed to itself(so it become recursive). Else it just returns x. The functions cant have more than one input. To combine 3 function(with the same input) into a single function. The name of the function if not needed. The result will be all the results added together:
 [x y]⎫
 [x x]⎬F
 [x y]⎭
This puts all the function into F. To get the letter from the function above ^ is used. There is no downward version of this cuz. Well idk. Oh also i will be replaced by user input and * will swap whats on the left and right of it and dissappear. Everything is evaluated left to right
=== is this usefull ===
I dont think so but who knows. But i dont know what to make of it
=== examples ===
truth-machine:
 Truthmachine[x ? 1 >]$
 F.i
This outputs:
 F[F[F[…]$ ? 1 >]$ /If the input is 1. Else it will output 0
Triangle:
 [x F >]⎫
 [x >< F >]⎬F
 [x >*F*. >]⎭
 F.r
This will create a triangle with 3 layers. Each one will be infinite but the first row will be ∞ The second row will be ∞+1 And the last ∞^2+1 I think
polyglot(with this and bf):
 ,[. >< ,]
In func[] this basically works as a unary multiply by 2 and increment by 1 if we treat both the . And the , As one number. And in brainfuck this sets the cell to user input does some non usefull commands(><) and is a Cat
Category:Functional paradigm
category:Nested
Category:Languages
Func++

Func++ is an extension of Func, created by User:None1, it is backwards compatible with Func.
In Func++, you are allowed to:
* Use decimal input and output.
* Make quines.
* Output strings easier.
==Extensions==
The follwing built-in functions are available in Func++, but not in Func.
 Extensions in Func++
Function 	Meaning
intinput() 	Reads an integer from user input and returns it.
intoutput(x) 	Outputs the decimal integer x.
quine() 	Outputs quine().
<anycharacter>()	Outputs <anycharacter> and returns its ASCII value.
==Example Programs==
===Hello World===
 do(do(do(do(do(do(do(do(do(do(do(H(),e()),l()),l()),o()), ()),W()),o()),r()),l()),d()),!())
===Quine===
 quine()
===A+B Problem===
 intoutput(add(intinput(),intinput())
==See also==
* Func
Category:Languages
Category:Unusable for programming
Category:Total
Category:Unimplemented
Category:Nested
Category:2023
Funcinton

Not to be confused with Funciton.
Funcinton is an esolang designed User:Monochromeninja to be able to use integers as functions and vice versa.
There is one stack that starts empty. Indexing out of bounds gives a 0.
==Integer-function interchanging==
The integer 0 is treated as an empty string. Any other integer n is treated as the function of the integer n//256 (where // means integer division) concatenated with the ASCII character with the codepoint of n%256 (where % means modulus). Concisely:
 func(0) = ""
 func(n) = func(n//256) + chr(n%256)
where chr(n) is the ASCII character with the codepoint of n.
==Commands==
* Any digit pushes itself to the stack.
* {N} pushes N (a multi-digit number) to the stack.
* ? pops N and pushes a random integer R such that 0 <= R <= N.
* Any of +-*/% pops Y, pops X, then pushes X OP Y. (/ is integer division; % is modulus.)
* > pops Y, pops X, then pushes 1 if X > Y else 0.
* @ pops N, then pushes a duplicate of the N'th element of the stack. (0@ duplicates the top element of the stack.)
* ! pops N, then pops the N'th element of the stack. (0! pops the top element of the stack.)
* _ pushes the codepoint of one character of input. (EOF is repeated -1.)
* . pops a codepoint and outputs it as a character.
* ^ pops a function F and runs it by inserting its code immediately after this instruction.
* # pops F, T, and C in that order, then runs T if C is nonzero, otherwise runs F.
==Examples==
===Cat program===
 {8292086038218679469791840846639459376902179}0@^
===Output stack===
 {1207624538945969667811301018820615670734492809758244679715}0@^
This can be trivially modified to output "Hello, world!" or any fixed string. (This does not reverse the stack.)
==External resources==
* Reference interpreter
* Function to integer and vice versa
Category:Languages
Category:Stack-based
Funciton/Digital root calculator

← Back to Funciton
This is a Funciton program that outputs the digital root of an input number. The input is expected to be an integer (not followed by a newline or any other whitespace).
I wrote this before I realised there is the efficient formula 1+(n-1)%9. The program could be a lot smaller if that formula were used. Nevertheless, this demonstrates recursion in Funciton as well as some library functions such as ÷% (division and modulo).
 ╓───╖
 ║ ‰ ║
 ╙─┬─╜
 ┌──────────┴────────┐
 ┌────────┴────────┐ ┌─────┴────┐
 │ │ ┌─┴─╖ │ ╔════════════════════════════════╗
 │ │ │ − ║ │ ║ digital root ║
 │ │ ╘═╤═╝ │ ╟────────────────────────────────╢
 │ ╔════╗ ┌───╖ │ ┌─┴─╖ │ ║ If ↓ < 0, negate ║
 │ ║ 10 ╟──┤ < ╟──┘ │ ‰ ║ │ ║ If ↓ < 10, answer is ↓ ║
 │ ╚════╝ ╘═╤═╝ ╘═╤═╝ ┌───┴───┐ ║ Else call ‰p and then repeat ║
 │ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ │ ╚════════════════════════════════╝
 └──────────┤ ? ╟─────┤ ? ╟──┤ > ║ │
 ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ │
 ┌─┴─╖ │ ╔═╧═╗ │
 │ ‰ ║ ║ 0 ║ │ ╔═══╗
 ╘═╤═╝ ╚═══╝ │ ║ ║
 ╔═══╗ ┌─┴──╖ │ ╚═╤═╝
 ║ 0 ╟──┤ ‰p ╟─────────────────────┘ ┌─┴─╖
 ╚═══╝ ╘════╝ │ 《 ║
 ╘═╤═╝
 ┌───────────────────────────┐ ┌─┴─╖
 │ ╓┬───╖ │ │ ‰ ║
 ├─────╫┘‰p ╟──┐ │ ╘═╤═╝
 │ ╙────╜ │ │ ┌─┴─╖
 │ ╔════╗ │ │ │ 》 ║
 │ ║ 10 ║ │ │ ╘═╤═╝
 │ ╚═╤══╝ │ │ │
 │ ┌─┴──╖ │ │
 │ ┌──┤ ÷% ╟──┴────────┐ │
 │ │ ╘═╤══╝ │ │ ╔═════════════════════════════╗
 │ │ └───────┐ │ │ ║ digital root (helper) ║
 │ │ ┌────╖ ┌─┴─╖ │ │ ╟─────────────────────────────╢
 │ └──┤ ‰p ╟──┤ + ║ │ │ ║ → is an accumulator ║
 │ ╘═╤══╝ ╘═╤═╝ ┌─┴─╖ │ ║ If → = 0, result is ← ║
 │ │ └────┤ · ╟──┘ ║ Else, add last digit of → ║
 │ ┌─┴─╖ ╘═╤═╝ ║ to ← and recurse ║
 └─────┤ ? ╟────────────┘ ╚═════════════════════════════╝
 ╘═╤═╝
 │
Category:Examples
Function x(y)

function x(y) is a language created by User:PythonshellDebugwindow.
==Datatypes==
function x(y) uses strings (example: "Hello World") and integers (example: 123 or -456).
==Syntax==
To start a function:
 function x()
Or:
 function x(y)
Or it can have as many arguments as you like:
 function x(a, b, c, d, e, f, g)
Default values:
 function f(requiredParameter, optionalParameter | defaultValue)
To print with a newline:
 [a]
To print without a newline:
 `a
To get user input:
 [~]
To get a live user input character:
 `~
To do math (must use spaces before and after the operator used) (+, -, *, or / (integer division), here + is shown), and there are only infix operators:
 a + b
Math in function x(y) uses BDMAS (shortened version of BEDMAS) by default, but you can also uses parentheses for grouping, so the following:
 a + b * c
would evaluate to a + (b * c), but for (a + b) * c:
 (a + b) * c
To do comparison (must use spaces before and after the operator used) (<, >, <=, =>, ==, or !=, here == is shown):
 a == b
Ternary (no spaces before/after the < or >):
 condition<valueIfTrue, valueIfFalse>
To call a function:
 x()
Or:
 x(y)
Or with as many arguments as the function takes:
 x(a, b, c, d, e, f, g)
To call a function recursively:
 {y}
To return (default return value is 0):
 -> a
To create a variable inside a function:
 var v: a
To access that variable:
 v
To set that variable:
 v; a
To use compound assignment (+=, -=, *=, and /= in C, but in function x(y) +&, -&, *&, and /& respectively, here +& is shown):
 v +& a
Comment until End of Line:
 #Comment
 someCode # Comment
==Execution==
Execution starts at the first function in the program, which is passed no arguments.
==Examples==
===Hello, World!===
 function helloWorld()
 ["Hello, World!"]
===Cat===
 function cat()
 [[~]]
===Absolute value function===
 function abs(n)
 -> (n < 0)<0 - n, n>
===Factorial function===
 function factorial(n)
 -> (n < 2)<1, n * {n - 1}>
===FizzBuzz===
 function fizzbuzz(n | 0)
 (n != 100)<((fizz(n) + buzz(n)) == "")<[n], printAndRecurse(n)>
 
 function fizz(n)
 -> ((n // 3) * 3 == n)<"Fizz", "">
 
 function buzz(n)
 -> ((n // 5) * 5 == n)<"Buzz", "">
 
 function printAndRecurse(n)
 [fizz(n) + buzz(n)]
 fizzbuzz(n + 1)
===Fibonacci sequence===
 function fib(acc | 0, num | 1)
 [num]
 -> fib(num, num + acc)
Category:2020 Category:Languages Category:Unimplemented Category:Turing complete