nyuuzyou/wikis huggingface dataset:
Functional

Functional is an esoteric programming language that only use function calls like this:
 print("Hello world!")
Even control structures, loops and variable declarations are function calls:
 print("What's your name?\n")
 set(name, input())
 printf("Hello, %s\n", name)
Even comments are function calls:
 rem("This is a comment.")
or
 nop("nop function does nothing")
==Data types==
There are three data types:
* Barewords: Unquoted string or numbers, like identifiers in other programming languages, for example: set(bareword, "string value") Most functions will treat barewords as an identifier. Numbers such as 12 are also barewords.
* Strings: They can be quoted with "" or ''. For example: "Hello, world!", 'Naruto\'s file'
* Code blocks: They are enclosed with { and }. For example: if (equals(a,b), {print("a equals to b") } )
==Standard functions==
* set(var, value) Set variable to value
* if(condition, code) Execute the code if condition is true or not zero/null.
* if_else(condition, code, else) Expands to if(condition){code}else{else}
* loop(code) An infinite loop.
* while(condition, code) A while loop.
* for(init, condition, incr, code)
* function(name, ..., code) Create a new function. The ... lists all arguments.
==Cat program==
 loop(
 {
 set(user_input, input())
 print(concat(user_input, "\n"))
 }
 )
=Functional as a Java scripting language=
If the Functional virtual machine is written in Java, it can let the Functional programs call Java methods and create Java objects, like what the Rhino JavaScript engine did.
 try_catch(
 {
 set(fs, new(java.io.FileWriter, "out.txt"))
 set(w, new(java.io.BufferedWriter, fs))
 w.write("Hello, world!")
 w.close()
 }, java.lang.Exception, e {
 System.err.println("Error: ")
 System.err.println(e.toString())
 })
==See also==
*Fünke
Category:Languages
Category:Unimplemented
Category:2008
Category:Functional paradigm
Functional deadfish

Functional deadfish is an expansion of Deadfish which adds "functions".
Its syntax is the same except for the f and c command. All commands between two f commands become part of the function. Functions do not have arguments. The function's name is the number that the iterator is at. The function can be called by using the c command when the iterator is at the functions name.
Example:
 fiofifdofdcccicc
prints 12321.
== Computational class ==
Functional deadfish has some similarities to Splinter, but a different data storage model. It effectively allows defining arbitrarily many functions (because Deadfish's counter can take on arbitrarily many values), but not redefining them; the only unbounded state in the language is the iterator (which does not allow arbitrary reads) and the function call stack (where each stack element has finitely many distinguishable values due to the inability to create a loop when the iterator is much higher than the highest defined function name). Functional deadfish is thus most likely to be a push-down automaton, but this has not been proven.
Category:Languages Category:2017 Category:Output only Category:Unknown computational class
Functional deadfish~

== Functional deadfish~ ==
Functional deadfish~ is a combination of Functional deadfish and Deadfish~. It has a single accumulator, which ranges from 0-255 unless squared, and a function stack. 
=== Commands ===
 Caption text
Command	Result
i 	Increment accumulator
d 	Decrement accumulator
s 	Square accumulator
o 	Output accumulator as number
c 	Output accumulator as character
w 	Output "Hello, world!"
h 	Halt program
{} 	Run code inside braces 10 times
() 	Skip code inside parentheses if accumulator is 0
f 	Delimit function declaration
C 	Call function
Functional deadfish~ also has a function stack. Any code between two matching fs is pushed to the function stack at the accumulator value before the fs. 
C calls the function at the accumulator's position in the function stack. 
=== Implementation ===
An implementation is available here
=== Example programs ===
Any valid deadfish~ or functional deadfish program is a valid functional deadfish~ program, however, the two's features can be combined to become very powerful and concise. 
Say you wanted to print 'abcabcabcabcabc':
In Deadfish~, you'd have the ugly {i}sdddcicicddcicicddcicicddcicicddcicicdd, where you have to type the print code five times.
In Functional deadfish, you'd have iiisisdddfcicicddfCCCCC - Simpler, but the code for getting to 97 is more complicated. 
In Functional deadfish~, you can use the good points of both to end up with {i}sdddfcicicddfCCCCC.
Category:Languages Category:Implemented Category:Output only
FunctionsFTW/99 bottles of beer

setNum("bottles", 99); "Set X (bottles) to 99";
 setStr("form", " bottles"); "Plural";
 
 label("l");
 if(gt(getNum("bottles"), 0), () { "If X > 0";
 print(numToStr(getNum("bottles"))); "X bottle(s) of beer on the wall,";
 print(getStr("form"));
 print(" of beer on the wall,\n");
 
 print(numToStr(getNum("bottles"))); "X bottle(s) of beer.";
 print(getStr("form")); "Take one down, pass it around,";
 print(" of beer.\nTake one down, pass it around,\n");
 
 setNum("bottles", add(getNum("bottles"), neg(1))); "X--";
 if(eqNum(getNum("bottles"), 1), () { "If X = 1";
 setStr("form", " bottle"); "Singular";
 }, () { "Else";
 setStr("form", " bottles"); "Plural";
 });
 
 if(gt(getNum("bottles"), 0), () { "If X > 0";
 print(numToStr(getNum("bottles"))); "Use X";
 }, () { "Else";
 print("No"); "Use No";
 });
 print(getStr("form")); "X/No bottle(s) of beer on the wall.";
 print(" of beer on the wall.\n\n");
 goto("l"); "Repeat";
 }, () {});
Minimized (522 bytes)
setNum("b",99);setStr("f"," bottles");label("l");if(gt(getNum("b"),0),(){print(numToStr(getNum("b")));print(getStr("f"));print(" of beer on the wall,\n");print(numToStr(getNum("b")));print(getStr("f"));print(" of beer.\nTake one down, pass it around,\n");setNum("bottles",add(getNum("b"),neg(1)));if(eqNum(getNum("b"),1),(){setStr("f"," bottle");},(){setStr("f"," bottles");});if(gt(getNum("b"),0),(){print(numToStr(getNum("b")));},(){print("No");});print(getStr("f"));print(" of beer on the wall.\n\n");goto("l");},(){});
Category:Examples
FunctionsFTW/Factorial

setNum("input", strtoNum(input())); "Get number";
 setNum("result", 1); "The result";
 
 label("l");
 if(gt(getNum("input"), 1), () { "If input > 1";
 setNum("result", mult(getNum("result"), getNum("input"))); "result = result * input";
 setNum("input", add(getNum("input"), neg(1))); "input--";
 goto("l"); "Repeat";
 }, () {});
 
 print(numToStr(getNumber("result"))); "Print result";
Minimized (207 bytes)
setNum("i",strtoNum(input()));setNum("r",1);label("l");if(gt(getNum("i"),1),(){setNum("r",mult(getNum("r"),getNum("i")));setNum("i",add(getNum("i"),neg(1)));goto("l");},(){});print(numToStr(getNumber("r")));
Category:Examples
FunctionsFTW/Fibonacci

:
 setNum("stl", 1); "Set stl(second to last) to 1";
 setNum("last", 0); "Set last to 0";
 
 label("l");
 print(numToStr(add(getNum("stl"), getNum("last")))); "Print stl + last";
 setNum("last", add(getNum("stl"), getNum("last"))); "last = stl + last";
 setNum("stl", add(getNum("last"), neg(getNum("stl")))); "stl = (stl + last) - stl = last";
 goto("l"); "Repeat";
Minimized (182 bytes)
setNum("s",1);setNum("l",0);label("L");print(numToStr(add(getNum("s"),getNum("l"))));setNum("l",add(getNum("s"),getNum("l")));setNum("s",add(getNum("l"),neg(getNum("s"))));goto("L");
Category:Examples
FunctionsFTW/FizzBuzz

setNum("i", 1); "Initialize i";
 label("l");
 if(not(gt(getNum("i"), 100)), () { "If i isn't greater than 100";
 if(eqNum(rem(getNum("i"), 15), 0), () { "If i is divisable by 15";
 print("FizzBuzz"); "Print FizzBuzz";
 }, () {
 if(eqNum(rem(getNum("i"), 3), 0), () { "Else if i is divisable by 3";
 print("Fizz"); "Print Fizz";
 }, () {
 if(eqNum(rem(getNum("i"), 5), 0), () { "Else if i is divisable by 5";
 print("Buzz"); "Print Buzz";
 }, () { "If all checks above failed";
 print(numToStr(getNum("i"))); "Print i";
 }); }); });
 print("\n"); "Return";
 setNum("i", add(getNum("i"), 1)); "Increment i by 1";
 goto("l"); "Repeat";
 }, () {});
Minimized (319 bytes)
setNum("i",1);label("l");if(not(gt(getNum("i"),100)),(){if(eqNum(rem(getNum("i"),15),0),(){print("FizzBuzz");},(){if(eqNum(rem(getNum("i"),3),0),(){print("Fizz");},(){if(eqNum(rem(getNum("i"),5),0),(){print("Buzz");},(){print(numToStr(getNum("i")));});});});print("\n");setNum("i",add(getNum("i"),1));goto("l");},(){});
Category:Examples
FunctionsFTW/Functions

:
This list is alphanumerically sorted.
 add(num n1, num n2) => num
 and(bool b1, bool b2) => bool
 boolInObj(obj object, str key) => bool
 boolToNum(bool val) => num
 call(str funcName, obj params)
 callBool(str funcName, obj params) => bool
 callFunc(str funcName, obj params) => func
 callNum(str funcName, obj params) => num
 callObj(str funcName, obj params) => obj
 callStr(str funcName, obj params) => str
 concatObj(obj o1, obj o2) => obj
 concatStr(str s1, str s2) => str
 def(str funcName, func val)
 eqNum(num n1, num n2) => bool
 eqStr(str s1, str s2) => bool
 ex(str varName) => bool
 funcInObj(obj object, str key) => func
 getBool(str varName) => bool
 getNum(str varName) => num
 getObj(str varName) => obj
 getStr(str varName) => str
 goto(str labelName)
 gt(num n1, num n2) => bool
 if(bool condition, func ifT func ifF)
 input() => str
 keys(obj object) => obj
 label(str labelName)
 len(obj object) => num
 log(num antiLog, num base) => num
 mult(num n1, num n2) => num
 neg(num number) => num
 not(bool val) => bool
 numInObj(obj object, str key) => num
 numToBool(num val) => bool
 numToStr(num val) => str
 objInObj(obj object, str key) => obj
 or(bool b1, bool b2) => bool
 pow(num base, num exponent) => num
 print(str content)
 recip(num number) => num
 rem(num n1, num n2) => num
 returnBool(bool val)
 returnFunc(func val)
 returnNum(num val)
 returnObj(obj val)
 returnStr(str val)
 setBool(str varName, bool value)
 setNum(str varName, num value)
 setObj(str varName, obj value)
 setStr(str varName, str value)
 strInObj(obj object, str key) => str
 strToBool(str val) => bool
 strToNum(str val) => num
 strToObj(str val) => obj
 type(str varName) => str
Category:Examples
FunctionsFTW/Recursive Fibonacci

def("fib", (num "index") {
 if(eqNum(getNum("index"), 0), () {
 "F(0)";
 returnNum(0);
 }, () {
 if(eqNum(getNum("index"), 0), () {
 "F(1)";
 returnNum(1);
 }, () {
 "F(i-2) + F(i-1)";
 returnNum(add(callNum("fib", [ "index" add(getNum("index"), neg(2)) ]), callNum("fib", [ "index" add(getNum("index"), neg(1)) ])));
 }); });
});
setNum("x", 1);
label("l");
print(callNum("fib", [ "index" getNum("x") ]));
setNum("x", add(getNum("x"), 1));
goto("l");
Minimized (323 bytes)
def("f",(num "i"){if(eqNum(getNum("i"),0),(){returnNum(0);},(){if(eqNum(getNum("i"),0),(){returnNum(1);},(){returnNum(add(callNum("f",["i" add(getNum("i"),neg(2))]),callNum("f",["i" add(getNum("i"),neg(1))])));});});});setNum("x",1);label("l");print(callNum("f",["i" getNum("x")]));setNum("x",add(getNum("x"),1));goto("l");
Category:Examples
FunctionsFTW/Truth-machine

setStr("input", input()); "Get input";
 if(eqStr(getStr("input"), "0")), () { "If input is 0";
 print("0"); "Print 0";
 }, () {
 if(eqStr(getStr("input"), "1"), () { "If input is 1";
 label("l");
 print("1\n"); "Print 1";
 goto("l"); "Repeat";
 }, () {});
 });
Minimized (140 bytes)
setStr("i",input());if(eqStr(getStr("i"),"0")),(){print("0");},(){if(eqStr(getStr("i"),"1"),(){label("l");print("1\n");goto("l");},(){});});
Category:Examples
Functoin

Functoin is a language by User:A inspired by Post-preprocessor.
==Syntax(= command)==
 f(x)=1/x`function`
 f(a)=`Put your code here`,f() (a!=0)
 `nothing here` (a==0)`if statement`
 a=0`variable(Set a into 0)`
commas are used to separate two lines of code.
==Computational Class==
This is an attempt to compile Home Row into it.
Define two(or 8, if you like) variables:
 a=0,b=0,
a:
 a=a+1,
Note that a can be both a and b.
s:
 a=a-1,
d & f:
 No direct code...directly change the operating variable.
k & ;:
 No code...That won't affect TC-ness.
j:
 jump(n)=`1st command`(n!=0)
 `2nd command`
l(Actually Brainfuck Style, but similar):
 loop()`Loop commands go here`,loop()(a!=0)
 `We have nothing here`(a==0)
Category:Languages
Category:Turing complete
Category:Turing tarpits
Functress

Functress is an esolang invented by User:Hakerh400 in 2023.
== Overview ==
This programming language is a derivative of the SKI combinator calculus. There are three combinators K, S, R, and the following rewriting rules:
 K a b ---> a
 S a b c ---> a c (b c)
 R K a b c d ---> a
 R S a b c d ---> b
 R R a b c d ---> c
 R (x y) a b c d ---> d x y
Reductions can be performed only at the beginning on the main expression. For example, R (K K K) does not reduce to R K, but R (K K K) a b c d does reduce to d (K K) K.
Category:Languages
Category:Turing complete
Category:2023
Fungot

Fungot is an IRC bot written in Funge-98 by User:fizzie.
Fungot is more or less the mascot of Libera.Chat's #esolangs channel. While not the only bot on the channel by far, it is the most advanced and only regularly present one which has been written in an esolang.
Fungot supports brainfuck and Underload interpretation, with the possibility to define commands using these. (Although fizzie needs to save fungot's state for such additions to become permanent.) 
Fungot also responds to mentions of its name (lowercase) with Markov chain-generated answers in several selectable styles.
Fungot commands are invoked with the caret (^) prefix. 
* ^help lists all built-in commands; ^show lists all commands, including user-defined ones.
* ^bf runs a brainfuck program, ^ul runs an Underload program.
* ^def lets you define a user-defined command in brainfuck or Underload, str lets you define commands whose source is longer than an IRC line.
* ^style chooses a Markov model for random Markov chain responses, or lists the available models. Creating such models is now a lost art.
==External resources==
*Fungot source code
*Fungot manual
*Description of the software that was used to generate most of the markov models of fungot
Category:People
Category:Probabilistic
Funicoton

Funicoton is an esoteric programming language with only 3 slots of memory; two for 8-bit integers and one for a function (which can store a set of instructions that get executed on a variable).
==Instructions==
$ is used as the function's argument when inside the function.
Funicoton has the following instructions, which in a program are seperated by spaces (c, d and e are arguments) :
 Instructions
Symbol 	Description
+d,c 	Adds c to integer variable d.
-d,c 	Substracts c from the integer variable d.
xd,c 	Multiplies the integer variable d by c.
=d,c 	Sets the integer variable d to be equal to c.
==d,c,e	If the integer variable d is equal to c, run the function with argument integer variable e.
!=d,c,e	If the integer variable d is not equal to c, run the function with argument integer variable e.
*d 	Jumps to instruction number integer variable d. (jumps locally in the function)
**c 	Jumps to instruction number c. (jumps locally in the function)
_e 	Appends the instruction e to the end of the function.
-_ 	Clears the function.
d^() 	(Function Only) Sets integer variable d to the value in brackets (can be instructions, like x2,7 or can use the function variable $, like x2,$).
'd 	Outputs the ASCII character with the code in the integer variable d.
"c 	Outputs the ASCII character with the code c.
,d 	Gets an ASCII input and stores it in integer variable d.
;d 	Gets a number input and stores it in integer variable d.
==Examples==
==="Hello, world!" Program===
"72 "101 "108 "108 "111 "44 "32 "119 "111 "114 "108 "100 "33
Category:Languages Category:Finite state automata Category:Unimplemented
Funnie

Funnie is an Esoteric data structure by User:ChuckEsoteric08 which goal was to make most different data structure.
==Operations==
===Basic Operations===
Operation	Function
PUSH x 	Push x to Funnie
POP x 	Pop x from middle of Funnie
NOP 	Do nothing(x is a comment)
===Additional operations===
INC x	increment middle of Funnie by x
DEC x	decrement middle of Funnie by x
Category:Data Types and Structures
FurASM

FurASM is a joke esoteric assembly language developed by Maow on July 13th, 2021. The Kotlin-based implementation of the language describes it as a "furry-themed assembly language." It is a simplified derivative of FASM syntax originally inspired by Furcode.
==Syntax==
* A line marks an instruction if it is not a comment or macro.
* Instruction arguments are separated by whitespace.
* Instruction arguments can only be register identifiers or int literals.
* A line marks a comment if it starts with an at sign (@).
* If a macro contains an equals sign (=), any text after it and before a newline (\n) is considered a macro value.
* Anything after a semicolon (;) is considered a comment.
==Registers==
# OWO
# UWU
# ONO
# UNU
# MEW (meta-register)
::* Values assigned to this meta-register will be printed to the console as an ASCII character.
::* Using this meta-register as an instruction argument will prompt that an optional number be requested from the console.
# DMW (meta-register)
::* Values assigned to this meta-register will be printed to the console.
::* Using this meta-register as an instruction argument will prompt that a required number be requested from the console.
==Instructions==
===pet===
Arguments [2]: register, value
Description: Sets <register> to <value>
===paw===
Arguments [2]: register, value
Description: Adds <register> and <value>
===bop===
Arguments [2]: register, value
Description: Subtracts <register> and <value>
===lik===
Arguments [2]: register, value
Description: Multiplies <register> and <value>
===kis===
Arguments [2]: register, value
Description: Divides <register> and <value>
===bte===
Arguments [2]: register, value
Description: Modulos <register> and <value>
===cyt===
Arguments [3]: register, value1, value2
Description: Sets <register> to 0 if value1 is greater than value2
===wag===
Arguments [3]: register, value1, value2
Description: Sets <register> to 0 if value1 is equal to value2
===pnc===
Arguments [1]: pointer
Description: Pushes the pointer of the next instruction to the stack and jumps to <pointer>
===wig===
Arguments [1]: pointer
Description: Jumps to <pointer>
===nuz===
Description: Pops stack and jumps to the returned pointer
===pat===
Arguments [1]: register
Description: Skips next instruction if <register> is 0
===yif===
Description: Terminate the program.
==Macros==
Macros are interpreter metadata that are expanded into one or more instructions, they can be given values that will influence their output.
* print: Generates a series of pet instructions that prints a string to the console via the MEW meta-register.
==See also==
Furcode
==External resources==
===Implementations===
JVM
* Official Kotlin interpreter (Link doesn't work)
* Kotlin interpreter
Category:2020 Category:Languages Category:Joke languages Category:Implemented Category:Low-level Category:Thematic
Furcode

Furcode is a joke programming language made by User:Oklomsy
Furcode is a furry-based programming language, There are two interpreters. The original interpreter was made by using Bash, However it is broken, and outdated and there is another interpreter made with JavaScript that works way better and it has more commands, the JavaScript Interpreter was made by Sparksammy.
== Furcode commands ==
 First things first, you will need to import this javascript into your HTML project.
 Then, these are the original commands:
 "In furcode there are only two commands.
 owo and uwu.
 owo is the print command
 uwu is for comparing two values and printing something"
 But there is now uwuEval. uwuEval is like uwu except it executes code after it finds something equal.
 Also, there's fursuit and fursuitEval, fursuit is the opposite of uwu. Where uwu checks for equality, this checks for inequality.
Be sure to run your code like: fureval("code") !
==Interpreters==
* JavaScript
* Bash (Broken)
==See also==
* FurASM
Category:Languages Category:Implemented
Category: Joke languages
Fusion Tag

Fusion Tag is a variant of a tag system created by User:ais523 in 2018. It's intended to require less complex data structures to implement than most tag system variants do.
== Commands ==
The language uses a single queue of integers (initially empty), and three commands:
0	Push a 0 onto the tail of the queue.
+	Increment the tail of the queue in-place.
^	Shift an integer n off the head of the queue, and goto the nth command (where the first command is numbered 0, the second is numbered 1, and so on).
Implementations of the language are free to vary the syntax to whatever they find most convenient to implement; however, the "canonical syntax" uses the three command characters above and interprets everything else as comments. Running off the end of the program terminates it. Running + or ^ on an empty queue is an error, but implementations need not be able to diagnose the error (and thus may treat it as undefined behaviour if they wish).
== Computational class ==
The language's author believes it is probably Turing complete. There are at least two sticking points in trying to create a proof of this, though. The largest is the initial initialisation of the queue; it may be that the language needs a different initial state to work correctly (the issue is that a run of + in unary will increase the labels of all commands to its right, thus requiring more +s – an infinite regress) and thus a compression scheme is needed to be able to store data within the program; such a compression scheme is entirely possible to implement given an arbitrary initial state, but may not be possible to bootstrap. The other, which is likely to be easier to fix, is that the control flow doesn't map neatly onto any of the usual suspects for proving Turing-completeness; in order to avoid the language degenerating to a 1-tag system (which is not Turing-complete), you need to start incrementing the tail of the queue before running a ^ command and continue running it afterwards, meaning that control flow is based on pairs of adjacent queue elements.
There is an outline plan for solving the former problem on the talk page Talk:Fusion Tag.
== Implementations ==
In Python 3:
c=input()
q=[]
i=0
while i<len(c):exec({"+":"q[-1]+=1","^":"i=q.pop(0)-1","0":"q+=0,"}[c[i]]);i+=1
Category:Languages
Category:Queue-based
Category:Usability unknown
Category:Unknown computational class
Category:No IO
Category:Implemented
Category:Low-level
Fuun RNA

Fuun RNA is a graphic description language. It was defined for the task of the ICFP contest 2007 (“Morph Endo”).
== Description ==
The RNA of the extraterrestrial Fuun species (program) is a string of RNA bases, where a base is one of the following four letters: I, C, F, P. RNA is normally generated from Fuun DNA. The RNA is always read as a sequence of chunks of 7 bases each (and the DNA actually writes it in the same 7 chunks). Every 7 byte chunk encodes an operation, and all the operations of the program are executed sequentially, without any forms of flow control. There are 21 operations, 20 of which each have a single encoding to chunks, and every other code is interpreted as a no-op.
The output of an RNA program is an 8 bit deep RGB bitmap image of size 600x600 pixels. 
== Links ==
* homepage of the contest 
* PDF specification of the contest task, including definition of the language 
Category:Languages
Category:2007
Category:ICFP contest