nyuuzyou/wikis huggingface dataset:
Parenthesis Hell

Parenthesis Hell is a Lisp-like language in which the only data types are the cons pair and nil. As a Lisp-like language, code is data, so the code consists only of nested matched pairs of open and close parentheses. Characters other than open or close parentheses are ignored.
==Description==
A Parenthesis Hell program is a single expression with the input as the argument. The output is the result of evaluating the expression.
An expression is either nil, written as (), or a cons pair, with the car specifying the function, and the cdr specifying its argument. () evaluates to the argument. A cons pair is evaluated by applying the function named by the car to the cdr.
===Predefined functions===
The root scope defines 7 functions.
* (): quote - evaluates to its unevaluated argument
* (()): letrec - creates a new scope with bindings from the list in the car of its argument and evaluates to the cdr of its argument in the new scope
* ((())): car - evaluates to the car of its argument, or nil if its argument is nil
* (()()): cdr - evaluates to the cdr of its argument, or nil if its argument is nil
* ((())()): cons - evaluates to the cons of the car of its argument and the cdr of its argument, or nil if its argument is nil
* (()()()): if - if the car of its argument is not nil, evaluates to the cadr of its argument, otherwise it evaluates to the cddr of its argument, or nil if its argument is nil or if the cdr of its argument is nil
* (((()))): eval - obligatory in code-is-data languages
A nil element in a letrec binding list is ignored.
The car of an element in a letrec binding list is the name of a function being defined. Within the letrec scope, it shadows all definitions of the same name in any enclosing scope, including the root scope. The cdr of the binding list element is the body of the function, which, when called, is evaluated in the letrec scope, and () evaluates to the argument it was called with.
Applying an undefined function is illegal.
===Values===
ASCII Strings are encoded by converting them to binary, where each character uses 8 bits. The bits 0 and 1 are encoded as () and (, respectively, where the ( for 1 is closed later to ensure the parentheses match. For example, a program to print the ASCII character 'I', which is 01001001 in binary, is (()()(()()(()()(())))).
==Examples==
Hello world (ASCII):
 (()()(()()(()()()()((()()(()(()((()((()()()((()((()()()((()((((()()(()(
 )()()()()(((()(((()((()((((()(((()()(()()((()((()()()((()()(()()()()(()
 ()()()(()()()()(()(())))))))))))))))))))))))))))))))))))))))))))))))))
cat:
 ()
quine:
 ((())(((())()((())())(()())((())())(((())())(((())())(()())((())())(())(()))()
 )(())))((())())(()())((())())(((())())(((())())(()())((())())(())(()))())(()))
==External resources==
* Interpreters in Clojure and Haskell
Category:Languages
Category:Implemented
Category:2009
Parenthesisfuck

Parenthesisfuck is invented by User:A.
==Syntax(and proof to be Turing-complete)==
 (while ...)
Same as Brainfuck []
 (add p1 p2)
equivalent to Brainfuck symbols "<>+-".
The 1st parameter is the adding times(can be negative).
The second parameter is the place to do the operation.
Category:Languages
Category:Turing complete
Category:Turing tarpits
Parenthetic

The Parenthetic programming language is a functional programming language that (like Parenthesis Hell) uses only parentheses in its code. All other characters are considered comments.
The language works by interpreting certain parenthesis sequences as symbols (for example, the sequence (()) corresponds to the add function). Currently, Parenthetic supports the following commands: define, lambda, if, not, <=, equal, + - * /, cons, car, cdr, and conversions between lists and strings.
== Examples ==
Hello World:
 
 ((()()())(()(()()))((()(()))((())()()()()()()())((()()(()))((())()()()()()()()()())
 ((())()()()()()()()()()()))))((()()())(()(()()()))((()(())(())())((())()()()()()()(
 )()()()()()()()()()()()()()()()()()()()()()()()()())))((()(()))((()(())(())())((()(
 ()))(()(()()))((())()()()()()()())))((()(())(())())((()(()))(()(()()))((())()()()()
 )))((()(())(())())((()(()))(()(()()))((())()()()()()()()()()()())))((()(())(())())(
 (()(()))(()(()()))((())()()()()()()()()()()())))((()(())(())())((()(()))(()(()()))(
 (())()()()()()()()()()()()()()())))(()(()()()))((()(())(())())((()(()))(()(()()))((
 ())()()()()()()()()()()()()()()()()()()()()()())))((()(())(())())((()(()))(()(()())
 )((())()()()()()()()()()()()()()())))((()(())(())())((()(()))(()(()()))((())()()()(
 )()()()()()()()()()()()()())))((()(())(())())((()(()))(()(()()))((())()()()()()()()
 ()()()())))((()(())(())())((()(()))(()(()()))((())()()()))))
==External resources==
Official Parenthetic page on Github
Category:Turing complete
Category:Implemented
Category:Languages
Category:2012
Category:Functional paradigm
Parigot numeral

A Parigot numeral is a natural number encoded into lambda calculus using Parigot encoding. One way to understand Parigot numerals is by relation with Church numerals, considering primitive recursion and recursion schemes; if Church numerals are like initial katamorphisms for the natural numbers, then Parigot numerals are like initial paramorphisms, with access to the numeral at each stage of recursion.
The Parigot numerals can be recursively defined by:
0 g h = h
(succ n) g h = g n (n g h)
and letting R(g,h) be a primitive recursive function with one parameter, then
R(g,h)(0) = h()
R(g,h)(S(xn)) = g(xn,(R(g,h)(xn)))
It can be observed that R is equivalent to the Parigot numeral λg.λh.λn.n g h.
== Examples ==
numbers
0 = λg.λh.h
1 = λg.λh.g 0 h
2 = λg.λh.g 1 (g 0 h)
3 = λg.λh.g 2 (g 1 (g 0 h))
(numbers require exponential space)
successor function and predecessor function
succ = λn.λg.λh.g n (n g h)
pred = λn.n (λa.λb.a) 0
=== Arithmetic ===
additive function
add = λx.λy.y (λa.λb.succ b) x
subtraction function
sub = λx.λy.y (λa.λb.pred b) x
multiplication function
mul = λx.λy.y (λa.λb.add x b) 0
division function
fix = (λx.x x)(λf.λx.x (f f x))
div = fix (λf.λx.λy.(succ (sub x y))(λa.λb.succ (f (sub x y) y)) 0)
(or use the minimalization)
Mu = (λx.x x 0)(λmu.λx.λf.(f x)(λa.λb.f f (succ x)) x)
div = λx.λy.Mu (λn.(pred (sub (mul (succ n) y) x))(λa.λb.0) 1)
=== convert between Church numeral ===
First,we need church succ
cSucc = λn.λs.λz.s (n s z)
convert to church numeral
toChurch = λn.n (λa.λb.cSucc b)(λs.λz.z)
convert from church numeral
fromChurch = λn.n succ 0
Category: Concepts
Parity

Parity was created by User:imcute and is called this name due to its only 2 instruction list and its way of doing instructions
an even number means to add 1 to the place of the number divided by 2
an odd number means jump to the number in the place of the number divided by 2 without the 0.5
this language has 2 dialects:list-starts-at-0 dialect and list-starts-at-1-dialect due to technical restrictions
a count to infinity program in dialect 0 would be 4 7 0 0 while in dialect 1 it would be 6 9 0 1
the turing completeness of this is questionable due to it not having a conditional jump
implementations:
python
LOOP_CHECK=1000
with open("code","r")as a:
	ram=list(map(int,a.read().split()))
i=0
try:
	while True:
		p=0+ram[i]
		if p%2==0:
			ram[p//2]+=1
			i+=1
		else:
			i=ram[p//2]
		print(" ".join(map(str,ram)))
		LOOP_CHECK-=1;
		if LOOP_CHECK<=0:
			raise ZeroDivisionError
except IndexError:
	print("result:")
	print(" ".join(map(str,ram)))
except ZeroDivisionError:
	print("Oops!Code too long to run.If this is intentional,make line one to something supra big")
snap https://snap.berkeley.edu/snap/snap.html#present:Username=18001767679&ProjectName=slate%20assembler (its called slate assembler cuz slate_technoligies wanted this in snap)
Category:Languages Category:Implemented Category:Unknown computational class Category:Low-level
Parking lot

==Memory==
There is a finite 2-D grid called the parking lot, every cell is a parking place.
==Commands==
All values are integers in the Parking lot language.
 The parking lot has x rows and y columns
Defines the size of the parking lot, this command must exist and only exist at the start of the program.
 There's a car at (x,y)
Creates a car, it initially faces right and has a speed of 0. After this command, the previous car (if it exists) becomes immutable. Immutable means that commands that move the car, change the properties of the car or parking the car are forbidden. Coordinate (x,y) stands for the x-th row from the top and the y-th column from the left.
 The car's speed becomes v
 The car rotates clockwise
 The car rotates counterclockwise
They explain themselves， but note that the car's speed must always be positive and strictly less than 299792458 (the speed of light).
 The car drives for t seconds
Moves the car t*v (v is the speed of the car) parking places in its direction, it is forbidden for two cars to be in the same parking place. The car cannot go outside the parking lot.
 The car pays $x to park
x is a positive integer, this command places the integer x on the parking place the car is at. After this command, the car becomes immutable.
After all the commands are done, for every row, all the parked cars have their integers in the corresponding parking place printed as ASCII in order (Rows with no integers are ignored). After a row is printed, a line feed is printed. For example, if the parking lot has 3 rows and 3 columns and the parking places look like this (* means no integers in the parking place):
 * 65 *
 66 67 *
 100 * 101
Prints:
 A
 BC
 d
==Errors==
When attempting to do an invalid operation (e.g.: Going outside the parking lot) or the program has a syntax error, the error message Look! There is a car accident! is printed and the program halts.
==Examples==
===Hello, World!===
The parking lot has 1 rows and 13 columns
There's a car at (1,1)
The car pays $72 to park
There's a car at (1,2)
The car pays $101 to park
There's a car at (1,3)
The car pays $108 to park
There's a car at (1,4)
The car pays $108 to park
There's a car at (1,5)
The car pays $111 to park
There's a car at (1,6)
The car pays $44 to park
There's a car at (1,7)
The car pays $32 to park
There's a car at (1,8)
The car pays $87 to park
There's a car at (1,9)
The car pays $111 to park
There's a car at (1,10)
The car pays $114 to park
There's a car at (1,11)
The car pays $108 to park
There's a car at (1,12)
The car pays $100 to park
There's a car at (1,13)
The car pays $33 to park
===Quine===
 Look! There is a car accident!
===XKCD Random Number===
 The parking lot has 299792458 rows and 11 columns
 There's a car at (1,1)
 The car rotates clockwise
 The car's speed becomes 299792457
 The car drives for 1 seconds
 The car rotates counterclockwise
 The car's speed becomes 2
 The car drives for 5 seconds
 The car pays $52 to park
Eventually, the car's position is (299792457,10).
Category:Languages
Category:Joke languages
Category:2024
Category:Unusable for programming
Category:Output only
Category:Total
Category:Unimplemented
Category:Pseudonatural
Parnassus

The Parnassus Programming Language (2007, by User:Pegasus) is a programming language with features that other languages never had before. It is based on the When instruction, that allows to run a procedure in the moment an event happen. It also has a support to multiple strings of OR and AND logical statements, making the program simplier. It will be implemented through Hera Runtime
=Hello World Example=
 Load "output.exe"
 When app.run = True
 Call write:string With const "Hello World"
 End
Another example: An application that receives a number from keyboard and it prints a message if the number is 2, 4, 5 or 11.
 Load "input.exe"
 Load "output.exe"
 When i = 5
 Call write:string With const "The number is five"
 End
 When app.run = True
 Call read:integer to i Comment: Reads an integer from the keyboard
 If i = ( 4; or 2; or 1)
 Call write:string With const "The number is two, four or eleven" 
 End
 End
If the number entered is 5 then program will print the message: "The number is five", If at some part of the program "i" loses its value of 5, and regains it later, the "When i = 5" method will be executed once more, right after the new assignment.
Category:2007Category:LanguagesCategory:Unimplemented
ParrBF

ParrBF is a joke language designed by User:Benni++, which is similar to Brainfuck, eventhough the commands < and > are not defined, but every collumn of the program is an variable. There is one additional command - ~ - which outputs the value of the actual cell as an integer.
To set the first variable to - for example - 3 an the second to 5, type
 ++
 ++
 ++
 +
 +
== Loops ==
The 2 Commands [ and ] are defined:
[: if the value of the actual cell is 0, jump behind the matching ] bracket in any cell
]: if the value of the actual cell is non-zero, jump back to the matching ] command, in whatever a cell it is.
== Example Programs ==
min(a,b)
 +
 +
 +
 +
 +
 +
 +
 [+
 -+
 +
 +
 +
 +
 +
 ]-
 The two values (8 & 5):
 ++
 ++
 ++
 ++
 ++
 +
 +
 +
 Execute min:
 [
 --+
 ].
Output "Hello World!":
 +
 +
 +
 +
 +
 +
 +
 +Helo Wrd!
 [+++++++++
 -+++++++++
 +++++++++
 +++++++++
 ++++ +++
 ++++ +++
 ++++ +++
 ++++ +++
 ++++ +++
 +++ +++
 +++ +++
 +++ ++
 +++ +
 + +
 ] -+- -+++
 -+ ++
 -+ +
 + +
 ...
 ....
 . .
 . ..
Category:Languages
Category: 2009
Category: Implemented
Category: Cell-based
Parrot

Parrot was a hoax introduced in an article from the Perl journal in April 2001. The authors of Perl and Python were supposedly going to merge their languages. O'Reilly even went so far as to create a web page for their Programming Parrot in a Nutshell book! (O'Reilly went on to explain the work that went into the hoax.)
Ironically, this engendered the name for a register-based virtual machine intended for dynamic scripting languages such as Perl.
==Example==
 # copy stdin to stdout, except for lines starting with #
 while left_angle_right_angle:
 if dollar_underscore[0] =eq= "#":
 continue_next;
 }
 print dollar_underscore;
 }
Category:Joke languages
Category:Unimplemented
Category:2001
Category:Languages
Particle automaton

A particle automaton is a cellular automaton that exhibits conservation of state; that is, state can neither be created nor destroyed; the number of cells in a given state will remain the same throughout the life of the automaton.
Most esoteric programming languages which are based on particle automata are not true particle automata, in that they allow some of their state to sometimes be created or destroyed.
==See also==
* :Category:Particle automata, a list of particle automata on the wiki
* Bully automaton
Category: Computational models
Partitioned

Partitioned is a WIP esoteric programming language created by Sekoia in 2021. The main limitation is ROM as each partition only contains 255 bytes, for both instructions and data.
Every partition shares a single byte at address 0xFF, permitting transmission between partitions. Partitions cycle one after the other, at one instruction per cycle.
A partition is formatted as a 16x16 array of bytes. Each byte is separated by a `,` and whitespace is ignored. As a rule of thumb, addresses are written as hexadecimal, instructions as binary, and data as decimal. Octal is also supported.
==Instruction Set==
Each instruction is five bits, followed by 3 flags. The general formatting for an instruction is `0bxxxxx_xxx` so that the 3 flags are distinct.
TODO
==Examples==
===Hello World===
 0b00101_010, 0x10, 0x0F, 0b11101_001, 0x10, 0b10000_100, 1, 1, 1, 0b10000_100, 4, 1, 4, 0b01000_000, 0x00, 0b11111000
 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33
This is actually a bit more general than just "Hello World!". Any ASCII code can be inserted starting at address 0x10, until it hits a 0.
The logic is as follows:
 pointer = 0x10
 LOOP: IF *pointer EQUAL TO ZERO GOTO END
 PRINT *pointer
 pointer++; // This is actually two instructions, because the code has 2 pointers instead
 GOTO LOOP
 END: RETURN
 // ASCII codes
Category: Golfing language
Category:Languages
Pass a symbol

pass a symbol or PAS (lol) is an esolang where the whole idea is you can make your own commands. Although this should not be considered a metalang (I think), it is a category anyway.
== How It Works ==
You start by putting a top binary number, then a symbol, and then another binary digit, like this:
 0
 E
 1
This defines E, which will take input as a binary number and output another one. If it has input 0, it will output 1. BUT this does not mean that passing 1 gives 0. Since that's not defined, passing a 1 to E will give 1. To define a NOT gate with symbol E, it would be:
 0
 E
 1
 -
 1
 E
 0
This defines a NOT gate, and a - separates these definitions. There is a special symbol that can replace a binary digit, which is i. This symbol will take user input as a binary digit (or digits). For example, like this:
 i
 E
 0
Adding a o at the end of a binary digit at the bottom of a definition will make it output itself. To make it output in Unicode, a $ is used instead:
 0
 E
 1
 #
 0
 E
 o
Also, # separates definitions from the calculation. To make an operator pass the result it makes to itself recursively, a ^ is used at the start of the first definition, and if there is a state that ends in * it will break out of recursion, which will make it pass the result to itself. If you want it for a spesific output it can replace the input of a function. If this is done ~ Will break the loop. Putting an X at input will make it halt itself. One last thing: there is a tape extending infinitely to the right. > and < move around the tape, ( is o but on the current cell, and ) is $ (these only work after the # or in the output of a definition). Putting a % at the end of the output in a definition will put that into the tape, and putting a * instead of a binary number in the # section will take the current tape cell.
== examples ==
Truth-machine:
 ^
 0
 E
 0oX
 -
 1
 E
 11o
 -
 11
 E
 1o
 #
 i
 E
infinite loop:
 ^
 0
 E
 0
 #
 0
 E
Double layer buffer:
 0
 ¬
 1
 - 
 1
 ¬
 0
 #
 0
 ¬
 ¬
=== logic gates ===
==== AND ====
 01
 A
 0
 -
 10
 A
 0
 -
 00
 A
 0
 - 
 11
 A
 1
 #
 11
 A
==== OR ====
 10
 R
 1
 -
 01
 R
 1
 -
 11
 R
 1
 -
 00
 R
 0
 #
 11
 R
==== NOR ====
 10
 R
 1
 -
 01
 R
 1
 -
 11
 R
 1
 -
 00
 R
 0
 -
 0
 ¬
 1
 - 
 1
 ¬
 0
 #
 11
 R
 ¬
==== NAND ====
 01
 A
 0
 -
 10
 A
 0
 -
 00
 A
 0
 - 
 11
 A
 1
 -
 0
 ¬
 1
 - 
 1
 ¬
 0
 #
 11
 A
 ¬
==== XOR ====
 10
 X
 1
 -
 01
 X
 1
 -
 11
 X
 0
 -
 00
 X
 0
 #
 11
 X
==== XNOR ====
 10
 X
 1
 -
 01
 X
 1
 -
 11
 X
 0
 -
 00
 X
 0
 -
 0
 ¬
 1
 - 
 1
 ¬
 0
 #
 11
 X
 ¬
== notes ==
* im not sure if this is even possible but isn't this both imperative and declarative?
* im pretty sure this is NOT turing complete
Category:Meta-languages
Category:Declarative paradigm
Category:Cell-based
Category:Unknown computational class
Category:Low-level
Category:2024
Category:Languages
Pastebin

Pastebin is a joke language made by Mihai Popa. It does this: when you put a Pastebin paste link, it will print the contents of it.
== Syntax ==
Every valid Pastebin paste link will print the contents of it. It's like a quine.
== Examples ==
=== Hello, world! ===
https://pastebin.com/YREyS9Gr
=== 99 Bottles of Beer ===
https://pastebin.com/unykvyD8
=== Some random C++ code I found online ===
https://pastebin.com/HGM1buqJ
== Interpreters ==
Any web browser or any tool, for example curl that can access pastebin.com is an interpreter
Category:Languages
Category:Joke languages
Category:2024
Category:Implemented
Category:Finite state automata
Category:Total
Category:Unusable for programming
Pathfollow

Pathfollow is an esolang invented by User:AnotherUser05.
==Commands==
 @ start of IP.
 | IP follows this vertically.
 - IP follows this horizontally.
 + corner turn.
 < one way (left).
 v one way (down).
 > one way (right).
 ^ one way (up).
 $ start a new value.
 0-9 add to the end of the current value.
 ; get an input and add it to the value.
 : output the current value and start a new value.
 . output the current value as an ASCII character and start a new value.
 ? all checks are branched out of this using one ways, and if the current value is equal to a number 
 that’s branching out, then go there. if none of them are true, then follow the path with no one ways.
 x terminate the program.
==Examples==
===Hello, World! Program===
 @-1-0-4-.-1-0-1-.-1-0-8-.-1-0-8-.-1-1-1-.-+
 |
 +-0-1-.-4–1-1-.-1-1-1-.-7-8-.-2-3-.-4-4-+
 |
 +-8-.-1-0-0-.-3-2-.-x
===Truth Machine===
 @
 |
 ;
 v
 x-?>0-0-:-x
 v
 1
 |
 1<+
 | |
 : |
 | |
 +-+
===Cat Program===
 @-;-:-x
===Not Finite Loop===
 @
 |
 +<+
 | |
 +-+
Pattern

Pattern is an esolang created by User:A that is inspired by English grammar word describers.
== Describers ==
x after y indicates that the following syntax must be fullfilled: The active item is y, and it is moving left towards x. This stops when y is right after the atom x.
x also y means that both x and y needs to be fullfilled. If trying to do both fails, only x is fullfilled.
x before y means that the active item was y, and it is moving right towards x. This stops when y is right before x.
no x means that execute x until the syntax is not fullfilled anymore.
x with y means that y needs to be right before OR right after the atom x. y is moving left.
== Example ==
2 with 1
3 after 2
1 with 3
Note that instructions in Pattern execute cyclically. Given an input 312 this does:
 312
2 w/ 1 -> *nothing*
3 a. 2 -> 123
1 w/ 3 -> 132
2 w/ 1 -> 321
3 a. 2 -> 213 -> 231
1 w/ 3 -> *nothing*
and so on...
Patterns

Patterns is a programming language that makes patterns
== A pattern ==
 P1:a1
 P is the letter made
 1 is the name
 : is the separator
 a1 is generated after P is generated, note: if one of the letters in the generator part is a pattern, it will be replaced, so a1 will be aa1 will be aaa1...
=== The start pattern ===
 S_:1
 S is the letter made
 _ is the start pattern piece
 : is the separator
 1 is a non existent pattern, so it will make the number 1
=== A pattern that generates nothing but the generator part ===
 _1:example
 _ is the no letter maker piece
 1 is the name
 : is the separator
 example is the text generated
=== The halt pattern ===
 _A:.
 A is an instant halt pattern
 every time a . is generated by itself, the program halts
=== The input pattern ===
 __:*+*0
 _0:.
 the * when generated is replaced by an amount of characters chosen by the program user, you can use multiple *
 if the first * is replaced by 1 and the second * is replaced by 2, the output is 1+2., the . is used to halt the program
== An example ==
 __:1nnnnnnno
 _1o:. ~halts and replaced with .
 _1n:a1
 output is aaaaaaa.
== A transition ==
 to transition from slashes to patterns, do this:
 replace the /a/b/ with _a:b
 replace the input as a to the program with __:a
 new thing that is different from slashes: use * to make dynamic input instead of static input, because the other way is hardcoded
Category:Languages Category:String-rewriting paradigm