nyuuzyou/wikis huggingface dataset:
Lambda: the Gathering

Lambda: the Gathering is a two-player competitive game and programming language defined in the task description of the ICFP programming contest 2011.
The language works with two kinds of values: integers and functions. Each player has a set of 256 "slots", each of which stores a single value and has a hit point counter ("vitality"). The functions are combinators composed of a small set of primitives that include well-known pure combinators like S, K, I, (KI), but also ones that have side effects on the game state. There are primitives for reading the value from a slot using its number, damaging the slots of the opponent, and more. 
The players act in alternating turns. Each turn, a player applies one of the 15 primitives ("cards") to one of his slots from either left or right. The resulting function call is evaluated, which may have side effects on the game, then the resulting value overwrites the same slot. The application may lead to an error (eg. using a number as a function or the other way, referring to a non-existant or dead slot), or time out (too many applications) in which case the application is halted and I is written to the slot value. 
If enough damage is dealt to a slot to bring its hit point counter to zero, the slot can no longer be used for either application or for reading its value (unless it's revived). This means that if your opponent harms your slot, you will have more difficulty writing programs. The player with the most slots alive after 100000 turns wins.
The slots with the first few ordinals are the most valuable because they're the easiest for you to access (you can construct their ordinal more easily), but are also one of the most difficult for the opponent to access. Players are able to read opponent's slot, thus they may be able to reuse values the opponent constructs. 
The game also has the complicated concept of zombies, which is not described here.
Category:ICFP contest
Category:2011
Category:Programming games
LambdaPython

LambdaPython is Python, but if your program includes def, it raises a syntax error (that means you must use built-in functions or lambda functions instead of normal ones, thus the name). It is named by User:None1 and inspired by UnnumericJS which is inspired by MangularJS.
==Examples==
Most programs are the same (as Python), but here is an example that computes the n-th Fibonacci number using recursion (reads n and outputs the n-th Fibonacci number):
exec('\x64\x65\x66\x20\x66\x69\x62\x28\x6e\x29\x3a\x0a\x09\x69\x66\x20\x6e\x3d\x3d\x30\x3a\x0a\x09\x09\x72\x65\x74\x75\x72\x6e\x20\x30\x0a\x09\x69\x66\x20\x6e\x3d\x3d\x31\x3a\x0a\x09\x09\x72\x65\x74\x75\x72\x6e\x20\x31\x0a\x09\x72\x65\x74\x75\x72\x6e\x28\x66\x69\x62\x28\x6e\x2d\x31\x29\x2b\x66\x69\x62\x28\x6e\x2d\x32\x29\x29\x0a\x70\x72\x69\x6e\x74\x28\x66\x69\x62\x28\x69\x6e\x74\x28\x69\x6e\x70\x75\x74\x28\x29\x29\x29\x29')
Athough it uses recursion, it does not include def, so it is still allowed.
Alternatively, every def can be transformed into a lambda. The above Fibonacci function can be expressed as:
 f = lambda n: 0 if n == 0 else 1 if n == 1 else f(n - 1) + f(n - 2)
Here is a lambda-only version of an iterative Fibonacci function which doesn't use recursion:
 f = lambda i, l=[0, 1]: [l.append(l[-1] + l[-2]) for _ in range(i + 1 - len(l))] and l[i]
==Interpreter in Python==
import sys
code=sys.stdin.read()
if 'def' in code:
 raise Exception('Syntax error')
else:
 exec(code)
==Self interpreter==
import sys
code=sys.stdin.read()
if '\x64\x65\x66' in code:
 raise Exception('Syntax error')
else:
 exec(code)
This is also an interpreter in Python.
==Turing completeness==
We can use exec() and the hexadecimal escape to run any Python code, so it is Turing complete.
Category:Languages
Category:Turing complete
Category:2023
Category:Esoteric subset
Lambda Calculus Primer

Lambda Calculus Primer is an esolang created by User:LarhoCherqi. It comprises of only four characters (any other characters are not parsed). Given how simple this is, I am very confident that a concept similar to this already exists.
== Terminology ==
The storage system (what this article will call memory past this point) of Lambda Calculus Primer is a set (this article calls them sets but they're not sets, think of them more as arrays). Each element of the set can either be a set itself or a lambda. Lambdas are an instruction or a group of instructions that are stored in memory.
=== Locations ===
In almost all instructions, a location is at play. A location is an index to a specific set in the memory. Locations in the context of programs are written as so:
* The starting memory set ([])'s location would be nothing. Everything in memory resides in this set.
* If there were to be a set inside of the starting set, that set's location would be []. For any additional elements, you add one extra [] to the location, so something at the second element of the main set's location would be [][].
* To get a location for a set inside one of those sets, first get the location of the parent set, then treat that set as the new "starting set". Next, place the relative location of the child set inside the brackets of the parent set. Repeat this process until you have reached the set you are looking for.
An example of this will be demonstrated using Python list indices. If the memory is a list, then an element at memory[2][1][0] would have a location of [][][[]].
== Instructions ==
The spaces in the syntax are not required, they are just there for clarity.
=== Period ===
The . character, when used as a command, can append or remove elements from any given set. An "element" can be either a set structure or a lambda. The syntax for . is the following:
 . item . location .
item is the element is being appended. location is what set the element gets appended to.
If item is nothing, the item at location is removed instead.
=== Slash ===
The / character, when used as a command, can retrieve data from memory and return it to other commands. It can alternatively execute code. The syntax for / is the following:
 / location .
location is where to get data from.
When an extra / is placed next to the existing one, it will execute the lambda stored at location.
=== Brackets ===
When brackets are used as a command, the syntax is the following:
 [ check ] true . false .
If the set at the location check is the empty set (if there are no elements in it), run the lambda at the location true. If not, run the lambda at the location false. Both true and false can be nothing.
=== Brackets (alternative use) ===
When check is nothing, the data at the memory location true is interpreted as a number and printed out. false is what mode to use when printing (the mode can either be [] or nothing at all). A number is represented by having a set contain x sets inside of it, with x being the number that's represented. If false is [], the ASCII character that corresponds to the number gets printed instead.
Category:Languages
Category:Output_only
Category:2022
Lambda Calculus to Brainfuck

The goal of this page is to compile Lambda Calculus into Brainfuck.
==Functions==
===Procedures===
You think Brainfuck is not functional? Not at all. You can make prodedures(functions without parameters and return values) with it.
Here, I made a procedure(permanently named procedure UN0, or NOT 0):
 Choose the procedure to call(Here calls UN0)
 +
 Here is the procedure checker(UN0 prints "Hello world")
 [>+[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++[.>]<<<<.+++.------.<<-.>>>>+.[>]]
See? You can also define procedure 0:
 Choose the procedure to call(Here calls P0)
 Here is the prodedure checker(P1 prints "Hello world")
 not the cell:
 [>+<[-]]+>[<->-][>+[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++[.>]<<<<.+++.------.<<-.>>>>+.[>]]
===Procedures with return values===
That's easy. Simply set a cell into a value as return value.
We will define procedure 2(print spaces forever)here:
 ++>++<
 Checker:
 [->-<]+>[<->[-]]<[++++++++.[-]>++>++<[->-<]+>[<->[-]]<]
Look! We just made a recursion program!(Recursion requires procedures with return values)
===Last but not least:functions===
We will make a procedure with parameters value here(which is a function).
Just for simplicity, we will swap 2 values.(We name is procedure UN0) 
 [>>[->+<]<[->+<]>>[-<<+>>]]
See...2 cells represent the return values(usually functions can only return 1 value)
===Anonymous functions===
We have to name the function, or it will be impossible to call it.
This is how we implement anonymous functions.
==Calling Functions==
We just called functions in the function checker.
==example==
Implement this:
 (λx.(λy.(λz.(λx.z x) (λy.z y)) x) y)
Think x, y, z as 3 cells on Brainfuck.
Implementation of the steps(for clearer logic. I am possibly wrong; please correct that if so):
 (λx.(λy.(λz.(λx.z) (λy.z)) x) y)
 (λx.(λy.(λz.z z) x) y)
 (λx.(λy.(λz.z) x) y)
 (λx.(λy.z x) y)
 (λx.z y)
 z
In every lambda expression
 (λx.z y)
x is the parameter, z is the return value, y is the parameter value.
Right, we can use the functions defined above.(We have to name it)
Let us first check out a function:
 ((λx.z) y)
Name it procedure UN0 ant try to implement it:
 [[<]>>>]
(P.S.:we permanently put cells 1-3 from x to y, and leave cell 0 blank)
However, we cannot implement Nested functions.
==Try Again==
Check out this program below:
 (λx.(λy.y x) y)
An example of nested functions.
Name the outside function 2, and the inner function 1.
====Step 1, predefine====
 >>+>++<<<
The predefine step. Define z as 1, a as 2. (function1, function2)
====Step 2, calling 1====
Just note that b is the calling byte.
 >>>>+[-<->]+<[>-<[-]][<<<<----]++++
I predefined x as 4, y as 2.
====Step 3, calling 2====
 [>]>[-]++[-<<->>]+<<[>>-<<[-]][<<<--]++
Successfully returned y.
===The execution in Lambda Calculus===
 (λx.(λy.y x) y)
 (λx.x y)
 y
===Comment: the sequence used in the program===
 xyzab0000000000000000000000000000...
Category:Brainfuck
Category:Proofs
Lambdabot

Lambdabot is an IRC bot used in the #esolangs IRC channel and several other channels on the Libera network. Its most notable feature is that it evaluates Haskell expressions in a sandbox interpreter. int-e currently hosts lambdabot.
Lambdabot's IRC nick is lambdabot. It can be invoked in channels or private message. Commands are invoked by the @ or ? prefix. Shortcut invocation prefixes are > , equivalent to @run, to evaluate a Haskell expression; as well as a few shortcuts that start with :. In channels, lambdabot prints one line of output for each command, and that one line is truncated to a very short limit. In private message, lambdabot is willing to print longer lines, and you can use the @more command to get additional lines out output.
== Messages ==
Lambdabot is sometimes used to send messages to people in the #esoteric community. The @tell command sends a message; its argument is an IRC nick followed by a message. The @ask command also works. The @messages command reads your messages and immediately forgets them: if you are disconnected from the IRC server just after you issue this command, your messages are lost. A few users don't want to receive lambdabot messages. You can ask who they are by saying `dontaskdonttelllist to HackEso.
Note that the Libera IRC server also has an unrelated message passing service called MemoServ. The mailboxes for these messages are tied to accounts registered to NickServ, rather than to IRC nicks. Use the MemoServ HELP IRC command to get information about that service. 
== Haskell-related commands ==
*TODO run define type kind
*TODO hoogle
*TODO pl unpl
*TODO djinn
== Commands ==
The following is a list of most commands of lambdabot. Any of these can be equivalently invoked with the @ or ? prefix. 
:activity bf check @ ? . compose dice roll dict-help all-dicts bouvier cide devils easton elements foldoc gazetteer hitchcock jargon thesaurus vera wn world02 djinn djinn-add djinn-del djinn-env djinn-names djinn-clr djinn-ver eval choose dummy bug id show wiki paste docs learn haskellers botsnack get-shapr shootout faq googleit hackage thanks thx thank you ping tic-tac-toe elite leet l33t 1337 run let define letlpaste undefine free freshname index help hoogle hoogle+ instances instances-importing karma karma+ karma- karma-all time localtime localtime-reply metar more oeis sequence pointless pl pl-resume pointful pointy repoint unpointless unpl unpf poll-list poll-show poll-add choice-add vote poll-result poll-close poll-remove pretty quote remember forget ghc fortune yow arr yarr keal b52s pinky brain palomer girl19 v yhjulwwiefzojcbxybbruweejw protontorpedo nixon farber google gsite gwiki slap smack src spell spell-all listchans listmodules listservers list echo uptime tell ask messages messages-loud messages? clear-messages auto-reply auto-reply? clear-auto-reply ticker bid todo todo-add set-topic get-topic unshift-topic queue-topic shift-topic push-topic pop-topic dequeue-topic clear-topic type kind undo do unlambda unmtl version where url what where+
== External links ==
* lambdabot homepage, which has more documentation
* git repository for source code
Category:People
Lamfunc

Lamfunc is a functional esolang by User:PythonshellDebugwindow.
==Memory==
Lamfunc uses a mapping of variable names to values (e.g., a dictionary/associative array) stored in VARS. There is no limit on the amount of name-value pairs in VARS at any one time.
==Syntax==
Lamfunc programs are made up of a series of function calls and function definitions.
===Function calls===
To call a function, you write its name followed by any arguments, as this is a prefix language, so what would in Python look like f(g(x(), y()), h()); i() would look like this in Lamfunc:
 f g x y h i
===Function definitions===
To define a function, you write F fname - code on its own line. (All function definitions are one line, and there are no nested function definitions.) To define a function called f that calls itself forever:
 F f - f
A function c that takes two arguments and calls them both (either with b on its own or as an argument to a, depending on a's arg count):
 F c a b - a b
Function redefinitions are invalid syntax.
===Lambdas===
If a function name fname is preceded by a period ., it will not be called, but instead it will return the function fname without immediately calling it. So this function is the identity function:
 F id f - .f
==Builtins==
Lamfunc has eight builtin functions:
* p takes one argument, prints it (prints its bits if given a number), and returns it.
* eq takes two arguments, returns 1 if they are equal, else returns 0.
* i takes three arguments; if the first argument is nonzero (see eq), it returns the second argument, otherwise it returns the third argument.
* cb takes two numbers, combines their bits, and returns that (e.g., 0b10 and 0b110 would become 0b10110).
* lb takes a number and returns its last bit.
* fb takes a number and returns all but its last bit.
* vs takes two arguments X and Y, sets VARS[X] to Y, and returns Y.
* vg takes an argument X, and returns VARS[X] (or 0 for VARS[X] = undefined).
==Edge cases==
If there aren't enough arguments passed to a function inside a function definition, a lambda function will be returned that takes the rest of that function's required arguments and then calls it. As an example, if you have a function f that takes 3 arguments and prints them all, this function:
 F example a b - f a b
and this call:
 example .p .eq .i
would call example with .p and .eq, but example would need another argument due to f's argument count. So it would be called with .i, calling f with the three functions and therefore printing them.
==Examples==
===While loop function===
 F _w c f - f while .c .f
 F while c f - i c _w .c .f eq .i .eq
==='Not' function (e.g. !x)===
 F not x - eq x eq .i .eq
Category:Languages Category:2020 Category:Turing complete Category:Functional paradigm Category:Unimplemented
Langlang

langlang is an esolang which just does what you tell it to do, similar to English.
note that there are alot of ways to do the same thing.
==Examples==
===Hello World===
say "Hello, World!" to the console.
golfed:
say "Hello, World!".
slightly more golfed:
say Hello, World!
===Cat===
get input and say it to the console.
===Truth-Machine===
get input, if it is 0 then say 0 to the console. If it is one however, say 1 to the console an infinite amount of times.
Golfed:
Run say 0, say 1 forever at the input index, 0-indexed.
===R cat===
You can find R cat on Hex
get input, reverse it and say it to the console.
===calculator===
ask for an equation and calculate the answer and print it to the console.
golfed:
calculate the input and say it.
slightly more golfed:
calculate input, say it.
===Solve the halting problem===
research the halting problem, solve it.
Category:Languages Category:Uncomputable Category:Turing complete Category:2019 Category:Unimplemented Category:Pseudonatural
Language of Laughing

Language of Laughing is a joke derivative of Brainfuck by CosmicMan08#1975 (User:CosmicMan08). it sucks lmao
== instructions i guess ==
Instruction	Meaning
lmfao 	jumps back to the matching lmao if the value at the pointer isn't 0
lmao 	skips ahead to the matching lmfao if the value at the pointer is 0
lol 	copies the accumulator into the cell at the pointer
pff 	copies the current cell into the accumulator
X 	increment the accumulator by the amount of Ds after it and decreases it by the amount of Ds behind it
: 	moves the pointer right by the amount of Ds after it and moves the pointer left by the amount of Ds behind it
😂 	prints the ascii character at the pointer if the value at the pointer isn't 0, otherwise it'll take a byte of input and puts it into the cell at the pointer
== stupid examples ==
=== a frickin' cat ===
XDlollmaolmaoDXlmfaolol😂lol😂lmfao
=== the world's least optimized heya ppl program ===
XDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDlol😂DDDXlol😂XDDDDDDDDDDDDDDDDDDDDlol😂DDDDDDDDDDDDDDDDDDDDDDDDXlol😂DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDXlol😂XDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDlol😂😂DDDDXlol😂
Category:Languages
Category:Low-level
Category:Brainfuck derivatives
Category:Joke languages
Category:Cell-based
Category:Stupid_family
Category:Thematic
Languages whose names are having a stroke

Languages whose names are having a stroke is a series of random languages by User:Cinnamony.
* VGFJKDMLFJNDSJHGFYHJDZNYFBICHU,SBYFHDSR,JCBVFBDSJ;
* Piiiikaaaatchuuuuuuuuuuuuuuuuioiuytreewertyuioiuytrewertyui, the literal definition of stroke
Larabee

Larabee is an assembly-like programming language designed by Chris Pressey in 2008
that borrows the notion of branch prediction from computer architecture:
whenever a branch instruction is executed, the branch that is taken
is determined partly by the history of previous branches. However, in Larabee this is not
just an optimization: the branching history actually affects the control flow in the program.
Larabee uses an S-expression-based syntax (like Lisp or Scheme).
==External resources==
* 
Category:Languages
Category:Implemented
Category:Turing complete
Category:2008
LargeFish

LargeFish is an esolang by User:ChuckEsoteric08 based on BigFish, which is itself based on Deadfish
==Specification==
LargeFish operates on infinite amount of registers which store nonnegative integers. It has the following commands:
 i x - increment x
 d x - decrement x
 s x - square x
 o - output x
 e x y - set x to y
 loop x - loop x times
 endloop - end loop
Note that if you put an asterisk before y in e, or before x in loop it would return value of a register. If x has changed while executing, then the amount of times code will be executed is also changed, and if that amount is less or equal to amount of times loop has been executed it would exit the loop when endloop is encountered
==Computational class==
LargeFish is Turing complete since it can implement PMNN. Increasing and decreasing counters is easy, we can simply use i and d commands. To test if a register x is zero we can use register which we will call test and a loop command like that:
 e test *x
 loop *test
 e test 1
 endloop
It would set test to 1 if x is not zero, and to 0 otherwise
==Examples==
===Counter===
This example program counts up from inclusive one (1) to inclusive five (5):
 e counter 1
 e number_of_repetitions 5
 loop *number_of_repetitions
 o counter
 i counter
 endloop
==Interpreter==
* Common Lisp implementation of the LargeFish programming language.
Category:Languages Category:Turing complete Category:Turing tarpits Category:2023 Category:Output only Category:Implemented
Laser

Laser is a 2D programming language built by User:FizzyApple12 based on lasers, color, brightness and direction.
== Commands ==
The laser is created (program start) with: ~ (laser always starts going right)
The laser is destroyed (program end) with: `
Laser instructions are categorized into 5 groups: up, down, left, right, and all.
All: instruction same from all directions (direction commands)
/ | Mirror
\ | Mirror
^ | changes laser's direction to up
V | changes laser's direction to down
< | changes laser's direction to left
> | changes laser's direction to right
& | sets laser's color or brightness to the value of the variable named the character to the right
Up: instruction is executed using this rule only if the laser is going up (string commands)
@ | changes laser's color to the character to the right
+ | pushes character to the right to the end of the laser's color
- | subtracts character from the end of the laser's color
$ | sets variable named the character to the right to the laser's color
Down: instruction is executed using this rule only if the laser is going down (number commands)
@ | changes laser's brightness to the number to the right
+ | adds brightness specified by the number to the right
- | subtracts brightness specified by the number to the right
* | multiplies brightness specified by the number to the right
% | divides brightness specified by the number to the right
$ | sets variable named the character to the right to the brightness
Left: instruction is executed using this rule only if the laser is going left (I/O commands)
@ | prints the color
$ | prints the brightness
= | sets the color to the next character in the keyboard buffer
: | prompts the user for keyboard input then sets the color to the text inputted
Right: instruction is executed using this rule only if the laser is going right (flow commands)
| | if brightness is greater than the number specified to the right, the laser will go up, if it is equal, the laser will go right, and if it is less, the laser will go down
- | if color is equal to the character on the right it will go up, otherwise laser will go down
{ | while the brightness is greater than the number specified the the right it will go right until it hits a ]
( | while the brightness is less than the number specified the the right it will go right until it hits a ]
[ | for the brightness values starting at the number on the bottom and ending at the number on the top incrementing by the number on the right until the laser hits a ]
] | when the laser hits this, it will loop back to the beginning of the loop unless the loop is completed, then the laser will go on like normal
== Examples ==
=== Hello World ===
 / \/ \/ \`@\
 +l + +r +!
 +e +o +o +d
 @H +l +W +l
~ / \/ \/ \ /
=== Truth Machine ===
~ \`@\ 
/:// / 
\ -0 
 @1 
 \ {0\
 /@/@/
 \]\] 
=== Cat Program ===
~ \
`@:/
== Implementations ==
=== JavaScript ===
An interpreter built in node.js can be found here.
Category:Languages
Category:Joke languages
Category:Implemented
Category:Two-dimensional languages