nyuuzyou/wikis huggingface dataset:
Infix notation

Infix notation is one of the 4 possible ways to describe a program. It is not as powerful as the others, so people usually add parenthesis, which makes it a combined notation (Infix-Surround).
== Examples ==
Here is an example of pure infix:
 1 + 2
And a way to encode * + 2 2 4 in infix-surround:
 (2 + 2) * 4
Category:Concepts
Category:Operator_notations
Inflection

i was thinking... could inflection find its way into programming languages?
not that I have any idea what it could be used for. 
like 
 > x is 2.
 > 2 xes?
 4
 > 3 xes?
 6
of course using plurals for multiplication is stupid... And such language shoudn't be english based. Latin may be, or Turkish.
:In my mind, the plural of x should be x's. --Ihope127 22:20, 27 May 2006 (UTC)
If the language were object oriented then nouns would be variables reffering to objects.
Genitive case could be use to denote object's fields or methods. Like:
 > FOOBAR = CLASS[int x, int y, int z].
 > foobar = FOOBAR[1,2,3].
 > foobarin x?
 1
 > foobarin x = 2.
 > foobar?
 FOOBAR(2,2,3]
(here "-in" is a genitive ending (one of actual Turkish or Russian genitive endings)).
Need to contemplate this more
Maybe Esperanto-based? --24.191.97.247 21:37, 27 May 2006 (UTC)
: This would not be very sucessfull, because there are not many inflections for Esperanto (genitive is made with preposition) and only acusative has special ending -n 
: Done - called Espro. :) Timwi (talk) 18:47, 28 September 2015 (UTC)
I found a discussion on Lambda The Ultimate; the comments by nilyab about the correspondence between natural and programming languages reminded me of this page.
If the language is not to be based on English (which might be interesting in view of the LTU discussion, but maybe not esoteric enough here) then I would suggest a strongly agglutinative (because otherwise too many different forms of a word may collapse together or be impossible to connect) case language like Hungarian (giving a new meaning to Hungarian notation). Just imagine a programming language with "free" word order. --Ørjan 16:07, 2 Jun 2006 (UTC)
Hasn't this already been done? Perl can already be used with Latin-like inflections, or isn't that what you meant? --Marinus 12:39, 30 June 2006
:Nihil sub sole novum. --Ørjan 13:02, 30 Jun 2006 (UTC)
Having just arrived from Wikipedia, I wasn't expecting discussion to be on this page. I left some notes on the "discussion" tab. Rhmccullough 10:43, 28 June 2008 (UTC)
This seems like a fun idea. I actually really like the idea of a language based on polysynthetic languages - so I might put something together sometime if I get a chance ;) Prof Apex (talk) 01:10, 30 March 2019 (UTC)
Category: Ideas
InfuckBra

infuckBra is brainfuck but its on a torus, so at the end, the code will go back to the start again with the same cell confirgurations
== extra commands ==
 % - skip next command if this is not first time through
== conceptualizing ==
the script "+>---<" can be imagined as this:
 +>--<+>--<+>--<+>--<+>--<+>--<+>--<+>--<+>--<+>--<+>--<+>--<+>--<+>--<+>--<+>--<+>--<+>--<+>--<+>--< and so on and so on to infinity and beyond
== infinite cat ==
 ,.
== ascii loop ==
 +.
Infunctional

Infunctional is a small, minimalist dysfunctional programming language that relies on infix notation. In addition, all lambda abstractions accept two arguments instead of one.
==Infunctional Operators==
Infunctional only has two operators.
;->:is the lambda abstraction, and
;=:is assignment.
===Behavior===
Variable names are 1 character long:
 a
 b
 c
The lambda abstraction is represented by the arrow: ->.
 ab -> c
Variable "assignment" is done by the = operator. They are the equivalent to C's #define in that they perform simple textual replacements before the program is parsed.
 some_variable = (xy -> x)
Function calls are done by placing the lambda expression in between its arguments. The following evaluates to a:
 a(xy -> x)b
Function calls are left-associative:
 a(xy -> x)b(xy -> x)c
 is equivalent to
 (a(xy -> x)b)(xy -> x)c
Both evaluate to a.
==Examples==
===A Twisted Version of Church Numerals===
 zero = (sz -> z)
 one = (sz -> zsz)
 two = (sz -> zs(zsz))
 plus = (xy -> (sz -> (syz)s(sxz)))
===Binary Church Numerals?===
Let z represent zero, o represent one, and p represent an arbitrary cons function.
 zero = (pzo -> z)
 one = (pzo -> o)
 two = (pzo -> opz)
 three = (pzo -> opo)
 four = (pzo -> op(zpz))
 five = (pzo -> op(zpo))
Category: Languages
Category: Functional paradigm
Category: High-level
Ingredients-oriented paradigm

The ingredients-oriented programming paradigm is an esoteric programming subparadigm oriented towards Information Security, being harder to hack, and based on cooking. The basic structure is to mix a set of ingredients in a vessel. Ingredients must be declared during the program (preferably at the start) and may only be used once. An example of Hello World in the paradigm is:
 stdout("Hello, World!")
Which effectively "Mixes" "Hello, World!" in the stdout vessel, which has the special property of sending its result product to the standard output.
== Ingredients ==
The ingredient declaration syntax is:
 [keywords] <type> <name>["["<count>"]"] = <value>
<type> is optional by language. This declares a group of ingredients of size <count> and type <type> named <name>, each item of the value <value>. For example:
 byte b[256] = 100
Will declare 256 bytes of value 100. Whenever the "b" variable is referenced as an ingredient, one item is popped from the array and its value is used in the combinator. If b is referenced with a subscript after it (b[n]), then that many b's are popped from the array and used as arguments. This means that this:
 byte b[4] = 5
 sum(b, b, b, b)
is equivalent to:
 byte b[4] = 5
 sum(b[4])
This feature may be excluded in some languages.
Keywords, also language-dependent features, are used to affect the way a variable works. Some example keywords are:
* Unending: Don't use up variables when used (used for constants)
* ...
== Mixing ==
In ingredients-oriented programming, actions are performed by Mixing ingredients in a vessel. The mixing syntax is:
 vessel(ingredient1, ingredient2...)
For many vessels, ingredient order is irrelevant.
== Vessels ==
Vessels are where ingredients are mixed. Vessels accept a list of arguments which's order may or may not matter and which may have special properties. Example vessels are:
* mixer: Standard mixer
* stdout: Prints its return value to the stdout
* stderr: Ditto for the stderr
* stdin: Automatically includes text from the stdin as an ingredient
* (vessel class) port: Sends data to a port when flushed
== Utensils ==
"Utensils" are the equivalent of first-class vessels in an ingredient language. They are similar to ingredients, except they aren't used up after usage in a declaration (and thus should not be used to store information). When mixed into a combinator, they are applied to all other non-utensil arguments, meaning this:
 vessel(ut, var1, var2)
is equivalent to:
 vessel(ut(var1), ut(var2))
== Exception Handling ==
Exception Handling should be powerful such as to avoid crashes. For example, at the beginning of a program, this line may be able to be added:
 #onerror <name> return <value>
This sets what value a vessel should output when an error is encountered during execution.
== Examples ==
=== Hash an Input (with MD5) ===
 import hash.md5 //Get the md5 utensil from the module
 stdout("Input to hash: ") //Print out "Input to hash: "
 stdout(mixer(md5, input())) // Hash the input by applying md5 utensil to input
Category:Concepts
Init

This language was created by User:WhyNot?.
== WHY?? ==
I created this language so it would be easy and quick to run, but at the programmer's expense. But no-one cares about programmers.
== Syntax ==
Syntax must be perfect, or else the program will crash without telling you what the error is. To differentiate between data, there are some symbols to help you with that:
 #83 ; Number
 @04 ; ROM address
 $39 ; RAM address
By the way, ; denotes a comment. This language isn't that heartless... Anyway, all numbers are in hexadecimal and are (usually) only 1 bit. Most of the time, each 'segment' of the code must be 3 letters long. A segment is a one word, for example add is a segment.
== Language ==
Here's where it gets better.
 add [ram address] [number] ; Self explanatory (adding)
 sub [ram address] [number] ; Self explanatory (subtracting)
 mul [ram address] [number] ; Self explanatory (multiplying)
 div [ram address] [number] ; Self explanatory (dividing)
 mod [ram address] [number] ; Modulo
 dat [data] ; Very important, stores data in ROM. The data can have infinite length. dat and ram can support strings, too.
 ram [ram address] [data] ; Also important, stores data in ram. The data can have infinite length.
 rnd [ram address] ; Puts either a 1 or a 0 in ram.
 out [anything] ; Self explanatory (output)
 inp [ram address] ; Self explanatory (input)
 nou ; A command that says NO U to the computer. The computer then fires back by deleting itself.
 jmp [number] ; jump, just remember that the first line is 0!
 if_ [number] ; if number == 0, skip next line.
 boo [ram address] [boolean] [number, if needed] ; boolean
 ; boolean: and, or_ not, xor, nor, nnd (nand), xnr (xnor)
 end ; end program
Category:Languages Category:Unimplemented
Initialization

:Rewrite It In Initialization!
Initialization is an esoteric programming language in which variables may only be initialized.
== Examples ==
This program prints "Hello, world!":
 main = putStrLn "Hello, world!"
This program calculates the factorial of a number:
 factorio n = if n == 0 then 1 else n * (factorio (n - 1))
 main = print . factorio =<< readLn
== Interpreters ==
A bash interpreter is reproduced below.
 #!/bin/bash
 runghc "$@"
Category:Languages
Category:Functional paradigm
Category:2019
Category:Unusable for programming
Category:Turing tarpits
Inject

Inject is an esolang by User:PythonshellDebugwindow. It is named after its first command.
==Syntax==
===Label===
A label is declared by writing a semicolon the label's name, which must be composed exclusively of letters, numbers, and/or underscores, and must be at least one character long. The first time a certain label is written, it begins a label-block; the second time, it ends a label block; any more times will result in a syntax error. For example, in the following code:
 labelA;
 lorem
 ipsum
 labelA;
the red lines are in labelA's label-block (the start and end of the block are not considered to be a part of the label-block they delimit). Labels can overlap:
 labelA;
 lorem
 labelB;
 ipsum
 labelA;
 dolor
 labelB;
In the above code, labelA's label-block is coloured red, labelB's is blue, and lines in both their label-blocks are purple.
Note: the semicolon at the end of a label is not a part of its name.
==Commands==
Label arguments (represented by X and Y) do not end with semicolons.
===Inject===
Syntax: inject X=S/R
Replaces the label-block of the label X with R according to the regex S; S cannot contain slashes, but R can. Regexes must be able to use at least the following features:
* Boolean "or"s (x|y)
* Wildcards (.)
* Grouping ((x))
* Kleene stars (x*)
* Kleene pluses (x+)
* Question marks (one or none) (x?)
Implementations can optionally support more than these basic features.
===Send===
Syntax: send X
Writes the contents of the label-block of the label X to STDOUT.
===Readto===
Syntax: readto X
Reads a line from STDIN and overwrites the contents of the label-block of the label X to the input received.
===Skip===
Syntax: skip
If the next line is a label, and if it begins (not ends) a label-block, don't run the code in its label's label-block. Otherwise, if the instruction pointer is in at least one label-block, then go back to the beginning label of the innermost label-block. If neither of these conditions is true, then exit the program.
===Skipif===
Syntax: skipif X
Same as skip, but only executes if the label-block of the label X has at least one line in it.
===Skipq===
Syntax: skipq X Y
Same as skip, but only executes if the label-blocks of the labels X and Y are equal.
==Examples==
===Hello, world!===
send data
skip
data;
Hello, world!
data;
===Truth-machine===
readto data
loop;
send data
skipq data 0
loop;
skip
data;
data;
0;
0
0;
===Cat program===
loop;
readto data
send data
skipif data
loop;
data;
data;
Category:Languages Category:2021 Category:Unimplemented Category:Unknown computational class
InputSet

InputSet is an esolang by User:ChuckEsoteric08 inspired by Wheat.
==Specification==
Memory consists of variables which contain arbitrary long strings. On the start of the program all of them are set to empty string
a, b and c are arguments that can be replaced with:
(a) which returns value of variable a.
(a/n) which returns n-th symbol in string a.
{a} which returns lenght of string a.
$ for refecencing current character in for loop
In all commands except in "input" command, argument a in "set" command and argument b in "replace" command. Arguments are seperated by space.
input a 	Store user input in variable a
output a 	Output string a
set a b 	Set variable a to string b
for a { 	Run code between this command and matching } command for every character in string a.
} 	End for-loop
if a b [ 	If string a is equal to string b execute commands between this command and matching ] command
] 	End if-statement
forever ( 	Start of forever loop
) 	End forever loop
replace a b c	Replace a-th character in variable b with string c. If there is no c, then it would delete that symbol.
==Examples==
===Hello, World!===
 output Hello,World!
==Computational class==
InputSet is Turing-complete because there is Cyclic Tag interpreter in it (version with comments is here):
 input data
 input program
 forever (
 for (program) {
 if $ ; [
 replace 1 data
 ]
 if $ 1 [
 if (data/1) 1 [
 if (data/{(data)}) 1 [ 
 replace {(data)} data 11
 ]
 if (data/{(data)}) 0 [
 replace {(data)} data 01
 ]
 ]
 ]
 if $ 0 [
 if (data/1) 1 [
 if (data/{(data)}) 0 [ 
 replace {(data)} data 00
 ]
 if (data/{(data)}) 1 [
 replace {(data)} data 10
 ]
 ]
 ]
 }
 )
Data is inputed First, then program itself
Category:Languages Category:Turing complete Category:String-rewriting paradigm
Input hello world or else:

input hello world or else: is a joke esolang created by User:Ractangle when he was looking at his IT computer desktop and found this file
==Syntax==
if the command is this:
 Hello world
it prints 
else print
 grrrrrrrrr
==Implementations==
===Python===
 a=input()
 if a=="Hello world":print("Hello world")
 else:print("grrrrrrrrr")
==See also==
* Input hello world or else without a quine
Category:LanguagesCategory:Joke languagesCategory:2024Category:ImplementedCategory:TotalCategory:Unusable for programmingCategory:Output only
Input hello world or else without a quine

If you type:
 grrrrrrrrr
It outputs:
 Why are you angry?
And if you type:
 Hello world
It outputs:
 Hello, World!
== Interpreters ==
=== JS ===
var command = ""; /* Replace the empty string with user input */
if (command != "Hello world") {
 if (command != "grrrrrrrrr") {
 console.log("grrrrrrrrr");
 } else {
 console.log("Why are you angry?");
 }
} else {
 console.log("Hello, World!");
}
Category:Joke languagesCategory:2024Category:ImplementedCategory:TotalCategory:Unusable for programmingCategory:Output only
Inputbrain

Inputbrain is BF derivate made by User:ChuckEsoteric08. It goal was to make Turing-complete language that can be implemented in FakeScript and it failed, because FakeScript can't make variables and tape need to be bounded
==Commands==
Command	Meaning
, 	Ask input, set current cell to it and print it
> 	Move pointer to the right
< 	Move pointer to the left
[ 	Jump past matching ] if cell is zero
] 	Jump back to matching [
==Interpreter==
 goto inp 
 !label c1 
 input 
 print #input 
 goto inp 
 !label c2 
 input 
 print #input 
 goto inp 
 !label c3 
 input 
 print #input 
 goto inp 
 !label c4 
 input 
 print #input 
 goto inp 
 !label c5 
 input 
 print #input 
 goto inp 
 !label c6 
 input 
 print #input 
 goto inp 
 !label c7 
 input 
 print #input 
 goto inp 
 !label c8 
 input 
 print #input 
 goto inp 
 !label c9 
 input 
 print #input 
 goto inp 
 !label c10 
 input 
 print #input 
 goto inp 
 !label inp 
 input 
 if #input 1 c1 
 if #input 2 c2 
 if #input 3 c3 
 if #input 4 c4 
 if #input 5 c5 
 if #input 6 c6 
 if #input 7 c7 
 if #input 8 c8 
 if #input 9 c9 
 if #input 10 c10
 goto inp 
It has 10 cells(you can add more if you edit code). It is possible to translate any inputbrain program without instruction "<" to FakeScripts
===How it works===
First, select cell. 1 if you want to go to cell 1, 2 for cell 2 and ect. Second, Input somthing, it will output it and you need to select cell agin. It also has no loops because whole progam is inside it. It has no ">" and "<" because you can't make it in FakeScript
Category:Languages Category:Implemented Category:Unusable for programming Category:Cell-based Category:Brainfuck derivatives Category:Low-level
Inputer

Inputer is a stack-based esolang by User:ChuckEsoteric08 which is based on inputing and inspired by Volatile.
==Commands==
Command	Operation
' 	input number and push it to the stack.
+ 	pop two number, a and b, push b+a.
- 	pop two number, a and b, push b-a.
* 	pop two number, a and b, push b*a.
/ 	pop two number, a and b, push b/a.
! 	NOP, but needs to match with ?.
? 	pop top element and if it is not equal to element on the top go back to matching !.
(...) 	loop while top element is not zero.
# 	debug command. Outputs stack.
==Examples==
===Cat program===
A one-time cat program is implemented in the following:
 '#
A repeating cat program, which terminates on a user input of zero, comprises this:
 '#('#)
===Truth-machine===
This program aspires to approximate a truth-machine:
 '(#)#
===Number guessing game===
This example program simulates a number guessing game, querying the user for the correct answer, then letting him probe for the same, while concomitantly printing each twain on the stack:
 '!'#?
===Addition===
The throughout simplistic program below queries the user for two numbers, pushes their sum unto the stack, and prints the result:
 +#
==Computational class==
It is Turing-complete by reduction from VolatiIO, version of Volatile where ~ inputs a number and push it to the stack:
+-*/() are the same
VolatilIO	Inputer
~ 	'
: 	Unknown
==Interpreter==
* Common Lisp implementation of the Inputer programming language.
Category:Languages Category:Turing complete Category:Implemented
Inputfish

Inputfish is an language by User:ChuckEsoteric08
==Commands==
i 	input
ox	output byte x
==Examples==
===Hello World===
 oHoeololooowooorolodo!
==External resources==
Implemented in python by User:Nmcassa
== See also ==
* How to learn this language
Category:Languages Category:Unusable for programming Category:Implemented Category:Low-level Category:Total
Insanity

Insanity is an esolang conceived by User:PythonshellDebugwindow and finalized by User:A. It’s based on Einstein’s definition of insanity—doing the same thing over and over again and expecting a different result.
== Program structure ==
The whole program is wrapped in an infinite loop, because in the body of the infinite loop the same thing is repeated over and over again. However, since there are mutable variables, you can expect a different result on every iteration of the loop, making you at least partially sane.
In the first line a set of variables is defined and is assigned to a specific value. Different variables are separated with commas. E.g.
1,1+2,5
They are assigned to a, b, and c, respectively. All assignable variables are a-z and A-Z, and operators are + - * /.
In the remaining lines an infinite loop is set to iterate these variables.
== Example programs ==
=== Fibonacci sequence ===
0, 1
b, a+b
=== Factorial ===
The following program generates the factorial n! for each n ≥ 1, storing the result n! in the variable a, while the variable b maintains the multiplicand n + 1 for the next cycle.
 1, 2
 a * b, b + 1
=== Counter ===
This simple program counts from one (1) up to infinity, storing each result in the variable a:
 1
 a+1
==Interpreter==
* Common Lisp implementation of the Insanity programming language.
Category:Languages Category:2020 Category:Unknown computational class Category:Implemented
Inse

Inse is an esoteric programming language where code can be stored in memory as strings and can be run later. Its syntax is similar to BASIC where a command is followed by a space and then the arguments. Inse commands end with a period.
There are no variables in Inse, as values are stored directly in memory addresses.
Control flow is handled by multiplying strings in Inse. If a string is multiplied by 0, then it will return nothing, if by a positive number, the string is repeated that many times, and if by a negative number, the commands in the string are reversed. This makes it possible to have different behavior occur based on the sign of a number.
Here is an example of a 99 bottles of beer program
 # address 0 is bottles #
 set /99/ &0&.
 # main loop of the program #
 set [
 out &0&.
 out [ bottles of beer on the wall \n].
 out &0&.
 out [ bottles of beer\n].
 out [take one down, pass it around\n].
 # subtraction #
 sub &0& /1/ &0&.
 out &0&.
 out [ bottles of beer on the wall \n \n].
 # test to see whether we are at 0 #
 # sign function will return 1 if we are not at 0, and 0 if we are (it will also turn negative if beer is negative but it should never be)#
 sgn &0& &1&.
 # multiply ourselves by the signed number, if we are 0, it will delete ourselves, it not nothing will happen #
 mul &10& &1& &10&.
 run &10&.
 ] &10&. # main loop is at address 10 #
 run &10&.
 dun.
See below for more information on the Language
==External Resources==
* Interpreter and Further Documentation on github
Category:Languages Category:Implemented
Inside-out notation

Inside-out notation is a bizarre version of infix notation. The idea is that an infix operator will take another operator as an argument, then grab the arguments for that operator from the inside of the expression. It was invented by Oren Watson based on infix notation.
For example:
 xy+*z -> y+(x*z)
 xy*+z -> y*(x+z)
 x+*yz -> (x+z)*y
 x*+yz -> (x*z)+y
 
 x+y**wz -> y*((x+z)*w)
Insignificant

Computing is best understood as a dialectical interplay of meaning and mechanism.
 Brian Cantwell Smith Age of Significance
A conforming Insignificant program can be written in any language as long as that program is understood as meaningless mechanical manipulation. A conforming program is forbidden from having any higher interpretation imposed on its actions such "adding numbers" or "computing π".
Insignificant was invented by Doesthiswork in 2017.
Category:Languages 
Category:2017 
Category:Unusable for programming
Insomnia 2.0

Insomnia 2.0 is based on Insomnia and was created to eliminate Insomnia's flaw command 7, to make it closer to impossible to code in.
== Workflow ==
Insomnia 2.0 has the same workflow as Insomnia. See here for more details.
== Commands ==
 0 - Flip current bit and move pointer right
 1 - Flip current bit and move pointer left
 2 - Flip current bit
 3 - Move pointer right to next group
 4 - Move pointer left to previous group
 5 - Output block as digit
 6 - Output block as letter
 7 - Flip every bit in the current group
 8 - While pointer is not 0
 9 - End while
Category:Languages
Category:Turing complete
Category:Cell-based
Category:Brainfuck derivatives
Category:Unimplemented